From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 797F03C0A15; Tue, 26 May 2026 21:18:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830303; cv=none; b=t0w1IKz/cVTi1fAKoAa3mhzjB3iXp2LdDTjM8Y+Eeed9ML+WQ5RWvaQTQrwy05kjG9mgpl38TYiVYgFJClH5lM8HaTgtEpzVYaMF2hMyg0ma78HGL+C8ikhTdzOor0h0Lzuym7fCEfUCKwpsfd5rgq+kYQgeG//GMFXye5IfOt0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830303; c=relaxed/simple; bh=m3Nyc1/tMu2Qw0Ch4VxQWF/Vv5iYyTVVIJHhb1fDxKQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=TJNjVF59lpK5dE0sw3mTAPa9KP8/40FWW5WkWtd4xEASNUCyEIhscDs6OHX7MnNQYwKxhGouhjAAtVasRl40ACjkEan3BVtB0cr3zyzqKvcwJDnXMgxnDTVWO5Ix1gHbekJGZZi6DLDGks3JdiLLDxWelgDW1V4n1zGXudYdbdA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Ev4/+Nac; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Ev4/+Nac" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4AACA1F00A3A; Tue, 26 May 2026 21:18:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830301; bh=SWCMSnNtfVnyAWAIWVo7IK27z/JemwC0+SY2Gkyjx2M=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Ev4/+NacRKtfE7QuKo+44tudxE2vczlUxckaG1CXwDxWAnSdjRUJ371eF03euGw17 xeU5P51rUKZCim8ZjvdnVrhQZCI59xAxTmVF9+WROIbQCGDGnSpXa8C5bIvUIYzuk+ Q8Ti79NG1T7mLBEvbWNP5DMTyxBcnA1z+qIz9+8bPnhMZ+HyxXNHBxF7c5uHyYV8r3 O8YGlMZ1OhdVX/2ZGDyfHqwGhisHC42NG7RfhsHJuXXp6hfDSW7MndCSHkwiTBDJmj RWIW4RVQxN8R13zrzjDaP9Zg5ZPdT/exzM7dmQy/il3yR9WbD/gLMlOd9EW/t7tbhM BjhLBxEYuJigw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 01/29] perf session: Add minimum event size and alignment validation Date: Tue, 26 May 2026 18:17:37 -0300 Message-ID: <20260526211806.1193848-2-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Add a per-type minimum size table (perf_event__min_size[]) and enforce it before swap and processing, so that both cross-endian and native-endian paths are protected from accessing fields past the event boundary. The table uses offsetof() for types with trailing variable-length fields (filenames, strings, msg arrays) and sizeof() for fixed-size types. Zero entries mean no minimum beyond the 8-byte header already enforced by the reader. Undersized events are skipped with a warning in process_event and rejected in peek_event =E2=80=94 both checked before the swap handler runs, preventing OOB access on crafted event fields. Also reject events whose header.size is not 8-byte aligned. The kernel aligns all event sizes to sizeof(u64) =E2=80=94 see perf_event_comm_event() (ALIGN), perf_event_mmap_event(), perf_event_cgroup(), perf_event_ksymbol() (IS_ALIGNED loops), and perf_event_text_poke() (ALIGN) in kernel/events/core.c. An unaligned size means the file is corrupted or crafted; reject early so downstream code that divides by sizeof(u64) to compute array element counts gets exact results. Three legacy user events are exempted from the alignment check: TRACING_DATA (66) had a 12-byte struct before commit b39c915a4f36 ("libperf event: Ensure tracing data is multiple of 8 sized") added padding, COMPRESSED (81) carries raw ZSTD output (already superseded by COMPRESSED2 with PERF_ALIGN), and HEADER_FEATURE (80) uses do_write_string() with a 4-byte length prefix. Also guard event_swap() against crafted event types >=3D PERF_RECORD_HEADER_MAX to prevent OOB reads on the perf_event__swap_ops[] array. Changes in v2: - Fix double-skip for unsupported event types: return 0 instead of event->header.size in perf_session__process_event() for HEADER_MAX, since reader__read_event() already advances by event->header.size (Reported-by: sashiko-bot@kernel.org) - Exempt TRACING_DATA, COMPRESSED, and HEADER_FEATURE from the alignment check =E2=80=94 these legacy user events predate the 8-byte alignment rule (Reported-by: sashiko-bot@kernel.org) - peek_event: return 0 (skip) for unknown event types instead of -1 (error), consistent with process_event which already skips unsupported types gracefully (Reported-by: sashiko-bot@kernel.org) Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 253 +++++++++++++++++++++++++++++++++----- 1 file changed, 220 insertions(+), 33 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 1e25892963b7857a..0523fd243e02c09b 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -1759,15 +1759,121 @@ int perf_session__deliver_synth_attr_event(struct = perf_session *session, return perf_session__deliver_synth_event(session, &ev.ev, NULL); } =20 -static void event_swap(union perf_event *event, bool sample_id_all) +/* + * Minimum event sizes indexed by type. Checked before swap and + * processing so that both cross-endian and native-endian paths + * are protected from accessing fields past the event boundary. + * Zero means no minimum beyond the 8-byte header (already + * enforced by the reader). + */ +static const u32 perf_event__min_size[PERF_RECORD_HEADER_MAX] =3D { + /* + * offsetof() + 1 for types with a trailing variable-length + * string (filename, comm, path, name, msg): the +1 ensures + * room for at least a null terminator. Full null-termination + * within the event boundary is checked separately. + * + * PERF_RECORD_SAMPLE is omitted: all64_swap is bounded by + * header.size, and the internal layout varies by sample_type + * so a fixed minimum is not meaningful. + */ + [PERF_RECORD_MMAP] =3D offsetof(struct perf_record_mmap, filename) + 1, + [PERF_RECORD_LOST] =3D sizeof(struct perf_record_lost), + [PERF_RECORD_COMM] =3D offsetof(struct perf_record_comm, comm) + 1, + [PERF_RECORD_EXIT] =3D sizeof(struct perf_record_fork), + [PERF_RECORD_THROTTLE] =3D sizeof(struct perf_record_throttle), + [PERF_RECORD_UNTHROTTLE] =3D sizeof(struct perf_record_throttle), + [PERF_RECORD_FORK] =3D sizeof(struct perf_record_fork), + /* + * The kernel dynamically sizes PERF_RECORD_READ based on + * attr.read_format =E2=80=94 the minimum has just pid + tid + value. + */ + [PERF_RECORD_READ] =3D offsetof(struct perf_record_read, time_enabled), + [PERF_RECORD_MMAP2] =3D offsetof(struct perf_record_mmap2, filename) += 1, + [PERF_RECORD_LOST_SAMPLES] =3D sizeof(struct perf_record_lost_samples), + [PERF_RECORD_AUX] =3D sizeof(struct perf_record_aux), + [PERF_RECORD_ITRACE_START] =3D sizeof(struct perf_record_itrace_start), + [PERF_RECORD_SWITCH] =3D sizeof(struct perf_event_header), + [PERF_RECORD_SWITCH_CPU_WIDE] =3D sizeof(struct perf_record_switch), + [PERF_RECORD_NAMESPACES] =3D sizeof(struct perf_record_namespaces), + [PERF_RECORD_CGROUP] =3D offsetof(struct perf_record_cgroup, path) + 1, + [PERF_RECORD_TEXT_POKE] =3D sizeof(struct perf_record_text_poke_event), + [PERF_RECORD_KSYMBOL] =3D offsetof(struct perf_record_ksymbol, name) += 1, + [PERF_RECORD_BPF_EVENT] =3D sizeof(struct perf_record_bpf_event), + [PERF_RECORD_HEADER_ATTR] =3D sizeof(struct perf_event_header) + PERF_A= TTR_SIZE_VER0, + [PERF_RECORD_HEADER_EVENT_TYPE] =3D sizeof(struct perf_record_header_ev= ent_type), + /* Legacy events predate the __u32 pad field, accept 12-byte records */ + [PERF_RECORD_HEADER_TRACING_DATA] =3D offsetof(struct perf_record_header_= tracing_data, pad), + [PERF_RECORD_AUX_OUTPUT_HW_ID] =3D sizeof(struct perf_record_aux_output= _hw_id), + [PERF_RECORD_AUXTRACE_INFO] =3D sizeof(struct perf_record_auxtrace_info= ), + [PERF_RECORD_AUXTRACE] =3D sizeof(struct perf_record_auxtrace), + [PERF_RECORD_AUXTRACE_ERROR] =3D offsetof(struct perf_record_auxtrace_e= rror, msg) + 1, + [PERF_RECORD_THREAD_MAP] =3D sizeof(struct perf_record_thread_map), + /* Smallest valid variant is RANGE_CPUS: header(8) + type(2) + range(6) */ + [PERF_RECORD_CPU_MAP] =3D sizeof(struct perf_event_header) + + sizeof(__u16) + + sizeof(struct perf_record_range_cpu_map), + [PERF_RECORD_STAT_CONFIG] =3D sizeof(struct perf_record_stat_config), + [PERF_RECORD_STAT] =3D sizeof(struct perf_record_stat), + [PERF_RECORD_STAT_ROUND] =3D sizeof(struct perf_record_stat_round), + /* Union inflates sizeof; use fixed header fields as minimum */ + [PERF_RECORD_EVENT_UPDATE] =3D offsetof(struct perf_record_event_update= , scale), + [PERF_RECORD_TIME_CONV] =3D offsetof(struct perf_record_time_conv, tim= e_cycles), + [PERF_RECORD_ID_INDEX] =3D sizeof(struct perf_record_id_index), + [PERF_RECORD_HEADER_BUILD_ID] =3D sizeof(struct perf_record_header_buil= d_id), + [PERF_RECORD_HEADER_FEATURE] =3D sizeof(struct perf_record_header_featu= re), + [PERF_RECORD_COMPRESSED2] =3D sizeof(struct perf_record_compressed2), + [PERF_RECORD_BPF_METADATA] =3D sizeof(struct perf_record_bpf_metadata), + [PERF_RECORD_CALLCHAIN_DEFERRED] =3D sizeof(struct perf_event_header) + = sizeof(__u64), + /* + * SCHEDSTAT events have a version-dependent union after the + * fixed header fields; the minimum is the base (pre-union) + * portion so old and new versions both pass. + */ + [PERF_RECORD_SCHEDSTAT_CPU] =3D offsetof(struct perf_record_schedstat_c= pu, v15), + [PERF_RECORD_SCHEDSTAT_DOMAIN] =3D offsetof(struct perf_record_schedsta= t_domain, v15), +}; + +/* + * Return true if the event is too small for its declared type. + * Caller must ensure event->header.type < PERF_RECORD_HEADER_MAX. + * If min is non-NULL, stores the required minimum on failure. + */ +static bool perf_event__too_small(const union perf_event *event, u32 *min) { - perf_event__swap_op swap; + u32 min_sz =3D perf_event__min_size[event->header.type]; + + if (min_sz && event->header.size < min_sz) { + if (min) + *min =3D min_sz; + return true; + } =20 - swap =3D perf_event__swap_ops[event->header.type]; + return false; +} + +/* Caller must ensure event->header.type < PERF_RECORD_HEADER_MAX */ +static void event_swap(union perf_event *event, bool sample_id_all) +{ + perf_event__swap_op swap =3D perf_event__swap_ops[event->header.type]; if (swap) swap(event, sample_id_all); } =20 +/* + * Read and validate the event at @file_offset. + * + * Returns: + * 0 =E2=80=94 success: *event_ptr is set and safe to access. + * -1 =E2=80=94 error; check *event_ptr to decide whether to advance or = abort: + * *event_ptr set =E2=80=94 event header was read but the event = is + * malformed (too small for its type, or byte-s= wap + * failed). header.size is still valid, so the + * caller can advance past the event. + * *event_ptr NULL =E2=80=94 fatal: couldn't read the header at a= ll + * (I/O error, offset out of range, pipe mode). + * Caller must abort. + */ int perf_session__peek_event(struct perf_session *session, off_t file_offs= et, void *buf, size_t buf_sz, union perf_event **event_ptr, @@ -1775,52 +1881,85 @@ int perf_session__peek_event(struct perf_session *s= ession, off_t file_offset, { union perf_event *event; size_t hdr_sz, rest; + u32 min_sz; int fd; =20 + *event_ptr =3D NULL; + if (session->one_mmap && !session->header.needs_swap) { event =3D file_offset - session->one_mmap_offset + session->one_mmap_addr; - goto out_parse_sample; - } =20 - if (perf_data__is_pipe(session->data)) - return -1; + /* Every event must at least contain its own header */ + if (event->header.size < sizeof(struct perf_event_header)) + return -1; + } else { + if (perf_data__is_pipe(session->data)) + return -1; =20 - fd =3D perf_data__fd(session->data); - hdr_sz =3D sizeof(struct perf_event_header); + fd =3D perf_data__fd(session->data); + hdr_sz =3D sizeof(struct perf_event_header); =20 - if (buf_sz < hdr_sz) - return -1; + if (buf_sz < hdr_sz) + return -1; =20 - if (lseek(fd, file_offset, SEEK_SET) =3D=3D (off_t)-1 || - readn(fd, buf, hdr_sz) !=3D (ssize_t)hdr_sz) - return -1; + if (lseek(fd, file_offset, SEEK_SET) =3D=3D (off_t)-1 || + readn(fd, buf, hdr_sz) !=3D (ssize_t)hdr_sz) + return -1; =20 - event =3D (union perf_event *)buf; + event =3D (union perf_event *)buf; =20 - if (session->header.needs_swap) - perf_event_header__bswap(&event->header); + if (session->header.needs_swap) + perf_event_header__bswap(&event->header); + + if (event->header.size < hdr_sz || event->header.size > buf_sz) + return -1; + + buf +=3D hdr_sz; + rest =3D event->header.size - hdr_sz; + + if (readn(fd, buf, rest) !=3D (ssize_t)rest) + return -1; + } =20 - if (event->header.size < hdr_sz || event->header.size > buf_sz) + /* Event data is fully loaded =E2=80=94 expose so callers can advance */ + *event_ptr =3D event; + + /* + * Check alignment before type: an unaligned size misaligns the + * stream for all subsequent reads regardless of event type. + * Three legacy user events predate the 8-byte rule =E2=80=94 exempt them. + */ + if (event->header.size % sizeof(u64) && + event->header.type !=3D PERF_RECORD_HEADER_TRACING_DATA && + event->header.type !=3D PERF_RECORD_COMPRESSED && + event->header.type !=3D PERF_RECORD_HEADER_FEATURE) { + pr_warning("WARNING: peek_event: event type %u size %u not aligned to %z= u\n", + event->header.type, + event->header.size, sizeof(u64)); return -1; + } =20 - buf +=3D hdr_sz; - rest =3D event->header.size - hdr_sz; + if (event->header.type >=3D PERF_RECORD_HEADER_MAX) { + pr_warning("WARNING: peek_event: unsupported event type %u, skipping\n", + event->header.type); + return 0; + } =20 - if (readn(fd, buf, rest) !=3D (ssize_t)rest) + if (perf_event__too_small(event, &min_sz)) { + pr_warning("WARNING: peek_event: %s event size %u too small (min %u)\n", + perf_event__name(event->header.type), + event->header.size, min_sz); return -1; + } =20 if (session->header.needs_swap) event_swap(event, evlist__sample_id_all(session->evlist)); =20 -out_parse_sample: - if (sample && event->header.type < PERF_RECORD_USER_TYPE_START && evlist__parse_sample(session->evlist, event, sample)) return -1; =20 - *event_ptr =3D event; - return 0; } =20 @@ -1858,23 +1997,71 @@ static s64 perf_session__process_event(struct perf_= session *session, { struct evlist *evlist =3D session->evlist; const struct perf_tool *tool =3D session->tool; + u32 min_sz; int ret; =20 - if (session->header.needs_swap) - event_swap(event, evlist__sample_id_all(evlist)); + /* + * The kernel aligns all event sizes to sizeof(u64) =E2=80=94 see + * perf_event_comm_event() (ALIGN), perf_event_mmap_event(), + * perf_event_cgroup(), perf_event_ksymbol() (IS_ALIGNED loops), + * and perf_event_text_poke() (ALIGN) in kernel/events/core.c. + * + * An unaligned size means the file is corrupted or crafted. + * Abort: there is no point continuing to read unaligned records + * because the caller advances rd->head by event->header.size, + * so every subsequent read would start at a misaligned offset, + * producing garbage headers for the rest of the file. + * + * Exempt three legacy user events that predate the alignment rule: + * + * TRACING_DATA (66): struct tracing_data_event was 12 bytes before + * b39c915a4f36 ("libperf event: Ensure tracing data is multiple + * of 8 sized") added __u32 pad; old perf.data files still contain + * 12-byte records. + * TODO: introduce HEADER_TRACING_DATA2 with guaranteed alignment. + * + * COMPRESSED (81): raw ZSTD output, arbitrary length. Already + * superseded by COMPRESSED2 (83) with PERF_ALIGN. + * + * HEADER_FEATURE (80): do_write_string() uses a 4-byte length + * prefix with no padding to 8-byte total. + * TODO: introduce HEADER_FEATURE2 with guaranteed alignment. + */ + if (event->header.size % sizeof(u64) && + event->header.type !=3D PERF_RECORD_HEADER_TRACING_DATA && + event->header.type !=3D PERF_RECORD_COMPRESSED && + event->header.type !=3D PERF_RECORD_HEADER_FEATURE) { + pr_err("ERROR: %s event size %u is not 8-byte aligned, aborting\n", + perf_event__name(event->header.type), + event->header.size); + return -EINVAL; + } =20 if (event->header.type >=3D PERF_RECORD_HEADER_MAX) { - /* perf should not support unaligned event, stop here. */ - if (event->header.size % sizeof(u64)) - return -EINVAL; - /* This perf is outdated and does not support the latest event type. */ ui__warning("Unsupported header type %u, please consider updating perf.\= n", event->header.type); - /* Skip unsupported event by returning its size. */ - return event->header.size; + /* + * Return 0 to skip: the caller (reader__read_event) + * already advances by event->header.size. + */ + return 0; } =20 + /* + * Skip rather than abort: a too-small-but-aligned event + * can be safely stepped over without misaligning the stream. + */ + if (perf_event__too_small(event, &min_sz)) { + pr_warning("WARNING: %s event size %u too small (min %u), skipping\n", + perf_event__name(event->header.type), + event->header.size, min_sz); + return 0; + } + + if (session->header.needs_swap) + event_swap(event, evlist__sample_id_all(evlist)); + events_stats__inc(&evlist->stats, event->header.type); =20 if (event->header.type >=3D PERF_RECORD_USER_TYPE_START) --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CB45B39732C; Tue, 26 May 2026 21:18:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830306; cv=none; b=K+IxUIKDnlu9hBt2JQEs7xsDIGGY/wjulTJo9A5S6/93aYUWHP/sDtT9QsJl6+g76OU4KEiAQEy9tBIWuRAqxy28eP0x3W2YlkcIk9Wec3gCmMUdhHUDDWXbQnaollD46nOkYYOquI4IYvtIoInZFQ7+NE3W/wZA0LO6qZE191M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830306; c=relaxed/simple; bh=EFl0ilw7DOSK6DwVd5+p0NyA5yFDMXfTnyy1U7dcmAo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=b2Ec8RFCRIPM2DklBoIK6H6NRS1JJyou2jN3A/EtXehmtepO4zy4ZbX1OuP3Efq0QdqL/+I7tPWi80MJnbgr9I+G6HgHcGgScMQd9aH0eGpFBp1uJiXV+1T1SGKi/UAT3e7IvHFX/oQ4Jl+ghytiSi9Gi6wUSNdVfG0XXcCEAWA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=e8vfTf1c; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="e8vfTf1c" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8FFF81F00A3C; Tue, 26 May 2026 21:18:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830304; bh=87T7wPlP1JWvoL8tVqclceY6ODGJmso4j6MMQOhWpYA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=e8vfTf1cn+yiVDBd+GcRHygT9nuDHgsDC6b9F7u4uz5MiI6xwFnKcpjnJ95KBI8pu z/GXLy30aLz4GeTDiNUH4GQWkmp9v29RFl06xR0Zh9pWFeUym6y8aKox9lrmQf1bpJ 86LQ0luk+gHmsnZgxH5TbyGYqyjGJFDAD7ofyWT98HhA7BUMabm/wIRGYqFPJlmQGw IuQSMnj/rkvssUSMHrBu5mInVj21Zolqbit7sLguSPM3bfbwuBBGE16tCtFpXmp8kB D+R1vzl65vsUDlhPkJy4kTuRa6JR+l8hoU/5OJx35r4TN0tESHEcAnbBUshoKjPJLD TECtT/BlaIR0A== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 02/29] perf session: Bounds-check one_mmap event pointer in peek_event Date: Tue, 26 May 2026 18:17:38 -0300 Message-ID: <20260526211806.1193848-3-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo perf_session__peek_event() computes an event pointer directly from file_offset when one_mmap is active, without verifying that file_offset and the subsequent event->header.size fall within the mapped region. A corrupted perf.data file could cause out-of-bounds memory reads. Add one_mmap_size to the session struct and validate both the header and full event fit within the mmap before dereferencing. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 29 ++++++++++++++++++++++++++--- tools/perf/util/session.h | 2 ++ 2 files changed, 28 insertions(+), 3 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 0523fd243e02c09b..c4cd8ad6d810a74c 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -1887,12 +1887,27 @@ int perf_session__peek_event(struct perf_session *s= ession, off_t file_offset, *event_ptr =3D NULL; =20 if (session->one_mmap && !session->header.needs_swap) { - event =3D file_offset - session->one_mmap_offset + - session->one_mmap_addr; + u64 offset_in_mmap; + + /* Validate offset with integer arithmetic to avoid pointer UB */ + if ((u64)file_offset < session->one_mmap_offset) + return -1; + + offset_in_mmap =3D (u64)file_offset - session->one_mmap_offset; + + /* Use subtraction to avoid addition overflow */ + if (offset_in_mmap >=3D session->one_mmap_size || + session->one_mmap_size - offset_in_mmap < sizeof(struct perf_event_h= eader)) + return -1; + + event =3D session->one_mmap_addr + offset_in_mmap; =20 - /* Every event must at least contain its own header */ if (event->header.size < sizeof(struct perf_event_header)) return -1; + + /* Ensure full event is within the mmap region */ + if (session->one_mmap_size - offset_in_mmap < event->header.size) + return -1; } else { if (perf_data__is_pipe(session->data)) return -1; @@ -2560,6 +2575,14 @@ reader__mmap(struct reader *rd, struct perf_session = *session) if (session->one_mmap) { session->one_mmap_addr =3D buf; session->one_mmap_offset =3D rd->file_offset; + /* + * mmap_size was set to the full file extent (data_offset + + * data_size) but file_offset was shifted forward by + * page_offset for page alignment. Reduce by page_offset + * so the bounds check reflects the file-backed portion + * of the mapping =E2=80=94 pages beyond the file cause SIGBUS. + */ + session->one_mmap_size =3D rd->mmap_size - page_offset; } =20 return 0; diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h index f05f0d4a6c238dc8..d554e2a1a50ed304 100644 --- a/tools/perf/util/session.h +++ b/tools/perf/util/session.h @@ -71,6 +71,8 @@ struct perf_session { void *one_mmap_addr; /** @one_mmap_offset: File offset in perf.data file when mapped. */ u64 one_mmap_offset; + /** @one_mmap_size: Size of the single mmap in bytes. */ + u64 one_mmap_size; /** @ordered_events: Used to turn unordered events into ordered ones. */ struct ordered_events ordered_events; /** @data: Optional perf data file being read from. */ --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C08643C09EC; Tue, 26 May 2026 21:18:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830309; cv=none; b=HMymn5nsMUMQs9aHZpFvwVPD27L+XbtF6Z6clAdmWHUvFIrGp+pyfOyC9zYceGiCQjSZQhcxtzcX6imcCaTA2EvVPJlarSMTKYOKiCGEf02/3GOydSl1v6/cNrwo9ncC6/FpSy/7IpobKR9rZXPEjUkaatOppicm6tqhDiWAQnY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830309; c=relaxed/simple; bh=OnqVr/x0PCFIuS9QoBjoftnmuBSOE+xs0TbXevOcqd4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=PCw3dvbO5ERWYVw/V17UoZ4CBNME2l90qV3dVZccr9IGOafPIxdsG6ZsW/R9A5WEiX7NyjyKrN/2u3Gp/Vea18WcW2ARE/lKJObMjgcJIoa9BfjuUHDFG0lgm8JF1048pwtZGImKLK5vVHJq8WXemLHEzM2jI8PdLpS8hPjjQaM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=YiGqf8VV; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="YiGqf8VV" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D3FED1F000E9; Tue, 26 May 2026 21:18:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830307; bh=XbGi1j8FII0Y0rwll19PJjGMweR7zPiMUsJf/hVVrWg=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=YiGqf8VVSX2D3YBkpPBPxR9mHcLIJ9RwB4/fK2h3KciofjsIqM4FF+c4SWmPgdfFj BQCEP9qjxRsM+a5n8OAz+Z5+gUifZ7cZLeVKoZeGd6S3FTo4R0+LUMAnMLClYM3Dr7 fmYUByeVKVCVhF12EI5DH40PAhxY5ssFtkEVpXblpNKsxkM2IhreZnd7iNcC5E1WmJ m2fO3bHy4xGwP7wzEL57pLAI2gnJFBevhpKq7rkGcKhJl1HPB1aUNqiP3I0QXdEQmX 3R1bRLYhJj8Jy5Re3HUtQm8zTCuV+YtvdqNcMvjcDIOSDd4OdkxzMSSU786yAFbbfj ShZYyNAK0ArKA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 03/29] perf tools: Fix event_contains() macro to verify full field extent Date: Tue, 26 May 2026 18:17:39 -0300 Message-ID: <20260526211806.1193848-4-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo event_contains() checked whether a field's start offset was within the event (header.size > offsetof), but not whether the full field fit. A crafted event with header.size =3D offsetof(field) + 1 would pass the check, but an 8-byte access (bswap_64, direct read) would overrun the event boundary by up to 7 bytes. Fix the macro to verify the complete field: header.size >=3D offsetof(field) + sizeof(field) Also update all callers that check event_contains(time_cycles) but access later fields (time_mask, cap_user_time_zero, cap_user_time_short) to check for cap_user_time_short =E2=80=94 the last field accessed =E2=80=94 so the entire extended block is verified: tsc.c, arm-spe.c, cs-etm.c, jitdump.c. Note: session.c's perf_event__time_conv_swap() also guards on time_cycles but accesses time_mask =E2=80=94 a pre-existing issue not introduced by this macro change. It is fixed by a later patch in this series ("perf session: Add validated swap infrastructure with null-termination checks"), which decouples time_cycles and time_mask into independent per-field event_contains() checks. The struct assignment overread (session->time_conv =3D event->time_conv copies sizeof on a potentially shorter event) is separately fixed by "perf session: Use bounded copy for PERF_RECORD_TIME_CONV". Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/lib/perf/include/perf/event.h | 9 ++++++++- tools/perf/util/arm-spe.c | 2 +- tools/perf/util/cs-etm.c | 2 +- tools/perf/util/jitdump.c | 2 +- tools/perf/util/tsc.c | 2 +- 5 files changed, 12 insertions(+), 5 deletions(-) diff --git a/tools/lib/perf/include/perf/event.h b/tools/lib/perf/include/p= erf/event.h index 9043dc72b5d68d58..fdced574c889e503 100644 --- a/tools/lib/perf/include/perf/event.h +++ b/tools/lib/perf/include/perf/event.h @@ -8,7 +8,14 @@ #include #include /* pid_t */ =20 -#define event_contains(obj, mem) ((obj).header.size > offsetof(typeof(obj)= , mem)) +/* + * Verify the full field fits within the event, not just its start offset. + * Only valid for fixed-size scalar fields =E2=80=94 for trailing arrays l= ike + * filename[PATH_MAX], sizeof() evaluates to the declared maximum, not + * the actual string length, so this would spuriously return false. + */ +#define event_contains(obj, mem) \ + ((obj).header.size >=3D offsetof(typeof(obj), mem) + sizeof((obj).mem)) =20 struct perf_record_mmap { struct perf_event_header header; diff --git a/tools/perf/util/arm-spe.c b/tools/perf/util/arm-spe.c index 31f05f46781092c1..552f063f126e6769 100644 --- a/tools/perf/util/arm-spe.c +++ b/tools/perf/util/arm-spe.c @@ -2002,7 +2002,7 @@ int arm_spe_process_auxtrace_info(union perf_event *e= vent, spe->tc.time_mult =3D tc->time_mult; spe->tc.time_zero =3D tc->time_zero; =20 - if (event_contains(*tc, time_cycles)) { + if (event_contains(*tc, cap_user_time_short)) { spe->tc.time_cycles =3D tc->time_cycles; spe->tc.time_mask =3D tc->time_mask; spe->tc.cap_user_time_zero =3D tc->cap_user_time_zero; diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 6ec48de29441012f..40c6ddfa8c8d91b6 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -3514,7 +3514,7 @@ int cs_etm__process_auxtrace_info_full(union perf_eve= nt *event, etm->tc.time_shift =3D tc->time_shift; etm->tc.time_mult =3D tc->time_mult; etm->tc.time_zero =3D tc->time_zero; - if (event_contains(*tc, time_cycles)) { + if (event_contains(*tc, cap_user_time_short)) { etm->tc.time_cycles =3D tc->time_cycles; etm->tc.time_mask =3D tc->time_mask; etm->tc.cap_user_time_zero =3D tc->cap_user_time_zero; diff --git a/tools/perf/util/jitdump.c b/tools/perf/util/jitdump.c index 52e6ffac2b3e1039..18fd84a82153c2ab 100644 --- a/tools/perf/util/jitdump.c +++ b/tools/perf/util/jitdump.c @@ -409,7 +409,7 @@ static uint64_t convert_timestamp(struct jit_buf_desc *= jd, uint64_t timestamp) * checks the event size and assigns these extended fields if these * fields are contained in the event. */ - if (event_contains(*time_conv, time_cycles)) { + if (event_contains(*time_conv, cap_user_time_short)) { tc.time_cycles =3D time_conv->time_cycles; tc.time_mask =3D time_conv->time_mask; tc.cap_user_time_zero =3D time_conv->cap_user_time_zero; diff --git a/tools/perf/util/tsc.c b/tools/perf/util/tsc.c index 511a517ce613dff1..ebf289bf6b9d9add 100644 --- a/tools/perf/util/tsc.c +++ b/tools/perf/util/tsc.c @@ -127,7 +127,7 @@ size_t perf_event__fprintf_time_conv(union perf_event *= event, FILE *fp) * when supported cap_user_time_short, for backward compatibility, * prints the extended fields only if they are contained in the event. */ - if (event_contains(*tc, time_cycles)) { + if (event_contains(*tc, cap_user_time_short)) { ret +=3D fprintf(fp, "... Time Cycles %" PRI_lu64 "\n", tc->time_cycles); ret +=3D fprintf(fp, "... Time Mask %#" PRI_lx64 "\n", --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 500213B47FF; Tue, 26 May 2026 21:18:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830312; cv=none; b=oDWCmUCa3L2fs39vhDr2Bvny5POWenyx4xTtRuelX5b7trhcwZSRIWOmNZ4wLsG4tqEDx3OzzOS7V+grE1G/yME556PkE2rMXLs2l+oc6opRO4FE27KeAHtIcyhg83/1KRxf1u+p4lUdCpYRVwbVwLzIz8/N0kHihO3mZaNfOv8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830312; c=relaxed/simple; bh=+FrKb/aPODbOMn4tQ14jFX4fEXNRcobwejc6zdUYsII=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=O1JRevd6SHXqJqshYjWKh1jA0KPeNlq3kuVve92v833ah2l0eQ9CE+aEgCOCTYhrBws32vqFS5S4ARb4nH6poFv0x41JmT+v2OhiEKeyLqf8CUmeLFNn57MCYxVJZE0pK42VoLDY9MQ1pamk0UPwiRs8bF7x/LGMRSqKKb9jrMU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=DUFrta12; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="DUFrta12" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 237F01F00A3A; Tue, 26 May 2026 21:18:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830311; bh=k+eYrXi6ugs6c61M2VwpDukIgVhLCh3dx5xvKu/yrMQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=DUFrta12H4xZBXa+Utctyoa+i+Zub9ODHqmaeQtvkYzKVARhsugRByoDbD0ztWILW 998trGj1J7re0t436i8kja4XB5Qc61fvky51BeE7lbCX7Qw3322pyIBUU2SQG7/AsN /VRzK3VAhbRvSxVV4IN3IZXjyLfW2+cbwALiV0oPUWr3jZ/lXPXrcqaxuKGsgzvuRc Ow69KT8mNWHAulnpMhbCwAwi+eQnsJ7DIzzZoqYGVN+kuJEecBZf0JGSUCNPNMb+/0 FGhnatQikjpwWAqLPU6n1TJU7GtfjbclTa3Cy3hv95CjnxSONbTc96f3DxOoI4Mff8 hzaJ20fWKHLqw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 04/29] perf zstd: Fix compression error path in zstd_compress_stream_to_records() Date: Tue, 26 May 2026 18:17:40 -0300 Message-ID: <20260526211806.1193848-5-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo The error fallback does memcpy(dst, src, src_size) intending to store uncompressed data when compression fails, but this has three bugs: 1. dst has been advanced past the record header (and potentially past earlier compressed records), so the copy writes to the wrong offset in the output buffer. 2. src still points to the start of the input, not to the remaining uncompressed data at src + input.pos. On a second or later iteration, previously compressed data would be duplicated. 3. No check that dst_size >=3D src_size =E2=80=94 if the remaining output space is smaller, this is an out-of-bounds write. Replace with return -1 after resetting the ZSTD compression context via ZSTD_initCStream(). The -1 propagates through zstd_compress() -> record__pushfn() -> perf_mmap__push() to the recording loop, which breaks out and terminates recording. Add an out_child_no_flush label in __cmd_record() so the mmap-read failure path skips the final record__mmap_read_all() flush =E2=80=94 retrying the same read that just failed would just fail again, and the flush is only useful when the mmap data is intact but the control path (auxtrace, switch_output) had an error. Consolidate all error paths through a single 'reset' label to ensure the compression context is always reset on failure =E2=80=94 including the output-buffer-full path, where a bare return without resetting would leave stale stream state that corrupts output if the caller retries. Also guard against process_header() writing the event header before the buffer-full check: add a sizeof(perf_event_header) pre-check so the callback never writes past the output buffer. Guard against ZSTD making no progress: if output.pos is zero after ZSTD_compressStream(), calling process_header(record, 0) would re-trigger header initialization, double-subtracting the header size from dst_size and underflowing the unsigned counter. Also fix two pre-existing issues in the same function: - Add a dst_size guard before subtracting the record header size: if the output buffer is nearly full, the unsigned dst_size -=3D size underflows to a huge value, causing ZSTD_compressStream to write past the buffer boundary. - Check the ZSTD_initCStream() return value and log an error if the context reset itself fails. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/builtin-record.c | 6 +++++- tools/perf/util/zstd.c | 27 +++++++++++++++++++++++++-- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c index cc601796b2c8ae60..f1877bac815d76b2 100644 --- a/tools/perf/builtin-record.c +++ b/tools/perf/builtin-record.c @@ -2743,7 +2743,7 @@ static int __cmd_record(struct record *rec, int argc,= const char **argv) trigger_error(&auxtrace_snapshot_trigger); trigger_error(&switch_output_trigger); err =3D -1; - goto out_child; + goto out_child_no_flush; } =20 if (auxtrace_record__snapshot_started) { @@ -2890,6 +2890,10 @@ static int __cmd_record(struct record *rec, int argc= , const char **argv) out_child: record__stop_threads(rec); record__mmap_read_all(rec, true); + goto out_free_threads; +out_child_no_flush: + /* mmap read already failed =E2=80=94 retrying would just fail again */ + record__stop_threads(rec); out_free_threads: record__free_thread_data(rec); evlist__finalize_ctlfd(rec->evlist); diff --git a/tools/perf/util/zstd.c b/tools/perf/util/zstd.c index 57027e0ac7b658a8..ecda9deb53b738fa 100644 --- a/tools/perf/util/zstd.c +++ b/tools/perf/util/zstd.c @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 =20 #include +#include =20 #include "util/compress.h" #include "util/debug.h" @@ -54,7 +55,13 @@ ssize_t zstd_compress_stream_to_records(struct zstd_data= *data, void *dst, size_ =20 while (input.pos < input.size) { record =3D dst; + /* process_header writes the event header into record */ + if (dst_size < sizeof(struct perf_event_header)) + goto reset; size =3D process_header(record, 0); + /* Output buffer full =E2=80=94 cannot fit even the record header */ + if (size > dst_size) + goto reset; compressed +=3D size; dst +=3D size; dst_size -=3D size; @@ -65,10 +72,18 @@ ssize_t zstd_compress_stream_to_records(struct zstd_dat= a *data, void *dst, size_ if (ZSTD_isError(ret)) { pr_err("failed to compress %ld bytes: %s\n", (long)src_size, ZSTD_getErrorName(ret)); - memcpy(dst, src, src_size); - return src_size; + goto reset; } size =3D output.pos; + /* + * No progress: ZSTD couldn't emit any bytes into the + * remaining output buffer. Calling process_header + * with size=3D0 would re-trigger header initialization, + * double-subtracting the header size from dst_size and + * underflowing the unsigned counter. + */ + if (size =3D=3D 0) + goto reset; size =3D process_header(record, size); compressed +=3D size; dst +=3D size; @@ -76,6 +91,14 @@ ssize_t zstd_compress_stream_to_records(struct zstd_data= *data, void *dst, size_ } =20 return compressed; + +reset: + /* Reset so the context is usable if the caller retries */ + ret =3D ZSTD_initCStream(data->cstream, data->comp_level); + if (ZSTD_isError(ret)) + pr_err("failed to reset compression context: %s\n", + ZSTD_getErrorName(ret)); + return -1; } =20 size_t zstd_decompress_stream(struct zstd_data *data, void *src, size_t sr= c_size, --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 544C43C09EB; Tue, 26 May 2026 21:18:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830315; cv=none; b=SEe/13X9nNdwOgqKA19EsNnDfocjyKeepHKfIwl0DF8SHYdG4KIn3wmfAj5JMuiIfI1aKDBZy+COtKFAB+6h5w9ojo6bWXS7kXfRZxvYzoNve8KeFvwkgCM5owg/KkMFoxpKM546xN5XSIdA8MdGe09El3kOvda7AiAYTd+J5Ac= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830315; c=relaxed/simple; bh=t4MWiZOVnbvgN1FLY3y20WYpEcIeoyhE5ptaJr2ZZp4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=EMTci3EkuVBsvnB9XOexUZvoHQVT+uXKbxx0CR4ReHVOJAQrnmK4SzW+63hnKkpiBzb1FpX7pP91vHWRznS9aBU+5stSLY7gRZwlXF9UD9cjdkPsnh0PkQqOXkSfyAgzbqrtIXnK8QG53SQv0yqv1kn+NUCTBM2KFx2ww+iUhNE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=lsjk8Z/5; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lsjk8Z/5" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 66ABA1F000E9; Tue, 26 May 2026 21:18:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830314; bh=J8t0BS/K7fNTh75SuO9HWTTq8JhLusrqBgf02oogCjw=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=lsjk8Z/5iKv03b5ZmB4yRHbhxxEa0WwYDqpYnQTelAX1S7NeImR0IzLBEdahcUHA1 AgFpGakCo9lU5OXE69Gn1C4WJqKg819qhANpgr/aga248Ynlc37p3b4HTcQD1Gj8a4 bylogTnGgri3OUktPPTlQlq5ZZ7t+jq2wxuQM/gypxmlsn9TuZzsH71AuJ1j7sLjz4 60Jq9yTFoklYmiGguHt8h42WAQDvMZ24sZurXr5Iab+Trn+BYV45hKCl5jCy2dPf5z 2UbAXqlO79e2yIHIFBQcL7VFTbkbg3J1ByMnR93f1QhDGDPQR2Jh+dPakBGeVeV2E2 9gJ5DOYZMyUYA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 05/29] perf zstd: Fix multi-iteration decompression and error handling Date: Tue, 26 May 2026 18:17:41 -0300 Message-ID: <20260526211806.1193848-6-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo zstd_decompress_stream() has two bugs in its multi-iteration loop: 1. After each ZSTD_decompressStream() call, the code advances output.dst by output.pos but doesn't reset output.pos to 0. ZSTD interprets output.pos relative to output.dst, so the next iteration writes at (dst + pos) + pos =3D dst + 2*pos, skipping a gap and potentially writing out of bounds. 2. On ZSTD_decompressStream() error, the loop executes break and returns output.pos (which is > 0 if some bytes were decompressed before the error). The caller checks !decomp_size and skips the error, silently accepting truncated or corrupted data. Fix both by removing the output buffer adjustment =E2=80=94 ZSTD correctly accumulates output.pos across calls without it. Return 0 on decompression error so the caller detects it. Add a no-progress guard to prevent infinite loops if the output buffer fills before all input is consumed. Note: the compressed event data_size is validated against header.size by a subsequent patch in this series ("perf tools: Harden compressed event processing"). Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/zstd.c | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/tools/perf/util/zstd.c b/tools/perf/util/zstd.c index ecda9deb53b738fa..21a0eb58597c21f9 100644 --- a/tools/perf/util/zstd.c +++ b/tools/perf/util/zstd.c @@ -123,14 +123,26 @@ size_t zstd_decompress_stream(struct zstd_data *data,= void *src, size_t src_size } } while (input.pos < input.size) { + size_t prev_in =3D input.pos; + size_t prev_out =3D output.pos; + ret =3D ZSTD_decompressStream(data->dstream, &output, &input); if (ZSTD_isError(ret)) { pr_err("failed to decompress (B): %zd -> %zd, dst_size %zd : %s\n", - src_size, output.size, dst_size, ZSTD_getErrorName(ret)); - break; + src_size, output.pos, dst_size, ZSTD_getErrorName(ret)); + return 0; } - output.dst =3D dst + output.pos; - output.size =3D dst_size - output.pos; + /* + * Neither stream advanced =E2=80=94 decompression is stuck. + * Return 0 (error) rather than partial output: perf + * uses ZSTD_flushStream (not ZSTD_endStream), so the + * stream is continuous across compressed events. + * Discarding unconsumed input would desynchronize the + * decompressor, causing the next call to produce + * garbage that could be misinterpreted as valid events. + */ + if (input.pos =3D=3D prev_in && output.pos =3D=3D prev_out) + return 0; } =20 return output.pos; --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 758AA3ABD83; Tue, 26 May 2026 21:18:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830318; cv=none; b=SK4pSddpl2PgGd3oCrl6xzWCow6KdVKhoJC2W7GK2rg2jzqkCddqgZCv7JOIAinrmViIdZ9ZwIsE6vXyynxDZ1/Y1eSdIVSmbBeSOONNsyexOLHwig0sBnSvB1MuE2pO6OYt6PBhvKbeedCisNcm8Vrn4ce9isG8wASMtwmewgw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830318; c=relaxed/simple; bh=1icRCEUVUbNpEULRDqf7Od1F6V14idhuhW/lrdRGItg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=L9xqxYRegtP6PUgndTm4mMrYN2lxDhab78iijbRMIj+V0F8RVFrXE+Ol0ZrkjS/hrFnJRfhtZdX61fLkomknk91Y9Sirn56rcLARg4K/RSMG6bx36SEy1Rsyb2L4V1tbVTtcAd8FlWnwQxMgspjEjCrQxDllRDmfLah3NKXKghM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=XwqHsIn2; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="XwqHsIn2" Received: by smtp.kernel.org (Postfix) with ESMTPSA id AB1B51F00A3A; Tue, 26 May 2026 21:18:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830317; bh=5DHJa/rQqcvUROnaKpJ3Zcfqv/577LXlWJV3fLKo5RY=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=XwqHsIn2XCAb362MWQv0zuGr7krma9bA0FZqdrpARzmpTzcQdHTGEXvlYIPTZ09V5 XQ+/dJXbMcUTJGbvKmuUXUlkZzNWKUSgl5nzu5cI3LALY+eva8sVvY8dg7g8rFZk4o XplFTrVxPtpaHX3IMKMptYgai2q4AJMVQHMzFQ346c7DO29XQd8h37aDtDfoc6F86l lENqHORZFqZ8wxULmuy7XnvGcHn4svkkR/D6PsgNEn4aS0R2Pp93r3jhk9fyuL4DU9 GK5aTUZf5NE9YM0HTr9CT3meWZ4XWIv/SQ9eE8NMSYYONr4N6HjVUi2H2WFy1l2Mjh sej171TvtzBrw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , "Claude Opus 4.6 (1M context)" Subject: [PATCH 06/29] perf session: Fix PERF_RECORD_READ swap and dump for variable-length events Date: Tue, 26 May 2026 18:17:42 -0300 Message-ID: <20260526211806.1193848-7-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo The kernel dynamically sizes PERF_RECORD_READ based on attr.read_format: only the fields enabled by PERF_FORMAT_TOTAL_TIME_ENABLED, PERF_FORMAT_TOTAL_TIME_RUNNING, PERF_FORMAT_ID, and PERF_FORMAT_LOST are emitted, packed with no gaps. perf_event__read_swap() unconditionally byte-swapped time_enabled, time_running, and id at their fixed struct offsets, causing out-of-bounds access on smaller events and swapping the wrong bytes when not all format fields are present. It also swapped sample_id_all at a fixed offset past the full struct, which is wrong for shorter events. Replace the individual field swaps with a single mem_bswap_64() over the entire tail from value onward. Since every field after pid/tid is u64 regardless of which combination is present, this correctly handles any read_format combination and any trailing sample_id_all fields. Similarly, dump_read() accessed optional fields via fixed struct offsets, displaying values from wrong positions when not all format bits are set. Walk the packed u64 array sequentially instead, with bounds checks against event->header.size. Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 61 ++++++++++++++++++++++++++++----------- 1 file changed, 44 insertions(+), 17 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index c4cd8ad6d810a74c..24f2ba599b8079bd 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -354,17 +354,24 @@ static void perf_event__task_swap(union perf_event *e= vent, bool sample_id_all) swap_sample_id_all(event, &event->fork + 1); } =20 -static void perf_event__read_swap(union perf_event *event, bool sample_id_= all) +static void perf_event__read_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { + size_t tail; + event->read.pid =3D bswap_32(event->read.pid); event->read.tid =3D bswap_32(event->read.tid); - event->read.value =3D bswap_64(event->read.value); - event->read.time_enabled =3D bswap_64(event->read.time_enabled); - event->read.time_running =3D bswap_64(event->read.time_running); - event->read.id =3D bswap_64(event->read.id); - - if (sample_id_all) - swap_sample_id_all(event, &event->read + 1); + /* + * Everything after pid/tid is u64: the read values (variable + * set determined by attr.read_format, which we don't have + * here) optionally followed by sample_id_all fields. + * Since all are u64, swap the entire remaining tail at once. + */ + tail =3D event->header.size - offsetof(struct perf_record_read, value); + /* mem_bswap_64 rounds up to 8-byte chunks =E2=80=94 unaligned tail overr= uns the buffer */ + if (tail % sizeof(u64)) + return; + mem_bswap_64(&event->read.value, tail); } =20 static void perf_event__aux_swap(union perf_event *event, bool sample_id_a= ll) @@ -1200,8 +1207,9 @@ static void dump_deferred_callchain(union perf_event = *event, struct perf_sample =20 static void dump_read(struct evsel *evsel, union perf_event *event) { - struct perf_record_read *read_event =3D &event->read; u64 read_format; + __u64 *array; + void *end; =20 if (!dump_trace) return; @@ -1213,18 +1221,37 @@ static void dump_read(struct evsel *evsel, union pe= rf_event *event) return; =20 read_format =3D evsel->core.attr.read_format; + /* + * The kernel packs only the enabled read_format fields + * after value, with no gaps. Walk the packed array + * instead of using fixed struct offsets. + */ + array =3D &event->read.value + 1; + end =3D (void *)event + event->header.size; =20 - if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) - printf("... time enabled : %" PRI_lu64 "\n", read_event->time_enabled); + if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) { + if ((void *)(array + 1) > end) + return; + printf("... time enabled : %" PRI_lu64 "\n", *array++); + } =20 - if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) - printf("... time running : %" PRI_lu64 "\n", read_event->time_running); + if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) { + if ((void *)(array + 1) > end) + return; + printf("... time running : %" PRI_lu64 "\n", *array++); + } =20 - if (read_format & PERF_FORMAT_ID) - printf("... id : %" PRI_lu64 "\n", read_event->id); + if (read_format & PERF_FORMAT_ID) { + if ((void *)(array + 1) > end) + return; + printf("... id : %" PRI_lu64 "\n", *array++); + } =20 - if (read_format & PERF_FORMAT_LOST) - printf("... lost : %" PRI_lu64 "\n", read_event->lost); + if (read_format & PERF_FORMAT_LOST) { + if ((void *)(array + 1) > end) + return; + printf("... lost : %" PRI_lu64 "\n", *array++); + } } =20 static struct machine *machines__find_for_cpumode(struct machines *machine= s, --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 064AD33F5B2; Tue, 26 May 2026 21:18:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830322; cv=none; b=oBAgfDZtmLtsfxnFny42irP6lTiS7yPxT85A1vSZ4wq4Dd5mfHyn/aaqUh+JFwYo2JuYdczVfpLgUtT+sP2oSd/rIDAUA23zc32WciGlkTfsPp65Nql+CBVpBPY+XfAXrZ8ZvaJUql0xnAF1fVhAlIH/JKoa66icy87UqBw+lp4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830322; c=relaxed/simple; bh=R3GbXHEydvHpCdmv3PE0mn3L5K8/Se/AEjcjuDAAn48=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=fL9lISy3pIXXeAyTHcs+R74b4mJzooUgS4dHVN8+mgbSzCU2gauzaN6E/g4uYU/Vu68G6F2AaI/zxPzoFWK6eJDJOWuJ3+198jQJkXAVXOWGOcNXWEw6rN956+I94DSu+i8zEEORXXGeD835869UH5tTmtYvH2rf9BDjrXgn24k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=PxHV37k8; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="PxHV37k8" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C38A51F00A3C; Tue, 26 May 2026 21:18:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830320; bh=YOgRclGyuH2hdXdLF1L0y2oloV3n3kTQAJZ/D0fqwIU=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=PxHV37k8YK8P/yC+2MPPMup5Jy2y5gKv7m6Zdhk4QvWd/LB/UWb4d8oXicihX4jsw nabPo3OSoxstq+NafukekAuwMtXt2zbhOfw2QV+VO1AmAx4U1/ick6LjUoAfOxZuxH QOolzq75xH3NMeOhk+7weewyLhr10Kyaua/RKWXrLXKQ9+oYL9BCk11TjWwcY6YmKz /tKi9TZrFwc8J5yvzWbfrE2FPD+6ZFYEc4052kN9e4xxLwAc4LlAg4qjoz3ngSEvt3 w9XQwsqIFqUbE2988jIBrWbIQtBvGEZM0i5Y6g8eDjqbqmo8zpg+Ex+C+2D55JQrHV qKDFShE91dCvg== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 07/29] perf session: Fix swap_sample_id_all() crash on crafted events Date: Tue, 26 May 2026 18:17:43 -0300 Message-ID: <20260526211806.1193848-8-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Arnaldo Carvalho de Melo swap_sample_id_all() calls BUG_ON(size % sizeof(u64)) which kills perf on any event where the sample_id_all tail is not 8-byte aligned. A crafted perf.data can trigger this trivially. Replace BUG_ON with a bounds check: skip the swap if the data pointer is past the end of the event, and only swap when there are bytes remaining. Note: the strlen calls in string-field swap handlers (comm, mmap, mmap2, cgroup) are replaced with bounded strnlen by the next patch in this series ("perf session: Add validated swap infrastructure with null-termination checks"). Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 24f2ba599b8079bd..37544a3574185bac 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -276,10 +276,18 @@ void perf_session__delete(struct perf_session *sessio= n) static void swap_sample_id_all(union perf_event *event, void *data) { void *end =3D (void *) event + event->header.size; - int size =3D end - data; + int size; =20 - BUG_ON(size % sizeof(u64)); - mem_bswap_64(data, size); + if (data >=3D end) + return; + + size =3D end - data; + if (size % sizeof(u64)) { + pr_warning("swap_sample_id_all: unaligned sample_id_all remainder (%d), = skipping swap\n", size); + return; + } + if (size > 0) + mem_bswap_64(data, size); } =20 static void perf_event__all64_swap(union perf_event *event, --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B45973C140D; Tue, 26 May 2026 21:18:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830327; cv=none; b=fxBOZg11s1AmJT45zui6rXtyOGHXDbnidZKMjhrHul0JXUPMmyJ36dQnb8xYdbyA0AIEHToRUWt0PZrobQvZCc0uMfav6taM1B8rGkP7UoBBAX0kzpqOabNvdPZQ4/1KEgamhCgrcEt1yc7LZmScMrOp7EqgYgRcClVdbdtbEgk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830327; c=relaxed/simple; bh=vse9qxy5SJdi7oWEjHAeods/avY1xi31a/3EXKPvVZI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=MQ6XerD9m+dUfKsTH7o2OuoMMeLbw+iWL1udUShKNty3rO1ZZPpugc5KKOEI7jcDORxSYQs1nQCyHSfGvctzjFivukKrpJI/aDkiR8mvyOIsdItcv5rWxYKWMV9YzvjWLJ842J01wgOp0u3EN9pU6TvlE5lfWY/xF2BRsjV5x1o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CihB0J8b; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="CihB0J8b" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 12D471F000E9; Tue, 26 May 2026 21:18:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830324; bh=++DQ7sYC0/zoxabRI+obKnVFFjKWy8TOLa2o8qs52Ts=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=CihB0J8bqahOWHcjAg3/PXK9DpR6QemKRTPMpEKshuYzTbt7JKxra0RvnXolreb4R NmslPGQ5/uM1yYHXtbPvGJ88S8Novc5LUaFwdmDmPUsUjtGoWMH8TE/3kghr6J5ng+ eYGmf8BF2ZirWczB5oYghRd+tor0r8gi/DUGJ2KFl2C4/S/hIwBRPvevMW9jZ6I4bV 1yvzCPgkp5AmxPUJUDoKeff0gUVbKP909hhmh/dFSEX0OlRbrEzGwjkaZ39fzNf1S9 EBVhVpmhifvQOkeLZGN95AbuuxDn38psX8ePbsPsfR2qaK2sfpjjS4hDNJ4Q2toFov GDkHBsGHyiFxQ== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, David Carrillo-Cisneros , Song Liu , "Claude Opus 4.6 (1M context)" Subject: [PATCH 08/29] perf session: Add validated swap infrastructure with null-termination checks Date: Tue, 26 May 2026 18:17:44 -0300 Message-ID: <20260526211806.1193848-9-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Change swap callbacks from void to int return so handlers can propagate errors. All 28 existing handlers are converted to return 0 on success, -1 on error. Three new handlers (KSYMBOL, BPF_EVENT, HEADER_FEATURE) are added returning int from the start, with sample_id_all handling for the kernel event types. event_swap() propagates the return to its callers (process_event and peek_event), which skip events that fail to swap. Add perf_event__check_nul() for null-termination enforcement on the common event delivery path for MMAP, MMAP2, COMM, CGROUP, and KSYMBOL events. Events with unterminated strings are skipped =E2=80=94 native-endian files are mapped read-only, so writing a NUL byte in place would segfault. Swap handler hardening: - Use strnlen bounded by event size (instead of strlen) in COMM/MMAP/MMAP2/CGROUP swap handlers, returning -1 on unterminated strings. - Bounds check text_poke old_len+new_len before computing the sample_id offset, returning -1 on overflow. Use offsetof() for the native-path check in machines__deliver_event() since sizeof() includes struct padding past the flexible array. - Fix PERF_RECORD_SWITCH sample_id_all: non-CPU_WIDE SWITCH events have sample_id immediately after the 8-byte header, not at sizeof(struct perf_record_switch) which is the CPU_WIDE variant size. - Fix perf_event__time_conv_swap(): decouple time_cycles and time_mask into independent per-field event_contains() checks, so each field is only swapped when the event is large enough to contain it. The original code guarded both fields under a single time_cycles check, which would swap time_mask on a short event that contains time_cycles but not time_mask. - Handle ABI0 (attr.size =3D=3D 0) in perf_event__attr_swap() by substituting PERF_ATTR_SIZE_VER0, so bswap_safe() correctly swaps VER0 fields instead of skipping everything. - peek_events: on swap failure, advance past the malformed entry instead of aborting the loop. Note: the nr-field bounds checks for namespaces, thread_map, cpu_map, and stat_config arrays are added by a subsequent patch ("perf session: Validate nr fields against event size on both swap and common paths"). The HEADER_ATTR attr.size validation is added by ("perf session: Validate HEADER_ATTR attr.size before swapping"). By establishing the int-returning swap infrastructure first, all subsequent hardening patches can use direct error returns from day one =E2=80=94 no poison values, no workarounds for void return. Changes in v2: - peek_events: abort instead of skip for AUXTRACE events on validation failure =E2=80=94 skipping only header.size would land inside the raw trace payload, causing subsequent iterations to misparse data as events (Reported-by: sashiko-bot@kernel.org) Fixes: 9aa0bfa370b2 ("perf tools: Handle PERF_RECORD_KSYMBOL") Fixes: 45178a928a4b ("perf tools: Handle PERF_RECORD_BPF_EVENT") Fixes: e9def1b2e74e ("perf tools: Add feature header record to pipe-mode") Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: David Carrillo-Cisneros Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Cc: Song Liu Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 406 ++++++++++++++++++++++++++++++-------- 1 file changed, 325 insertions(+), 81 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 37544a3574185bac..d5864e380c1bd52e 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -290,28 +290,44 @@ static void swap_sample_id_all(union perf_event *even= t, void *data) mem_bswap_64(data, size); } =20 -static void perf_event__all64_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__all64_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { struct perf_event_header *hdr =3D &event->header; - mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr)); + size_t size =3D event->header.size - sizeof(*hdr); + + /* mem_bswap_64 rounds up to 8-byte chunks =E2=80=94 unaligned size overr= uns the buffer */ + if (size % sizeof(u64)) + return -1; + mem_bswap_64(hdr + 1, size); + return 0; } =20 -static void perf_event__comm_swap(union perf_event *event, bool sample_id_= all) +static int perf_event__comm_swap(union perf_event *event, bool sample_id_a= ll) { event->comm.pid =3D bswap_32(event->comm.pid); event->comm.tid =3D bswap_32(event->comm.tid); =20 if (sample_id_all) { void *data =3D &event->comm.comm; + void *end =3D (void *)event + event->header.size; + size_t len =3D strnlen(data, end - data); =20 - data +=3D PERF_ALIGN(strlen(data) + 1, sizeof(u64)); + /* + * No NUL within the event boundary =E2=80=94 can't locate where + * sample_id_all starts. Reject so the event is skipped + * rather than swapping garbage. + */ + if (len =3D=3D (size_t)(end - data)) + return -1; + data +=3D PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } + return 0; } =20 -static void perf_event__mmap_swap(union perf_event *event, - bool sample_id_all) +static int perf_event__mmap_swap(union perf_event *event, + bool sample_id_all) { event->mmap.pid =3D bswap_32(event->mmap.pid); event->mmap.tid =3D bswap_32(event->mmap.tid); @@ -321,13 +337,19 @@ static void perf_event__mmap_swap(union perf_event *e= vent, =20 if (sample_id_all) { void *data =3D &event->mmap.filename; + void *end =3D (void *)event + event->header.size; + size_t len =3D strnlen(data, end - data); =20 - data +=3D PERF_ALIGN(strlen(data) + 1, sizeof(u64)); + /* See comment in perf_event__comm_swap() */ + if (len =3D=3D (size_t)(end - data)) + return -1; + data +=3D PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } + return 0; } =20 -static void perf_event__mmap2_swap(union perf_event *event, +static int perf_event__mmap2_swap(union perf_event *event, bool sample_id_all) { event->mmap2.pid =3D bswap_32(event->mmap2.pid); @@ -345,12 +367,19 @@ static void perf_event__mmap2_swap(union perf_event *= event, =20 if (sample_id_all) { void *data =3D &event->mmap2.filename; + void *end =3D (void *)event + event->header.size; + size_t len =3D strnlen(data, end - data); =20 - data +=3D PERF_ALIGN(strlen(data) + 1, sizeof(u64)); + /* See comment in perf_event__comm_swap() */ + if (len =3D=3D (size_t)(end - data)) + return -1; + data +=3D PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } + return 0; } -static void perf_event__task_swap(union perf_event *event, bool sample_id_= all) + +static int perf_event__task_swap(union perf_event *event, bool sample_id_a= ll) { event->fork.pid =3D bswap_32(event->fork.pid); event->fork.tid =3D bswap_32(event->fork.tid); @@ -360,10 +389,11 @@ static void perf_event__task_swap(union perf_event *e= vent, bool sample_id_all) =20 if (sample_id_all) swap_sample_id_all(event, &event->fork + 1); + return 0; } =20 -static void perf_event__read_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__read_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { size_t tail; =20 @@ -378,11 +408,12 @@ static void perf_event__read_swap(union perf_event *e= vent, tail =3D event->header.size - offsetof(struct perf_record_read, value); /* mem_bswap_64 rounds up to 8-byte chunks =E2=80=94 unaligned tail overr= uns the buffer */ if (tail % sizeof(u64)) - return; + return -1; mem_bswap_64(&event->read.value, tail); + return 0; } =20 -static void perf_event__aux_swap(union perf_event *event, bool sample_id_a= ll) +static int perf_event__aux_swap(union perf_event *event, bool sample_id_al= l) { event->aux.aux_offset =3D bswap_64(event->aux.aux_offset); event->aux.aux_size =3D bswap_64(event->aux.aux_size); @@ -390,19 +421,21 @@ static void perf_event__aux_swap(union perf_event *ev= ent, bool sample_id_all) =20 if (sample_id_all) swap_sample_id_all(event, &event->aux + 1); + return 0; } =20 -static void perf_event__itrace_start_swap(union perf_event *event, - bool sample_id_all) +static int perf_event__itrace_start_swap(union perf_event *event, + bool sample_id_all) { event->itrace_start.pid =3D bswap_32(event->itrace_start.pid); event->itrace_start.tid =3D bswap_32(event->itrace_start.tid); =20 if (sample_id_all) swap_sample_id_all(event, &event->itrace_start + 1); + return 0; } =20 -static void perf_event__switch_swap(union perf_event *event, bool sample_i= d_all) +static int perf_event__switch_swap(union perf_event *event, bool sample_id= _all) { if (event->header.type =3D=3D PERF_RECORD_SWITCH_CPU_WIDE) { event->context_switch.next_prev_pid =3D @@ -411,30 +444,45 @@ static void perf_event__switch_swap(union perf_event = *event, bool sample_id_all) bswap_32(event->context_switch.next_prev_tid); } =20 - if (sample_id_all) - swap_sample_id_all(event, &event->context_switch + 1); + if (sample_id_all) { + /* + * PERF_RECORD_SWITCH has no fields beyond the header; + * SWITCH_CPU_WIDE adds pid/tid. Use the right offset + * so sample_id starts at the correct position. + */ + if (event->header.type =3D=3D PERF_RECORD_SWITCH) + swap_sample_id_all(event, (void *)event + sizeof(event->header)); + else + swap_sample_id_all(event, &event->context_switch + 1); + } + return 0; } =20 -static void perf_event__text_poke_swap(union perf_event *event, bool sampl= e_id_all) +static int perf_event__text_poke_swap(union perf_event *event, bool sample= _id_all) { event->text_poke.addr =3D bswap_64(event->text_poke.addr); event->text_poke.old_len =3D bswap_16(event->text_poke.old_len); event->text_poke.new_len =3D bswap_16(event->text_poke.new_len); =20 if (sample_id_all) { + void *data =3D &event->text_poke.old_len; + void *end =3D (void *)event + event->header.size; size_t len =3D sizeof(event->text_poke.old_len) + sizeof(event->text_poke.new_len) + event->text_poke.old_len + event->text_poke.new_len; - void *data =3D &event->text_poke.old_len; =20 + /* old_len + new_len exceeds event =E2=80=94 can't find sample_id_all */ + if (data + len > end) + return -1; data +=3D PERF_ALIGN(len, sizeof(u64)); swap_sample_id_all(event, data); } + return 0; } =20 -static void perf_event__throttle_swap(union perf_event *event, - bool sample_id_all) +static int perf_event__throttle_swap(union perf_event *event, + bool sample_id_all) { event->throttle.time =3D bswap_64(event->throttle.time); event->throttle.id =3D bswap_64(event->throttle.id); @@ -442,10 +490,11 @@ static void perf_event__throttle_swap(union perf_even= t *event, =20 if (sample_id_all) swap_sample_id_all(event, &event->throttle + 1); + return 0; } =20 -static void perf_event__namespaces_swap(union perf_event *event, - bool sample_id_all) +static int perf_event__namespaces_swap(union perf_event *event, + bool sample_id_all) { u64 i; =20 @@ -462,18 +511,25 @@ static void perf_event__namespaces_swap(union perf_ev= ent *event, =20 if (sample_id_all) swap_sample_id_all(event, &event->namespaces.link_info[i]); + return 0; } =20 -static void perf_event__cgroup_swap(union perf_event *event, bool sample_i= d_all) +static int perf_event__cgroup_swap(union perf_event *event, bool sample_id= _all) { event->cgroup.id =3D bswap_64(event->cgroup.id); =20 if (sample_id_all) { void *data =3D &event->cgroup.path; + void *end =3D (void *)event + event->header.size; + size_t len =3D strnlen(data, end - data); =20 - data +=3D PERF_ALIGN(strlen(data) + 1, sizeof(u64)); + /* See comment in perf_event__comm_swap() */ + if (len =3D=3D (size_t)(end - data)) + return -1; + data +=3D PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } + return 0; } =20 static u8 revbyte(u8 b) @@ -514,9 +570,19 @@ void perf_event__attr_swap(struct perf_event_attr *att= r) attr->type =3D bswap_32(attr->type); attr->size =3D bswap_32(attr->size); =20 -#define bswap_safe(f, n) \ - (attr->size > (offsetof(struct perf_event_attr, f) + \ - sizeof(attr->f) * (n))) + /* + * ABI0: size =3D=3D 0 means the producer didn't set it. + * Assume PERF_ATTR_SIZE_VER0 so bswap_safe() below + * correctly swaps the VER0 fields instead of skipping + * everything. Same convention as read_attr(). + */ + if (!attr->size) + attr->size =3D PERF_ATTR_SIZE_VER0; + +/* Verify the full field extent fits, not just its start offset */ +#define bswap_safe(f, n) \ + (attr->size >=3D (offsetof(struct perf_event_attr, f) + \ + sizeof(attr->f) * ((n) + 1))) #define bswap_field(f, sz) \ do { \ if (bswap_safe(f, 0)) \ @@ -554,8 +620,8 @@ do { \ #undef bswap_safe } =20 -static void perf_event__hdr_attr_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__hdr_attr_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { size_t size; =20 @@ -564,30 +630,34 @@ static void perf_event__hdr_attr_swap(union perf_even= t *event, size =3D event->header.size; size -=3D perf_record_header_attr_id(event) - (void *)event; mem_bswap_64(perf_record_header_attr_id(event), size); + return 0; } =20 -static void perf_event__event_update_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__event_update_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->event_update.type =3D bswap_64(event->event_update.type); event->event_update.id =3D bswap_64(event->event_update.id); + return 0; } =20 -static void perf_event__event_type_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__event_type_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->event_type.event_type.event_id =3D bswap_64(event->event_type.event_type.event_id); + return 0; } =20 -static void perf_event__tracing_data_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__tracing_data_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->tracing_data.size =3D bswap_32(event->tracing_data.size); + return 0; } =20 -static void perf_event__auxtrace_info_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__auxtrace_info_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { size_t size; =20 @@ -596,10 +666,11 @@ static void perf_event__auxtrace_info_swap(union perf= _event *event, size =3D event->header.size; size -=3D (void *)&event->auxtrace_info.priv - (void *)event; mem_bswap_64(event->auxtrace_info.priv, size); + return 0; } =20 -static void perf_event__auxtrace_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__auxtrace_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->auxtrace.size =3D bswap_64(event->auxtrace.size); event->auxtrace.offset =3D bswap_64(event->auxtrace.offset); @@ -607,10 +678,11 @@ static void perf_event__auxtrace_swap(union perf_even= t *event, event->auxtrace.idx =3D bswap_32(event->auxtrace.idx); event->auxtrace.tid =3D bswap_32(event->auxtrace.tid); event->auxtrace.cpu =3D bswap_32(event->auxtrace.cpu); + return 0; } =20 -static void perf_event__auxtrace_error_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__auxtrace_error_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->auxtrace_error.type =3D bswap_32(event->auxtrace_error.type); event->auxtrace_error.code =3D bswap_32(event->auxtrace_error.code); @@ -625,10 +697,11 @@ static void perf_event__auxtrace_error_swap(union per= f_event *event, event->auxtrace_error.machine_pid =3D bswap_32(event->auxtrace_error.mac= hine_pid); event->auxtrace_error.vcpu =3D bswap_32(event->auxtrace_error.vcpu); } + return 0; } =20 -static void perf_event__thread_map_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__thread_map_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { unsigned i; =20 @@ -636,10 +709,11 @@ static void perf_event__thread_map_swap(union perf_ev= ent *event, =20 for (i =3D 0; i < event->thread_map.nr; i++) event->thread_map.entries[i].pid =3D bswap_64(event->thread_map.entries[= i].pid); + return 0; } =20 -static void perf_event__cpu_map_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__cpu_map_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { struct perf_record_cpu_map_data *data =3D &event->cpu_map.data; =20 @@ -677,20 +751,22 @@ static void perf_event__cpu_map_swap(union perf_event= *event, default: break; } + return 0; } =20 -static void perf_event__stat_config_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__stat_config_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { u64 size; =20 size =3D bswap_64(event->stat_config.nr) * sizeof(event->stat_config.dat= a[0]); size +=3D 1; /* nr item itself */ mem_bswap_64(&event->stat_config.nr, size); + return 0; } =20 -static void perf_event__stat_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__stat_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->stat.id =3D bswap_64(event->stat.id); event->stat.thread =3D bswap_32(event->stat.thread); @@ -698,44 +774,90 @@ static void perf_event__stat_swap(union perf_event *e= vent, event->stat.val =3D bswap_64(event->stat.val); event->stat.ena =3D bswap_64(event->stat.ena); event->stat.run =3D bswap_64(event->stat.run); + return 0; } =20 -static void perf_event__stat_round_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__stat_round_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->stat_round.type =3D bswap_64(event->stat_round.type); event->stat_round.time =3D bswap_64(event->stat_round.time); + return 0; } =20 -static void perf_event__time_conv_swap(union perf_event *event, - bool sample_id_all __maybe_unused) +static int perf_event__time_conv_swap(union perf_event *event, + bool sample_id_all __maybe_unused) { event->time_conv.time_shift =3D bswap_64(event->time_conv.time_shift); event->time_conv.time_mult =3D bswap_64(event->time_conv.time_mult); event->time_conv.time_zero =3D bswap_64(event->time_conv.time_zero); =20 - if (event_contains(event->time_conv, time_cycles)) { + if (event_contains(event->time_conv, time_cycles)) event->time_conv.time_cycles =3D bswap_64(event->time_conv.time_cycles); + if (event_contains(event->time_conv, time_mask)) event->time_conv.time_mask =3D bswap_64(event->time_conv.time_mask); - } + return 0; } =20 -static void +static int perf_event__schedstat_cpu_swap(union perf_event *event __maybe_unused, bool sample_id_all __maybe_unused) { /* FIXME */ + return 0; } =20 -static void +static int perf_event__schedstat_domain_swap(union perf_event *event __maybe_unused, bool sample_id_all __maybe_unused) { /* FIXME */ + return 0; +} + +static int perf_event__ksymbol_swap(union perf_event *event, + bool sample_id_all) +{ + event->ksymbol.addr =3D bswap_64(event->ksymbol.addr); + event->ksymbol.len =3D bswap_32(event->ksymbol.len); + event->ksymbol.ksym_type =3D bswap_16(event->ksymbol.ksym_type); + event->ksymbol.flags =3D bswap_16(event->ksymbol.flags); + + if (sample_id_all) { + void *data =3D &event->ksymbol.name; + void *end =3D (void *)event + event->header.size; + size_t len =3D strnlen(data, end - data); + + /* See comment in perf_event__comm_swap() */ + if (len =3D=3D (size_t)(end - data)) + return -1; + data +=3D PERF_ALIGN(len + 1, sizeof(u64)); + swap_sample_id_all(event, data); + } + return 0; +} + +static int perf_event__bpf_event_swap(union perf_event *event, + bool sample_id_all) +{ + event->bpf.type =3D bswap_16(event->bpf.type); + event->bpf.flags =3D bswap_16(event->bpf.flags); + event->bpf.id =3D bswap_32(event->bpf.id); + + if (sample_id_all) + swap_sample_id_all(event, &event->bpf + 1); + return 0; } =20 -typedef void (*perf_event__swap_op)(union perf_event *event, - bool sample_id_all); +static int perf_event__header_feature_swap(union perf_event *event, + bool sample_id_all __maybe_unused) +{ + event->feat.feat_id =3D bswap_64(event->feat.feat_id); + return 0; +} + +typedef int (*perf_event__swap_op)(union perf_event *event, + bool sample_id_all); =20 static perf_event__swap_op perf_event__swap_ops[] =3D { [PERF_RECORD_MMAP] =3D perf_event__mmap_swap, @@ -755,6 +877,8 @@ static perf_event__swap_op perf_event__swap_ops[] =3D { [PERF_RECORD_SWITCH_CPU_WIDE] =3D perf_event__switch_swap, [PERF_RECORD_NAMESPACES] =3D perf_event__namespaces_swap, [PERF_RECORD_CGROUP] =3D perf_event__cgroup_swap, + [PERF_RECORD_KSYMBOL] =3D perf_event__ksymbol_swap, + [PERF_RECORD_BPF_EVENT] =3D perf_event__bpf_event_swap, [PERF_RECORD_TEXT_POKE] =3D perf_event__text_poke_swap, [PERF_RECORD_AUX_OUTPUT_HW_ID] =3D perf_event__all64_swap, [PERF_RECORD_CALLCHAIN_DEFERRED] =3D perf_event__all64_swap, @@ -762,6 +886,7 @@ static perf_event__swap_op perf_event__swap_ops[] =3D { [PERF_RECORD_HEADER_EVENT_TYPE] =3D perf_event__event_type_swap, [PERF_RECORD_HEADER_TRACING_DATA] =3D perf_event__tracing_data_swap, [PERF_RECORD_HEADER_BUILD_ID] =3D NULL, + [PERF_RECORD_HEADER_FEATURE] =3D perf_event__header_feature_swap, [PERF_RECORD_ID_INDEX] =3D perf_event__all64_swap, [PERF_RECORD_AUXTRACE_INFO] =3D perf_event__auxtrace_info_swap, [PERF_RECORD_AUXTRACE] =3D perf_event__auxtrace_swap, @@ -1488,6 +1613,25 @@ static int session__flush_deferred_samples(struct pe= rf_session *session, return ret; } =20 +/* + * Return true if the string field is properly null-terminated + * within the event boundary. Native-endian files are mapped + * read-only (MAP_SHARED + PROT_READ) so we cannot write a + * null byte in place; skip the event instead. + */ +static bool perf_event__check_nul(const char *str, const void *end, const = char *event_name) +{ + size_t max_len =3D (const char *)end - str; + + if (max_len =3D=3D 0 || strnlen(str, max_len) =3D=3D max_len) { + pr_warning("WARNING: PERF_RECORD_%s: string not null-terminated, skippin= g event\n", + event_name); + return false; + } + + return true; +} + static int machines__deliver_event(struct machines *machines, struct evlist *evlist, union perf_event *event, @@ -1536,16 +1680,32 @@ static int machines__deliver_event(struct machines = *machines, } return evlist__deliver_sample(evlist, tool, event, sample, machine); case PERF_RECORD_MMAP: + if (!perf_event__check_nul(event->mmap.filename, + (void *)event + event->header.size, + "MMAP")) + return 0; return tool->mmap(tool, event, sample, machine); case PERF_RECORD_MMAP2: if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT) ++evlist->stats.nr_proc_map_timeout; + if (!perf_event__check_nul(event->mmap2.filename, + (void *)event + event->header.size, + "MMAP2")) + return 0; return tool->mmap2(tool, event, sample, machine); case PERF_RECORD_COMM: + if (!perf_event__check_nul(event->comm.comm, + (void *)event + event->header.size, + "COMM")) + return 0; return tool->comm(tool, event, sample, machine); case PERF_RECORD_NAMESPACES: return tool->namespaces(tool, event, sample, machine); case PERF_RECORD_CGROUP: + if (!perf_event__check_nul(event->cgroup.path, + (void *)event + event->header.size, + "CGROUP")) + return 0; return tool->cgroup(tool, event, sample, machine); case PERF_RECORD_FORK: return tool->fork(tool, event, sample, machine); @@ -1584,11 +1744,25 @@ static int machines__deliver_event(struct machines = *machines, case PERF_RECORD_SWITCH_CPU_WIDE: return tool->context_switch(tool, event, sample, machine); case PERF_RECORD_KSYMBOL: + if (!perf_event__check_nul(event->ksymbol.name, + (void *)event + event->header.size, + "KSYMBOL")) + return 0; return tool->ksymbol(tool, event, sample, machine); case PERF_RECORD_BPF_EVENT: return tool->bpf(tool, event, sample, machine); - case PERF_RECORD_TEXT_POKE: + case PERF_RECORD_TEXT_POKE: { + /* offsetof(bytes), not sizeof =E2=80=94 sizeof includes padding past th= e flexible array */ + size_t text_poke_len =3D offsetof(struct perf_record_text_poke_event, by= tes) + + event->text_poke.old_len + + event->text_poke.new_len; + + if (event->header.size < text_poke_len) { + pr_warning("WARNING: PERF_RECORD_TEXT_POKE: old_len+new_len exceeds eve= nt, skipping\n"); + return 0; + } return tool->text_poke(tool, event, sample, machine); + } case PERF_RECORD_AUX_OUTPUT_HW_ID: return tool->aux_output_hw_id(tool, event, sample, machine); case PERF_RECORD_CALLCHAIN_DEFERRED: @@ -1794,12 +1968,28 @@ int perf_session__deliver_synth_attr_event(struct p= erf_session *session, return perf_session__deliver_synth_event(session, &ev.ev, NULL); } =20 +/* Caller must ensure event->header.type < PERF_RECORD_HEADER_MAX */ +static int event_swap(union perf_event *event, bool sample_id_all) +{ + perf_event__swap_op swap =3D perf_event__swap_ops[event->header.type]; + + if (swap) + return swap(event, sample_id_all); + return 0; +} + /* * Minimum event sizes indexed by type. Checked before swap and * processing so that both cross-endian and native-endian paths * are protected from accessing fields past the event boundary. * Zero means no minimum beyond the 8-byte header (already * enforced by the reader). + * + * These values represent the smallest event the kernel has ever + * emitted for each type, so they do not reject legitimate legacy + * perf.data files from older kernels. Variable-length events + * use offsetof() to the first variable field; the variable + * content is validated separately (e.g., perf_event__check_nul). */ static const u32 perf_event__min_size[PERF_RECORD_HEADER_MAX] =3D { /* @@ -1821,7 +2011,9 @@ static const u32 perf_event__min_size[PERF_RECORD_HEA= DER_MAX] =3D { [PERF_RECORD_FORK] =3D sizeof(struct perf_record_fork), /* * The kernel dynamically sizes PERF_RECORD_READ based on - * attr.read_format =E2=80=94 the minimum has just pid + tid + value. + * attr.read_format =E2=80=94 only the enabled fields are emitted, + * packed with no gaps. The minimum valid event has just + * pid + tid + one u64 value (no optional fields). */ [PERF_RECORD_READ] =3D offsetof(struct perf_record_read, time_enabled), [PERF_RECORD_MMAP2] =3D offsetof(struct perf_record_mmap2, filename) += 1, @@ -1844,14 +2036,25 @@ static const u32 perf_event__min_size[PERF_RECORD_H= EADER_MAX] =3D { [PERF_RECORD_AUXTRACE] =3D sizeof(struct perf_record_auxtrace), [PERF_RECORD_AUXTRACE_ERROR] =3D offsetof(struct perf_record_auxtrace_e= rror, msg) + 1, [PERF_RECORD_THREAD_MAP] =3D sizeof(struct perf_record_thread_map), - /* Smallest valid variant is RANGE_CPUS: header(8) + type(2) + range(6) */ + /* + * sizeof(perf_record_cpu_map) is 20 because the outer struct + * isn't packed and GCC adds 2 bytes of trailing padding. + * The smallest valid variant (RANGE_CPUS) is only 16 bytes: + * header(8) + type(2) + range_cpu_data(6). Per-variant + * bounds are checked in the swap handler via payload. + */ [PERF_RECORD_CPU_MAP] =3D sizeof(struct perf_event_header) + sizeof(__u16) + sizeof(struct perf_record_range_cpu_map), [PERF_RECORD_STAT_CONFIG] =3D sizeof(struct perf_record_stat_config), [PERF_RECORD_STAT] =3D sizeof(struct perf_record_stat), [PERF_RECORD_STAT_ROUND] =3D sizeof(struct perf_record_stat_round), - /* Union inflates sizeof; use fixed header fields as minimum */ + /* + * EVENT_UPDATE has a union whose largest member (cpus) + * inflates sizeof to 40, but SCALE events are only 32 + * and UNIT/NAME events can be even smaller. Use the + * fixed header fields (header + type + id) as minimum. + */ [PERF_RECORD_EVENT_UPDATE] =3D offsetof(struct perf_record_event_update= , scale), [PERF_RECORD_TIME_CONV] =3D offsetof(struct perf_record_time_conv, tim= e_cycles), [PERF_RECORD_ID_INDEX] =3D sizeof(struct perf_record_id_index), @@ -1887,14 +2090,6 @@ static bool perf_event__too_small(const union perf_e= vent *event, u32 *min) return false; } =20 -/* Caller must ensure event->header.type < PERF_RECORD_HEADER_MAX */ -static void event_swap(union perf_event *event, bool sample_id_all) -{ - perf_event__swap_op swap =3D perf_event__swap_ops[event->header.type]; - if (swap) - swap(event, sample_id_all); -} - /* * Read and validate the event at @file_offset. * @@ -2003,8 +2198,16 @@ int perf_session__peek_event(struct perf_session *se= ssion, off_t file_offset, return -1; } =20 - if (session->header.needs_swap) - event_swap(event, evlist__sample_id_all(session->evlist)); + if (session->header.needs_swap && + event_swap(event, evlist__sample_id_all(session->evlist))) { + /* + * The header was already swapped so header.size is + * valid =E2=80=94 expose the event so callers can advance + * past this malformed entry instead of aborting. + */ + *event_ptr =3D event; + return -1; + } =20 if (sample && event->header.type < PERF_RECORD_USER_TYPE_START && evlist__parse_sample(session->evlist, event, sample)) @@ -2022,11 +2225,37 @@ int perf_session__peek_events(struct perf_session *= session, u64 offset, int err; =20 do { + event =3D NULL; err =3D perf_session__peek_event(session, offset, buf, PERF_SAMPLE_MAX_SIZE, &event, NULL); - if (err) - return err; + if (err) { + /* + * Recoverable error: peek_event returns -1 but + * sets event_ptr when the header was read + * successfully but the event is malformed (too + * small or swap failed). Skip past it using + * header.size =E2=80=94 don't invoke the callback since + * type-specific fields may be truncated. + * + * Must abort if: event_ptr is NULL (I/O error), + * size is 0 (can't advance), type is AUXTRACE + * (payload extends beyond header.size), or size + * is unaligned (would misalign all subsequent reads). + * + * Direct callers (auxtrace, cs-etm) treat any + * non-zero return as fatal =E2=80=94 only this loop skips. + */ + if (event && event->header.size && + event->header.type !=3D PERF_RECORD_AUXTRACE && + event->header.size % sizeof(u64) =3D=3D 0) { + offset +=3D event->header.size; + err =3D 0; + } else { + return err; + } + continue; + } =20 err =3D cb(session, event, offset, data); if (err) @@ -2109,8 +2338,12 @@ static s64 perf_session__process_event(struct perf_s= ession *session, return 0; } =20 - if (session->header.needs_swap) - event_swap(event, evlist__sample_id_all(evlist)); + if (session->header.needs_swap && + event_swap(event, evlist__sample_id_all(evlist))) { + pr_warning("WARNING: swap failed for %s event, skipping\n", + perf_event__name(event->header.type)); + return 0; + } =20 events_stats__inc(&evlist->stats, event->header.type); =20 @@ -2579,6 +2812,17 @@ reader__mmap(struct reader *rd, struct perf_session = *session) char *buf, **mmaps =3D rd->mmaps; u64 page_offset; =20 + /* + * Native-endian: MAP_SHARED + PROT_READ =E2=80=94 the kernel + * guarantees page-level coherence but a concurrent writer + * could modify the file between validation and use. This + * is a theoretical TOCTOU that affects the entire perf.data + * processing pipeline; fixing it would require copying each + * event to a private buffer before processing. + * + * Cross-endian: MAP_PRIVATE + PROT_WRITE =E2=80=94 swap handlers + * get a copy-on-write snapshot immune to concurrent writes. + */ mmap_prot =3D PROT_READ; mmap_flags =3D MAP_SHARED; =20 --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 055553BADB6; Tue, 26 May 2026 21:18:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830329; cv=none; b=PvMI/dmG8SW8DLUPL8EutaEXXVH7jvaJno/Sv2HxQIh0yeF5qP2cFNGG2QBtDNtckCYQL4p1DsQZtYIS1aDkFHPWb/ZlWhRz8qMwHtm279vTxkEsUj3QtrPvhzaMAXg0FAri8/7NNvci7myi5GWCzYCXG7d5Xe1h9U2msemFvls= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830329; c=relaxed/simple; bh=SH0mYYMdGrciBpnXiSaYprMGXE4zE58WFtxSIHwLyfU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QX3rtT8gaTALZ9I/L/VlIA6E5QWdfFc40iH8LB8RX1oOa9zdTbVFnYT3id6iHUopBt/O5qTosiRpdl9Xd1yBQWpybb/TiHvni/4qRv90Rxw+FdGWelOJrsOsIgHaLkWZrqAiyTv8FD4eS3EDic9MWHI+ncxUHFw1wP+9syIbD5A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=GF6O9XSq; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="GF6O9XSq" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DACC81F00A3A; Tue, 26 May 2026 21:18:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830327; bh=hpnZa/NuRnZDfrhu8D/hsundXd+0STyIyXSz89U9iCM=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=GF6O9XSqLe9BiHUBklDvCou0MPxLM8xPSkZ/cNYlghwHYjhArAubsyb9Edvh0fRVu NC4JF98Tup0rypARVmBLA6U+lfzrRD0B7MdtQqxYb+m4JNaWrS39wryJU5XPoY1E0R hqGV1BH8Dazg4KTn1GIAToU2LjSZ5AwCmll3pVugzedNyTJ+UzSUq6+JhLruoHwyvB tXCBEBZWXGmeqsSkZLpq22CVm9oaq2EMcgZ35Uf2V0FuB4uYwdRiQzs2pgaLCo6fz7 GAGHoDnGs4vzHAEJ7bRRmKZaYfxdszDrOG/JB/z08XfcXwATiVE5j5VwumQ4oP2fOn dqUjstW9F0Ciw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 09/29] perf session: Use bounded copy for PERF_RECORD_TIME_CONV Date: Tue, 26 May 2026 18:17:45 -0300 Message-ID: <20260526211806.1193848-10-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Arnaldo Carvalho de Melo session->time_conv =3D event->time_conv copies sizeof(struct perf_record_time_conv) bytes unconditionally, but older kernels emit shorter TIME_CONV events without the time_cycles, time_mask, cap_user_time_zero, and cap_user_time_short fields. For a 32-byte event (the original format), this reads 24 bytes past the event boundary into adjacent mmap'd data. The garbage values end up in session->time_conv and can cause incorrect TSC conversion if cap_user_time_zero happens to be non-zero. Replace the struct assignment with a bounded memcpy capped at event->header.size, zeroing the remainder so extended fields default to off when absent. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index d5864e380c1bd52e..3f72b80aac56b04e 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -1897,7 +1897,14 @@ static s64 perf_session__process_user_event(struct p= erf_session *session, err =3D tool->stat_round(tool, session, event); break; case PERF_RECORD_TIME_CONV: - session->time_conv =3D event->time_conv; + /* + * Bounded copy: older kernels emit a shorter struct + * without time_cycles/time_mask/cap_user_time_*. + * Zero the rest so extended fields default to off. + */ + memset(&session->time_conv, 0, sizeof(session->time_conv)); + memcpy(&session->time_conv, &event->time_conv, + min((size_t)event->header.size, sizeof(session->time_conv))); err =3D tool->time_conv(tool, session, event); break; case PERF_RECORD_HEADER_FEATURE: --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2263E3B47FF; Tue, 26 May 2026 21:18:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830332; cv=none; b=BT5PymIbdxmqTi9ffAFpvk6pAEdFIzFwkE5uRd9utodUElfv9yhx0fdvnO+rz/DbHtFrbx9BLnpIDBNFJgQd0r3bNyYtZeX+uX+BojHxBUammFixqZ8cBWIMn1UKodoT9ve5Q23MiV8drNFYbsP4aRaHqi4SDEvce2EpIpT+FQY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830332; c=relaxed/simple; bh=eiVYkRqohCAAgwJ1x4LdrDqpvvrJJ2X8doypd8lLppQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=I8fVjWkuSc+oY8zLJKZ4YoQEz7V9Aj2MtpfZBcJ8OxAY6Qw0K49Bs/3SO1i1r2wVs3MDVl3eopM9zS6i7BY+AZkl6jYRBkpClyMDoJm1LjmWbRHw7tkPBA1q7WhGzf0b5MWTnajjmnEYg6yEklHmaY5oWsmpQlQ5dJDs6v+bEQA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=A6MJLhqg; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="A6MJLhqg" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2C2C21F000E9; Tue, 26 May 2026 21:18:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830331; bh=2zHJwBEeIA/Pf+33FPHv0njK7SPUFwC+poNQl/qO5lQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=A6MJLhqga8730WKeAm4LillYknaE8HjCmyYqPYhJWM+KHFdevGkAP/mhFdogmlBj8 CHdqC6F+vCSpAxb1EknsYlmahvMZ00o7veB3mQy43tXI6pziR23Xj/x5U/6DfGQkfx Fap9GCRgIVAyCMhhyETu2ip4Bx1Y5FL5+5Y7NI0eloYDB7rBB6L9I0k2daOdecrqGC 46vE4l4rO2qh/Ri3CsTB5SAs/PoNZkKkcE9O9nysoBNvSS4Zxn/2FO9Y4GGSJbpO/F gFhomYOuhvXaAhKpXDmTohU67K56PS48Hc7O9aN/XcGnYwSBFjMJL0KyXDHJaEWfpm U7qMsrNYEwwZA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 10/29] perf session: Validate HEADER_ATTR attr.size before swapping Date: Tue, 26 May 2026 18:17:46 -0300 Message-ID: <20260526211806.1193848-11-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Harden PERF_RECORD_HEADER_ATTR handling against crafted perf.data: - Validate attr.size: must be >=3D PERF_ATTR_SIZE_VER0, a multiple of sizeof(u64), and fit within the event payload. - Copy only min(attr.size, sizeof(struct perf_event_attr)) bytes into a local attr, zeroing the rest so legacy files don't leak adjacent event data into new fields. - Keep the original attr.size so perf_event__synthesize_attr() uses it for both allocation and ID-array placement. Fix perf_event__synthesize_attr() to use attr->size (not the compiled sizeof) for event allocation and layout, so perf inject correctly re-synthesizes attrs from files recorded by a different perf version. Without this, the ID array destination pointer (computed via perf_record_header_attr_id()) would be inconsistent with the allocation when attr->size differs from sizeof. Also fix the parse-no-sample-id-all test to set attr.size, which is now validated, and improve error handling in read_attr() for short reads and invalid attr sizes. Handle ABI0 pipe/inject events where attr.size is 0: use a local attr_size variable set to PERF_ATTR_SIZE_VER0 for both the bounded copy and ID array position, instead of writing back to the event. Native-endian files may be MAP_SHARED (read-only mmap), so writing to the event buffer would SIGSEGV. The swap path handles ABI0 in perf_event__attr_swap() which writes to the MAP_PRIVATE copy. header.size alignment is now validated centrally in perf_session__process_event() (see "Add minimum event size and alignment validation"). Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/builtin-inject.c | 23 ++++-- tools/perf/tests/parse-no-sample-id-all.c | 6 ++ tools/perf/util/header.c | 96 +++++++++++++++++++++-- tools/perf/util/session.c | 31 ++++++++ tools/perf/util/synthetic-events.c | 25 +++++- 5 files changed, 166 insertions(+), 15 deletions(-) diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c index 41a3721a194dc9b9..d8cb1f562f690ce4 100644 --- a/tools/perf/builtin-inject.c +++ b/tools/perf/builtin-inject.c @@ -229,6 +229,7 @@ static int perf_event__repipe_attr(const struct perf_to= ol *tool, struct perf_inject *inject =3D container_of(tool, struct perf_inject, tool); struct perf_event_attr attr; + u32 raw_attr_size, attr_size; size_t n_ids; u64 *ids; int ret; @@ -244,24 +245,34 @@ static int perf_event__repipe_attr(const struct perf_= tool *tool, if (!inject->itrace_synth_opts.set) return perf_event__repipe_synth(tool, event); =20 - if (event->header.size < sizeof(struct perf_event_header) + sizeof(u64)) { + if (event->header.size < sizeof(struct perf_event_header) + PERF_ATTR_SIZ= E_VER0) { pr_err("Attribute event size %u is too small\n", event->header.size); return -EINVAL; } =20 - if (event->header.size - sizeof(event->header) < event->attr.attr.size) { + /* + * ABI0 pipe/inject events have attr.size =3D=3D 0; default to + * PERF_ATTR_SIZE_VER0 (the ABI0 footprint) for the bounded + * copy and ID array position. Same pattern as + * perf_event__process_attr() in header.c. + */ + raw_attr_size =3D event->attr.attr.size; + attr_size =3D raw_attr_size ?: PERF_ATTR_SIZE_VER0; + + if (raw_attr_size && (raw_attr_size < PERF_ATTR_SIZE_VER0 || + raw_attr_size > event->header.size - sizeof(event->header))) { pr_err("Attribute event size %u is too small for attr.size %u\n", - event->header.size, event->attr.attr.size); + event->header.size, raw_attr_size); return -EINVAL; } =20 memset(&attr, 0, sizeof(attr)); memcpy(&attr, &event->attr.attr, - min_t(size_t, sizeof(attr), (size_t)event->attr.attr.size)); + min_t(size_t, sizeof(attr), attr_size)); =20 - n_ids =3D event->header.size - sizeof(event->header) - event->attr.attr.s= ize; + n_ids =3D event->header.size - sizeof(event->header) - attr_size; n_ids /=3D sizeof(u64); - ids =3D perf_record_header_attr_id(event); + ids =3D (void *)&event->attr.attr + attr_size; =20 attr.size =3D sizeof(struct perf_event_attr); attr.sample_type &=3D ~PERF_SAMPLE_AUX; diff --git a/tools/perf/tests/parse-no-sample-id-all.c b/tools/perf/tests/p= arse-no-sample-id-all.c index 50e68b7d43aad030..8ac862c94879f3a3 100644 --- a/tools/perf/tests/parse-no-sample-id-all.c +++ b/tools/perf/tests/parse-no-sample-id-all.c @@ -82,6 +82,9 @@ static int test__parse_no_sample_id_all(struct test_suite= *test __maybe_unused, .type =3D PERF_RECORD_HEADER_ATTR, .size =3D sizeof(struct test_attr_event), }, + .attr =3D { + .size =3D sizeof(struct perf_event_attr), + }, .id =3D 1, }; struct test_attr_event event2 =3D { @@ -89,6 +92,9 @@ static int test__parse_no_sample_id_all(struct test_suite= *test __maybe_unused, .type =3D PERF_RECORD_HEADER_ATTR, .size =3D sizeof(struct test_attr_event), }, + .attr =3D { + .size =3D sizeof(struct perf_event_attr), + }, .id =3D 2, }; struct perf_record_mmap event3 =3D { diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index f30e48eb3fc32da2..967c3d8ff12c8676 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -4770,9 +4770,15 @@ static int read_attr(int fd, struct perf_header *ph, if (sz =3D=3D 0) { /* assume ABI0 */ sz =3D PERF_ATTR_SIZE_VER0; + } else if (sz < PERF_ATTR_SIZE_VER0) { + pr_debug("bad attr size %zu, expected at least %d\n", + sz, PERF_ATTR_SIZE_VER0); + errno =3D EINVAL; + return -1; } else if (sz > our_sz) { pr_debug("file uses a more recent and unsupported ABI" " (%zu bytes extra)\n", sz - our_sz); + errno =3D EINVAL; return -1; } /* what we have not yet read and that we know about */ @@ -4782,11 +4788,21 @@ static int read_attr(int fd, struct perf_header *ph, ptr +=3D PERF_ATTR_SIZE_VER0; =20 ret =3D readn(fd, ptr, left); + if (ret <=3D 0) { + if (ret =3D=3D 0) + errno =3D EIO; + return -1; + } } /* read perf_file_section, ids are read in caller */ ret =3D readn(fd, &f_attr->ids, sizeof(f_attr->ids)); + if (ret <=3D 0) { + if (ret =3D=3D 0) + errno =3D EIO; + return -1; + } =20 - return ret <=3D 0 ? -1 : 0; + return 0; } =20 #ifdef HAVE_LIBTRACEEVENT @@ -5094,11 +5110,42 @@ int perf_event__process_attr(const struct perf_tool= *tool __maybe_unused, union perf_event *event, struct evlist **pevlist) { - u32 i, n_ids; + struct perf_event_attr attr; + u32 i, n_ids, raw_attr_size; u64 *ids; + size_t attr_size, copy_size; struct evsel *evsel; struct evlist *evlist =3D *pevlist; =20 + /* + * HEADER_ATTR event layout (pipe/inject mode): + * + * [header (8 bytes)] [attr (attr_size bytes)] [id0 id1 ... idN] + * |<------------------ header.size --------------------------->| + * + * attr_size varies across perf versions: VER0 =3D 64 bytes, + * current sizeof(struct perf_event_attr) =3D larger. A newer + * producer may emit a larger attr than we understand. + * + * attr.size =3D=3D 0 (ABI0) means the producer didn't set it + * (e.g., bench/inject-buildid, older perf). Treat as VER0. + * + * Require 8-byte alignment so the u64 ID array is aligned + * and attr.size fits cleanly within the payload. + * + * Read attr.size once =E2=80=94 the event may be on a shared mmap + * and re-reading could yield a different value. + */ + raw_attr_size =3D event->attr.attr.size; + if (event->header.size < sizeof(event->header) + PERF_ATTR_SIZE_VER0 || + (raw_attr_size && (raw_attr_size < PERF_ATTR_SIZE_VER0 || + raw_attr_size % sizeof(u64) || + raw_attr_size > event->header.size - sizeof(event->header)))) { + pr_err("PERF_RECORD_HEADER_ATTR: invalid attr.size %u (event size %u, mi= n %d)\n", + raw_attr_size, event->header.size, PERF_ATTR_SIZE_VER0); + return -EINVAL; + } + if (dump_trace) perf_event__fprintf_attr(event, stdout); =20 @@ -5108,13 +5155,46 @@ int perf_event__process_attr(const struct perf_tool= *tool __maybe_unused, return -ENOMEM; } =20 - evsel =3D evsel__new(&event->attr.attr); + /* + * attr_size =3D footprint of the attr in the event =E2=80=94 determines + * where the ID array starts. For ABI0, assume VER0 (64 bytes). + * + * copy_size =3D how much we copy into our local struct, capped at + * sizeof(attr) so a newer producer's larger attr doesn't + * overflow. Fields beyond copy_size are zeroed. + * + * Do NOT write attr_size back to the event =E2=80=94 native-endian + * files use MAP_SHARED (read-only), writing would SIGSEGV. + * The swap path handles ABI0 in perf_event__attr_swap() + * which writes to the writable MAP_PRIVATE copy instead. + */ + attr_size =3D raw_attr_size ?: PERF_ATTR_SIZE_VER0; + copy_size =3D min(attr_size, sizeof(attr)); + memcpy(&attr, &event->attr.attr, copy_size); + if (copy_size < sizeof(attr)) + memset((void *)&attr + copy_size, 0, sizeof(attr) - copy_size); + + /* + * Normalize ABI0: the swap path sets attr.size =3D VER0 on the + * event, but the native path leaves it as 0. Set it on the + * local copy so perf inject re-synthesizes with consistent + * layout regardless of endianness. + */ + attr.size =3D attr_size; + + evsel =3D evsel__new(&attr); if (evsel =3D=3D NULL) return -ENOMEM; =20 evlist__add(evlist, evsel); =20 - n_ids =3D event->header.size - sizeof(event->header) - event->attr.attr.s= ize; + /* + * IDs occupy the remainder after header + attr. Use attr_size + * (not copy_size) =E2=80=94 even if the producer's attr is larger than + * our struct, the IDs start after attr_size bytes in the event. + * Validation above guarantees attr_size <=3D payload size. + */ + n_ids =3D event->header.size - sizeof(event->header) - attr_size; n_ids =3D n_ids / sizeof(u64); /* * We don't have the cpu and thread maps on the header, so @@ -5124,7 +5204,13 @@ int perf_event__process_attr(const struct perf_tool = *tool __maybe_unused, if (perf_evsel__alloc_id(&evsel->core, 1, n_ids)) return -ENOMEM; =20 - ids =3D perf_record_header_attr_id(event); + /* + * Locate IDs at attr_size bytes past the attr start in the + * event. Cannot use perf_record_header_attr_id() =E2=80=94 that + * macro reads event->attr.attr.size, which is 0 for ABI0 + * on the native-endian path (no swap handler to fix it up). + */ + ids =3D (void *)&event->attr.attr + attr_size; for (i =3D 0; i < n_ids; i++) { perf_evlist__id_add(&evlist->core, &evsel->core, 0, i, ids[i]); } diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 3f72b80aac56b04e..aef10d42be35487a 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -623,8 +623,39 @@ do { \ static int perf_event__hdr_attr_swap(union perf_event *event, bool sample_id_all __maybe_unused) { + u32 attr_size, payload_size; size_t size; =20 + /* + * Validate attr.size (still foreign-endian) before calling + * perf_event__attr_swap(), which uses it via bswap_safe() + * to decide which fields to swap. A crafted attr.size + * larger than the event payload would swap past the event + * boundary and corrupt adjacent memory. + * + * header.size alignment is already validated by + * perf_session__process_event(). The min_size table + * guarantees header.size >=3D sizeof(header) + + * PERF_ATTR_SIZE_VER0, so attr.size is safe to access. + */ + attr_size =3D bswap_32(event->attr.attr.size); + /* + * ABI0: size field not set. This only happens in pipe/inject + * mode where HEADER_ATTR events carry their own attr. For + * regular perf.data files, read_attr() uses f_header.attr_size + * from the file header instead. Assume PERF_ATTR_SIZE_VER0. + */ + if (!attr_size) + attr_size =3D PERF_ATTR_SIZE_VER0; + payload_size =3D event->header.size - sizeof(event->header); + + if (attr_size < PERF_ATTR_SIZE_VER0 || attr_size % sizeof(u64) || + attr_size > payload_size) { + pr_err("PERF_RECORD_HEADER_ATTR: invalid attr.size %u (min: %d, max: %u,= 8-byte aligned)\n", + attr_size, PERF_ATTR_SIZE_VER0, payload_size); + return -1; + } + perf_event__attr_swap(&event->attr.attr); =20 size =3D event->header.size; diff --git a/tools/perf/util/synthetic-events.c b/tools/perf/util/synthetic= -events.c index d665b0f94b321433..5307d707711d876c 100644 --- a/tools/perf/util/synthetic-events.c +++ b/tools/perf/util/synthetic-events.c @@ -2181,11 +2181,21 @@ int perf_event__synthesize_attr(const struct perf_t= ool *tool, struct perf_event_ u32 ids, u64 *id, perf_event__handler_t process) { union perf_event *ev; - size_t size; + size_t attr_size, size; int err; =20 - size =3D sizeof(struct perf_event_attr); - size =3D PERF_ALIGN(size, sizeof(u64)); + /* + * Use attr->size for the event layout, not the compiled + * sizeof(struct perf_event_attr), so that synthesized events + * match the source perf.data layout. This matters for perf + * inject, which re-synthesizes attrs from a file that may + * have been recorded by a different version of perf. + * perf_record_header_attr_id() locates the ID array at + * attr->size bytes past the attr. + */ + attr_size =3D attr->size ?: sizeof(struct perf_event_attr); + + size =3D PERF_ALIGN(attr_size, sizeof(u64)); size +=3D sizeof(struct perf_event_header); size +=3D ids * sizeof(u64); =20 @@ -2194,7 +2204,14 @@ int perf_event__synthesize_attr(const struct perf_to= ol *tool, struct perf_event_ if (ev =3D=3D NULL) return -ENOMEM; =20 - ev->attr.attr =3D *attr; + /* + * Copy only the bytes we understand; zalloc ensures that any + * extra bytes between sizeof(struct perf_event_attr) and + * attr_size are zero when the source file uses a newer, larger + * struct. + */ + memcpy(&ev->attr.attr, attr, min(sizeof(struct perf_event_attr), attr_siz= e)); + ev->attr.attr.size =3D attr_size; memcpy(perf_record_header_attr_id(ev), id, ids * sizeof(u64)); =20 ev->attr.header.type =3D PERF_RECORD_HEADER_ATTR; --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5CEDF3C09EB; Tue, 26 May 2026 21:18:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830336; cv=none; b=m7QN+zdl4Dqe6KPYlFcbVDBj+ONIUBfTI4Sa/tLIaaPUHynxMBfaR1CgUMCPeE28DervPl0scQt5hQEaUr5kqMd13kTBfUvyBLEIXNIk5Md4vw9lnkE2lVdcYzYF5+n/70bVWtQDau1xoZDevPmo1CXKkXL0MITEk2k+ivtP28o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830336; c=relaxed/simple; bh=IMm6QqciKoj9L86ffNAHT3CHzVjj1Uev6t0eb+VdG2w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=GPamZoSE8PDnqHtKOjDqJPVNFN4NfGpx28sgek/mhqlWSQtHbaWK6P98rvPAa5BoHhYzHWAUZ0iLolxFUarxXYgCMn4aG3o5RTQIE9y7DhCPytYTbyW4807BpmEPcVP3I1SvZ79PQbhYW8Rs8JNgi+Jom3PYZAOPKUgkpqahdsQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Tq3ybSxe; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Tq3ybSxe" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 702C01F00A3A; Tue, 26 May 2026 21:18:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830334; bh=PqqN3TMSovKEaOntcbHHKrbyahaJzHRxFuKowFiVyu0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Tq3ybSxeZBmhemwuvFkqPWyo+aKtN/vVjX0WBNYkDNQX9gN+4KUmWQ6/F9pRP9X1b g1Xm7c+IwY/jVxwkndf4gWIG2hwE45RPy0l/Uunb9IfetATZ+kVDQD1Dp+ZxKPYEBw RKRBm8NkS+gEw13NiJjccUngl5wT9ig5piPHo/uur9U5D4ArNUBakCQj478MxCBFI9 UXDmquvTuxM8TIEQo8fLhxPxirP8hB88zgqVfEGmWbJ4layBVqwad5z+ME1Owe5nq8 /s7r5UQjWs7a+NiLLE7h9sE35/rgUEJ9GnUDqZNt48HAtTbycpHEZ+VOxwaLVjp3X1 Sla7dy9l+uH6g== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 11/29] perf session: Validate nr fields against event size on both swap and common paths Date: Tue, 26 May 2026 18:17:47 -0300 Message-ID: <20260526211806.1193848-12-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Several event types use an nr field to control iteration over variable-length arrays. The swap handlers byte-swap and loop using these fields without bounds checks, and the native processing path trusts them as well. Add bounds checks on both paths for: - PERF_RECORD_THREAD_MAP: validate nr against payload, return -1 on the swap path. On the native path, reject with -EINVAL. - PERF_RECORD_NAMESPACES: clamp nr on the swap path (safe because each entry is indexed by type; missing entries just won't be resolved). Skip the event on the native path. - PERF_RECORD_CPU_MAP: clamp nr for CPUS and MASK sub-types on the swap path. Add bounds checks for mask64 which previously had no nr validation. Skip the event on the native path. - PERF_RECORD_STAT_CONFIG: clamp nr on the swap path (safe because each config entry is self-describing via its tag). Skip the event on the native path. The swap path (cross-endian, writable MAP_PRIVATE mapping) can safely clamp by writing back to the event. The native path (read-only MAP_SHARED mapping) must skip instead of clamping because writing to the mmap'd event would segfault. Also fix stat_config swap range: change size +=3D 1 to size +=3D sizeof(event->stat_config.nr) for clarity. The old +1 happened to work because mem_bswap_64 processes 8-byte chunks, but the intent is to include the 8-byte nr field in the swap range. Changes in v2: - Document that PERF_RECORD_NAMESPACES max_nr includes trailing sample_id space when sample_id_all is present =E2=80=94 harmless on the swap path because both per-element bswap_64 and swap_sample_id_all() perform the same u64 byte swap (Reported-by: sashiko-bot@kernel.org) Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 253 +++++++++++++++++++++++++++++++++++--- 1 file changed, 234 insertions(+), 19 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index aef10d42be35487a..8588e12f110fca70 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -496,13 +496,35 @@ static int perf_event__throttle_swap(union perf_event= *event, static int perf_event__namespaces_swap(union perf_event *event, bool sample_id_all) { - u64 i; + u64 i, nr, max_nr; =20 event->namespaces.pid =3D bswap_32(event->namespaces.pid); event->namespaces.tid =3D bswap_32(event->namespaces.tid); event->namespaces.nr_namespaces =3D bswap_64(event->namespaces.nr_namespa= ces); =20 - for (i =3D 0; i < event->namespaces.nr_namespaces; i++) { + nr =3D event->namespaces.nr_namespaces; + /* + * Cannot underflow: perf_event__min_size[] guarantees header.size >=3D s= izeof. + * When sample_id_all is present max_nr slightly overestimates the + * array space because header.size includes the trailing sample_id. + * Harmless: both the per-element bswap_64 loop and swap_sample_id_all() + * perform the same u64 byte swap, so the result is correct regardless + * of where the boundary between array and sample_id falls. + */ + max_nr =3D (event->header.size - sizeof(event->namespaces)) / + sizeof(event->namespaces.link_info[0]); + /* + * Safe to clamp: each namespace entry is indexed by type; + * missing entries just won't be resolved. + */ + if (nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_NAMESPACES: nr_namespaces %" PRIu64 " e= xceeds payload (max %" PRIu64 "), clamping\n", + nr, max_nr); + nr =3D max_nr; + event->namespaces.nr_namespaces =3D nr; + } + + for (i =3D 0; i < nr; i++) { struct perf_ns_link_info *ns =3D &event->namespaces.link_info[i]; =20 ns->dev =3D bswap_64(ns->dev); @@ -734,11 +756,23 @@ static int perf_event__auxtrace_error_swap(union perf= _event *event, static int perf_event__thread_map_swap(union perf_event *event, bool sample_id_all __maybe_unused) { - unsigned i; + unsigned int i; + u64 nr; =20 event->thread_map.nr =3D bswap_64(event->thread_map.nr); =20 - for (i =3D 0; i < event->thread_map.nr; i++) + /* + * Reject rather than clamp: unlike namespaces (indexed by type) + * or stat_config (self-describing tags), a truncated thread map + * is structurally broken =E2=80=94 downstream would get a wrong map. + */ + /* Cannot underflow: perf_event__min_size[] guarantees header.size >=3D s= izeof */ + nr =3D event->thread_map.nr; + if (nr > (event->header.size - sizeof(event->thread_map)) / + sizeof(event->thread_map.entries[0])) + return -1; + + for (i =3D 0; i < nr; i++) event->thread_map.entries[i].pid =3D bswap_64(event->thread_map.entries[= i].pid); return 0; } @@ -747,32 +781,80 @@ static int perf_event__cpu_map_swap(union perf_event = *event, bool sample_id_all __maybe_unused) { struct perf_record_cpu_map_data *data =3D &event->cpu_map.data; + u32 payload =3D event->header.size - sizeof(event->header); =20 data->type =3D bswap_16(data->type); =20 + /* + * Safe to clamp: a shorter CPU map just means some CPUs + * are absent; tools process the CPUs that are present. + */ switch (data->type) { - case PERF_CPU_MAP__CPUS: - data->cpus_data.nr =3D bswap_16(data->cpus_data.nr); + case PERF_CPU_MAP__CPUS: { + u16 nr, max_nr; =20 - for (unsigned i =3D 0; i < data->cpus_data.nr; i++) + data->cpus_data.nr =3D bswap_16(data->cpus_data.nr); + nr =3D data->cpus_data.nr; + max_nr =3D (payload - offsetof(struct perf_record_cpu_map_data, + cpus_data.cpu)) / + sizeof(data->cpus_data.cpu[0]); + if (nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_CPU_MAP: nr %u exceeds payload (max %u= ), clamping\n", + nr, max_nr); + nr =3D max_nr; + data->cpus_data.nr =3D nr; + } + for (unsigned int i =3D 0; i < nr; i++) data->cpus_data.cpu[i] =3D bswap_16(data->cpus_data.cpu[i]); break; + } case PERF_CPU_MAP__MASK: data->mask32_data.long_size =3D bswap_16(data->mask32_data.long_size); =20 switch (data->mask32_data.long_size) { - case 4: + case 4: { + u16 nr, max_nr; + data->mask32_data.nr =3D bswap_16(data->mask32_data.nr); - for (unsigned i =3D 0; i < data->mask32_data.nr; i++) + nr =3D data->mask32_data.nr; + max_nr =3D (payload - offsetof(struct perf_record_cpu_map_data, + mask32_data.mask)) / + sizeof(data->mask32_data.mask[0]); + if (nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_CPU_MAP mask32: nr %u exceeds payload= (max %u), clamping\n", + nr, max_nr); + nr =3D max_nr; + data->mask32_data.nr =3D nr; + } + for (unsigned int i =3D 0; i < nr; i++) data->mask32_data.mask[i] =3D bswap_32(data->mask32_data.mask[i]); break; - case 8: + } + case 8: { + u16 nr, max_nr; + data->mask64_data.nr =3D bswap_16(data->mask64_data.nr); - for (unsigned i =3D 0; i < data->mask64_data.nr; i++) + nr =3D data->mask64_data.nr; + if (payload < offsetof(struct perf_record_cpu_map_data, mask64_data.mas= k)) { + data->mask64_data.nr =3D 0; + break; + } + max_nr =3D (payload - offsetof(struct perf_record_cpu_map_data, + mask64_data.mask)) / + sizeof(data->mask64_data.mask[0]); + if (nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_CPU_MAP mask64: nr %u exceeds payload= (max %u), clamping\n", + nr, max_nr); + nr =3D max_nr; + data->mask64_data.nr =3D nr; + } + for (unsigned int i =3D 0; i < nr; i++) data->mask64_data.mask[i] =3D bswap_64(data->mask64_data.mask[i]); break; + } default: - pr_err("cpu_map swap: unsupported long size\n"); + pr_err("cpu_map swap: unsupported long size %u\n", + data->mask32_data.long_size); } break; case PERF_CPU_MAP__RANGE_CPUS: @@ -788,11 +870,27 @@ static int perf_event__cpu_map_swap(union perf_event = *event, static int perf_event__stat_config_swap(union perf_event *event, bool sample_id_all __maybe_unused) { - u64 size; + u64 nr, max_nr, size; =20 - size =3D bswap_64(event->stat_config.nr) * sizeof(event->stat_config.dat= a[0]); - size +=3D 1; /* nr item itself */ + nr =3D bswap_64(event->stat_config.nr); + /* Cannot underflow: perf_event__min_size[] guarantees header.size >=3D s= izeof */ + max_nr =3D (event->header.size - sizeof(event->stat_config)) / + sizeof(event->stat_config.data[0]); + /* + * Safe to clamp: each config entry is self-describing + * via its tag; missing entries keep their defaults. + */ + if (nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_STAT_CONFIG: nr %" PRIu64 " exceeds pay= load (max %" PRIu64 "), clamping\n", + nr, max_nr); + nr =3D max_nr; + } + size =3D nr * sizeof(event->stat_config.data[0]); + /* The swap starts at &nr, so add its size to cover the full range */ + size +=3D sizeof(event->stat_config.nr); mem_bswap_64(&event->stat_config.nr, size); + /* Persist the clamped value in native byte order */ + event->stat_config.nr =3D nr; return 0; } =20 @@ -1730,8 +1828,27 @@ static int machines__deliver_event(struct machines *= machines, "COMM")) return 0; return tool->comm(tool, event, sample, machine); - case PERF_RECORD_NAMESPACES: + case PERF_RECORD_NAMESPACES: { + /* + * Cannot underflow: perf_event__min_size[] guarantees header.size >=3D = sizeof. + * Includes trailing sample_id space when present, but prevents OOB. + */ + u64 max_nr =3D (event->header.size - sizeof(event->namespaces)) / + sizeof(event->namespaces.link_info[0]); + + /* + * Native-endian events are mmap'd read-only, so we + * cannot clamp nr in place. Skip the event instead. + * The swap handler already clamps on the writable + * cross-endian path. + */ + if (event->namespaces.nr_namespaces > max_nr) { + pr_warning("WARNING: PERF_RECORD_NAMESPACES: nr_namespaces %" PRIu64 " = exceeds payload (max %" PRIu64 "), skipping\n", + (u64)event->namespaces.nr_namespaces, max_nr); + return 0; + } return tool->namespaces(tool, event, sample, machine); + } case PERF_RECORD_CGROUP: if (!perf_event__check_nul(event->cgroup.path, (void *)event + event->header.size, @@ -1912,15 +2029,112 @@ static s64 perf_session__process_user_event(struct= perf_session *session, perf_session__auxtrace_error_inc(session, event); err =3D tool->auxtrace_error(tool, session, event); break; - case PERF_RECORD_THREAD_MAP: + case PERF_RECORD_THREAD_MAP: { + u64 max_nr; + + if (event->header.size < sizeof(event->thread_map)) { + pr_err("PERF_RECORD_THREAD_MAP: header.size (%u) too small\n", + event->header.size); + err =3D -EINVAL; + break; + } + + max_nr =3D (event->header.size - sizeof(event->thread_map)) / + sizeof(event->thread_map.entries[0]); + if (event->thread_map.nr > max_nr) { + pr_err("PERF_RECORD_THREAD_MAP: nr %" PRIu64 " exceeds max %" PRIu64 "\= n", + (u64)event->thread_map.nr, max_nr); + err =3D -EINVAL; + break; + } + err =3D tool->thread_map(tool, session, event); break; - case PERF_RECORD_CPU_MAP: + } + case PERF_RECORD_CPU_MAP: { + struct perf_record_cpu_map_data *data =3D &event->cpu_map.data; + u32 payload =3D event->header.size - sizeof(event->header); + + /* + * Native-endian events are mmap'd read-only, so we + * cannot clamp nr fields in place. Skip the event + * if any variant overflows. + */ + switch (data->type) { + case PERF_CPU_MAP__CPUS: { + u16 max_nr =3D (payload - offsetof(struct perf_record_cpu_map_data, + cpus_data.cpu)) / + sizeof(data->cpus_data.cpu[0]); + + if (data->cpus_data.nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_CPU_MAP: nr %u exceeds payload (max %= u), skipping\n", + data->cpus_data.nr, max_nr); + err =3D 0; + goto out; + } + break; + } + case PERF_CPU_MAP__MASK: + if (data->mask32_data.long_size =3D=3D 4) { + u16 max_nr =3D (payload - offsetof(struct perf_record_cpu_map_data, + mask32_data.mask)) / + sizeof(data->mask32_data.mask[0]); + + if (data->mask32_data.nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_CPU_MAP mask32: nr %u exceeds payloa= d (max %u), skipping\n", + data->mask32_data.nr, max_nr); + err =3D 0; + goto out; + } + } else if (data->mask64_data.long_size =3D=3D 8) { + u16 max_nr; + + if (payload < offsetof(struct perf_record_cpu_map_data, mask64_data.ma= sk)) { + err =3D 0; + goto out; + } + max_nr =3D (payload - offsetof(struct perf_record_cpu_map_data, + mask64_data.mask)) / + sizeof(data->mask64_data.mask[0]); + if (data->mask64_data.nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_CPU_MAP mask64: nr %u exceeds payloa= d (max %u), skipping\n", + data->mask64_data.nr, max_nr); + err =3D 0; + goto out; + } + } else { + pr_warning("WARNING: PERF_RECORD_CPU_MAP: unsupported long_size %u, sk= ipping\n", + data->mask32_data.long_size); + err =3D 0; + goto out; + } + break; + default: + break; + } + err =3D tool->cpu_map(tool, session, event); break; - case PERF_RECORD_STAT_CONFIG: + } + case PERF_RECORD_STAT_CONFIG: { + /* Cannot underflow: perf_event__min_size[] guarantees header.size >=3D = sizeof */ + u64 max_nr =3D (event->header.size - sizeof(event->stat_config)) / + sizeof(event->stat_config.data[0]); + + /* + * Native-endian events are mmap'd read-only, so we + * cannot clamp nr in place. Skip the event instead. + */ + if (event->stat_config.nr > max_nr) { + pr_warning("WARNING: PERF_RECORD_STAT_CONFIG: nr %" PRIu64 " exceeds pa= yload (max %" PRIu64 "), skipping\n", + (u64)event->stat_config.nr, max_nr); + err =3D 0; + goto out; + } + err =3D tool->stat_config(tool, session, event); break; + } case PERF_RECORD_STAT: err =3D tool->stat(tool, session, event); break; @@ -1963,6 +2177,7 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, err =3D -EINVAL; break; } +out: perf_sample__exit(&sample); return err; } --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A066A3B774A; Tue, 26 May 2026 21:18:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830339; cv=none; b=FyLTJVpwlrTlVC2KqADxuoNFHpcsSKW+SfrahUeS5C5VOvG8uClLP7YwEBcaxDxD0SJ8RNZ1q6o3OR+zslqrgQRa/cKrH6Xy8Uj2+J8uV9W6YTl7MNYXH8hMeBTEibQdwLus4J+4nOq4zfWxNFx3xIaE5NUGPKn/qqrYRSJJIB8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830339; c=relaxed/simple; bh=jpJOzq+jJ4TOARSX9r2mgNN7gWRRi6NiutiJi0+5S98=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=PrnY8TJ+pS+t+s8l1qFczQBVn1JfTZoDJVUWsqPoEWwiUOcP24Gwb643krznbe3o4sgDWrC/yBIpxuvksvvR9HM6xldioqCldeGpMjYNWIByyymKd6DdxvjbPFzBqdYzfKx+/XEYdk8ZjeKhOwi3cEU+ZyQT1m7aT/eBpv1LQI8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CrWmI+fX; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="CrWmI+fX" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B45F71F000E9; Tue, 26 May 2026 21:18:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830337; bh=PRRMEZI1ciOv6zdG3OAY209euY2o8p2qL1Z0agAyrtQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=CrWmI+fXMO+7ejcKQkK28r2oC1Sk/zZgNIzWFQloltpXyhuLsII3h14ETMpDbObm4 257gKh34EjS90qoTNxk0b3BhyO1oerRTqrApTZlEEJwXE4KQyaUtBASTUEMa3R9PfT VB1wJvX7jrKqjv8+m5fAa1FJRQ160l7McGDcAE8wkZbyV2HvdIYdBTCPS+rwXINiLU o0OHhuWkHoKfH+Tnp2/Zv8aMqlWdqFFERm3HWilwiq5XtHkcbkfuFX/9bWCxgYM1hN MweF0MWJKTqtjRBPCPMhFXv4Gyhknq1xeGan4nkXcWJ0zUgOmyGMQw7AKOqtgMVWA4 PX6le5fT31aeA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 12/29] perf header: Byte-swap build ID event pid and bounds check section entries Date: Tue, 26 May 2026 18:17:48 -0300 Message-ID: <20260526211806.1193848-13-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo perf_header__read_build_ids() swaps the event header fields for cross-endian perf.data files but not bev.pid. This causes perf_session__findnew_machine() to look up the wrong machine for guest VM build IDs, misattributing them. Swap bev.pid alongside the header fields. Also add a build_id_swap callback for stream-mode build ID events, and validate NUL-termination of build_id.filename on the native-endian delivery path (perf_session__process_user_event) =E2=80=94 events with unterminated filenames are skipped. Harden perf_header__read_build_ids() against crafted perf.data files: - Add overflow check on offset + size to prevent wrap past ULLONG_MAX. - Reject bev.header.size =3D=3D 0 which would loop forever. - Reject bev.header.size > remaining section to prevent reading past the section boundary. - Guard memcmp(filename, "nel.kallsyms]", 13) with len >=3D 13 to avoid reading uninitialized stack memory on short filenames. - Force NUL-termination of filename before passing it to functions like machine__findnew_dso() that use strlen/strcmp. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 50 +++++++++++++++++++++++++++++++++++---- tools/perf/util/session.c | 27 ++++++++++++++++++++- 2 files changed, 72 insertions(+), 5 deletions(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index 967c3d8ff12c8676..c0b5c99f462ad925 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include #include +#include #include "string2.h" #include #include @@ -2578,7 +2579,13 @@ static int perf_header__read_build_ids_abi_quirk(str= uct perf_header *header, } old_bev; struct perf_record_header_build_id bev; char filename[PATH_MAX]; - u64 limit =3D offset + size; + u64 limit; + + /* Prevent offset + size from wrapping past ULLONG_MAX */ + if (size > ULLONG_MAX - offset) + return -1; + + limit =3D offset + size; =20 while (offset < limit) { ssize_t len; @@ -2589,6 +2596,10 @@ static int perf_header__read_build_ids_abi_quirk(str= uct perf_header *header, if (header->needs_swap) perf_event_header__bswap(&old_bev.header); =20 + /* size =3D=3D 0 loops forever; size > remaining reads past section */ + if (old_bev.header.size =3D=3D 0 || old_bev.header.size > limit - offset) + return -1; + len =3D old_bev.header.size - sizeof(old_bev); if (len < 0 || len >=3D PATH_MAX) { pr_warning("invalid build_id filename length %zd\n", len); @@ -2597,6 +2608,13 @@ static int perf_header__read_build_ids_abi_quirk(str= uct perf_header *header, =20 if (readn(input, filename, len) !=3D len) return -1; + /* + * The file data may lack a null terminator, which could + * indicate a corrupt or crafted perf.data file. Ensure + * filename is always a valid C string before passing it + * to functions like machine__findnew_dso(). + */ + filename[len] =3D '\0'; =20 bev.header =3D old_bev.header; =20 @@ -2624,17 +2642,32 @@ static int perf_header__read_build_ids(struct perf_= header *header, struct perf_session *session =3D container_of(header, struct perf_session= , header); struct perf_record_header_build_id bev; char filename[PATH_MAX]; - u64 limit =3D offset + size, orig_offset =3D offset; + u64 limit, orig_offset =3D offset; int err =3D -1; =20 + /* Prevent offset + size from wrapping past ULLONG_MAX */ + if (size > ULLONG_MAX - offset) + return -1; + + limit =3D offset + size; + while (offset < limit) { ssize_t len; =20 if (readn(input, &bev, sizeof(bev)) !=3D sizeof(bev)) goto out; =20 - if (header->needs_swap) + if (header->needs_swap) { perf_event_header__bswap(&bev.header); + bev.pid =3D bswap_32(bev.pid); + } + + /* + * size =3D=3D 0 would loop forever (offset never advances); + * size > remaining would read past the section boundary. + */ + if (bev.header.size =3D=3D 0 || bev.header.size > limit - offset) + goto out; =20 len =3D bev.header.size - sizeof(bev); if (len < 0 || len >=3D PATH_MAX) { @@ -2644,6 +2677,13 @@ static int perf_header__read_build_ids(struct perf_h= eader *header, =20 if (readn(input, filename, len) !=3D len) goto out; + /* + * The file data may lack a null terminator, which could + * indicate a corrupt or crafted perf.data file. Ensure + * filename is always a valid C string before passing it + * to functions like machine__findnew_dso(). + */ + filename[len] =3D '\0'; /* * The a1645ce1 changeset: * @@ -2657,7 +2697,9 @@ static int perf_header__read_build_ids(struct perf_he= ader *header, * '[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) =3D=3D 0) { + /* Guard short filenames against memcmp reading past the buffer */ + if (len >=3D (ssize_t)sizeof("nel.kallsyms]") - 1 && + memcmp(filename, "nel.kallsyms]", sizeof("nel.kallsyms]") - 1) =3D= =3D 0) { if (lseek(input, orig_offset, SEEK_SET) =3D=3D (off_t)-1) return -1; return perf_header__read_build_ids_abi_quirk(header, input, offset, siz= e); diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 8588e12f110fca70..0fac8f4e0e22310f 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -686,6 +686,25 @@ static int perf_event__hdr_attr_swap(union perf_event = *event, return 0; } =20 +static int perf_event__build_id_swap(union perf_event *event, + bool sample_id_all) +{ + event->build_id.pid =3D bswap_32(event->build_id.pid); + + if (sample_id_all) { + void *data =3D &event->build_id.filename; + void *end =3D (void *)event + event->header.size; + size_t len =3D strnlen(data, end - data); + + /* See comment in perf_event__comm_swap() */ + if (len =3D=3D (size_t)(end - data)) + return -1; + data +=3D PERF_ALIGN(len + 1, sizeof(u64)); + swap_sample_id_all(event, data); + } + return 0; +} + static int perf_event__event_update_swap(union perf_event *event, bool sample_id_all __maybe_unused) { @@ -1014,7 +1033,7 @@ static perf_event__swap_op perf_event__swap_ops[] =3D= { [PERF_RECORD_HEADER_ATTR] =3D perf_event__hdr_attr_swap, [PERF_RECORD_HEADER_EVENT_TYPE] =3D perf_event__event_type_swap, [PERF_RECORD_HEADER_TRACING_DATA] =3D perf_event__tracing_data_swap, - [PERF_RECORD_HEADER_BUILD_ID] =3D NULL, + [PERF_RECORD_HEADER_BUILD_ID] =3D perf_event__build_id_swap, [PERF_RECORD_HEADER_FEATURE] =3D perf_event__header_feature_swap, [PERF_RECORD_ID_INDEX] =3D perf_event__all64_swap, [PERF_RECORD_AUXTRACE_INFO] =3D perf_event__auxtrace_info_swap, @@ -2004,6 +2023,12 @@ static s64 perf_session__process_user_event(struct p= erf_session *session, err =3D tool->tracing_data(tool, session, event); break; case PERF_RECORD_HEADER_BUILD_ID: + if (!perf_event__check_nul(event->build_id.filename, + (void *)event + event->header.size, + "HEADER_BUILD_ID")) { + err =3D 0; + break; + } err =3D tool->build_id(tool, session, event); break; case PERF_RECORD_FINISHED_ROUND: --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2240D3C13FE; Tue, 26 May 2026 21:19:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830342; cv=none; b=H+MNfJoLqTy/zm7pspTks+9qlAsOqLIv48dKuw72guH+4KUElRhulWTZM6x0Ms8aeJy9a7tkPAHKqrseoFTJ3BiVp5/57l2OjMB7bjp2xXWHEpJhGNbK+t6v3FnVZqqCBgN3aJd1RhythlR2rtIK0wi3yPRec+CsvEpHpk6VZ+c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830342; c=relaxed/simple; bh=AisTe5aNqx5CvT1F82WxI0V4CfiyYNVG1u/onxrZmks=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=XUYLltnimNtgVZbUU4tb+NNZm25suYHJHBm05iJWJbiOYs2rd0skfbrZgnG2pMwqv77obv79LOQBeT2WhWJ9lsq4cFR6oU7oyYlUkhRDNTXPV8Cnnai5JqUOPtdGqabg/BrspxVZcnr0xs/1Q2tEoS1kpT63XflLV8tuo5wkgxE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=c00uTCq8; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="c00uTCq8" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 01FCB1F00A3A; Tue, 26 May 2026 21:18:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830340; bh=s2fVRvE1DE0+S2DjkNwQCDdJdaMAXP10pP6s9pG8VJc=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=c00uTCq8WY8j7T/NsAKhGEFZO0y5JE7uYMEnyzuuCoJXkWI+Ax2Rlir+F3/wDlzsr ou1sKodh09nEL3gwEY7clpH41eXvSqsnYJvo0rX0GsQ0t/u7b6Pnrn5JKke2lwE9dQ 3sfPt6a3j62rGMh3yDVwHqglhoIrtVXYlsF81PD9++rGlZpz8DOEYxxfgF58uT3bbP mf2bM5q+ZGD0Szw9KxTkhrBZhEVw31XrN2SEHpvdnsFQBGktullh5VPK3OABlEN6d9 VCnRBCOqLa61ooK6QhdGaDbv45/MusnIe5ZjHhMaFM1ycUHbNaVFMc0KnO3BDqte0R m4WcCpw0xtHsg== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 13/29] perf cpumap: Reject RANGE_CPUS with start_cpu > end_cpu Date: Tue, 26 May 2026 18:17:49 -0300 Message-ID: <20260526211806.1193848-14-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo cpu_map__from_range() computes nr_cpus as end_cpu - start_cpu + 1. When a crafted perf.data has start_cpu > end_cpu, this wraps to a huge value, causing perf_cpu_map__empty_new() to attempt a massive allocation. Return NULL when the range is inverted. Also clamp any_cpu to boolean (0 or 1) since it is added to the allocation count =E2=80=94 a crafted value > 1 would inflate the map size. Harden cpu_map__from_mask() to reject unsupported long_size values (anything other than 4 or 8), preventing misinterpretation of the mask data layout. Snapshot mmap'd fields via READ_ONCE() into locals to prevent TOCTOU re-reads =E2=80=94 the data pointer references MAP_SHARED mmap'd memory that could theoretically change between reads on a FUSE-backed file: - cpu_map__from_range(): snapshot start_cpu, end_cpu, any_cpu - cpu_map__from_entries(): snapshot nr and each cpu[i] element - cpu_map__from_mask(): snapshot long_size (before validation, closing the check-then-read gap), mask_nr - perf_record_cpu_map_data__read_one_mask(): add u16 long_size parameter so callers pass the validated copy instead of re-reading data->mask32_data.long_size from mmap'd memory Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/cpumap.c | 62 +++++++++++++++++++++++++++++----------- 1 file changed, 45 insertions(+), 17 deletions(-) diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c index 11922e1ded844a03..b1e5c29c6e3ec8df 100644 --- a/tools/perf/util/cpumap.c +++ b/tools/perf/util/cpumap.c @@ -10,6 +10,7 @@ #include #include "asm/bug.h" =20 +#include #include #include #include @@ -40,15 +41,16 @@ bool perf_record_cpu_map_data__test_bit(int i, =20 /* Read ith mask value from data into the given 64-bit sized bitmap */ static void perf_record_cpu_map_data__read_one_mask(const struct perf_reco= rd_cpu_map_data *data, - int i, unsigned long *bitmap) + int i, unsigned long *bitmap, + u16 long_size) { #if __SIZEOF_LONG__ =3D=3D 8 - if (data->mask32_data.long_size =3D=3D 4) + if (long_size =3D=3D 4) bitmap[0] =3D data->mask32_data.mask[i]; else bitmap[0] =3D data->mask64_data.mask[i]; #else - if (data->mask32_data.long_size =3D=3D 4) { + if (long_size =3D=3D 4) { bitmap[0] =3D data->mask32_data.mask[i]; bitmap[1] =3D 0; } else { @@ -64,24 +66,27 @@ static void perf_record_cpu_map_data__read_one_mask(con= st struct perf_record_cpu } static struct perf_cpu_map *cpu_map__from_entries(const struct perf_record= _cpu_map_data *data) { + /* Snapshot nr =E2=80=94 data is mmap'd and could change between reads */ + u16 nr =3D READ_ONCE(data->cpus_data.nr); struct perf_cpu_map *map; =20 - map =3D perf_cpu_map__empty_new(data->cpus_data.nr); + map =3D perf_cpu_map__empty_new(nr); if (!map) return NULL; =20 - for (unsigned int i =3D 0; i < data->cpus_data.nr; i++) { + for (unsigned int i =3D 0; i < nr; i++) { + u16 cpu =3D READ_ONCE(data->cpus_data.cpu[i]); /* * Special treatment for -1, which is not real cpu number, * and we need to use (int) -1 to initialize map[i], * otherwise it would become 65535. */ - if (data->cpus_data.cpu[i] =3D=3D (u16) -1) { + if (cpu =3D=3D (u16) -1) { RC_CHK_ACCESS(map)->map[i].cpu =3D -1; - } else if (data->cpus_data.cpu[i] < INT16_MAX) { - RC_CHK_ACCESS(map)->map[i].cpu =3D (int16_t) data->cpus_data.cpu[i]; + } else if (cpu < INT16_MAX) { + RC_CHK_ACCESS(map)->map[i].cpu =3D (int16_t) cpu; } else { - pr_err("Invalid cpumap entry %u\n", data->cpus_data.cpu[i]); + pr_err("Invalid cpumap entry %u\n", cpu); perf_cpu_map__put(map); return NULL; } @@ -93,11 +98,21 @@ static struct perf_cpu_map *cpu_map__from_entries(const= struct perf_record_cpu_m static struct perf_cpu_map *cpu_map__from_mask(const struct perf_record_cp= u_map_data *data) { DECLARE_BITMAP(local_copy, 64); - int weight =3D 0, mask_nr =3D data->mask32_data.nr; + int weight =3D 0, mask_nr; + /* Snapshot before validation =E2=80=94 data is mmap'd and could change */ + u16 long_size =3D READ_ONCE(data->mask32_data.long_size); struct perf_cpu_map *map; =20 + /* long_size must be 4 or 8; other values overflow cpus_per_i below */ + if (long_size !=3D 4 && long_size !=3D 8) { + pr_warning("WARNING: cpu_map mask: unsupported long_size %u\n", long_siz= e); + return NULL; + } + + mask_nr =3D READ_ONCE(data->mask32_data.nr); + for (int i =3D 0; i < mask_nr; i++) { - perf_record_cpu_map_data__read_one_mask(data, i, local_copy); + perf_record_cpu_map_data__read_one_mask(data, i, local_copy, long_size); weight +=3D bitmap_weight(local_copy, 64); } =20 @@ -106,11 +121,14 @@ static struct perf_cpu_map *cpu_map__from_mask(const = struct perf_record_cpu_map_ return NULL; =20 for (int i =3D 0, j =3D 0; i < mask_nr; i++) { - int cpus_per_i =3D (i * data->mask32_data.long_size * BITS_PER_BYTE); + int cpus_per_i =3D (i * long_size * BITS_PER_BYTE); int cpu; =20 - perf_record_cpu_map_data__read_one_mask(data, i, local_copy); + perf_record_cpu_map_data__read_one_mask(data, i, local_copy, long_size); for_each_set_bit(cpu, local_copy, 64) { + /* Guard against more set bits than the first pass counted */ + if (j >=3D weight) + break; if (cpu + cpus_per_i < INT16_MAX) { RC_CHK_ACCESS(map)->map[j++].cpu =3D cpu + cpus_per_i; } else { @@ -126,18 +144,28 @@ static struct perf_cpu_map *cpu_map__from_mask(const = struct perf_record_cpu_map_ =20 static struct perf_cpu_map *cpu_map__from_range(const struct perf_record_c= pu_map_data *data) { + /* Snapshot fields =E2=80=94 data is mmap'd and could change between read= s */ + u16 start_cpu =3D READ_ONCE(data->range_cpu_data.start_cpu); + u16 end_cpu =3D READ_ONCE(data->range_cpu_data.end_cpu); + u16 any_cpu =3D READ_ONCE(data->range_cpu_data.any_cpu); struct perf_cpu_map *map; unsigned int i =3D 0; =20 - map =3D perf_cpu_map__empty_new(data->range_cpu_data.end_cpu - - data->range_cpu_data.start_cpu + 1 + data->range_cpu_data.any_cpu); + if (end_cpu < start_cpu) { + pr_warning("WARNING: cpu_map range: end_cpu %u < start_cpu %u\n", + end_cpu, start_cpu); + return NULL; + } + + /* any_cpu is boolean (0 or 1), not a count =E2=80=94 clamp to avoid infl= ated nr */ + map =3D perf_cpu_map__empty_new(end_cpu - start_cpu + 1 + !!any_cpu); if (!map) return NULL; =20 - if (data->range_cpu_data.any_cpu) + if (any_cpu) RC_CHK_ACCESS(map)->map[i++].cpu =3D -1; =20 - for (int cpu =3D data->range_cpu_data.start_cpu; cpu <=3D data->range_cpu= _data.end_cpu; + for (int cpu =3D start_cpu; cpu <=3D end_cpu; i++, cpu++) { if (cpu < INT16_MAX) { RC_CHK_ACCESS(map)->map[i].cpu =3D cpu; --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 74BB63B774A; Tue, 26 May 2026 21:19:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830345; cv=none; b=LFc1hFcprU6T1ed47FPDSNZwDjs7crn0d/tUNKxipsapFoQsVcEjdtI8VeWqauTieTVn+h83J77P0cBB4E5M8uWRg7BAxyd4rQOVvbmAsROXbUNmTKT/cDSNr6JIWjDzpr0nE5GZDyvTpSpM5a5lbVnv4iljL0tFtto59o0YH/E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830345; c=relaxed/simple; bh=c8LmFqoBwFFnW/2a+mXF84aFq6jEaI+1bdFDGhMSLJE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=IyPTyPyCdOsEjW0NllaNl3LkWgj7+Lq3ONqY/HUU9v8BJ742Bi50vQbXRS2l2vNTJO3b/khNlF2WDJhJxfg4aadyL437gOv3SUFnHdpHN8LqyC4sgMeR7ANUkKrTzejSvdgAGaxrKvTfqOcENsi7ny8ceCv3ZrsTys9MxsGZol4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=U36AiqFp; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="U36AiqFp" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 48B571F000E9; Tue, 26 May 2026 21:19:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830344; bh=9DK6QpOGTWcXfQ/MK9EZrQbmQtQu4Qk9L3Hajw1+8gw=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=U36AiqFpwofepRQtcWIVfvtq1XV0T/ONk4sF46Zs5mvwz25/nCxhkFrKK3LCaicG4 51Sc8AR3DBki2UoFRETVHCCwdk90NW71lbNQS9PC0PuTL0B0sMIglIvS02+/quUFBs K3vHF3fkilm6/n/TbnGDXckjs+o4KuArJtMyr7kWSEsIfMH4BHlNYSdY+J+DaQKQ7M 33CgUO7yA6ZnaU4Khi65KJsZ0X9JF8foyVQycymelfiF58Wv4SGl351wgUwRzTgTbd IoevKmgpDMoLhBPtaj6HpVaHm64Jr0BTD8P7EqU2JygBOkSRUraQQYHpwiVeAuO8jI 6A20y76CO9Fqg== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 14/29] perf auxtrace: Harden auxtrace_error event handling Date: Tue, 26 May 2026 18:17:50 -0300 Message-ID: <20260526211806.1193848-15-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Fix four issues in PERF_RECORD_AUXTRACE_ERROR handling: 1. auxtrace_error_name() takes a signed int parameter, but e->type is __u32. A crafted value like 0xFFFFFFFF converts to -1, passes the bounds check, and causes a negative array index. Fix by changing the parameter to unsigned int. 2. The msg field is printed via %s without a length bound. The min_size table only guarantees fields up to msg (offset 48), so a truncated event has zero msg bytes within the event boundary. Compute the available msg length from header.size, cap at sizeof(e->msg), and use %.*s. 3. fmt >=3D 2 adds machine_pid and vcpu fields after msg[64]. Older files may have fmt >=3D 2 but an event size that doesn't include these fields. Add a size check in the swap handler to downgrade fmt before the conditional field access, and a matching size guard in the fprintf path for native-endian events (which are mmap'd read-only and can't be modified in place). 4. python_process_auxtrace_error() had the same issues: msg was passed to tuple_set_string() unbounded, and machine_pid/vcpu were accessed unconditionally without checking fmt or event size. Apply the same bounds checks. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/auxtrace.c | 24 +++++++++++++--- .../scripting-engines/trace-event-python.c | 28 +++++++++++++++++-- tools/perf/util/session.c | 18 ++++++++++-- 3 files changed, 61 insertions(+), 9 deletions(-) diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c index a224687ffbc1b5be..d9770e1d2f959fc4 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -1759,7 +1759,7 @@ static const char * const auxtrace_error_type_name[] = =3D { [PERF_AUXTRACE_ERROR_ITRACE] =3D "instruction trace", }; =20 -static const char *auxtrace_error_name(int type) +static const char *auxtrace_error_name(unsigned int type) { const char *error_type_name =3D NULL; =20 @@ -1775,6 +1775,7 @@ size_t perf_event__fprintf_auxtrace_error(union perf_= event *event, FILE *fp) struct perf_record_auxtrace_error *e =3D &event->auxtrace_error; unsigned long long nsecs =3D e->time; const char *msg =3D e->msg; + int msg_max; int ret; =20 ret =3D fprintf(fp, " %s error type %u", @@ -1792,11 +1793,26 @@ size_t perf_event__fprintf_auxtrace_error(union per= f_event *event, FILE *fp) if (!e->fmt) msg =3D (const char *)&e->time; =20 - if (e->fmt >=3D 2 && e->machine_pid) + /* Bound msg to the bytes actually within the event, capped at the array = size */ + msg_max =3D (int)((void *)event + event->header.size - (void *)msg); + if (msg_max < 0) + msg_max =3D 0; + if (msg_max > (int)sizeof(e->msg)) + msg_max =3D sizeof(e->msg); + + /* + * Unlike the swap path which downgrades fmt in place, + * native-endian events are mmap'd read-only =E2=80=94 check size + * instead to avoid accessing machine_pid/vcpu OOB. + */ + if (e->fmt >=3D 2 && + event->header.size >=3D offsetof(typeof(event->auxtrace_error), vcpu)= + + sizeof(event->auxtrace_error.vcpu) && + e->machine_pid) ret +=3D fprintf(fp, " machine_pid %d vcpu %d", e->machine_pid, e->vcpu); =20 - ret +=3D fprintf(fp, " cpu %d pid %d tid %d ip %#"PRI_lx64" code %u: %s\n= ", - e->cpu, e->pid, e->tid, e->ip, e->code, msg); + ret +=3D fprintf(fp, " cpu %d pid %d tid %d ip %#"PRI_lx64" code %u: %.*s= \n", + e->cpu, e->pid, e->tid, e->ip, e->code, msg_max, msg); return ret; } =20 diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools= /perf/util/scripting-engines/trace-event-python.c index 8edd2f36e5a95829..cee1f32d70225cc7 100644 --- a/tools/perf/util/scripting-engines/trace-event-python.c +++ b/tools/perf/util/scripting-engines/trace-event-python.c @@ -1607,6 +1607,9 @@ static void python_process_auxtrace_error(struct perf= _session *session __maybe_u const char *handler_name =3D "auxtrace_error"; unsigned long long tm =3D e->time; const char *msg =3D e->msg; + s32 machine_pid =3D 0, vcpu =3D 0; + char msg_buf[MAX_AUXTRACE_ERROR_MSG + 1]; + int msg_max; PyObject *handler, *t; =20 handler =3D get_handler(handler_name); @@ -1618,6 +1621,25 @@ static void python_process_auxtrace_error(struct per= f_session *session __maybe_u msg =3D (const char *)&e->time; } =20 + /* Bound msg to the bytes within the event, ensure NUL-termination */ + msg_max =3D (int)((void *)event + event->header.size - (void *)msg); + if (msg_max <=3D 0) { + msg_buf[0] =3D '\0'; + } else { + if (msg_max > (int)sizeof(msg_buf) - 1) + msg_max =3D sizeof(msg_buf) - 1; + memcpy(msg_buf, msg, msg_max); + msg_buf[msg_max] =3D '\0'; + } + + /* Only access fmt >=3D 2 fields if the event is large enough */ + if (e->fmt >=3D 2 && + event->header.size >=3D offsetof(typeof(event->auxtrace_error), vcpu)= + + sizeof(event->auxtrace_error.vcpu)) { + machine_pid =3D e->machine_pid; + vcpu =3D e->vcpu; + } + t =3D tuple_new(11); =20 tuple_set_u32(t, 0, e->type); @@ -1627,10 +1649,10 @@ static void python_process_auxtrace_error(struct pe= rf_session *session __maybe_u tuple_set_s32(t, 4, e->tid); tuple_set_u64(t, 5, e->ip); tuple_set_u64(t, 6, tm); - tuple_set_string(t, 7, msg); + tuple_set_string(t, 7, msg_buf); tuple_set_u32(t, 8, cpumode); - tuple_set_s32(t, 9, e->machine_pid); - tuple_set_s32(t, 10, e->vcpu); + tuple_set_s32(t, 9, machine_pid); + tuple_set_s32(t, 10, vcpu); =20 call_object(handler, t, handler_name); =20 diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 0fac8f4e0e22310f..092fccbea8f8017e 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -766,8 +766,22 @@ static int perf_event__auxtrace_error_swap(union perf_= event *event, if (event->auxtrace_error.fmt) event->auxtrace_error.time =3D bswap_64(event->auxtrace_error.time); if (event->auxtrace_error.fmt >=3D 2) { - event->auxtrace_error.machine_pid =3D bswap_32(event->auxtrace_error.mac= hine_pid); - event->auxtrace_error.vcpu =3D bswap_32(event->auxtrace_error.vcpu); + /* + * fmt >=3D 2 adds machine_pid and vcpu after msg[64]. + * Older files may have fmt >=3D 2 but an event size + * that doesn't include these fields =E2=80=94 downgrade to + * avoid swapping out of bounds. + */ + if (event->header.size < offsetof(typeof(event->auxtrace_error), vcpu) + + sizeof(event->auxtrace_error.vcpu)) { + pr_warning("WARNING: PERF_RECORD_AUXTRACE_ERROR: fmt %u but event too s= mall for machine_pid/vcpu (%u bytes), downgrading fmt\n", + event->auxtrace_error.fmt, + event->header.size); + event->auxtrace_error.fmt =3D 1; + } else { + event->auxtrace_error.machine_pid =3D bswap_32(event->auxtrace_error.ma= chine_pid); + event->auxtrace_error.vcpu =3D bswap_32(event->auxtrace_error.vcpu); + } } return 0; } --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AC1853C09E6; Tue, 26 May 2026 21:19:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830349; cv=none; b=b5EV1JniQRRQhXPiRjqDydQlynrgY55SktZAPiiwajJmYU2CkhwlzsGW7QB+I9yPTO+oWixwO4KRnca3uUmnZvkU5RZ4um0ltwTSGWB2mVJ2jaz8Vl7iNnhCdYubJI/pq1o7pBdoVe+H8XtxEKxFG45xlcxIodsraLpdAU2Og2Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830349; c=relaxed/simple; bh=lV3o7wSqt6gf7qo3X4B75PPG9EyW2b4n3mNAXZLNqiM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=W8aexNlkd60gezrh1dUZHpgpn6KwzHkUVurhKoceDtvSFvKoy3fEWwdIO2K0HKWghG9/N+XjmnpSpiZjikJ/hyjjUJKiPBRVqnEXGzSp/ikpExPdjipsHR0sKFNDFnUWd4fqbOHZaA5oIFz1oYG29gE9k2RBwbVK8zDGHKv5mmY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LtXP/cpb; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="LtXP/cpb" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 92FCB1F00A3A; Tue, 26 May 2026 21:19:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830347; bh=0jd9gLHDEow7WRRukiyWGgglP3tX3lCGhXqiW8lqeyI=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=LtXP/cpbabAZVhmf0WUSdjjs1oRLUIvq9yliyGOHXRIaAefPBoNpQWFcuywKKtvqh SiAvWLREwnrCc4i+SHDPF9En9CChge72oyY1GPKTr8VMX3q0TlBfkZWOdszPtZx7RL tBVBI/hP4YpvlJMHTYDvxWjmY6qkEw25hQk/U/ysk6LS2SP6ZVykDNwzJvZeVN/sNu +ZCPiNHSaSwcQcYgE4PA09RZeC73+gXPFiCc8iVWshPvu9Xn+3yxyjdMlkfOMF6CWp Zzv77Dxh6NJEM5GkEBRCPk3LwUXp1mX7JiuCJqb5Wk/S9t7U5pLkwN4gb96rEfDRjm MgBZANERiVegA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, Blake Jones , "Claude Opus 4.6 (1M context)" Subject: [PATCH 15/29] perf session: Add byte-swap and bounds check for PERF_RECORD_BPF_METADATA events Date: Tue, 26 May 2026 18:17:51 -0300 Message-ID: <20260526211806.1193848-16-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo PERF_RECORD_BPF_METADATA has no entry in perf_event__swap_ops[], so its nr_entries field is never byte-swapped when reading a cross-endian perf.data file. Downstream processing in perf_event__fprintf_bpf_metadata() loops over nr_entries, so a foreign-endian value causes out-of-bounds reads. Add a swap handler that byte-swaps nr_entries after validating that header.size is large enough. The entries[] array contains only char arrays (key/value strings), so no per-entry swap is needed =E2=80=94 but en= sure NUL-termination on the writable cross-endian path. Validate header.size, nr_entries, and string NUL-termination in the common event delivery path so that native-endian files with malicious values are also rejected. Snapshot nr_entries via READ_ONCE() before validation =E2=80=94 the event is on a MAP_SHARED mmap that could theoretic= ally change between the bounds check and the loop. Changes in v2: - Snapshot event->header.size via READ_ONCE() into a local variable to prevent a double-fetch underflow in the max_entries calculation (Reported-by: sashiko-bot@kernel.org) - Write back clamped nr_entries to the event on the swap path, consistent with NAMESPACES and STAT_CONFIG handlers =E2=80=94 without writeback the native path sees the inflated nr and skips the event entirely (Reported-by: sashiko-bot@kernel.org) Fixes: ab38e84ba9a8 ("perf record: collect BPF metadata from existing BPF p= rograms") Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Blake Jones Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 89 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 88 insertions(+), 1 deletion(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 092fccbea8f8017e..95eb793026de6d8d 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -961,6 +961,48 @@ static int perf_event__time_conv_swap(union perf_event= *event, return 0; } =20 +static int perf_event__bpf_metadata_swap(union perf_event *event, + bool sample_id_all __maybe_unused) +{ + u64 i, nr, max_nr; + + /* Fixed header must fit before accessing nr_entries or prog_name */ + if (event->header.size < sizeof(event->bpf_metadata)) + return -1; + + event->bpf_metadata.nr_entries =3D bswap_64(event->bpf_metadata.nr_entrie= s); + + /* + * Ensure NUL-termination on the cross-endian path where the + * mapping is writable (MAP_PRIVATE + PROT_WRITE). Fixing + * the string in place is preferred over rejecting because it + * preserves the event for downstream processing =E2=80=94 only the + * last byte is lost. + * + * The native-endian path (MAP_SHARED + PROT_READ) cannot + * write, so it validates and skips unterminated events in + * perf_session__process_user_event() instead. The two + * strategies produce different outcomes for the same + * malformed input (fix vs skip), which is inherent in the + * writable-vs-read-only mapping model. + */ + event->bpf_metadata.prog_name[BPF_PROG_NAME_LEN - 1] =3D '\0'; + + nr =3D event->bpf_metadata.nr_entries; + max_nr =3D (event->header.size - sizeof(event->bpf_metadata)) / + sizeof(event->bpf_metadata.entries[0]); + if (nr > max_nr) { + /* Persist clamped value so the native path processes entries, not skips= */ + nr =3D max_nr; + event->bpf_metadata.nr_entries =3D nr; + } + + for (i =3D 0; i < nr; i++) { + event->bpf_metadata.entries[i].key[BPF_METADATA_KEY_LEN - 1] =3D '\0'; + event->bpf_metadata.entries[i].value[BPF_METADATA_VALUE_LEN - 1] =3D '\0= '; + } + return 0; +} static int perf_event__schedstat_cpu_swap(union perf_event *event __maybe_unused, bool sample_id_all __maybe_unused) @@ -1060,6 +1102,7 @@ static perf_event__swap_op perf_event__swap_ops[] =3D= { [PERF_RECORD_STAT_ROUND] =3D perf_event__stat_round_swap, [PERF_RECORD_EVENT_UPDATE] =3D perf_event__event_update_swap, [PERF_RECORD_TIME_CONV] =3D perf_event__time_conv_swap, + [PERF_RECORD_BPF_METADATA] =3D perf_event__bpf_metadata_swap, [PERF_RECORD_SCHEDSTAT_CPU] =3D perf_event__schedstat_cpu_swap, [PERF_RECORD_SCHEDSTAT_DOMAIN] =3D perf_event__schedstat_domain_swap, [PERF_RECORD_HEADER_MAX] =3D NULL, @@ -2203,9 +2246,53 @@ static s64 perf_session__process_user_event(struct p= erf_session *session, case PERF_RECORD_FINISHED_INIT: err =3D tool->finished_init(tool, session, event); break; - case PERF_RECORD_BPF_METADATA: + case PERF_RECORD_BPF_METADATA: { + u64 nr_entries, max_entries; + u32 hdr_size =3D READ_ONCE(event->header.size); + + if (hdr_size < sizeof(event->bpf_metadata)) { + pr_warning("WARNING: PERF_RECORD_BPF_METADATA: header.size (%u) too sma= ll, skipping\n", + hdr_size); + err =3D 0; + break; + } + + /* + * Native-endian files are mmap'd read-only =E2=80=94 validate + * NUL-termination instead of writing. + */ + if (strnlen(event->bpf_metadata.prog_name, + BPF_PROG_NAME_LEN) =3D=3D BPF_PROG_NAME_LEN) { + pr_warning("WARNING: PERF_RECORD_BPF_METADATA: prog_name not null-termi= nated, skipping\n"); + err =3D 0; + break; + } + + /* Snapshot =E2=80=94 event is mmap'd and could change between reads */ + nr_entries =3D READ_ONCE(event->bpf_metadata.nr_entries); + max_entries =3D (hdr_size - sizeof(event->bpf_metadata)) / + sizeof(event->bpf_metadata.entries[0]); + if (nr_entries > max_entries) { + pr_warning("WARNING: PERF_RECORD_BPF_METADATA: nr_entries %" PRIu64 " e= xceeds max %" PRIu64 ", skipping\n", + nr_entries, max_entries); + err =3D 0; + break; + } + + for (u64 i =3D 0; i < nr_entries; i++) { + if (strnlen(event->bpf_metadata.entries[i].key, + BPF_METADATA_KEY_LEN) =3D=3D BPF_METADATA_KEY_LEN || + strnlen(event->bpf_metadata.entries[i].value, + BPF_METADATA_VALUE_LEN) =3D=3D BPF_METADATA_VALUE_LEN) { + pr_warning("WARNING: PERF_RECORD_BPF_METADATA: entry %" PRIu64 " key/v= alue not null-terminated, skipping\n", i); + err =3D 0; + goto out; + } + } + err =3D tool->bpf_metadata(tool, session, event); break; + } case PERF_RECORD_SCHEDSTAT_CPU: err =3D tool->schedstat_cpu(tool, session, event); break; --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3686A3C1F50; Tue, 26 May 2026 21:19:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830352; cv=none; b=o8uyn4eC9eaTx0pylYkPPBT2r3zLyVYCa7O/ZoKCCbgcmEYXQcLqddy4Z04mqmSxMDqMP+ciqUNvL/dkrD47yGhJj4/MUlEuZpfJO+OgVzSXmkUyVz7BnuzkT0hitX2zBNUr82SFqPY2j1KP+UvZkaJnziGbE2CVGgxDtf3mqyA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830352; c=relaxed/simple; bh=T8lyPQAmftbTGhbsCJSWbiwQAjA7UjnhXJELe3ZByuI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=TR691wYuXWS0O5fsphdr1fM8vlD5nJmZuxE+/TS8iWo/bQj6HTtdvvbE2hoKeN7CZOxcyN1Wo7TtP0Jp6JH3rKtrgFh9n7AETdzgLjbWRGPcW4Zl1tceb351R7pkjV+tHP3+GX9yGXaNeyoORqSLNgQWuV92GjC4/snLTeozxyg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Z1YjVBdc; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Z1YjVBdc" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0F88B1F000E9; Tue, 26 May 2026 21:19:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830350; bh=+9cKaWbIh+Vw1PR+pWyKXFZuwH9ByvWNQeiRkqjkmqU=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Z1YjVBdcgzRmH0GzCShkLDum3jJ+n5nMrwiZuylLzsxrLt9KyD8zEYiIy9ECS1ZGC q0xlqRpVv+lk6uY3cXiCMaMUUy+wv38prqxGstCciU52VkE/LZ5NSrgYKPbyPdFuHT wYsHK6tZatnsLmJAs8GGdLlldIRPb9Kq8l4eCxnHcEdQyHVsgpltcatxYc9Dn0brP0 dO9d+0hC0Y1nIvmrXGgP3X+wf4OQXCEJWbk1M2h4X6DsHjQxaASTkpe0WE4sXGpu4z n0ehxDtwVdceK8HbgKSYDAJf4EMTaUxfwed3xIN3UfyF/vzJTjUTGOP99K00XCuo21 taRoww3LXVGgg== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 16/29] perf header: Validate null-termination in PERF_RECORD_EVENT_UPDATE string fields Date: Tue, 26 May 2026 18:17:52 -0300 Message-ID: <20260526211806.1193848-17-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo strdup(ev->unit) and strdup(ev->name) read until '\0' with no guarantee the string is null-terminated within event->header.size. The dump_trace fprintf path has the same problem with %s. Validate before either path runs =E2=80=94 same class of bug fixed for MMAP/MMAP2/COMM/CGROUP by perf_event__check_nul(). Also harden the event_update swap handler to: - Validate SCALE event size before swapping the double at offset 24, which exceeds the 24-byte min_size. - Validate CPUS event size before accessing the cpu_map type/nr/long_size fields, which also start at the min_size boundary. - Swap CPUS variant fields (type, nr, long_size) so the processing path sees native byte order. Add validation in perf_event__process_event_update() for all event update variants (UNIT, NAME, SCALE, CPUS) before dump_trace or processing. Validate CPUS nr against payload size for both PERF_CPU_MAP__CPUS and PERF_CPU_MAP__MASK types on the fprintf (dump_trace) path: - CPUS: check nr does not exceed available cpu entries - MASK: check nr does not exceed available mask entries for both mask32 (long_size =3D=3D 4) and mask64 (long_size =3D=3D 8) layouts, with underflow guards on the offsetof subtraction Fix a missing break before the default case in the CPUS switch path. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 150 ++++++++++++++++++++++++++++++++++++-- tools/perf/util/session.c | 99 ++++++++++++++++++++++++- 2 files changed, 242 insertions(+), 7 deletions(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index c0b5c99f462ad925..9e3a08b1f8ae5a73 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -5117,15 +5117,76 @@ size_t perf_event__fprintf_event_update(union perf_= event *event, FILE *fp) =20 switch (ev->type) { case PERF_EVENT_UPDATE__SCALE: + if (event->header.size < offsetof(struct perf_record_event_update, scale= ) + + sizeof(ev->scale)) { + ret +=3D fprintf(fp, "... scale: (truncated)\n"); + break; + } ret +=3D fprintf(fp, "... scale: %f\n", ev->scale.scale); break; case PERF_EVENT_UPDATE__UNIT: - ret +=3D fprintf(fp, "... unit: %s\n", ev->unit); - break; - case PERF_EVENT_UPDATE__NAME: - ret +=3D fprintf(fp, "... name: %s\n", ev->name); + case PERF_EVENT_UPDATE__NAME: { + size_t str_off =3D offsetof(struct perf_record_event_update, unit); + size_t max_len =3D event->header.size > str_off ? + event->header.size - str_off : 0; + + if (max_len =3D=3D 0 || strnlen(ev->unit, max_len) =3D=3D max_len) { + ret +=3D fprintf(fp, "... %s: (unterminated)\n", + ev->type =3D=3D PERF_EVENT_UPDATE__UNIT ? "unit" : "name"); + break; + } + ret +=3D fprintf(fp, "... %s: %s\n", + ev->type =3D=3D PERF_EVENT_UPDATE__UNIT ? "unit" : "name", + ev->unit); break; - case PERF_EVENT_UPDATE__CPUS: + } + case PERF_EVENT_UPDATE__CPUS: { + size_t cpus_off =3D offsetof(struct perf_record_event_update, cpus); + u32 cpus_payload; + + if (event->header.size < cpus_off + sizeof(__u16) + + sizeof(struct perf_record_range_cpu_map)) { + ret +=3D fprintf(fp, "... cpus: (truncated)\n"); + break; + } + + /* + * Validate nr against payload =E2=80=94 this function may be + * called from the stub handler (dump_trace path) which + * bypasses perf_event__process_event_update() validation. + */ + cpus_payload =3D event->header.size - cpus_off; + if (ev->cpus.cpus.type =3D=3D PERF_CPU_MAP__CPUS) { + if (cpus_payload < offsetof(struct perf_record_cpu_map_data, cpus_data.= cpu) || + ev->cpus.cpus.cpus_data.nr > + (cpus_payload - offsetof(struct perf_record_cpu_map_data, cpus_data= .cpu)) / + sizeof(ev->cpus.cpus.cpus_data.cpu[0])) { + ret +=3D fprintf(fp, "... cpus: nr %u exceeds payload\n", + ev->cpus.cpus.cpus_data.nr); + break; + } + } else if (ev->cpus.cpus.type =3D=3D PERF_CPU_MAP__MASK) { + if (ev->cpus.cpus.mask32_data.long_size =3D=3D 4) { + if (cpus_payload < offsetof(struct perf_record_cpu_map_data, mask32_da= ta.mask) || + ev->cpus.cpus.mask32_data.nr > + (cpus_payload - offsetof(struct perf_record_cpu_map_data, mask32_d= ata.mask)) / + sizeof(ev->cpus.cpus.mask32_data.mask[0])) { + ret +=3D fprintf(fp, "... cpus: mask nr %u exceeds payload\n", + ev->cpus.cpus.mask32_data.nr); + break; + } + } else if (ev->cpus.cpus.mask64_data.long_size =3D=3D 8) { + if (cpus_payload < offsetof(struct perf_record_cpu_map_data, mask64_da= ta.mask) || + ev->cpus.cpus.mask64_data.nr > + (cpus_payload - offsetof(struct perf_record_cpu_map_data, mask64_d= ata.mask)) / + sizeof(ev->cpus.cpus.mask64_data.mask[0])) { + ret +=3D fprintf(fp, "... cpus: mask nr %u exceeds payload\n", + ev->cpus.cpus.mask64_data.nr); + break; + } + } + } + ret +=3D fprintf(fp, "... "); =20 map =3D cpu_map__new_data(&ev->cpus.cpus); @@ -5135,6 +5196,7 @@ size_t perf_event__fprintf_event_update(union perf_ev= ent *event, FILE *fp) } else ret +=3D fprintf(fp, "failed to get cpus\n"); break; + } default: ret +=3D fprintf(fp, "... unknown type\n"); break; @@ -5269,6 +5331,83 @@ int perf_event__process_event_update(const struct pe= rf_tool *tool __maybe_unused struct evsel *evsel; struct perf_cpu_map *map; =20 + /* + * Validate payload before dump_trace or processing =E2=80=94 both + * paths access variant-specific fields without further checks. + */ + if (ev->type =3D=3D PERF_EVENT_UPDATE__UNIT || + ev->type =3D=3D PERF_EVENT_UPDATE__NAME) { + size_t str_off =3D offsetof(struct perf_record_event_update, unit); + size_t max_len =3D event->header.size > str_off ? + event->header.size - str_off : 0; + + if (max_len =3D=3D 0 || strnlen(ev->unit, max_len) =3D=3D max_len) { + pr_warning("WARNING: PERF_RECORD_EVENT_UPDATE: %s not null-terminated, = skipping\n", + ev->type =3D=3D PERF_EVENT_UPDATE__UNIT ? "unit" : "name"); + return 0; + } + } else if (ev->type =3D=3D PERF_EVENT_UPDATE__SCALE) { + if (event->header.size < offsetof(struct perf_record_event_update, scale= ) + + sizeof(ev->scale)) { + pr_warning("WARNING: PERF_RECORD_EVENT_UPDATE: SCALE payload too small,= skipping\n"); + return 0; + } + } else if (ev->type =3D=3D PERF_EVENT_UPDATE__CPUS) { + size_t cpus_off =3D offsetof(struct perf_record_event_update, cpus); + size_t min_cpus =3D sizeof(__u16) + + sizeof(struct perf_record_range_cpu_map); + u32 cpus_payload; + + if (event->header.size < cpus_off + min_cpus) { + pr_warning("WARNING: PERF_RECORD_EVENT_UPDATE: CPUS payload too small, = skipping\n"); + return 0; + } + + /* + * Validate per-variant nr against the remaining + * payload on the native path =E2=80=94 the swap path clamps + * nr in perf_event__event_update_swap(), but native + * events are read-only and cannot be clamped in place. + * cpu_map__new_data() trusts nr for allocation and + * iteration, so unchecked values cause OOB reads. + */ + cpus_payload =3D event->header.size - cpus_off; + switch (ev->cpus.cpus.type) { + case PERF_CPU_MAP__CPUS: + if (ev->cpus.cpus.cpus_data.nr > + (cpus_payload - offsetof(struct perf_record_cpu_map_data, cpus_data= .cpu)) / + sizeof(ev->cpus.cpus.cpus_data.cpu[0])) { + pr_warning("WARNING: EVENT_UPDATE CPUS: nr %u exceeds payload, skippin= g\n", + ev->cpus.cpus.cpus_data.nr); + return 0; + } + break; + case PERF_CPU_MAP__MASK: + if (ev->cpus.cpus.mask32_data.long_size =3D=3D 4) { + if (cpus_payload < offsetof(struct perf_record_cpu_map_data, mask32_da= ta.mask) || + ev->cpus.cpus.mask32_data.nr > + (cpus_payload - offsetof(struct perf_record_cpu_map_data, mask32_d= ata.mask)) / + sizeof(ev->cpus.cpus.mask32_data.mask[0])) { + pr_warning("WARNING: EVENT_UPDATE MASK: nr %u exceeds payload, skippi= ng\n", + ev->cpus.cpus.mask32_data.nr); + return 0; + } + } else if (ev->cpus.cpus.mask64_data.long_size =3D=3D 8) { + if (cpus_payload < offsetof(struct perf_record_cpu_map_data, mask64_da= ta.mask) || + ev->cpus.cpus.mask64_data.nr > + (cpus_payload - offsetof(struct perf_record_cpu_map_data, mask64_d= ata.mask)) / + sizeof(ev->cpus.cpus.mask64_data.mask[0])) { + pr_warning("WARNING: EVENT_UPDATE MASK: nr %u exceeds payload, skippi= ng\n", + ev->cpus.cpus.mask64_data.nr); + return 0; + } + } + break; + default: + break; + } + } + if (dump_trace) perf_event__fprintf_event_update(event, stdout); =20 @@ -5300,6 +5439,7 @@ int perf_event__process_event_update(const struct per= f_tool *tool __maybe_unused evsel->core.pmu_cpus =3D map; } else pr_err("failed to get event_update cpus\n"); + break; default: break; } diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 95eb793026de6d8d..8280413f4528f53c 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -708,8 +708,103 @@ static int perf_event__build_id_swap(union perf_event= *event, static int perf_event__event_update_swap(union perf_event *event, bool sample_id_all __maybe_unused) { - event->event_update.type =3D bswap_64(event->event_update.type); - event->event_update.id =3D bswap_64(event->event_update.id); + struct perf_record_event_update *ev =3D &event->event_update; + + ev->type =3D bswap_64(ev->type); + ev->id =3D bswap_64(ev->id); + + /* + * Swap variant-specific fields so the processing path + * sees native byte order. + */ + if (ev->type =3D=3D PERF_EVENT_UPDATE__SCALE) { + if (event->header.size < offsetof(struct perf_record_event_update, scale= ) + + sizeof(ev->scale)) + return -1; + mem_bswap_64(&ev->scale.scale, sizeof(ev->scale.scale)); + } else if (ev->type =3D=3D PERF_EVENT_UPDATE__CPUS) { + u32 cpus_payload; + struct perf_record_cpu_map_data *data =3D &ev->cpus.cpus; + + /* CPUS fields start at the same offset as scale (union) */ + if (event->header.size < offsetof(struct perf_record_event_update, cpus)= + + sizeof(__u16) + sizeof(struct perf_record_range_cpu_map)) + return -1; + cpus_payload =3D event->header.size - offsetof(struct perf_record_event_= update, cpus); + data->type =3D bswap_16(data->type); + /* + * Full swap including array elements =E2=80=94 same logic as + * perf_event__cpu_map_swap() but scoped to the + * embedded cpu_map_data within EVENT_UPDATE. + */ + switch (data->type) { + case PERF_CPU_MAP__CPUS: { + u16 nr, max_nr; + + data->cpus_data.nr =3D bswap_16(data->cpus_data.nr); + nr =3D data->cpus_data.nr; + max_nr =3D (cpus_payload - offsetof(struct perf_record_cpu_map_data, + cpus_data.cpu)) / + sizeof(data->cpus_data.cpu[0]); + if (nr > max_nr) { + nr =3D max_nr; + data->cpus_data.nr =3D nr; + } + for (unsigned int i =3D 0; i < nr; i++) + data->cpus_data.cpu[i] =3D bswap_16(data->cpus_data.cpu[i]); + break; + } + case PERF_CPU_MAP__MASK: + data->mask32_data.long_size =3D bswap_16(data->mask32_data.long_size); + switch (data->mask32_data.long_size) { + case 4: { + u16 nr, max_nr; + + data->mask32_data.nr =3D bswap_16(data->mask32_data.nr); + nr =3D data->mask32_data.nr; + max_nr =3D (cpus_payload - offsetof(struct perf_record_cpu_map_data, + mask32_data.mask)) / + sizeof(data->mask32_data.mask[0]); + if (nr > max_nr) { + nr =3D max_nr; + data->mask32_data.nr =3D nr; + } + for (unsigned int i =3D 0; i < nr; i++) + data->mask32_data.mask[i] =3D bswap_32(data->mask32_data.mask[i]); + break; + } + case 8: { + u16 nr, max_nr; + + data->mask64_data.nr =3D bswap_16(data->mask64_data.nr); + nr =3D data->mask64_data.nr; + if (cpus_payload < offsetof(struct perf_record_cpu_map_data, mask64_da= ta.mask)) { + data->mask64_data.nr =3D 0; + break; + } + max_nr =3D (cpus_payload - offsetof(struct perf_record_cpu_map_data, + mask64_data.mask)) / + sizeof(data->mask64_data.mask[0]); + if (nr > max_nr) { + nr =3D max_nr; + data->mask64_data.nr =3D nr; + } + for (unsigned int i =3D 0; i < nr; i++) + data->mask64_data.mask[i] =3D bswap_64(data->mask64_data.mask[i]); + break; + } + default: + break; + } + break; + case PERF_CPU_MAP__RANGE_CPUS: + data->range_cpu_data.start_cpu =3D bswap_16(data->range_cpu_data.start_= cpu); + data->range_cpu_data.end_cpu =3D bswap_16(data->range_cpu_data.end_cpu); + break; + default: + break; + } + } return 0; } =20 --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4094D3C1F48; Tue, 26 May 2026 21:19:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830355; cv=none; b=gIvcWBaSBTVx2oZqVx4fFgehBwBfI/bEnNUv8JPHD9McCGZV1IYD/1pH43sHleG29S4m5FoLP8vShHS4pqKapBdxwiunoPO9LsX6uh/xcdM7h+O9GgXQzo6484RD8fM0MRWHmf0GNFT8I/r9D2+ZGKct7guoHu40bxhFrQrZTis= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830355; c=relaxed/simple; bh=u751ixX0jEHsdPlMqWV97szdRNRjH9sHNZMGQb3GjAI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=jidDO2oFQY5QsXZklBchMIf+j5ZGRnvJxEjOy2WxuQBq2COajxhE+ck3+L6zTewPRV/7rsKOr26DKcs+Oydjs2lvkd52Tlcy0PesXXDmvX3VfbhG4ZUrGu9onKSh5zNhT86JnPchh18evEo9wE2Hwmfr9uulh8YD1nVuJeG9POA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TvLEDeR5; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="TvLEDeR5" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5379B1F00A3A; Tue, 26 May 2026 21:19:11 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830354; bh=Jfgzy8boP/NNe/LEp+Qb45IhBF9e22pQs6ylpcebsJQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=TvLEDeR5rB0QEnmhzz02x75Bdcy1B0SLbcaVNzylKmVxuSFLZGBzPFq1ijVyi8MLH 25I//Z5IAP4XfXPcVSzyu9bz9VCa4dYbbLlSWiBPZTG8wkWJEoBhWvyGeC/mR3Hg3E rqhURYp0pQZYiH1iHWopQHCcSDuEq+YFeoPntp1OwtwN/df2ZW7rWRRqWcYmXjquGx x4sdHWBO5Po6gNoPYFhPcRcwSnnO78SMtS+375D5/8/Dl9QHoxKaryXS7zj4tc1x6y N957CSXu6oa3q/fCCs5n03dhsjRfFnrt5YzrCYES0AmN32hxQXxq4/LqYU9xF6cC2u A4eCdQYMdJzQg== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 17/29] perf tools: Bounds check perf_event_attr fields against attr.size before printing Date: Tue, 26 May 2026 18:17:53 -0300 Message-ID: <20260526211806.1193848-18-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo perf_event_attr__fprintf() accessed all struct fields unconditionally, but attrs from older perf.data files or BPF-captured syscall payloads may have a smaller size than the current struct. Fields beyond the recorded size contain uninitialized or zero-filled data. Add size-guarded macros (PRINT_ATTRn, PRINT_ATTRn_bf) that compare each field's offset against attr->size before accessing it. Guard the bitfield block (disabled, inherit, ... defer_output) with attr_size >=3D 48. These bitfields share a single __u64 at offset 40, which is within PERF_ATTR_SIZE_VER0 for validated perf.data attrs, but BPF-captured attrs from perf trace can have a smaller size when the tracee passes a minimal struct to sys_perf_event_open. Also fix the BPF trace path: when perf trace intercepts sys_perf_event_open via BPF, the program copies PERF_ATTR_SIZE_VER0 bytes when the tracee passes size=3D0, but leaves the size field as 0. Set attr->size to PERF_ATTR_SIZE_VER0 in the augmented syscall handler so the bounds checks match the actual copied size. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/trace/beauty/perf_event_open.c | 23 +++- tools/perf/util/perf_event_attr_fprintf.c | 141 ++++++++++++++-------- 2 files changed, 114 insertions(+), 50 deletions(-) diff --git a/tools/perf/trace/beauty/perf_event_open.c b/tools/perf/trace/b= eauty/perf_event_open.c index c1c7445dcff994cb..6315b46bcdf02b8c 100644 --- a/tools/perf/trace/beauty/perf_event_open.c +++ b/tools/perf/trace/beauty/perf_event_open.c @@ -1,4 +1,5 @@ // SPDX-License-Identifier: LGPL-2.1 +#include #include "trace/beauty/beauty.h" #include "util/evsel_fprintf.h" #include @@ -80,7 +81,27 @@ static size_t perf_event_attr___scnprintf(struct perf_ev= ent_attr *attr, char *bf =20 static size_t syscall_arg__scnprintf_augmented_perf_event_attr(struct sysc= all_arg *arg, char *bf, size_t size) { - return perf_event_attr___scnprintf((void *)arg->augmented.args->value, bf= , size, + struct perf_event_attr *attr =3D (void *)arg->augmented.args->value; + struct perf_event_attr local_attr; + + /* + * augmented_raw_syscalls.bpf.c (shipped with perf) copies + * PERF_ATTR_SIZE_VER0 bytes when the tracee passes size=3D0, + * but leaves the size field as 0. The payload size is + * guaranteed by perf's own BPF program, not externally + * controllable. Copy to a local so we can fix up size + * without writing to the potentially read-only augmented + * args buffer. + */ + if (!attr->size) { + memcpy(&local_attr, attr, PERF_ATTR_SIZE_VER0); + memset((void *)&local_attr + PERF_ATTR_SIZE_VER0, 0, + sizeof(local_attr) - PERF_ATTR_SIZE_VER0); + local_attr.size =3D PERF_ATTR_SIZE_VER0; + attr =3D &local_attr; + } + + return perf_event_attr___scnprintf(attr, bf, size, trace__show_zeros(arg->trace)); } =20 diff --git a/tools/perf/util/perf_event_attr_fprintf.c b/tools/perf/util/pe= rf_event_attr_fprintf.c index 741c3d657a8b6ae7..3933639d76c54bb3 100644 --- a/tools/perf/util/perf_event_attr_fprintf.c +++ b/tools/perf/util/perf_event_attr_fprintf.c @@ -275,24 +275,56 @@ static void __p_config_id(struct perf_pmu *pmu, char = *buf, size_t size, u32 type #define p_type_id(val) __p_type_id(buf, BUF_SIZE, pmu, val) #define p_config_id(val) __p_config_id(pmu, buf, BUF_SIZE, attr->type, val) =20 -#define PRINT_ATTRn(_n, _f, _p, _a) \ -do { \ - if (_a || attr->_f) { \ - _p(attr->_f); \ - ret +=3D attr__fprintf(fp, _n, buf, priv);\ - } \ +#define PRINT_ATTRn(_n, _f, _p, _a) \ +do { \ + if (attr_size >=3D offsetof(struct perf_event_attr, _f) + \ + sizeof(attr->_f) && \ + (_a || attr->_f)) { \ + _p(attr->_f); \ + ret +=3D attr__fprintf(fp, _n, buf, priv); \ + } \ +} while (0) + +/* bitfield members share an offset; most are within PERF_ATTR_SIZE_VER0 */ +#define PRINT_ATTRn_bf(_n, _f, _p, _a) \ +do { \ + if (_a || attr->_f) { \ + _p(attr->_f); \ + ret +=3D attr__fprintf(fp, _n, buf, priv); \ + } \ } while (0) =20 #define PRINT_ATTRf(_f, _p) PRINT_ATTRn(#_f, _f, _p, false) +#define PRINT_ATTRf_bf(_f, _p) PRINT_ATTRn_bf(#_f, _f, _p, false) =20 int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr, attr__fprintf_f attr__fprintf, void *priv) { struct perf_pmu *pmu =3D perf_pmus__find_by_type(attr->type); + /* + * size =3D=3D 0 means ABI0 =E2=80=94 the producer didn't set attr.size. + * perf_event__fprintf_attr() may pass the raw mmap'd event + * before the local copy, so default to PERF_ATTR_SIZE_VER0 + * (the ABI0 footprint) to avoid reading past the attr into + * the ID array that follows it in HEADER_ATTR events. + */ + u32 attr_size =3D attr->size ?: PERF_ATTR_SIZE_VER0; char buf[BUF_SIZE]; int ret =3D 0; =20 - if (!pmu && (attr->type =3D=3D PERF_TYPE_HARDWARE || attr->type =3D=3D PE= RF_TYPE_HW_CACHE)) { + /* + * Cap to what we understand: all callers store the attr in a + * buffer of sizeof(*attr) bytes (perf.data read path copies + * min(attr.size, sizeof), BPF augmented path copies into a + * fixed-size value[] array). A spoofed attr->size larger + * than sizeof would cause PRINT_ATTRn to read past the + * actual buffer. + */ + if (attr_size > sizeof(*attr)) + attr_size =3D sizeof(*attr); + + if (!pmu && attr_size >=3D offsetof(struct perf_event_attr, config) + siz= eof(attr->config) && + (attr->type =3D=3D PERF_TYPE_HARDWARE || attr->type =3D=3D PERF_TYPE_= HW_CACHE)) { u32 extended_type =3D attr->config >> PERF_PMU_TYPE_SHIFT; =20 if (extended_type) @@ -306,45 +338,53 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_ev= ent_attr *attr, PRINT_ATTRf(sample_type, p_sample_type); PRINT_ATTRf(read_format, p_read_format); =20 - PRINT_ATTRf(disabled, p_unsigned); - PRINT_ATTRf(inherit, p_unsigned); - PRINT_ATTRf(pinned, p_unsigned); - PRINT_ATTRf(exclusive, p_unsigned); - PRINT_ATTRf(exclude_user, p_unsigned); - PRINT_ATTRf(exclude_kernel, p_unsigned); - PRINT_ATTRf(exclude_hv, p_unsigned); - PRINT_ATTRf(exclude_idle, p_unsigned); - PRINT_ATTRf(mmap, p_unsigned); - PRINT_ATTRf(comm, p_unsigned); - PRINT_ATTRf(freq, p_unsigned); - PRINT_ATTRf(inherit_stat, p_unsigned); - PRINT_ATTRf(enable_on_exec, p_unsigned); - PRINT_ATTRf(task, p_unsigned); - PRINT_ATTRf(watermark, p_unsigned); - PRINT_ATTRf(precise_ip, p_unsigned); - PRINT_ATTRf(mmap_data, p_unsigned); - PRINT_ATTRf(sample_id_all, p_unsigned); - PRINT_ATTRf(exclude_host, p_unsigned); - PRINT_ATTRf(exclude_guest, p_unsigned); - PRINT_ATTRf(exclude_callchain_kernel, p_unsigned); - PRINT_ATTRf(exclude_callchain_user, p_unsigned); - PRINT_ATTRf(mmap2, p_unsigned); - PRINT_ATTRf(comm_exec, p_unsigned); - PRINT_ATTRf(use_clockid, p_unsigned); - PRINT_ATTRf(context_switch, p_unsigned); - PRINT_ATTRf(write_backward, p_unsigned); - PRINT_ATTRf(namespaces, p_unsigned); - PRINT_ATTRf(ksymbol, p_unsigned); - PRINT_ATTRf(bpf_event, p_unsigned); - PRINT_ATTRf(aux_output, p_unsigned); - PRINT_ATTRf(cgroup, p_unsigned); - PRINT_ATTRf(text_poke, p_unsigned); - PRINT_ATTRf(build_id, p_unsigned); - PRINT_ATTRf(inherit_thread, p_unsigned); - PRINT_ATTRf(remove_on_exec, p_unsigned); - PRINT_ATTRf(sigtrap, p_unsigned); - PRINT_ATTRf(defer_callchain, p_unsigned); - PRINT_ATTRf(defer_output, p_unsigned); + /* + * All bitfields share a single __u64 right after read_format. + * BPF-captured attrs from perf trace may have a small size + * when the tracee passes a minimal struct, so skip the + * entire block when it's not covered. + */ + if (attr_size >=3D offsetof(struct perf_event_attr, wakeup_events)) { + PRINT_ATTRf_bf(disabled, p_unsigned); + PRINT_ATTRf_bf(inherit, p_unsigned); + PRINT_ATTRf_bf(pinned, p_unsigned); + PRINT_ATTRf_bf(exclusive, p_unsigned); + PRINT_ATTRf_bf(exclude_user, p_unsigned); + PRINT_ATTRf_bf(exclude_kernel, p_unsigned); + PRINT_ATTRf_bf(exclude_hv, p_unsigned); + PRINT_ATTRf_bf(exclude_idle, p_unsigned); + PRINT_ATTRf_bf(mmap, p_unsigned); + PRINT_ATTRf_bf(comm, p_unsigned); + PRINT_ATTRf_bf(freq, p_unsigned); + PRINT_ATTRf_bf(inherit_stat, p_unsigned); + PRINT_ATTRf_bf(enable_on_exec, p_unsigned); + PRINT_ATTRf_bf(task, p_unsigned); + PRINT_ATTRf_bf(watermark, p_unsigned); + PRINT_ATTRf_bf(precise_ip, p_unsigned); + PRINT_ATTRf_bf(mmap_data, p_unsigned); + PRINT_ATTRf_bf(sample_id_all, p_unsigned); + PRINT_ATTRf_bf(exclude_host, p_unsigned); + PRINT_ATTRf_bf(exclude_guest, p_unsigned); + PRINT_ATTRf_bf(exclude_callchain_kernel, p_unsigned); + PRINT_ATTRf_bf(exclude_callchain_user, p_unsigned); + PRINT_ATTRf_bf(mmap2, p_unsigned); + PRINT_ATTRf_bf(comm_exec, p_unsigned); + PRINT_ATTRf_bf(use_clockid, p_unsigned); + PRINT_ATTRf_bf(context_switch, p_unsigned); + PRINT_ATTRf_bf(write_backward, p_unsigned); + PRINT_ATTRf_bf(namespaces, p_unsigned); + PRINT_ATTRf_bf(ksymbol, p_unsigned); + PRINT_ATTRf_bf(bpf_event, p_unsigned); + PRINT_ATTRf_bf(aux_output, p_unsigned); + PRINT_ATTRf_bf(cgroup, p_unsigned); + PRINT_ATTRf_bf(text_poke, p_unsigned); + PRINT_ATTRf_bf(build_id, p_unsigned); + PRINT_ATTRf_bf(inherit_thread, p_unsigned); + PRINT_ATTRf_bf(remove_on_exec, p_unsigned); + PRINT_ATTRf_bf(sigtrap, p_unsigned); + PRINT_ATTRf_bf(defer_callchain, p_unsigned); + PRINT_ATTRf_bf(defer_output, p_unsigned); + } =20 PRINT_ATTRn("{ wakeup_events, wakeup_watermark }", wakeup_events, p_unsig= ned, false); PRINT_ATTRf(bp_type, p_unsigned); @@ -359,9 +399,12 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_eve= nt_attr *attr, PRINT_ATTRf(sample_max_stack, p_unsigned); PRINT_ATTRf(aux_sample_size, p_unsigned); PRINT_ATTRf(sig_data, p_unsigned); - PRINT_ATTRf(aux_start_paused, p_unsigned); - PRINT_ATTRf(aux_pause, p_unsigned); - PRINT_ATTRf(aux_resume, p_unsigned); + /* aux_{start_paused,pause,resume} are at byte 116, past VER0 */ + if (attr_size >=3D offsetof(struct perf_event_attr, sig_data)) { + PRINT_ATTRf_bf(aux_start_paused, p_unsigned); + PRINT_ATTRf_bf(aux_pause, p_unsigned); + PRINT_ATTRf_bf(aux_resume, p_unsigned); + } =20 return ret; } --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 95E7F3C1F50; Tue, 26 May 2026 21:19:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830358; cv=none; b=ms+2Z0UVyi6q2yUfHC2pVs4jnzECCHYN2cb2xZjkHud/GZSCsNpzng9g/7QwhMssC311+javopz6ZGl4C5G2G7XS3AMY6w4DPOIkiLxUI39cPm9j22vjSdQRHBf3OQTKQbo+AAINO4395fDFWh3fUWGDNV+XAJsv0tQZFdwLOA8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830358; c=relaxed/simple; bh=xnReiC7LIc4FIhhidxubs+j9XOP3YYMrtGBU1PE5CRE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=AtGVn0//jjM7iGKcogprvvT8qwcx2LwoTsaHfoYQRc/p/IdFdnZCzEXpBEF3mss59dyOKQXcTSMGzO3e/ScYU8m8eBukK/lZmBeZLbzsVq56XaQWAr8bognTFmaA9L6yL8ChtUXHOxjozljIVCInc593FoDoLr8cuQNEKmCiMgY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=YnmxXqIX; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="YnmxXqIX" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 972E61F000E9; Tue, 26 May 2026 21:19:14 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830357; bh=Xjh9T5IiUdv+9+73B/1Edup0Gp0kWtbO/ZdAKxTcb8I=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=YnmxXqIXmHuBx2JXs32tm6kUPzcpHq1Vs7nWgf4bf8K4/nUatvnpBkvmycuRZMnB/ BFG/vA48BWoQGet5jVGtgePewxf8ZNdifxPmffU7F6AxRJb5hY4dv3rFB2jWmT0rYo tpGFqw7Iy8U/XgLz1vehotsKAqNRoogEa1acL+018ahPoDip78cznyhqUmWwfAj4Bc HHj1YMK9jlcH5PiwuW87bI1GPoHHKL4U1Mvq7FwvWvuam9p64A33mcfhXWiIrQFIeL UN4Oy//77a91U2haIeX041kpMPDZ0SjJxzCjRu8iSo93/vjMfl2BiQGBfkVK8uMnhv Tr20iAywMPfKA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , "Claude Opus 4.6 (1M context)" Subject: [PATCH 18/29] perf header: Propagate feature section processing errors Date: Tue, 26 May 2026 18:17:54 -0300 Message-ID: <20260526211806.1193848-19-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo perf_session__read_header() discards the return value from perf_header__process_sections(), so any error from a feature section processor (process_nrcpus, process_compressed, etc.) is silently ignored and the session opens as if nothing went wrong. This defeats the validation added by subsequent commits in this series: a crafted perf.data that fails a feature section check would still be processed with partially-initialized state. Check the return value and fail the session if any feature section processor returns an error. For truncated files (data.size =3D=3D 0, i.e. recording was interrupted before the header was finalized), skip feature section processing entirely and clear the feature bitmap so tools use their "feature not present" fallbacks instead of accessing uninitialized env fields. Change the feature processor stubs for optional libraries (libtraceevent, libbpf) from returning -1 to returning 0, so that perf.data files containing these features can still be opened on builds without the optional library =E2=80=94 the feature is simply skipped rather than causing a fatal error. Also propagate evlist__prepare_tracepoint_events() failure as -ENOMEM, since the function can fail due to strdup() allocation failure inside evsel__prepare_tracepoint_event(). Fixes: 1c0b04d12ae9 ("perf tools: Add perf_session__read_header function") Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 51 ++++++++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 13 deletions(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index 9e3a08b1f8ae5a73..f4e0e257ff7226ac 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -2748,8 +2748,9 @@ static int process_tracing_data(struct feat_fd *ff __= maybe_unused, void *data __ =20 return ret < 0 ? -1 : 0; #else - pr_err("ERROR: Trying to read tracing data without libtraceevent support.= \n"); - return -1; + /* Not an error =E2=80=94 the feature is simply unsupported in this build= */ + pr_debug("Tracing data present but libtraceevent not available, skipping.= \n"); + return 0; #endif } =20 @@ -3643,8 +3644,9 @@ static int process_bpf_prog_info(struct feat_fd *ff _= _maybe_unused, void *data _ up_write(&env->bpf_progs.lock); return err; #else - pr_err("ERROR: Trying to read bpf_prog_info without libbpf support.\n"); - return -1; + /* Not an error =E2=80=94 the feature is simply unsupported in this build= */ + pr_debug("BPF prog info present but libbpf not available, skipping.\n"); + return 0; #endif // HAVE_LIBBPF_SUPPORT } =20 @@ -3712,8 +3714,9 @@ static int process_bpf_btf(struct feat_fd *ff __mayb= e_unused, void *data __mayb free(node); return err; #else - pr_err("ERROR: Trying to read btf data without libbpf support.\n"); - return -1; + /* Not an error =E2=80=94 the feature is simply unsupported in this build= */ + pr_debug("BTF data present but libbpf not available, skipping.\n"); + return 0; #endif // HAVE_LIBBPF_SUPPORT } =20 @@ -4900,7 +4903,7 @@ int perf_session__read_header(struct perf_session *se= ssion) struct perf_file_header f_header; struct perf_file_attr f_attr; u64 f_id; - int nr_attrs, nr_ids, i, j, err; + int nr_attrs, nr_ids, i, j, err =3D -ENOMEM; int fd =3D perf_data__fd(data); =20 session->evlist =3D evlist__new(); @@ -4920,6 +4923,7 @@ int perf_session__read_header(struct perf_session *se= ssion) return err; } =20 + err =3D -ENOMEM; if (perf_file_header__read(&f_header, header, fd) < 0) return -EINVAL; =20 @@ -4997,15 +5001,36 @@ int perf_session__read_header(struct perf_session *= session) lseek(fd, tmp, SEEK_SET); } =20 + /* + * Skip feature section processing for truncated files + * (data.size =3D=3D 0 means recording was interrupted). The + * section table is unreliable in that case, and the event + * data can still be processed without the feature headers. + * Clear the bitmap so has_feat() returns false and tools + * use their "feature not present" fallbacks instead of + * accessing uninitialized env fields. + */ + if (f_header.data.size =3D=3D 0) { + bitmap_zero(header->adds_features, HEADER_FEAT_BITS); + } else { #ifdef HAVE_LIBTRACEEVENT - perf_header__process_sections(header, fd, &session->tevent, - perf_file_section__process); + err =3D perf_header__process_sections(header, fd, &session->tevent, + perf_file_section__process); + if (err < 0) + goto out_delete_evlist; =20 - if (evlist__prepare_tracepoint_events(session->evlist, session->tevent.pe= vent)) - goto out_delete_evlist; + if (evlist__prepare_tracepoint_events(session->evlist, + session->tevent.pevent)) { + err =3D -ENOMEM; + goto out_delete_evlist; + } #else - perf_header__process_sections(header, fd, NULL, perf_file_section__proces= s); + err =3D perf_header__process_sections(header, fd, NULL, + perf_file_section__process); + if (err < 0) + goto out_delete_evlist; #endif + } =20 return 0; out_errno: @@ -5014,7 +5039,7 @@ int perf_session__read_header(struct perf_session *se= ssion) out_delete_evlist: evlist__delete(session->evlist); session->evlist =3D NULL; - return -ENOMEM; + return err; } =20 int perf_event__process_feature(const struct perf_tool *tool __maybe_unuse= d, --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9CBD23C1F57; Tue, 26 May 2026 21:19:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830361; cv=none; b=IBkY0RNzUlB/tlea2Y8azmFLG2iaBIzu0CHvwv9WZEGTxGpLEltvvNBaHSneB1ALuxvax+FkgpaHBQB5+q7DML3db7VqmZu9ZnrKc8fZ78xYUygilCld8y/ERheDNsDI/G0tYaCXY5rD+hpKfaBCklxzn019ziFYCo+/qHJq59w= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830361; c=relaxed/simple; bh=jXjvoV4cpNi9Z/JaNAGHITCqK28buPQzHl0Tsj1uLyw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=WiltXuUNxxddTKx/YTtolWlrGoAdh268Ww7o3cOkAA9HeM5nUVCKbz2sD6jOuRxQJCCq6XSouls9CEwluB1ia0p6h6XlvE56UHv75NTIqXlPobhk1Lxz98FWfYdkyPnQijNNmwlo/D3QE3qxOha5KinIJD23abUexFStxkFME/o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=UeZ2GNzy; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="UeZ2GNzy" Received: by smtp.kernel.org (Postfix) with ESMTPSA id AE9961F00A3A; Tue, 26 May 2026 21:19:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830360; bh=XiuT+0Wo8/JradWW/zhKNB69DQkSoJ7QybFBqeEaTqA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=UeZ2GNzy8LK5jhvUpqCM3mLBagIqbExfPq2ylPFMk4O42lFzbZKH4T5In7WYHFuFk PpzwYBQehpuPVNkjaeSl/u+zGQCne82sCvp7q1OyLH3zSf0ppM1M4sJrrtkerVubB8 B8mUgNkPCIwO1VrxR3fmH4d1aV7fLc14WgmpIMBJVUTHSChudYBufxRe1UEieXgS6H C4iYsZNsSZaWug8Ug8/DfMturMqURtiHAwQ29uHRiHFl6XQlfNO090xWJCHw6QiHiP o5+0Wjrv8tcbOhzg6LnqlexWlJLz3SaifwWXZapjrxwrfJdv3wVSHdIW4r6vyR2vVT n+MUt7VhhPjLQ== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 19/29] perf header: Validate f_attr.ids section before use in perf_session__read_header() Date: Tue, 26 May 2026 18:17:55 -0300 Message-ID: <20260526211806.1193848-20-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo perf_session__read_header() reads f_attr.ids.size from the perf.data file and divides it by sizeof(u64) to compute nr_ids, which is declared as int. No validation is performed on the value before it is used to allocate arrays and drive a read loop. On 32-bit architectures, a crafted f_attr.ids.size of 0x100000000 (4 GB) produces nr_ids =3D 0x20000000, but the allocation size 1 * 0x20000000 * 8 overflows size_t to 0, so zalloc(0) returns a valid pointer. The subsequent loop writes 0x20000000 IDs into that zero-length buffer, corrupting the heap. On 64-bit, the u64-to-int truncation silently drops high bits, processing fewer IDs than the file claims. While not exploitable, this is a data integrity issue. Add validation before using f_attr.ids: - Cap nr_attrs (attrs.size / attr_size) to MAX_NR_ATTRS (1 << 16) with overflow-safe u64 comparison before assigning to int - Reject ids.size not aligned to sizeof(u64) - Cap ids.size / sizeof(u64) to MAX_IDS_PER_ATTR (1 << 24) to prevent int truncation and size_t overflow on 32-bit - Reject ids sections that extend past the end of the file, guarded by S_ISREG() so non-regular files (block devices, pipes) are not falsely rejected Also fix perf_header__getbuffer64() to set errno =3D EIO when readn() returns 0 (EOF). Without this, the out_errno path in perf_session__read_header() returns -errno which is 0 (success) on truncated files, causing downstream NULL dereferences. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 77 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 76 insertions(+), 1 deletion(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index f4e0e257ff7226ac..fe23bbd8370c0190 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -64,6 +64,25 @@ #include #endif =20 +/* + * nr_ids * sizeof(struct perf_sample_id) must not overflow + * size_t on 32-bit; the struct is ~104 bytes (32-bit) or + * ~184 bytes (64-bit), so 1<<24 (16M) keeps the product + * under 2 GB on 32-bit. + * + * This is a per-attribute cap only =E2=80=94 the total across all + * attributes is not capped because legitimate high-core-count + * workloads (e.g. 5000 tracepoints =C3=97 4096 CPUs) can exceed + * a single-attribute limit. + */ +#define MAX_IDS_PER_ATTR (1 << 24) +/* + * Cap nr_attrs to prevent resource exhaustion from crafted + * files. 65536 is well beyond any real workload (perf stat + * typically uses < 100 events) but prevents u64-to-int + * truncation on the attr count. + */ +#define MAX_NR_ATTRS (1 << 16) #define MAX_BPF_DATA_LEN (256 * 1024 * 1024) #define MAX_BPF_PROGS 131072 #define MAX_CACHE_ENTRIES 32768 @@ -4468,8 +4487,13 @@ int perf_session__inject_header(struct perf_session = *session, static int perf_header__getbuffer64(struct perf_header *header, int fd, void *buf, size_t size) { - if (readn(fd, buf, size) <=3D 0) + ssize_t n =3D readn(fd, buf, size); + + if (n <=3D 0) { + if (n =3D=3D 0) + errno =3D EIO; return -1; + } =20 if (header->needs_swap) mem_bswap_64(buf, size); @@ -4803,6 +4827,8 @@ static int read_attr(int fd, struct perf_header *ph, if (ret <=3D 0) { pr_debug("cannot read %d bytes of header attr\n", PERF_ATTR_SIZE_VER0); + if (ret =3D=3D 0) + errno =3D EIO; return -1; } =20 @@ -4903,6 +4929,7 @@ int perf_session__read_header(struct perf_session *se= ssion) struct perf_file_header f_header; struct perf_file_attr f_attr; u64 f_id; + struct stat input_stat; int nr_attrs, nr_ids, i, j, err =3D -ENOMEM; int fd =3D perf_data__fd(data); =20 @@ -4951,6 +4978,15 @@ int perf_session__read_header(struct perf_session *s= ession) return -EINVAL; } =20 + if (fstat(fd, &input_stat) < 0) + return -errno; + + /* Check before assigning to int to avoid u64-to-int truncation */ + if (f_header.attrs.size / f_header.attr_size > MAX_NR_ATTRS) { + pr_err("Too many attributes: %" PRIu64 " (max %d)\n", + f_header.attrs.size / f_header.attr_size, MAX_NR_ATTRS); + return -EINVAL; + } nr_attrs =3D f_header.attrs.size / f_header.attr_size; lseek(fd, f_header.attrs.offset, SEEK_SET); =20 @@ -4967,6 +5003,45 @@ int perf_session__read_header(struct perf_session *s= ession) perf_event__attr_swap(&f_attr.attr); } =20 + /* + * Validate ids section: must be aligned to u64, and + * the count must fit in an int to avoid truncation in + * nr_ids and size_t overflow in perf_evsel__alloc_id() + * on 32-bit architectures. + */ + if (f_attr.ids.size % sizeof(u64)) { + pr_err("Invalid ids section size %" PRIu64 " for attr %d, not aligned t= o u64\n", + f_attr.ids.size, i); + err =3D -EINVAL; + goto out_delete_evlist; + } + + /* + * Cap the ID count to avoid int truncation of nr_ids + * on 64-bit and size_t overflow in the allocation + * paths (nr_ids * sizeof(u64), nr_ids * + * sizeof(struct perf_sample_id)) on 32-bit. + */ + if (f_attr.ids.size / sizeof(u64) > MAX_IDS_PER_ATTR) { + pr_err("Invalid ids section size %" PRIu64 " for attr %d, too many IDs\= n", + f_attr.ids.size, i); + err =3D -EINVAL; + goto out_delete_evlist; + } + + /* + * FIXME: see perf_header__process_sections() =E2=80=94 block + * devices bypass this check because st_size is 0. + */ + if (S_ISREG(input_stat.st_mode) && + (f_attr.ids.offset > (u64)input_stat.st_size || + f_attr.ids.size > (u64)input_stat.st_size - f_attr.ids.offset)) { + pr_err("Invalid ids section for attr %d: offset=3D%" PRIu64 " size=3D%"= PRIu64 " exceeds file size %" PRIu64 "\n", + i, f_attr.ids.offset, f_attr.ids.size, (u64)input_stat.st_size); + err =3D -EINVAL; + goto out_delete_evlist; + } + tmp =3D lseek(fd, 0, SEEK_CUR); evsel =3D evsel__new(&f_attr.attr); =20 --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1870B3C343C; Tue, 26 May 2026 21:19:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830365; cv=none; b=YkIJenEkq/uSepLfdCWVIfzjvlgsIz1oeukP4p9ys42wMNo/R1iiJFC2JtDx7/bOhznqSvbIvp+zhFd8fZfLvHTEpGkPpaNESvo/9MACLgQj5qy7GFOg/Mo/MaGYkpwU2wvVFPzCybVTeg7n8rA/t/j3LpN9CJ0wL2Z51nX8F+g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830365; c=relaxed/simple; bh=rXpWMVq0vZNm/1G8S/G4aTJpj/1iyln2NW4PkO9AbbU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=BryK/5aK+iYtOaqK0TiEyDbr83SJ/dWdDpjQ7kKlKZWs+ZgQsaS/sVnZFn8X51kxY9aLNsIfZMbRBuNFWMCgk2mSOKE0gjGKK6UNukWweuYmHvS5MP3Qe3LXfmsf1ACyFDaoZC7kGAkJUnu1vcyhvBgP+PD65aO1OT9wuUyQYG0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=H5KTSBJe; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="H5KTSBJe" Received: by smtp.kernel.org (Postfix) with ESMTPSA id F38421F000E9; Tue, 26 May 2026 21:19:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830364; bh=qkKddOM1EB8b+sluilVDNZPKGYWZkmZB4j/EQLMORI0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=H5KTSBJeMuM5LBfaDv3/OugL7CIFlLuBGSl5z/hqjP6tLyM4SiZL0xN9TktEGF36w t2y/Br54uPYmKxIiJZcX8dvn1Df5fuiafFliHV3JBG07udrrWHw4VcOJLApbUNQqq9 8zFqoQC9CFqKIXj3MwcfepQ8mHnmJC9rIZPQoljess55jZM3awlAFyrQVnwmAHUpza z6GhduoUtouoWI+3lsBgvDWAQh8GAu0nIPfEmXXAfAWlG7edhscmvkzN9aqpPFSAOW ltLKskGCBTEbzC10nCA6iUBngP6lMUk/dmU1thQeE1MrtohndrJJW1G5Rgxscbvndg FTgY2N9+FWqag== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, David Carrillo-Cisneros , "Claude Opus 4.6 (1M context)" Subject: [PATCH 20/29] perf header: Validate feature section size and add read path bounds checking Date: Tue, 26 May 2026 18:17:56 -0300 Message-ID: <20260526211806.1193848-21-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Harden feature section parsing against crafted perf.data files: 1. perf_header__process_sections() reads the feature section table and passes each section's offset and size directly to the processing callbacks without validating them against the actual file size. A crafted section size would make all downstream bounds checks against ff->size ineffective since they compare against the untrusted, inflated bound. Add an fstat() check with S_ISREG() guard and verify that each section's offset + size does not extend past EOF. 2. __do_read_buf() validates reads against ff->size (section size), but __do_read_fd() had no such check, so a malformed perf.data with an understated section size could cause reads past the end of the current section into the next section's data. Add the bounds check in __do_read(), the common caller of both helpers, so it is enforced uniformly for both the fd and buf paths. Track the section-relative offset in __do_read_fd() so the check works for the fd path. Reject negative sizes which on 32-bit can occur when a u32 >=3D 0x80000000 is passed as ssize_t. 3. do_read_string() relied on file data being null-padded. Add explicit null-termination (buf[len-1] =3D '\0') after reading and validate length (>=3D 1, fits within section) before allocating, so callers like process_cpu_topology() never receive an unterminated string. 4. Initialize feat_fd.offset to 0 (section-relative) instead of section->offset (file-absolute) so the bounds tracking is consistent with __do_read()'s section-relative comparison. Adjust process_build_id() to use lseek() for its file-absolute offset needs since it cannot rely on ff->offset for that. 5. Propagate ff->size to perf_file_section__fprintf_info() so its reads are also bounded. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: David Carrillo-Cisneros Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 66 ++++++++++++++++++++++++++++++++++------ 1 file changed, 57 insertions(+), 9 deletions(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index fe23bbd8370c0190..90417a478c8db2e1 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -233,23 +233,32 @@ static int __do_read_fd(struct feat_fd *ff, void *add= r, ssize_t size) =20 if (ret !=3D size) return ret < 0 ? (int)ret : -1; + ff->offset +=3D size; return 0; } =20 static int __do_read_buf(struct feat_fd *ff, void *addr, ssize_t size) { - if (size > (ssize_t)ff->size - ff->offset) - return -1; - memcpy(addr, ff->buf + ff->offset, size); ff->offset +=3D size; =20 return 0; - } =20 static int __do_read(struct feat_fd *ff, void *addr, ssize_t size) { + /* + * Reject negative sizes, which on 32-bit can occur when a + * u32 >=3D 0x80000000 is passed as ssize_t. The cast to + * ssize_t is safe because perf_header__process_sections() + * validates that each section fits within the file size + * before any feature callback reaches here, and only + * feature sections (metadata like build IDs, topology, etc.) + * use this path =E2=80=94 these cannot legitimately approach 2GB. + */ + if (size < 0 || size > (ssize_t)ff->size - ff->offset) + return -1; + if (!ff->buf) return __do_read_fd(ff, addr, size); return __do_read_buf(ff, addr, size); @@ -289,16 +298,25 @@ static char *do_read_string(struct feat_fd *ff) if (do_read_u32(ff, &len)) return NULL; =20 + /* At least the null terminator. */ + if (len < 1 || len > ff->size - ff->offset) { + pr_debug("do_read_string: invalid length %u (remaining %zu)\n", + len, (size_t)(ff->size - ff->offset)); + return NULL; + } + buf =3D malloc(len); if (!buf) return NULL; =20 if (!__do_read(ff, buf, len)) { /* - * strings are padded by zeroes - * thus the actual strlen of buf - * may be less than len + * do_write_string() writes len including the null + * terminator, padded to NAME_ALIGN. Ensure the + * string is always null-terminated even if the file + * data has been tampered with. */ + buf[len - 1] =3D '\0'; return buf; } =20 @@ -2775,7 +2793,13 @@ static int process_tracing_data(struct feat_fd *ff _= _maybe_unused, void *data __ =20 static int process_build_id(struct feat_fd *ff, void *data __maybe_unused) { - if (perf_header__read_build_ids(ff->ph, ff->fd, ff->offset, ff->size)) + /* lseek fails in pipe mode =E2=80=94 fall back to ff->offset */ + off_t offset =3D lseek(ff->fd, 0, SEEK_CUR); + + if (offset =3D=3D (off_t)-1) + offset =3D ff->offset; + + if (perf_header__read_build_ids(ff->ph, ff->fd, offset, ff->size)) pr_debug("Failed to read buildids, continuing...\n"); return 0; } @@ -4152,6 +4176,7 @@ static int perf_file_section__fprintf_info(struct per= f_file_section *section, ff =3D (struct feat_fd) { .fd =3D fd, .ph =3D ph, + .size =3D section->size, }; =20 if (!feat_ops[feat].full_only || hd->full) @@ -4512,6 +4537,7 @@ int perf_header__process_sections(struct perf_header = *header, int fd, int sec_size; int feat; int err; + struct stat st; =20 nr_sections =3D bitmap_weight(header->adds_features, HEADER_FEAT_BITS); if (!nr_sections) @@ -4529,7 +4555,29 @@ int perf_header__process_sections(struct perf_header= *header, int fd, if (err < 0) goto out_free; =20 + if (fstat(fd, &st) < 0) { + pr_err("Failed to stat the perf data file\n"); + err =3D -1; + goto out_free; + } + for_each_set_bit(feat, header->adds_features, header->last_feat) { + /* + * FIXME: block devices have st_size =3D=3D 0, so we skip + * bounds checking entirely. Historically perf never + * prevented using a block device as input, but it + * probably should =E2=80=94 there's no valid use case for it + * and it bypasses all file-size validation. + */ + if (S_ISREG(st.st_mode) && + (sec->offset > (u64)st.st_size || + sec->size > (u64)st.st_size - sec->offset)) { + pr_err("Feature %s (%d) section extends past EOF (offset=3D%" PRIu64 ",= size=3D%" PRIu64 ", file=3D%" PRIu64 ")\n", + header_feat__name(feat), feat, + sec->offset, sec->size, (u64)st.st_size); + err =3D -1; + goto out_free; + } err =3D process(sec++, header, feat, fd, data); if (err < 0) goto out_free; @@ -4756,7 +4804,7 @@ static int perf_file_section__process(struct perf_fil= e_section *section, .fd =3D fd, .ph =3D ph, .size =3D section->size, - .offset =3D section->offset, + .offset =3D 0, }; =20 if (lseek(fd, section->offset, SEEK_SET) =3D=3D (off_t)-1) { --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C42AF3C3426; Tue, 26 May 2026 21:19:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830369; cv=none; b=lRByO0k6TlgEhVsqJNoIegxhmIqCEWoG/TzJKThkxNkI8RoWgokMKk0L0A6Omkl80OhLS3McJuQv4aFkGpOnII+0XIH58Ni4mq6ATn2tC14fzytUeUmV65H2OJ3DKD5v/H5Evb2qB4EkwSGTiTsoD/A9bQXdUWxliLbnm139ngA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830369; c=relaxed/simple; bh=2tspnYnFV2/mcTNat8MjyF0yJMZPMqCkwJiD0xzu5Pc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=ZokOXEPskOQR5CF2Hyupibc3pTRmfmEZWalTWC3JssjpP59Kn5zlon27lerMHtzm7HoVRum9ZN2JMStZhDboIyhjFuQEHQ/LLSLWtO5EOGRQSWKTDmUGmsASh9D+h2Mirke20owzZjMWB/siIowep3xTvn6ZsQSIreXO0uir2Qg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=QlZEYxEX; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="QlZEYxEX" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6FAFE1F00A3A; Tue, 26 May 2026 21:19:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830367; bh=mVc8jbO9aj9r6TWlD3OrE7dSxeoBoQfzzEhSx+Srlww=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=QlZEYxEXptfKu9Dl4m4zRwpTaiaFaNF3v157w5V36SaC/5DF9cjBQnxbGXwjuT6sE qxQ715ZYWXciEnIy0Ini6SyphLAtILU8N6npwGa5e3lqJO1+8bEx1jibe5DZPV/3lQ 7eAqZfgZgOPcku0xQjgL2myQVfNmU/kQUaKcXVQs98YpZOs0+eKrjFxEwut+iWMZ34 kivQoRIAlhydOhDnP1cMIKsbvjmFboatj3Jn1VOvSzvJEgNoqRjZxLsyOP08eE91qh XVt1sMDvA7uXgOeN7/bKdu93fHniE8FHsF1v4tYZJBlYC0YVaOUumSx3K1jyhwMdsa qN7lwPt7OByDw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, Wang Nan , "Claude Opus 4.6 (1M context)" Subject: [PATCH 21/29] perf header: Sanity check HEADER_EVENT_DESC attr.size before swap Date: Tue, 26 May 2026 18:17:57 -0300 Message-ID: <20260526211806.1193848-22-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo read_event_desc() reads nre (event count), sz (attr size), and nr (IDs per event) from the file and uses them to control allocations and loops without validating them against the section size. A crafted perf.data could trigger large allocations or many loop iterations before __do_read() eventually rejects the reads. Add bounds checks in read_event_desc(): - Reject sz smaller than PERF_ATTR_SIZE_VER0. - Require at least one event (nre > 0). - Check that nre events fit in the remaining section, using the minimum per-event footprint of sz + sizeof(u32). - Pre-swap attr->size to native byte order, then reject values below PERF_ATTR_SIZE_VER0 or above sz before calling perf_event__attr_swap() to prevent heap out-of-bounds access. - Handle ABI0 (attr.size =3D=3D 0): substitute PERF_ATTR_SIZE_VER0, and on native-endian files write the value back so free_event_desc() does not treat the zero as its end-of-array sentinel (it iterates while attr.size !=3D 0). The swap path skips the write-back =E2=80=94 perf_event__attr_swap() has its own ABI0 fallback that sets VER0 after swapping. - Check that nr IDs fit in the remaining section before allocating. Fixes: b30b61729246 ("perf tools: Fix a problem when opening old perf.data = with different byte order") Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Cc: Wang Nan Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 54 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index 90417a478c8db2e1..37d7c9849e0e9199 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -2173,9 +2173,28 @@ static struct evsel *read_event_desc(struct feat_fd = *ff) if (do_read_u32(ff, &nre)) goto error; =20 + /* Size of each of the nre attributes. */ if (do_read_u32(ff, &sz)) goto error; =20 + /* + * Require at least one event with an attr no smaller than the + * first published struct, and reject sz values where + * sz + sizeof(u32) would overflow size_t (possible on 32-bit) + * or nre =3D=3D UINT32_MAX where nre + 1 wraps to 0 in the calloc. + * + * The minimum section footprint per event is sz bytes for the + * attr plus a u32 for the id count, check that nre events fit. + */ + if (!nre || sz < PERF_ATTR_SIZE_VER0 || + sz > ff->size || (size_t)sz > SIZE_MAX - sizeof(u32) || + nre =3D=3D UINT32_MAX || + nre > (ff->size - ff->offset) / (sz + sizeof(u32))) { + pr_err("Invalid HEADER_EVENT_DESC: nre=3D%u sz=3D%u (min %d)\n", + nre, sz, PERF_ATTR_SIZE_VER0); + goto error; + } + /* buffer to hold on file attr struct */ buf =3D malloc(sz); if (!buf) @@ -2191,6 +2210,9 @@ static struct evsel *read_event_desc(struct feat_fd *= ff) msz =3D sz; =20 for (i =3D 0, evsel =3D events; i < nre; evsel++, i++) { + struct perf_event_attr *attr =3D buf; + u32 attr_size; + evsel->core.idx =3D i; =20 /* @@ -2200,6 +2222,32 @@ static struct evsel *read_event_desc(struct feat_fd = *ff) if (__do_read(ff, buf, sz)) goto error; =20 + /* Reject before attr_swap to prevent OOB via bswap_safe() */ + attr_size =3D ff->ph->needs_swap ? bswap_32(attr->size) : attr->size; + /* ABI0: size =3D=3D 0 means the producer didn't set it */ + if (!attr_size) { + attr_size =3D PERF_ATTR_SIZE_VER0; + /* + * Write back so free_event_desc() doesn't + * treat this event as the end-of-array sentinel + * (it iterates while attr.size !=3D 0). + * + * Only for native =E2=80=94 the swap path must NOT + * write native-endian VER0 here because + * perf_event__attr_swap() would re-swap it + * to 0x40000000, defeating bswap_safe() bounds. + * perf_event__attr_swap() has its own ABI0 + * fallback that sets VER0 after swapping. + */ + if (!ff->ph->needs_swap) + attr->size =3D attr_size; + } + if (attr_size < PERF_ATTR_SIZE_VER0 || attr_size > sz) { + pr_err("Event %d attr.size (%u) invalid (min: %d, max: %u)\n", + i, attr_size, PERF_ATTR_SIZE_VER0, sz); + goto error; + } + if (ff->ph->needs_swap) perf_event__attr_swap(buf); =20 @@ -2221,6 +2269,12 @@ static struct evsel *read_event_desc(struct feat_fd = *ff) if (!nr) continue; =20 + /* Prevent oversized allocation from crafted nr */ + if (nr > (ff->size - ff->offset) / sizeof(*id)) { + pr_err("Event %d: id count %u exceeds remaining section\n", i, nr); + goto error; + } + id =3D calloc(nr, sizeof(*id)); if (!id) goto error; --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1B1423C3438; Tue, 26 May 2026 21:19:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830372; cv=none; b=akGjZgm/5XqkWW2by5TuBQr9LbtBFwaOKq8p+vBzMvrC2NCy8MSiQJDxyRGidmNTji6n03mseD/F5jHj15gSjPCJSoYhJnW+nNk+SiiRu0TD7yqj/B7yff7FClFbDu9+GVo4RnOGifhoTrXUycyJFO3m7IJdF4tbLIQfjNcPLAs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830372; c=relaxed/simple; bh=t51kJSKgQ1QhqHUHse3qJiAts71QK2AzbgbVpiCUAgs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=nO/AxxUIOaB1zC2dqhUKlxfPIAanFO8P4WoEDnigqh5iYewq/TJUHqclBXaFAS3DLKcYwVI7WS/ERGcHE2FORLM64McccCw15VphptNTqY21+woR1jekd231GUI8KU8tMflkLSgg0lpOJv70qInCiuM8Y9uYMEmToReRZDTaHw4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=csU2YzjN; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="csU2YzjN" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DEB901F000E9; Tue, 26 May 2026 21:19:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830370; bh=geL9Gql17fvUbFAYLrM7ws30+a0sTOEDvlQUZYd6JrM=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=csU2YzjN5Eh2t4zFSrTYHyxclxj9yqfcqfpZ/IyvgLxeQyXhYKfQApFzyHd6DjIL8 02nScblqYZNw2jYzZnycXxafQ08V3c6veoksQSe3o6VcssqkYcVvawZdb6WPXv1asB FAwzV6mX9aSi6p5pm46oVJvZVHVnGc0relT5h4WDgUCbZk3TY3hjifWIkbDTjA/Mjl bEO/Xoc5WAHpd3zQCC927cPSUWQ8VAWtBf4l6yN2bN2N230Mg/kHh25yH1SIej7Ju7 q3MGvEHWe6oHhIbijBbFqOjvQZXbH1tUkTgWwonFqqYyJqGeNecBwqE4Vo0gXru+8u zyCdonX33551A== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 22/29] perf header: Validate bitmap size before allocating in do_read_bitmap() Date: Tue, 26 May 2026 18:17:58 -0300 Message-ID: <20260526211806.1193848-23-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Arnaldo Carvalho de Melo do_read_bitmap() reads a u64 bit count from the file and passes it to bitmap_zalloc() without checking it against the remaining section size. A crafted perf.data could trigger a large allocation that would only fail later when the per-element reads exceed section bounds. Additionally, bitmap_zalloc() takes an int parameter, so a crafted size with bits set above bit 31 (e.g. 0x100000040) would pass the section bounds check but truncate when passed to bitmap_zalloc(), allocating a much smaller buffer than the subsequent read loop expects. Reject size values that exceed INT_MAX, and check that the data needed (BITS_TO_U64(size) u64 values) fits in the remaining section before allocating. Switch from bitmap_zalloc() to calloc() of u64 units so the allocation size matches the u64 read/write granularity and avoids unsigned long vs u64 mismatch on 32-bit architectures. Fix do_write_bitmap() to use memcpy to read u64-sized chunks from the unsigned long bitmap, preventing out-of-bounds reads on 32-bit systems where sizeof(unsigned long) is 4 but the bitmap is stored in u64 units. Fix process_mem_topology() minimum section size: the check used nr * 2 * sizeof(u64) per node, but do_read_bitmap() reads an additional u64 for the bitmap size, so the minimum is 3 * sizeof(u64). Fix memory leak in process_mem_topology() error paths: replace free(nodes) with memory_node__delete_nodes() to free per-node bitmaps allocated by do_read_bitmap(). Currently used by process_mem_topology() for HEADER_MEM_TOPOLOGY. Fixes: a881fc56038a ("perf header: Sanity check HEADER_MEM_TOPOLOGY") Reported-by: sashiko-bot@kernel.org # Running on a local machine Closes: https://lore.kernel.org/linux-perf-users/20260414224622.2AE69C19425= @smtp.kernel.org/ Closes: https://lore.kernel.org/linux-perf-users/20260410223242.DD76FC19421= @smtp.kernel.org/ Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index 37d7c9849e0e9199..2fea0172140e4abd 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -178,15 +178,25 @@ int do_write(struct feat_fd *ff, const void *buf, siz= e_t size) /* Return: 0 if succeeded, -ERR if failed. */ static int do_write_bitmap(struct feat_fd *ff, unsigned long *set, u64 siz= e) { - u64 *p =3D (u64 *) set; + size_t byte_size =3D BITS_TO_LONGS(size) * sizeof(unsigned long); int i, ret; =20 ret =3D do_write(ff, &size, sizeof(size)); if (ret < 0) return ret; =20 + /* + * The on-disk format uses u64 elements, but the in-memory bitmap + * uses unsigned long, which is only 4 bytes on 32-bit architectures. + * Copy with bounded size so the last element doesn't read past the + * bitmap allocation when BITS_TO_LONGS(size) is odd. + */ for (i =3D 0; (u64) i < BITS_TO_U64(size); i++) { - ret =3D do_write(ff, p + i, sizeof(*p)); + u64 val =3D 0; + size_t off =3D i * sizeof(val); + + memcpy(&val, (char *)set + off, min(sizeof(val), byte_size - off)); + ret =3D do_write(ff, &val, sizeof(val)); if (ret < 0) return ret; } @@ -335,7 +345,20 @@ static int do_read_bitmap(struct feat_fd *ff, unsigned= long **pset, u64 *psize) if (ret) return ret; =20 - set =3D bitmap_zalloc(size); + /* Bitmap APIs use int for nbits; reject u64 values that truncate. */ + if (size > INT_MAX || + BITS_TO_U64(size) > (ff->size - ff->offset) / sizeof(u64)) { + pr_debug("do_read_bitmap: size %" PRIu64 " exceeds section bounds\n", si= ze); + return -1; + } + + /* + * bitmap_zalloc() allocates in unsigned long units, which are only + * 4 bytes on 32-bit architectures. The read loop below casts the + * buffer to u64 * and writes 8-byte elements, so allocate in u64 + * units to ensure the buffer is large enough. + */ + set =3D calloc(BITS_TO_U64(size), sizeof(u64)); if (!set) return -ENOMEM; =20 @@ -3497,7 +3520,8 @@ static int process_mem_topology(struct feat_fd *ff, return -1; } =20 - if (ff->size < 3 * sizeof(u64) + nr * 2 * sizeof(u64)) { + /* Per node: node_id(u64) + mem_size(u64) + bitmap_nr_bits(u64) */ + if (ff->size < 3 * sizeof(u64) + nr * 3 * sizeof(u64)) { pr_err("Invalid HEADER_MEM_TOPOLOGY: section too small (%zu) for %llu no= des\n", ff->size, (unsigned long long)nr); return -1; @@ -3532,7 +3556,7 @@ static int process_mem_topology(struct feat_fd *ff, =20 out: if (ret) - free(nodes); + memory_node__delete_nodes(nodes, nr); return ret; } =20 --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 47E653C2B8B; Tue, 26 May 2026 21:19:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830375; cv=none; b=UQnDyjouBdDdMguv4H73cES9IHHL0UV82ZhdDhPxD/aRPacHYqniRhPJ5ZnFw+XyNtXyFXZ9F5rSfOmXodDzGDTZEKm2UhER3pY+nesl6sDz/f/48esCzgKtwwDR2qRG75z6uOVSe5u6DPRA08E8eyi9Mt1Z46magIs/BTmU92Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830375; c=relaxed/simple; bh=WKoFQjJDe0IHzs+e/rLQ4u/bvS6zSfWdfUsgGZRTjfk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=IArmmcSmBLjuxSst3hLF39JUbG7u16B61/ef2nRVlncr3nh/t38jBe0rE883CVQ8tPbN3EuhFW46V9fuKd/UNI/gZXKazJ0iKhfeuz1bNxKZG3ObBkAE21czXPdvKb91KXGnJy3hVObCzMKOEt724vZcWpx195/yoqL3CoB5Cr8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=D9f06IAv; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="D9f06IAv" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2E3881F00A3A; Tue, 26 May 2026 21:19:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830374; bh=P5azfTMXGrs1XaBtFDBxFOfqbcoD+gR0GYYpU+KoUJY=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=D9f06IAv7SGf40OHZhEWVm5eNVcuKpkffVf8anySU/Bk6J+pwi7BkhsY6jyqHm8AV 1dx1hfVqd7R4NolVQPy/QjwqlinPrldn5dx6n1Y+DyXubCuArbCWb5hSTlpwL5mBYt R4uQoe5D7UWXcJZ7w08x+o/fnoazaB3iWJhUFZH6OcVMCHQJwPPqcXpK4OaDdxODX5 Hu5hWwXDWUMRHRjF/0NkHnPy/n/jjRvPC+ESJ7EqeQ6pdNV4sIXYm+u4vpSgcLn/gS RK0bbN0bHpoUfiy/JANbURplUQCc0Bo7WrxFtfZJNOwgHzfZS3Uwti2vuuiPnhFOhV Pj1zqkyWjFmQw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, Chun-Tse Shao , "Claude Opus 4.6 (1M context)" Subject: [PATCH 23/29] perf session: Add byte-swap handler for PERF_RECORD_COMPRESSED2 Date: Tue, 26 May 2026 18:17:59 -0300 Message-ID: <20260526211806.1193848-24-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo PERF_RECORD_COMPRESSED2 events carry a data_size field that must be byte-swapped when reading cross-endian perf.data files. Without a swap handler, reading COMPRESSED2 events on a different-endian machine would misinterpret data_size as a garbage value, causing the decompression path to read the wrong number of bytes. The compressed payload itself is a raw byte stream and needs no swapping. Fixes: 208c0e16834472bb ("perf record: Add 8-byte aligned event type PERF_R= ECORD_COMPRESSED2") Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Adrian Hunter Cc: Chun-Tse Shao Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 8280413f4528f53c..9271885e3920f897 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -1056,6 +1056,14 @@ static int perf_event__time_conv_swap(union perf_eve= nt *event, return 0; } =20 +static int perf_event__compressed2_swap(union perf_event *event, + bool sample_id_all __maybe_unused) +{ + /* Only data_size needs swapping =E2=80=94 compressed payload is a raw by= te stream */ + event->pack2.data_size =3D bswap_64(event->pack2.data_size); + return 0; +} + static int perf_event__bpf_metadata_swap(union perf_event *event, bool sample_id_all __maybe_unused) { @@ -1197,6 +1205,7 @@ static perf_event__swap_op perf_event__swap_ops[] =3D= { [PERF_RECORD_STAT_ROUND] =3D perf_event__stat_round_swap, [PERF_RECORD_EVENT_UPDATE] =3D perf_event__event_update_swap, [PERF_RECORD_TIME_CONV] =3D perf_event__time_conv_swap, + [PERF_RECORD_COMPRESSED2] =3D perf_event__compressed2_swap, [PERF_RECORD_BPF_METADATA] =3D perf_event__bpf_metadata_swap, [PERF_RECORD_SCHEDSTAT_CPU] =3D perf_event__schedstat_cpu_swap, [PERF_RECORD_SCHEDSTAT_DOMAIN] =3D perf_event__schedstat_domain_swap, --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8B9ED3C4168; Tue, 26 May 2026 21:19:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830378; cv=none; b=m88A4hnis0ivPf5M9OUT6e7HnLDvgyficiX2bna/zjmfP9Q0PnumUTVJu3BiW9qOKMgRSFLn0xjaYfbD3IPpx5EiN1Ml1EMmbCTRYU4/iGk2ZV61kbiHPwy2+vgb7j+Z6VKynQPeWj4yHnrB2x1KkTLrBKMTytunOeze/9W2qDE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830378; c=relaxed/simple; bh=lVcXrVb/bPFXiwynCn08mN3G3rFzP3WlTTAQ+pcdKm4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=t5AnEBtBu3/kPKtz1zT7CvlU/g/KhMzhvRov7KyAunXx2fVRgwAXyisvauNsYLVGmKHz2458wp2l0e852XUElAKDesBfZ/YSsVi6JU3adpxxbAcPnW70URXKwo2cm1FYXb9bk7FCZ6GxeG9xHmpSFQlDKP4add27H3c2up6ZR/4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=AAtW7psw; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="AAtW7psw" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9E49D1F000E9; Tue, 26 May 2026 21:19:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830377; bh=GSuRKQKNYJ5bT2rZ0zUxu05C+XLZ1XWSeGKEdbMqIyQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=AAtW7pswY7yX6FC5p4ddSJ6q8XYcYKSyj6Mj8qvCewZ+c+VyIYwS/jhWwlyIALOEV 9GloxZVqasqm2+yes4m5bRy2E1fpr0B6ea8s1l2R6cAsa+pJ0Uv4YScz4/CqAgToHH S3WpFKY5dAXupwHGlAj9wR4uLtbQF0M98oHhjVG3+9JfQFt+cGfIA4TI7r0M2Yovw9 TqcT9j37RdJsDfBwoW0cSTTAXORVRPPXZ3uUk/YhWPDZ7l4fS+8EPZh3Y+2po87DXW sz2WzQP2JXcMbKKRwEx7NetQ9lsDCNG5TfD6dRikvT9hERIAHH2Sx9QDOCXcnE2jb0 azD527ZdYq6Og== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 24/29] perf tools: Harden compressed event processing Date: Tue, 26 May 2026 18:18:00 -0300 Message-ID: <20260526211806.1193848-25-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Add several hardening checks to the compressed event decompression pipeline: 1. Guard against decomp_last_rem underflow: check that decomp_last->head does not exceed decomp_last->size before subtracting. A u64 underflow here would produce a huge decomp_len, causing an oversized mmap allocation. 2. Validate comp_mmap_len from the HEADER_COMPRESSED feature section: reject values that are not 4K-aligned or smaller than 4096. The downstream decompression path checks allocation sizes against SIZE_MAX, which handles 32-bit safety. 3. Validate COMPRESSED event header size: reject events where header.size is too small to contain the fixed struct fields, preventing underflow in the payload size calculation. 4. Validate COMPRESSED2 event data_size: check that data_size does not exceed the available payload (header.size minus the fixed struct fields) for the newer compressed format. 5. Reject compressed events when the HEADER_COMPRESSED feature is missing from the file header, which means no decompression context was initialized. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 17 +++++++++++++++++ tools/perf/util/tool.c | 38 +++++++++++++++++++++++++++++++++++++- 2 files changed, 54 insertions(+), 1 deletion(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index 2fea0172140e4abd..f771a76321c10a02 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -3861,6 +3861,23 @@ static int process_compressed(struct feat_fd *ff, if (do_read_u32(ff, &(env->comp_mmap_len))) return -1; =20 + /* + * FIXME: perf.data should record the recording system's page + * size =E2=80=94 it affects mmap buffer alignment, sample addresses, + * and data_page_size/code_page_size interpretation. Without + * it we assume 4K (the smallest Linux page size) as a safe + * minimum alignment for comp_mmap_len validation. + * + * No upper-bound cap: perf_session__process_compressed_event() + * checks decomp_len + sizeof(struct decomp) against SIZE_MAX + * before allocating, which handles 32-bit safety. + */ + if (env->comp_mmap_len < 4096 || env->comp_mmap_len % 4096) { + pr_err("Invalid HEADER_COMPRESSED: comp_mmap_len (%u) must be a 4K-align= ed value >=3D 4096\n", + env->comp_mmap_len); + return -1; + } + return 0; } =20 diff --git a/tools/perf/util/tool.c b/tools/perf/util/tool.c index 225a77d530ce8ab3..18641919473a859f 100644 --- a/tools/perf/util/tool.c +++ b/tools/perf/util/tool.c @@ -24,7 +24,15 @@ static int perf_session__process_compressed_event(const = struct perf_tool *tool _ size_t mmap_len, decomp_len =3D perf_session__env(session)->comp_mmap_len; struct decomp *decomp, *decomp_last =3D session->active_decomp->decomp_la= st; =20 + if (!decomp_len) { + pr_err("Compressed events found but HEADER_COMPRESSED not set\n"); + return -1; + } + if (decomp_last) { + /* Prevent u64 underflow in decomp_last_rem */ + if (decomp_last->head > decomp_last->size) + return -1; decomp_last_rem =3D decomp_last->size - decomp_last->head; decomp_len +=3D decomp_last_rem; } @@ -47,14 +55,37 @@ static int perf_session__process_compressed_event(const= struct perf_tool *tool _ decomp->size =3D decomp_last_rem; } =20 + /* + * Events are read directly from the mmap'd file; fields could + * theoretically change via a FUSE-backed file, but that applies + * to the entire event processing pipeline, not just here. + */ if (event->header.type =3D=3D PERF_RECORD_COMPRESSED) { + if (event->header.size < sizeof(struct perf_record_compressed)) + goto err_decomp; src =3D (void *)event + sizeof(struct perf_record_compressed); src_size =3D event->pack.header.size - sizeof(struct perf_record_compres= sed); } else if (event->header.type =3D=3D PERF_RECORD_COMPRESSED2) { + /* + * prefetch_event() only guarantees that the 8-byte + * event header fits; validate that header.size covers + * the data_size field before accessing it, otherwise a + * crafted event reads data_size from adjacent memory. + */ + if (event->header.size < sizeof(struct perf_record_compressed2)) + goto err_decomp; src =3D (void *)event + sizeof(struct perf_record_compressed2); src_size =3D event->pack2.data_size; + /* + * data_size is independent of header.size (which + * includes padding); verify it doesn't exceed the + * actual payload to prevent out-of-bounds reads in + * zstd_decompress_stream(). + */ + if (src_size > event->header.size - sizeof(struct perf_record_compressed= 2)) + goto err_decomp; } else { - return -1; + goto err_decomp; } =20 decomp_size =3D zstd_decompress_stream(session->active_decomp->zstd_decom= p, src, src_size, @@ -77,6 +108,11 @@ static int perf_session__process_compressed_event(const= struct perf_tool *tool _ pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size); =20 return 0; + +err_decomp: + munmap(decomp, mmap_len); + pr_err("Couldn't decompress data\n"); + return -1; } #endif =20 --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 105C23C344B; Tue, 26 May 2026 21:19:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830382; cv=none; b=dmM1/oNLi5ygOP9sWSH2kSg9TVzKozPAnfp/ooquePlh5HBWG3AqQHy1wuH0I8tS8JImHR94j7+h/f8CsmdnHrO9vXbSHQvAIkCxPok4OYhlwMfQDydcgQDwlLhif1DbYZGLXKA5qhmAFNinSS4h5zW0LVba4se6p16s3D4a2aE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830382; c=relaxed/simple; bh=w/pT8AP7RhSfJf8c4H672m1DgmrBA2oeSXO3E3FZegU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=G06x6g4FTAbn+SrDeY7lYL638bziAmY5Q/M3mSQeGl6Vcx8SBlkP6KXV5UlE7tkEnXql4xLUNBkdJCHWPBMmWKFB9tA0JsGo2eS2i1SjZ20MlG9t/paWrke2GUOkP2JoucX6KMXwQyODm14TlYUk4SOMMB0KJg49GT1eFOXJ+48= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=fzULREIY; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="fzULREIY" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E335F1F00A3A; Tue, 26 May 2026 21:19:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830380; bh=lkbSJHOm8dsNCLi2f3ly1BjsY0Qy63cC+DmLvcV8EYk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=fzULREIYAmWnjHcxAx8ykbgH7VvAwIYwM2MnSzoMaZuYpPshItgu6qIFiFAeZOUi9 tADniuIL4geA/g0GuVHXhiCJkF7YhR/fLppHFKN6jw/iEbsTD9R0B/AUrGGu0Mi+LK xW3u+NE9DR7UpJvtzIO8TwRX2XX3EyU0W6Sz+refmh5u72vy45uBg/rccE7XeeXgGe rM85aEC0f3j2/4YeCClQ7ZJIZpRx+xjOd+8ulEvkB8YndFVZ5vPAl4govyuuZzcpfk y9KSZAbCpctWNnR5EiHVti1PIBf54jMRnqM+DaWLXfZI+MJjrccmPC9DRdkGxM2UoO IMykCpB02bw+A== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 25/29] perf session: Check for decompression buffer size overflow Date: Tue, 26 May 2026 18:18:01 -0300 Message-ID: <20260526211806.1193848-26-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Arnaldo Carvalho de Melo On 32-bit systems, sizeof(struct decomp) + decomp_len can wrap size_t when comp_mmap_len is large. The preceding patch validates comp_mmap_len alignment but does not cap the upper bound, so two additions can still overflow: 1. decomp_len +=3D decomp_last_rem: on 32-bit, adding a u64 to size_t silently truncates, producing a corrupted decomp_len that would bypass the subsequent overflow check and result in an undersized buffer allocation. 2. sizeof(struct decomp) + decomp_len: the final addition could overflow on systems with small size_t. Add explicit overflow checks before each addition as defense-in-depth. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/tool.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tools/perf/util/tool.c b/tools/perf/util/tool.c index 18641919473a859f..25c9b378aa163664 100644 --- a/tools/perf/util/tool.c +++ b/tools/perf/util/tool.c @@ -34,9 +34,22 @@ static int perf_session__process_compressed_event(const = struct perf_tool *tool _ if (decomp_last->head > decomp_last->size) return -1; decomp_last_rem =3D decomp_last->size - decomp_last->head; + /* + * Check before adding: on 32-bit, size_t +=3D u64 + * silently truncates, bypassing the overflow check + * below and producing an undersized buffer. + */ + if (decomp_last_rem > SIZE_MAX - decomp_len - sizeof(struct decomp)) { + pr_err("Decompression buffer size overflow\n"); + return -1; + } decomp_len +=3D decomp_last_rem; } =20 + if (decomp_len > SIZE_MAX - sizeof(struct decomp)) { + pr_err("Decompression buffer size overflow\n"); + return -1; + } mmap_len =3D sizeof(struct decomp) + decomp_len; decomp =3D mmap(NULL, mmap_len, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 60BED3C2797; Tue, 26 May 2026 21:19:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830385; cv=none; b=FfFxCr6YF6QHu3QxL8XbRPhIH4O5Y30ZANHAT0ouAuWqtejazebdHAijHcZG8Sij3QYdz/mbP0KsPkX6vii2vkWOm4iw6ARsUYWJJiiESYF0e/D+N2c56DOaB5sqFIEni1ciAHF3shoSAjIIAucbgzlLjAXRuKoijHuikkL54BM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830385; c=relaxed/simple; bh=8E9RIlbyvVDBk235UNUwM9fkK9UZ7p1GRFqPdxPKE3A=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=ofWo5CKx9Hg+yY9M6gaomcExt2PrrJR/UKPqIRNaZuZLz3Ilga5KNuN8izTU3aY9CqU1ZUCR0811bcVKxcI2GfV5gxtaeGTrP0WSJaKe9ouHkOVUm69BbTtpwzSMVQh7+J72LoOmNbrEXAaPuExi3WoubTZO1cMMXhVWj0eka0M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=L+JXo8bi; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="L+JXo8bi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 352931F000E9; Tue, 26 May 2026 21:19:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830384; bh=/MQAOBlHH4kWSzGdREJ/sx9SwrF4xqRIQrt4huN03as=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=L+JXo8biyuzIb5UKiuBTqxIuXQNN5bsd4Y1ekjYimmuS1MfRjEiE8L1KJp4lDoFk3 RhRcM7bRVNT5S5oVVTcDhStuGC/kFWAjqRiQbvvB995ZGW9PHQqGBZUFxzhvkWgh/R hrYK1Y+LIacfhOigYONrduWnRsYwZmyxYZj8GYqPbHKGIFLWVcEVOEAPfviCXnNH8C kGoh4VvlXf8nPyc5qVwZrHQIX6sjQF/FuYekj6gNIF5puS8Xu+0RB/gcMHxqY+TZsa 08vKRNfE15oOb7inS3O3j4S3NahfCRuFhMfFUl31zHY2Y0snEgWNxBsPaxNRGekM/4 o0KT5GacD95IA== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 26/29] perf session: Bound nr_cpus_avail and validate sample CPU Date: Tue, 26 May 2026 18:18:02 -0300 Message-ID: <20260526211806.1193848-27-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Several downstream consumers (timechart, kwork, sched) use fixed-size arrays indexed by CPU. A crafted perf.data can supply arbitrary CPU values that index past these arrays, causing out-of-bounds access. Validate sample.cpu against min(nr_cpus_avail, MAX_NR_CPUS) in perf_session__deliver_event() before any tool callback runs. The cap at MAX_NR_CPUS protects fixed-size downstream arrays; the true nr_cpus_avail is preserved in env for header parsing (e.g. process_cpu_topology) which needs the real count. Fall back to MAX_NR_CPUS when HEADER_NRCPUS is missing (truncated files, pipe mode, pre-2017 perf). Only validate when PERF_SAMPLE_CPU is set in sample_type =E2=80=94 when absent, evsel__parse_sample() leaves sample.cpu as (u32)-1, a sentinel that downstream tools (script, inject) check to identify events without CPU info. Clamping it to 0 would break those checks. Inline evlist__parse_sample() into perf_session__deliver_event() so the evsel lookup needed for sample_type checking reuses the same evsel that parsed the sample, avoiding a second evlist__event2evsel() call on every event. For pipe-mode streams where HEADER_NRCPUS may arrive late or not at all, the MAX_NR_CPUS fallback ensures the bounds check is still effective against the fixed-size downstream arrays. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/header.c | 30 +++++++++++++ tools/perf/util/session.c | 88 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 117 insertions(+), 1 deletion(-) diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index f771a76321c10a02..5b1fa1653d2a48cc 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -48,6 +48,7 @@ #include #include "asm/bug.h" #include "tool.h" +#include "../perf.h" #include "time-utils.h" #include "units.h" #include "util/util.h" // perf_exe() @@ -2895,6 +2896,17 @@ static int process_nrcpus(struct feat_fd *ff, void *= data __maybe_unused) if (ret) return ret; =20 + /* + * Cap at 1M CPUs =E2=80=94 generous for any real system but prevents + * stack overflow from VLA allocations sized by nr_cpus_avail + * (e.g. DECLARE_BITMAP in builtin-c2c.c node_entry()). + */ + if (nr_cpus_avail > (1U << 20)) { + pr_err("Invalid HEADER_NRCPUS: nr_cpus_avail (%u) exceeds maximum (%u)\n= ", + nr_cpus_avail, 1U << 20); + return -1; + } + if (nr_cpus_online > nr_cpus_avail) { pr_err("Invalid HEADER_NRCPUS: nr_cpus_online (%u) > nr_cpus_avail (%u)\= n", nr_cpus_online, nr_cpus_avail); @@ -5250,6 +5262,24 @@ int perf_session__read_header(struct perf_session *s= ession) #endif } =20 + /* + * Without nr_cpus_avail the sample CPU bounds check in + * perf_session__deliver_event() is bypassed, allowing crafted + * CPU IDs to reach downstream consumers that index fixed-size + * arrays (timechart, kwork, sched =E2=80=94 all sized MAX_NR_CPUS). + * + * This can happen with truncated files (interrupted recording + * loses all feature sections), very old files that predate + * HEADER_NRCPUS, or crafted files that omit it. Fall back to + * MAX_NR_CPUS so the bounds check is still effective =E2=80=94 any + * CPU ID below that limit is safe for all downstream arrays. + */ + if (header->env.nr_cpus_avail =3D=3D 0) { + header->env.nr_cpus_avail =3D MAX_NR_CPUS; + pr_warning("WARNING: perf.data is missing HEADER_NRCPUS, using MAX_NR_CP= US (%d) as CPU bound\n", + MAX_NR_CPUS); + } + return 0; out_errno: return -errno; diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 9271885e3920f897..6de665d3c9054179 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -2110,14 +2110,100 @@ static int perf_session__deliver_event(struct perf= _session *session, const char *file_path) { struct perf_sample sample; + struct evsel *evsel; int ret; =20 perf_sample__init(&sample, /*all=3D*/false); - ret =3D evlist__parse_sample(session->evlist, event, &sample); + evsel =3D evlist__event2evsel(session->evlist, event); + if (!evsel) { + pr_err("No evsel found for event type %u\n", + event->header.type); + ret =3D -EFAULT; + goto out; + } + ret =3D evsel__parse_sample(evsel, event, &sample); if (ret) { pr_err("Can't parse sample, err =3D %d\n", ret); goto out; } + /* + * evsel__parse_sample() doesn't populate machine_pid/vcpu, + * which are needed by machines__find_for_cpumode() to + * attribute samples to guest VMs. The SID table maps + * sample IDs to the guest that owns the event. + */ + if (perf_guest && sample.id) { + struct perf_sample_id *sid =3D evlist__id2sid(session->evlist, sample.id= ); + + if (sid) { + sample.machine_pid =3D sid->machine_pid; + sample.vcpu =3D sid->vcpu.cpu; + } + } + + /* + * Validate sample.cpu before any callback can use it as an + * array index (kwork cpus_runtime, timechart cpus_cstate_*, + * sched cpu_last_switched). + * + * When PERF_SAMPLE_CPU is absent, evsel__parse_sample() leaves + * sample.cpu as (u32)-1 =E2=80=94 a sentinel that downstream tools + * (script, inject) check to identify events without CPU info. + * Only check when sample.cpu was actually populated from event + * data: PERF_RECORD_SAMPLE always has it when PERF_SAMPLE_CPU + * is set; non-sample events only have it when sample_id_all is + * enabled. Otherwise sample.cpu is the (u32)-1 sentinel from + * evsel__parse_sample() and must not be validated or clamped. + */ + if ((evsel->core.attr.sample_type & PERF_SAMPLE_CPU) && + (event->header.type =3D=3D PERF_RECORD_SAMPLE || + evsel->core.attr.sample_id_all)) { + int nr_cpus_avail =3D perf_session__env(session)->nr_cpus_avail; + + /* + * For perf.data files the MAX_NR_CPUS fallback in + * perf_session__read_header() guarantees this is set. + * For pipe mode, HEADER_NRCPUS may arrive late or not + * at all (pre-2017 perf, third-party tools). Fall + * back to MAX_NR_CPUS so the bounds check still works + * against fixed-size downstream arrays. + * + * Do NOT write back to env: this function runs during + * recording (synthesized events) when nr_cpus_avail is + * legitimately 0. Writing MAX_NR_CPUS would cause + * write_cpu_topology() to emit 4096 core_id/socket_id + * pairs instead of the real CPU count, corrupting the + * topology section in the generated perf.data. + */ + if (nr_cpus_avail <=3D 0) + nr_cpus_avail =3D MAX_NR_CPUS; + /* + * Cap at MAX_NR_CPUS for the bounds check =E2=80=94 downstream + * consumers use fixed-size arrays of that size. Keep + * the true nr_cpus_avail in env for header parsing + * (e.g. process_cpu_topology) which needs the real count. + */ + if (nr_cpus_avail > MAX_NR_CPUS) + nr_cpus_avail =3D MAX_NR_CPUS; + if (sample.cpu >=3D (u32)nr_cpus_avail && + sample.cpu !=3D (u32)-1) { + /* + * Warn rather than abort: synthesized events + * (MMAP, COMM) lack sample_id_all data, so + * parse_id_sample reads garbage from the event + * payload. Clamping to 0 protects downstream + * array indexing while keeping the session alive. + * + * Preserve (u32)-1: perf script and perf inject + * use it as a sentinel for "CPU not applicable." + * Downstream array users (timechart, kwork) have + * their own per-callback bounds checks. + */ + pr_warning_once("WARNING: sample CPU %u >=3D nr_cpus_avail %u, clamping= to 0\n", + sample.cpu, nr_cpus_avail); + sample.cpu =3D 0; + } + } =20 ret =3D auxtrace__process_event(session, event, &sample, tool); if (ret < 0) --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 90F813C09E6; Tue, 26 May 2026 21:19:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830388; cv=none; b=CfNFYP3UdcKp9L+a2+hl3jP/q4p8j0n66wEImvIQMknxKcCnjppPu9vp2thBBMu+aB/kk6xtRQLA4qnTVAFzsH3Skx3TrYr/n1bgJiALyR9YATdRX3RI/gqv4Qj98uszgO7vC4rgbiIYME+wLnpUvnepSZgqjL3qEwQxuFqMg9A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830388; c=relaxed/simple; bh=cFbcd6tg4S4vTQ4OH5ZDXc6IUgIdEztjTvppO5X9nXs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=DPhY6w6bj9F2NoIrDvMfKke0jwruydcaY5sT2dHA94rTmCSu8fIw9ge0BbC0CZp2b6Jvkho+bzqCpdxe+74PbpI308JFVl5hg2Y6rdKJyCOKFy8I8fnncIfjlz2cSEanH/+Zl7EjixKqBQKriMV7osqKsDXBvZjinRW12ITRhxU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=S4EC+gbG; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="S4EC+gbG" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 78B021F00A3C; Tue, 26 May 2026 21:19:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830387; bh=Gu5rtWBHTYXbvUrpZQHMBKoyRKvBtzO1Zg4Rx3KVL50=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=S4EC+gbG5T+tNTUyoiC8OxuZyucuIKWtATGuAgSnEBP6r0Th/TRjzxfpwvO7GiZpS Cfods/zxMvMwGQdCVN9KfuEOFNaTg/s4H9KSBxaLo6/VwboPjiMFtIPgWHOqTkhITS rTrnHeWMPSse3WU5Cy2p0+I3GAkHWsTlo2wwFS9VCttKPu0389Iuk3hNQyFdR2zxoT dUizXXfVt7Hxzw5M1CWRGLrEZACfWSBwWh5tXhJbyI/h9BdSt/97cwAm9yVPKRFWmv 5gM5gp+TneTU3THUU+SLCGnfRo73flRAMoAjA+vD0D3CxkEVwV/ScGBD9k8eUyUA/z jwcgAI2JHlY2w== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, Yang Jihong , "Claude Opus 4.6 (1M context)" Subject: [PATCH 27/29] perf kwork: Bounds check work->cpu before indexing cpus_runtime[] Date: Tue, 26 May 2026 18:18:03 -0300 Message-ID: <20260526211806.1193848-28-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo work->cpu comes from sample->cpu which is (u32)-1 when PERF_SAMPLE_CPU is absent. Stored as int, this becomes -1 which passes the signed BUG_ON(work->cpu >=3D MAX_NR_CPUS) but causes an out-of-bounds access on cpus_runtime[-1]. Replace the BUG_ON in top_calc_total_runtime() with an unsigned bounds check that skips entries with invalid CPU values, counting them for a summary warning. Guard the same index in profile_event_match() (bitmap OOB), top_calc_idle_time(), top_calc_irq_runtime(), top_calc_cpu_usage(), and top_calc_load_runtime(). Also guard against division by zero in top_calc_cpu_usage() when no runtime was accumulated. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Cc: Yang Jihong Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/builtin-kwork.c | 45 +++++++++++++++++++++++++++++++++----- tools/perf/util/kwork.h | 1 + 2 files changed, 40 insertions(+), 6 deletions(-) diff --git a/tools/perf/builtin-kwork.c b/tools/perf/builtin-kwork.c index f793ea578515d08c..99dc293a0744726e 100644 --- a/tools/perf/builtin-kwork.c +++ b/tools/perf/builtin-kwork.c @@ -467,7 +467,9 @@ static bool profile_event_match(struct perf_kwork *kwor= k, u64 time =3D sample->time; struct perf_time_interval *ptime =3D &kwork->ptime; =20 - if ((kwork->cpu_list !=3D NULL) && !test_bit(cpu, kwork->cpu_bitmap)) + /* Guard test_bit: cpu =3D=3D -1 (absent PERF_SAMPLE_CPU) would index pas= t the bitmap */ + if ((kwork->cpu_list !=3D NULL) && + ((unsigned int)cpu >=3D MAX_NR_CPUS || !test_bit(cpu, kwork->cpu_bitm= ap))) return false; =20 if (((ptime->start !=3D 0) && (ptime->start > time)) || @@ -2041,7 +2043,18 @@ static void top_calc_total_runtime(struct perf_kwork= *kwork) next =3D rb_first_cached(&class->work_root); while (next) { work =3D rb_entry(next, struct kwork_work, node); - BUG_ON(work->cpu >=3D MAX_NR_CPUS); + /* + * work->cpu comes from sample->cpu which is -1 when + * PERF_SAMPLE_CPU is absent. As int that's -1, but as + * unsigned it exceeds MAX_NR_CPUS =E2=80=94 skip to avoid OOB + * on cpus_runtime[]. + */ + /* Counted and reported in perf_kwork__top_report() */ + if ((unsigned int)work->cpu >=3D MAX_NR_CPUS) { + stat->nr_skipped_cpu++; + next =3D rb_next(next); + continue; + } stat->cpus_runtime[work->cpu].total +=3D work->total_runtime; stat->cpus_runtime[MAX_NR_CPUS].total +=3D work->total_runtime; next =3D rb_next(next); @@ -2053,7 +2066,8 @@ static void top_calc_idle_time(struct perf_kwork *kwo= rk, { struct kwork_top_stat *stat =3D &kwork->top_stat; =20 - if (work->id =3D=3D 0) { + /* See comment in top_calc_total_runtime() */ + if (work->id =3D=3D 0 && (unsigned int)work->cpu < MAX_NR_CPUS) { stat->cpus_runtime[work->cpu].idle +=3D work->total_runtime; stat->cpus_runtime[MAX_NR_CPUS].idle +=3D work->total_runtime; } @@ -2065,6 +2079,10 @@ static void top_calc_irq_runtime(struct perf_kwork *= kwork, { struct kwork_top_stat *stat =3D &kwork->top_stat; =20 + /* See comment in top_calc_total_runtime() */ + if ((unsigned int)work->cpu >=3D MAX_NR_CPUS) + return; + if (type =3D=3D KWORK_CLASS_IRQ) { stat->cpus_runtime[work->cpu].irq +=3D work->total_runtime; stat->cpus_runtime[MAX_NR_CPUS].irq +=3D work->total_runtime; @@ -2117,12 +2135,19 @@ static void top_calc_cpu_usage(struct perf_kwork *k= work) if (work->total_runtime =3D=3D 0) goto next; =20 + /* See comment in top_calc_total_runtime() */ + if ((unsigned int)work->cpu >=3D MAX_NR_CPUS) + goto next; + __set_bit(work->cpu, stat->all_cpus_bitmap); =20 top_subtract_irq_runtime(kwork, work); =20 - work->cpu_usage =3D work->total_runtime * 10000 / - stat->cpus_runtime[work->cpu].total; + /* Guard against division by zero if no runtime was accumulated */ + if (stat->cpus_runtime[work->cpu].total) { + work->cpu_usage =3D work->total_runtime * 10000 / + stat->cpus_runtime[work->cpu].total; + } =20 top_calc_idle_time(kwork, work); next: @@ -2135,7 +2160,8 @@ static void top_calc_load_runtime(struct perf_kwork *= kwork, { struct kwork_top_stat *stat =3D &kwork->top_stat; =20 - if (work->id !=3D 0) { + /* See comment in top_calc_total_runtime() */ + if (work->id !=3D 0 && (unsigned int)work->cpu < MAX_NR_CPUS) { stat->cpus_runtime[work->cpu].load +=3D work->total_runtime; stat->cpus_runtime[MAX_NR_CPUS].load +=3D work->total_runtime; } @@ -2211,6 +2237,13 @@ static void perf_kwork__top_report(struct perf_kwork= *kwork) next =3D rb_next(next); } =20 + if (kwork->top_stat.nr_skipped_cpu) { + printf(" Warning: %u work entries with invalid CPU were excluded from t= otals.\n" + " Task runtimes may appear inflated (IRQ time not subtracted).\n" + " Consider re-recording with PERF_SAMPLE_CPU enabled.\n", + kwork->top_stat.nr_skipped_cpu); + } + printf("\n"); } =20 diff --git a/tools/perf/util/kwork.h b/tools/perf/util/kwork.h index 81d39a7f78c8b811..6ec70dcc4157a1f2 100644 --- a/tools/perf/util/kwork.h +++ b/tools/perf/util/kwork.h @@ -202,6 +202,7 @@ struct __top_cpus_runtime { struct kwork_top_stat { DECLARE_BITMAP(all_cpus_bitmap, MAX_NR_CPUS); struct __top_cpus_runtime *cpus_runtime; + unsigned int nr_skipped_cpu; }; =20 struct perf_kwork { --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D4C6B3C2BA7; Tue, 26 May 2026 21:19:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830392; cv=none; b=T9hcE7Pl124fK4lsd459kXyvx99FO3ZUxSip5cwfjayBcJV0yXEsU2bL9ZoUkoMi6CACGjmsO5oQ/60jlIt/9BsWntGRbMaJPRCvtdQyuhDlOMpabUwnrEppl77xSD6g9HxqlEjsYsmP9YFtz/HhLFt339h1fEdmuwFESS8NA8o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830392; c=relaxed/simple; bh=KHaK6TV1L+WqQwQ3G7IF1H5tzBLYca3Yc478KX1vzc8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=j4XJ1mceZH5JIqRO0TPefhlOIxD+E+DRZKFLnyaKrD227JaStDA7nC1Bgw/zi+5TT5vNZNKnfXUfgRm1oIim2RINMBNW0ifHfTpPuq+qAQKr2FVT+vObRYqCPrfVBAG2PT72TGDQOtvW4wjewyZ5l3b1gron8WZ3f0IXyVMHeow= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Ua0ii8c0; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Ua0ii8c0" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E7EF91F000E9; Tue, 26 May 2026 21:19:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830390; bh=MAhgt6MF/Lvwd+vbi4l3VmdHB5RN7EJYTE2MMA7COA4=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Ua0ii8c01hQkjr5KlEQRy6J03iz6ykswmrNMlVYeuYuVMyaWOzoh4GqTSU3hsvMse Ba3mGgZyeEY/hXx6Q79tda4x4ePWTOQcxVxL+J6zAqvYZsqwW7x+TVvwYRUa/ba7l3 U3tIHlM95wDaQ84ysu9zc2KMfzrQmleYWtdqv9Y/F3CzEzQz6xpQaGNdKg/cpysSD0 CRCT4HoddZyk9fz1Ce+ZfVJd0WaOo3aR46c8JoqFtlMEr6esetFESTTQph7jhHyKid NVfKIbiFSEceUuW0N8xpf0Hp43reaJYtsGtCZ1/2l23pqeCLu8G+o5djyaeRRbjj5p Jxxz+4iL/7e+A== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , sashiko-bot@kernel.org, "Claude Opus 4.6 (1M context)" Subject: [PATCH 28/29] perf session: Snapshot event->header.size in process_user_event() Date: Tue, 26 May 2026 18:18:04 -0300 Message-ID: <20260526211806.1193848-29-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo On native-endian files, events are read from MAP_SHARED memory. Multiple reads of event->header.size can return different values if the file is concurrently modified, allowing an attacker to bypass bounds checks performed on an earlier read. Snapshot header.size into a local variable at function entry using READ_ONCE() to prevent compiler rematerialization, and use it for all size-dependent arithmetic within the function. This ensures every bounds calculation uses the same value that was validated by the reader. Reported-by: sashiko-bot@kernel.org # Running on a local machine Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/util/session.c | 27 +++++++++++++-------------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 6de665d3c9054179..e2e821b77766dbfc 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -2230,6 +2230,7 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, { struct ordered_events *oe =3D &session->ordered_events; const struct perf_tool *tool =3D session->tool; + const u32 event_size =3D READ_ONCE(event->header.size); struct perf_sample sample; int fd =3D perf_data__fd(session->data); s64 err; @@ -2271,7 +2272,7 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, break; case PERF_RECORD_HEADER_BUILD_ID: if (!perf_event__check_nul(event->build_id.filename, - (void *)event + event->header.size, + (void *)event + event_size, "HEADER_BUILD_ID")) { err =3D 0; break; @@ -2294,7 +2295,7 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, * place already. */ if (!perf_data__is_pipe(session->data)) - lseek(fd, file_offset + event->header.size, SEEK_SET); + lseek(fd, file_offset + event_size, SEEK_SET); err =3D tool->auxtrace(tool, session, event); break; case PERF_RECORD_AUXTRACE_ERROR: @@ -2304,14 +2305,14 @@ static s64 perf_session__process_user_event(struct = perf_session *session, case PERF_RECORD_THREAD_MAP: { u64 max_nr; =20 - if (event->header.size < sizeof(event->thread_map)) { + if (event_size < sizeof(event->thread_map)) { pr_err("PERF_RECORD_THREAD_MAP: header.size (%u) too small\n", - event->header.size); + event_size); err =3D -EINVAL; break; } =20 - max_nr =3D (event->header.size - sizeof(event->thread_map)) / + max_nr =3D (event_size - sizeof(event->thread_map)) / sizeof(event->thread_map.entries[0]); if (event->thread_map.nr > max_nr) { pr_err("PERF_RECORD_THREAD_MAP: nr %" PRIu64 " exceeds max %" PRIu64 "\= n", @@ -2325,7 +2326,7 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, } case PERF_RECORD_CPU_MAP: { struct perf_record_cpu_map_data *data =3D &event->cpu_map.data; - u32 payload =3D event->header.size - sizeof(event->header); + u32 payload =3D event_size - sizeof(event->header); =20 /* * Native-endian events are mmap'd read-only, so we @@ -2389,8 +2390,8 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, break; } case PERF_RECORD_STAT_CONFIG: { - /* Cannot underflow: perf_event__min_size[] guarantees header.size >=3D = sizeof */ - u64 max_nr =3D (event->header.size - sizeof(event->stat_config)) / + /* Cannot underflow: perf_event__min_size[] guarantees event_size >=3D s= izeof */ + u64 max_nr =3D (event_size - sizeof(event->stat_config)) / sizeof(event->stat_config.data[0]); =20 /* @@ -2421,7 +2422,7 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, */ memset(&session->time_conv, 0, sizeof(session->time_conv)); memcpy(&session->time_conv, &event->time_conv, - min((size_t)event->header.size, sizeof(session->time_conv))); + min((size_t)event_size, sizeof(session->time_conv))); err =3D tool->time_conv(tool, session, event); break; case PERF_RECORD_HEADER_FEATURE: @@ -2438,11 +2439,10 @@ static s64 perf_session__process_user_event(struct = perf_session *session, break; case PERF_RECORD_BPF_METADATA: { u64 nr_entries, max_entries; - u32 hdr_size =3D READ_ONCE(event->header.size); =20 - if (hdr_size < sizeof(event->bpf_metadata)) { + if (event_size < sizeof(event->bpf_metadata)) { pr_warning("WARNING: PERF_RECORD_BPF_METADATA: header.size (%u) too sma= ll, skipping\n", - hdr_size); + event_size); err =3D 0; break; } @@ -2458,9 +2458,8 @@ static s64 perf_session__process_user_event(struct pe= rf_session *session, break; } =20 - /* Snapshot =E2=80=94 event is mmap'd and could change between reads */ nr_entries =3D READ_ONCE(event->bpf_metadata.nr_entries); - max_entries =3D (hdr_size - sizeof(event->bpf_metadata)) / + max_entries =3D (event_size - sizeof(event->bpf_metadata)) / sizeof(event->bpf_metadata.entries[0]); if (nr_entries > max_entries) { pr_warning("WARNING: PERF_RECORD_BPF_METADATA: nr_entries %" PRIu64 " e= xceeds max %" PRIu64 ", skipping\n", --=20 2.54.0 From nobody Sat May 30 09:28:23 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 35EDD3C2BBB; Tue, 26 May 2026 21:19:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830395; cv=none; b=tCtKyjZeKY/wt2rmyZrIfS+Ri4pDS6aR5Jf7DSBqsrmAcy/7B80reI7Y00wzVhSrKFdhQA1Kkm8ocN9moJm8/mIeL1opBeWDjYBumo1NwplmAu8VaaPoCo0Xu+84wrOvgppYegEpMSZH1H2+bqkvwz9Wu70v9ldo+RAGMeCuLYA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779830395; c=relaxed/simple; bh=45YV/A2vxvmFnS+TUv5RdKm/LuMb4XCpm9wjd0m/jME=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=GzrEPThZxZrHhyb5z4Xr7GRgjhOtIhlnozGXoliQdHRm6r0xxn+clBgy/A0uyd1fVpQYzqLR/OPcGXHd1E0/nPnfwVc/AC+WJjhw+5OifKz8gYdH5bf6QcLzBSQ79WItg9sWkoIOCmm8oeqxXDs8fF4LrEXd+3kVh8TVkSXUxfE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KmHK1s8c; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="KmHK1s8c" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 375A31F00A3A; Tue, 26 May 2026 21:19:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1779830393; bh=gJZ9uX+TETf2L0ylRETv0sF3eX/B6hGQzGWBb5NwiHE=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=KmHK1s8cpIX8DsAPVp2S/TP5G1XKn66U/wdhZgZ7qbFlan1E17sHzWcwbvFd8foFs 39PBjZHB8ItvMwZ0TkYmzH0Zqt8if7jNjq9ptUfhjgTLqbpqumR2g92JJIypG9c9KC tdqpVDDzDThdWdL0ZjLbcK7EL9vx4nTjPNQ3jNHDOIBLsZ64br3G7bMgx5oTg9Gx0O 6GqcOkPl3kBZ26Cugyhbyu5zqrCrvDI/cLZljTvaoJZyROuuCGvVAcprO7IBotChkq uOgl5x/N+VltDj1myA8HeFAZYKBMaXbSc1pUBUJ4zqF57yODVkkDueq+GmuFwDCxGb 0HUCWWVDzg8Aw== From: Arnaldo Carvalho de Melo To: Namhyung Kim Cc: Ingo Molnar , Thomas Gleixner , James Clark , Jiri Olsa , Ian Rogers , Adrian Hunter , Clark Williams , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, Arnaldo Carvalho de Melo , "Claude Opus 4.6 (1M context)" Subject: [PATCH 29/29] perf test: Add truncated perf.data robustness test Date: Tue, 26 May 2026 18:18:05 -0300 Message-ID: <20260526211806.1193848-30-acme@kernel.org> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260526211806.1193848-1-acme@kernel.org> References: <20260526211806.1193848-1-acme@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Arnaldo Carvalho de Melo Add a shell test that verifies perf report handles truncated perf.data files gracefully =E2=80=94 exiting with an error code rather than crashing = with SIGSEGV or SIGABRT. The test records a simple workload, then truncates the resulting perf.data at four offsets that exercise different parsing stages: 8 bytes =E2=80=94 file header magic only 64 bytes =E2=80=94 partial file header (attr section incomplete) 256 bytes =E2=80=94 into the first events (partial event headers) 75% size =E2=80=94 mid-stream truncation (partial event data) For each truncation, perf report is run and the exit code is checked: - Exit code 0 (success) fails the test =E2=80=94 a truncated file should never parse without error. - Crash signals are detected portably via kill -l, which maps the signal number to a name on the running system. This handles architectures where signal numbers differ (e.g. SIGBUS is 7 on x86/ARM but 10 on MIPS/SPARC). Core-dump and fatal signals (KILL, ILL, ABRT, BUS, FPE, SEGV, TRAP, SYS) fail the test. - Higher exit codes (200+) are perf's own negative-errno returns (e.g. -EINVAL =3D 234) and are expected. This exercises the bounds checking, minimum-size validation, and error propagation added by the preceding patches in this series. Testing it: root@number:~# perf test truncat 84: Test that perf report handles truncated perf.data gracefully (no cra= sh, no segfault =E2=80=94 clean error exit).: Ok root@number:~# perf test -vv truncat 84: Test that perf report handles truncated perf.data gracefully (no cra= sh, no segfault =E2=80=94 clean error exit).: --- start --- test child forked, pid 62890 ---- end(0) ---- 84: Test that perf report handles truncated perf.data gracefully (no cra= sh, no segfault =E2=80=94 clean error exit).: Ok root@number:~# Changes in v2: - Add SIGKILL to the list of fatal signals so OOM kills from resource exhaustion bugs are detected (Reported-by: sashiko-bot@kernel.or= g) Cc: Adrian Hunter Cc: Ian Rogers Cc: Jiri Olsa Cc: Namhyung Kim Assisted-by: Claude Opus 4.6 (1M context) [ Fixed the SPDX on the line where 'perf test' expects the test description= , reviewed by Ian Rogers ] Signed-off-by: Arnaldo Carvalho de Melo Reviewed-by: Ian Rogers --- tools/perf/tests/shell/data_validation.sh | 85 +++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100755 tools/perf/tests/shell/data_validation.sh diff --git a/tools/perf/tests/shell/data_validation.sh b/tools/perf/tests/s= hell/data_validation.sh new file mode 100755 index 0000000000000000..5c3e6fced6fce0cb --- /dev/null +++ b/tools/perf/tests/shell/data_validation.sh @@ -0,0 +1,85 @@ +#!/bin/bash +# Test that perf report handles truncated perf.data gracefully (no crash, = no segfault =E2=80=94 clean error exit). +# SPDX-License-Identifier: GPL-2.0 +# +# Exercises the bounds checking and minimum-size validation added +# by the perf-data-validation hardening series. + +err=3D0 + +cleanup() { + rm -f "${perfdata}" "${perfdata}.old" "${truncated}" "${stderrfile}" + trap - EXIT TERM INT +} +trap 'cleanup; exit 1' TERM INT +trap cleanup EXIT + +perfdata=3D$(mktemp /tmp/__perf_test.perf.data.XXXXX) || exit 2 +truncated=3D$(mktemp /tmp/__perf_test.perf.data.XXXXX) || exit 2 +stderrfile=3D$(mktemp /tmp/__perf_test.perf.data.XXXXX) || exit 2 + +# Record a simple workload +if ! perf record -o "${perfdata}" -- perf test -w noploop 2>/dev/null; then + echo "Skip: perf record failed" + cleanup + exit 2 +fi + +file_size=3D$(wc -c < "${perfdata}") +if [ "${file_size}" -lt 512 ]; then + echo "Skip: perf.data too small (${file_size} bytes)" + cleanup + exit 2 +fi + +# Test truncation at various offsets that exercise different +# parsing stages: +# 8 =E2=80=94 file header magic only, no attrs or data +# 64 =E2=80=94 partial file header (attr section incomplete) +# 256 =E2=80=94 into the first events (partial event headers) +# 75% =E2=80=94 mid-stream truncation (partial event data) +for cut_at in 8 64 256 $((file_size * 3 / 4)); do + if [ "${cut_at}" -ge "${file_size}" ]; then + continue + fi + dd if=3D"${perfdata}" of=3D"${truncated}" bs=3D"${cut_at}" count=3D1 2>/d= ev/null + + # perf report should exit with an error, not crash. + # Capture stderr to detect sanitizer violations. + perf report -i "${truncated}" --stdio > /dev/null 2> "${stderrfile}" + exit_code=3D$? + + # A truncated file should never parse successfully + if [ ${exit_code} -eq 0 ]; then + echo "FAIL: perf report exited 0 (success) on ${cut_at}-byte truncated f= ile =E2=80=94 expected an error" + err=3D1 + continue + fi + + # Detect sanitizer violations =E2=80=94 ASAN/MSAN/TSAN/UBSAN exit + # with code 1 by default, which would otherwise look like a + # clean error exit. Check stderr for their markers. + if grep -qE "^(=3D=3D[0-9]+=3D=3DERROR:|SUMMARY: [A-Za-z]*Sanitizer)" "${= stderrfile}" 2>/dev/null; then + sanitizer=3D$(grep -oE "(Address|Memory|Thread|UndefinedBehavior)Sanitiz= er" "${stderrfile}" | head -1) + echo "FAIL: perf report triggered ${sanitizer:-sanitizer} on ${cut_at}-b= yte truncated file" + err=3D1 + continue + fi + + # Detect crash signals portably =E2=80=94 signal numbers differ + # across architectures (e.g. SIGBUS is 7 on x86/ARM but + # 10 on MIPS/SPARC). Use kill -l to map the number to a + # name on the running system. + if [ ${exit_code} -gt 128 ] && [ ${exit_code} -lt 200 ]; then + sig_name=3D$(kill -l $((exit_code - 128)) 2>/dev/null) + case ${sig_name} in + KILL|ILL|ABRT|BUS|FPE|SEGV|TRAP|SYS) + echo "FAIL: perf report crashed (SIG${sig_name}) on ${cut_at}-byte trun= cated file" + err=3D1 + ;; + esac + fi +done + +cleanup +exit ${err} --=20 2.54.0