From nobody Thu Apr 2 17:22:47 2026 Received: from mail-wm1-f73.google.com (mail-wm1-f73.google.com [209.85.128.73]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BF3443E9582 for ; Mon, 9 Mar 2026 16:26:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.73 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773073571; cv=none; b=CUSFovAZbvgicCfUC6ys8oMqz1/l8sNrqHtyvunm1jDM/7shgU932hAPdzBNIolAXN+JJ7LKH+jJl8yHmAHs0g8GnCRMpYJJBpkc3zyScxdkByLghvYhVinN7MmAJSHXN4x1uOodD9+EFXi5VGGz5qZFnwteMZJxe/whp3y7cX0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773073571; c=relaxed/simple; bh=ODvjriFqVfSmyiDYcVBoWo/RZkQlSW3RVl2G3JPmqFs=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=Re6250lIZt2Itsi2SP1rUtMMzmulHB03/5e8Uv+F1G48ktl4sk9dJBWOOfzzDNv85nCIFwzBK3gGAQummM+nlXGN5dHLN5EWy7Gy+JA8OCZo6Qe5cVMYZiXLg4kmu0N6qdrIT7ybELgxZxm+yvvJ210gdx1UQ7N1mvYb8zBkodE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--vdonnefort.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=voLujR9A; arc=none smtp.client-ip=209.85.128.73 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--vdonnefort.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="voLujR9A" Received: by mail-wm1-f73.google.com with SMTP id 5b1f17b1804b1-48535f4d5e1so6900535e9.0 for ; Mon, 09 Mar 2026 09:26:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1773073567; x=1773678367; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=ZNkHNHr5G2vNTCQRTPifNKGoQqTU1hFM0mR58SBV6Xg=; b=voLujR9AypRisYDFR3zMcA55DzqlOnhsUEdifXIfV+VoYAAiuUUgRoNh6iQKHbHYtV efD3VMqrl+cWRA5+TNA/LQVKuf7mY1yQwSC6z6FDbF0otkAWgiycHGKee9TgGcT9KPju sU5QobcBpjhLIa6BduIaiQ5xocRpQiTDffBD9y81T92Txu5yY1beuXh5XWD2XA+pLxGA ZkPJnJjblWV5ng1NbJJQvsNGQEu/S9YOqse9ob1Mi4oyCv6x3NSGNiVaAalVAu3s4dQK /1WD5XuALCCwswlPIoZbtu9KIyg+UswBhfidYQ7uageaR758qf3WRM6mSVNHcLrcn4/q lgfA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1773073567; x=1773678367; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=ZNkHNHr5G2vNTCQRTPifNKGoQqTU1hFM0mR58SBV6Xg=; b=DB5zJuAu4YlamsMTGFTNlFeF9rIZY4OMNkToJKQKV1V0RKQ/vfPOgnHXVjFstZw4rK iLCohTv5Py6g1Cc5UgEg9ifygzNTS9ylJq9TK8nV/5zJ8XGMX8kirg92tT1EemzqeAMJ jZFy9ZQ8uTpUcubTvVpiii5f/A+sMst5DL/WUGL2uPxSrbWOcyH4oy+wZc5GsnH01zcv l2atrZx8/jyMpcp/ermxeUnQKlJXXSewb97lyHwLwbHsS1h3Hh26VDh/iqzbcVO/5u4N cIfYFG79nchSR61Cxz8dMNeusruMX+rp9W7/YWIK+ZRdgoEKps4rkM0VMUgNBQ0L4QYy ly+A== X-Forwarded-Encrypted: i=1; AJvYcCXKK7ewLYvBTpe/LKo92wEFWK8If+Ul/Tae4by1nyTHHbyv9GyXpV/3zml7zbk7mE+BB2+PB8OykbNtXpg=@vger.kernel.org X-Gm-Message-State: AOJu0YwQlNMKm6rP7giB4Ohu7vXX+3CNTf2OyE02Nm0kKjOmAYJtAoRy wcEyKOvy1VdtfuQOOkpza1/li11TiiDpX2n7DjR8915clrP2XuBeK1g2xd0AayfXknzDtxRggDT BIr8n36Xisp89Citf0nsCHA== X-Received: from wmgp3.prod.google.com ([2002:a05:600c:2043:b0:483:509d:729b]) (user=vdonnefort job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:3e11:b0:485:3a22:69b9 with SMTP id 5b1f17b1804b1-4853a226f66mr72368395e9.29.1773073567277; Mon, 09 Mar 2026 09:26:07 -0700 (PDT) Date: Mon, 9 Mar 2026 16:24:53 +0000 In-Reply-To: <20260309162516.2623589-1-vdonnefort@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260309162516.2623589-1-vdonnefort@google.com> X-Mailer: git-send-email 2.53.0.473.g4a7958ca14-goog Message-ID: <20260309162516.2623589-8-vdonnefort@google.com> Subject: [PATCH v14 07/30] tracing: Add non-consuming read to trace remotes From: Vincent Donnefort To: rostedt@goodmis.org, mhiramat@kernel.org, mathieu.desnoyers@efficios.com, linux-trace-kernel@vger.kernel.org, maz@kernel.org, oliver.upton@linux.dev, joey.gouly@arm.com, suzuki.poulose@arm.com, yuzenghui@huawei.com Cc: kvmarm@lists.linux.dev, linux-arm-kernel@lists.infradead.org, jstultz@google.com, qperret@google.com, will@kernel.org, aneesh.kumar@kernel.org, kernel-team@android.com, linux-kernel@vger.kernel.org, Vincent Donnefort Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Allow reading the trace file for trace remotes. This performs a non-consuming read of the trace buffer. Reviewed-by: Steven Rostedt (Google) Signed-off-by: Vincent Donnefort diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index e33cb3c39f6e..5e1129b011cb 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -3856,7 +3856,7 @@ static int s_show(struct seq_file *m, void *v) * Should be used after trace_array_get(), trace_types_lock * ensures that i_cdev was already initialized. */ -static inline int tracing_get_cpu(struct inode *inode) +int tracing_get_cpu(struct inode *inode) { if (inode->i_cdev) /* See trace_create_cpu_file() */ return (long)inode->i_cdev - 1; diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index d6af4405b341..fbbd0b2ee76f 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -695,6 +695,7 @@ struct dentry *trace_create_cpu_file(const char *name, void *data, long cpu, const struct file_operations *fops); +int tracing_get_cpu(struct inode *inode); =20 =20 /** diff --git a/kernel/trace/trace_remote.c b/kernel/trace/trace_remote.c index a7b94736dd38..039ba71c3b3e 100644 --- a/kernel/trace/trace_remote.c +++ b/kernel/trace/trace_remote.c @@ -18,14 +18,23 @@ #define TRACEFS_MODE_WRITE 0640 #define TRACEFS_MODE_READ 0440 =20 +enum tri_type { + TRI_CONSUMING, + TRI_NONCONSUMING, +}; + struct trace_remote_iterator { struct trace_remote *remote; struct trace_seq seq; struct delayed_work poll_work; unsigned long lost_events; u64 ts; + struct ring_buffer_iter *rb_iter; + struct ring_buffer_iter **rb_iters; int cpu; int evt_cpu; + loff_t pos; + enum tri_type type; }; =20 struct trace_remote { @@ -36,6 +45,8 @@ struct trace_remote { unsigned long trace_buffer_size; struct ring_buffer_remote rb_remote; struct mutex lock; + struct rw_semaphore reader_lock; + struct rw_semaphore *pcpu_reader_locks; unsigned int nr_readers; unsigned int poll_ms; bool tracing_on; @@ -230,6 +241,20 @@ static int trace_remote_get(struct trace_remote *remot= e, int cpu) if (ret) return ret; =20 + if (cpu !=3D RING_BUFFER_ALL_CPUS && !remote->pcpu_reader_locks) { + int lock_cpu; + + remote->pcpu_reader_locks =3D kcalloc(nr_cpu_ids, sizeof(*remote->pcpu_r= eader_locks), + GFP_KERNEL); + if (!remote->pcpu_reader_locks) { + trace_remote_try_unload(remote); + return -ENOMEM; + } + + for_each_possible_cpu(lock_cpu) + init_rwsem(&remote->pcpu_reader_locks[lock_cpu]); + } + remote->nr_readers++; =20 return 0; @@ -244,6 +269,9 @@ static void trace_remote_put(struct trace_remote *remot= e) if (remote->nr_readers) return; =20 + kfree(remote->pcpu_reader_locks); + remote->pcpu_reader_locks =3D NULL; + trace_remote_try_unload(remote); } =20 @@ -258,13 +286,55 @@ static void __poll_remote(struct work_struct *work) msecs_to_jiffies(iter->remote->poll_ms)); } =20 -static struct trace_remote_iterator *trace_remote_iter(struct trace_remote= *remote, int cpu) +static void __free_ring_buffer_iter(struct trace_remote_iterator *iter, in= t cpu) +{ + if (cpu !=3D RING_BUFFER_ALL_CPUS) { + ring_buffer_read_finish(iter->rb_iter); + return; + } + + for_each_possible_cpu(cpu) { + if (iter->rb_iters[cpu]) + ring_buffer_read_finish(iter->rb_iters[cpu]); + } + + kfree(iter->rb_iters); +} + +static int __alloc_ring_buffer_iter(struct trace_remote_iterator *iter, in= t cpu) +{ + if (cpu !=3D RING_BUFFER_ALL_CPUS) { + iter->rb_iter =3D ring_buffer_read_start(iter->remote->trace_buffer, cpu= , GFP_KERNEL); + + return iter->rb_iter ? 0 : -ENOMEM; + } + + iter->rb_iters =3D kcalloc(nr_cpu_ids, sizeof(*iter->rb_iters), GFP_KERNE= L); + if (!iter->rb_iters) + return -ENOMEM; + + for_each_possible_cpu(cpu) { + iter->rb_iters[cpu] =3D ring_buffer_read_start(iter->remote->trace_buffe= r, cpu, + GFP_KERNEL); + if (!iter->rb_iters[cpu]) { + __free_ring_buffer_iter(iter, RING_BUFFER_ALL_CPUS); + return -ENOMEM; + } + } + + return 0; +} + +static struct trace_remote_iterator +*trace_remote_iter(struct trace_remote *remote, int cpu, enum tri_type typ= e) { struct trace_remote_iterator *iter =3D NULL; int ret; =20 lockdep_assert_held(&remote->lock); =20 + if (type =3D=3D TRI_NONCONSUMING && !trace_remote_loaded(remote)) + return NULL; =20 ret =3D trace_remote_get(remote, cpu); if (ret) @@ -279,9 +349,21 @@ static struct trace_remote_iterator *trace_remote_iter= (struct trace_remote *remo if (iter) { iter->remote =3D remote; iter->cpu =3D cpu; + iter->type =3D type; trace_seq_init(&iter->seq); - INIT_DELAYED_WORK(&iter->poll_work, __poll_remote); - schedule_delayed_work(&iter->poll_work, msecs_to_jiffies(remote->poll_ms= )); + + switch (type) { + case TRI_CONSUMING: + INIT_DELAYED_WORK(&iter->poll_work, __poll_remote); + schedule_delayed_work(&iter->poll_work, msecs_to_jiffies(remote->poll_m= s)); + break; + case TRI_NONCONSUMING: + ret =3D __alloc_ring_buffer_iter(iter, cpu); + break; + } + + if (ret) + goto err; =20 return iter; } @@ -305,10 +387,100 @@ static void trace_remote_iter_free(struct trace_remo= te_iterator *iter) =20 lockdep_assert_held(&remote->lock); =20 + switch (iter->type) { + case TRI_CONSUMING: + cancel_delayed_work_sync(&iter->poll_work); + break; + case TRI_NONCONSUMING: + __free_ring_buffer_iter(iter, iter->cpu); + break; + } + kfree(iter); trace_remote_put(remote); } =20 +static void trace_remote_iter_read_start(struct trace_remote_iterator *ite= r) +{ + struct trace_remote *remote =3D iter->remote; + int cpu =3D iter->cpu; + + /* Acquire global reader lock */ + if (cpu =3D=3D RING_BUFFER_ALL_CPUS && iter->type =3D=3D TRI_CONSUMING) + down_write(&remote->reader_lock); + else + down_read(&remote->reader_lock); + + if (cpu =3D=3D RING_BUFFER_ALL_CPUS) + return; + + /* + * No need for the remote lock here, iter holds a reference on + * remote->nr_readers + */ + + /* Get the per-CPU one */ + if (WARN_ON_ONCE(!remote->pcpu_reader_locks)) + return; + + if (iter->type =3D=3D TRI_CONSUMING) + down_write(&remote->pcpu_reader_locks[cpu]); + else + down_read(&remote->pcpu_reader_locks[cpu]); +} + +static void trace_remote_iter_read_finished(struct trace_remote_iterator *= iter) +{ + struct trace_remote *remote =3D iter->remote; + int cpu =3D iter->cpu; + + /* Release per-CPU reader lock */ + if (cpu !=3D RING_BUFFER_ALL_CPUS) { + /* + * No need for the remote lock here, iter holds a reference on + * remote->nr_readers + */ + if (iter->type =3D=3D TRI_CONSUMING) + up_write(&remote->pcpu_reader_locks[cpu]); + else + up_read(&remote->pcpu_reader_locks[cpu]); + } + + /* Release global reader lock */ + if (cpu =3D=3D RING_BUFFER_ALL_CPUS && iter->type =3D=3D TRI_CONSUMING) + up_write(&remote->reader_lock); + else + up_read(&remote->reader_lock); +} + +static struct ring_buffer_iter *__get_rb_iter(struct trace_remote_iterator= *iter, int cpu) +{ + return iter->cpu !=3D RING_BUFFER_ALL_CPUS ? iter->rb_iter : iter->rb_ite= rs[cpu]; +} + +static struct ring_buffer_event * +__peek_event(struct trace_remote_iterator *iter, int cpu, u64 *ts, unsigne= d long *lost_events) +{ + struct ring_buffer_event *rb_evt; + struct ring_buffer_iter *rb_iter; + + switch (iter->type) { + case TRI_CONSUMING: + return ring_buffer_peek(iter->remote->trace_buffer, cpu, ts, lost_events= ); + case TRI_NONCONSUMING: + rb_iter =3D __get_rb_iter(iter, cpu); + rb_evt =3D ring_buffer_iter_peek(rb_iter, ts); + if (!rb_evt) + return NULL; + + *lost_events =3D ring_buffer_iter_dropped(rb_iter); + + return rb_evt; + } + + return NULL; +} + static bool trace_remote_iter_read_event(struct trace_remote_iterator *ite= r) { struct trace_buffer *trace_buffer =3D iter->remote->trace_buffer; @@ -318,7 +490,7 @@ static bool trace_remote_iter_read_event(struct trace_r= emote_iterator *iter) if (ring_buffer_empty_cpu(trace_buffer, cpu)) return false; =20 - if (!ring_buffer_peek(trace_buffer, cpu, &iter->ts, &iter->lost_events)) + if (!__peek_event(iter, cpu, &iter->ts, &iter->lost_events)) return false; =20 iter->evt_cpu =3D cpu; @@ -333,7 +505,7 @@ static bool trace_remote_iter_read_event(struct trace_r= emote_iterator *iter) if (ring_buffer_empty_cpu(trace_buffer, cpu)) continue; =20 - if (!ring_buffer_peek(trace_buffer, cpu, &ts, &lost_events)) + if (!__peek_event(iter, cpu, &ts, &lost_events)) continue; =20 if (ts >=3D iter->ts) @@ -347,6 +519,20 @@ static bool trace_remote_iter_read_event(struct trace_= remote_iterator *iter) return iter->ts !=3D U64_MAX; } =20 +static void trace_remote_iter_move(struct trace_remote_iterator *iter) +{ + struct trace_buffer *trace_buffer =3D iter->remote->trace_buffer; + + switch (iter->type) { + case TRI_CONSUMING: + ring_buffer_consume(trace_buffer, iter->evt_cpu, NULL, NULL); + break; + case TRI_NONCONSUMING: + ring_buffer_iter_advance(__get_rb_iter(iter, iter->evt_cpu)); + break; + } +} + static int trace_remote_iter_print_event(struct trace_remote_iterator *ite= r) { unsigned long usecs_rem; @@ -369,13 +555,14 @@ static int trace_pipe_open(struct inode *inode, struc= t file *filp) { struct trace_remote *remote =3D inode->i_private; struct trace_remote_iterator *iter; - int cpu =3D RING_BUFFER_ALL_CPUS; - - if (inode->i_cdev) - cpu =3D (long)inode->i_cdev - 1; + int cpu =3D tracing_get_cpu(inode); =20 guard(mutex)(&remote->lock); - iter =3D trace_remote_iter(remote, cpu); + + iter =3D trace_remote_iter(remote, cpu, TRI_CONSUMING); + if (IS_ERR(iter)) + return PTR_ERR(iter); + filp->private_data =3D iter; =20 return IS_ERR(iter) ? PTR_ERR(iter) : 0; @@ -410,6 +597,8 @@ static ssize_t trace_pipe_read(struct file *filp, char = __user *ubuf, size_t cnt, if (ret < 0) return ret; =20 + trace_remote_iter_read_start(iter); + while (trace_remote_iter_read_event(iter)) { int prev_len =3D iter->seq.seq.len; =20 @@ -418,9 +607,11 @@ static ssize_t trace_pipe_read(struct file *filp, char= __user *ubuf, size_t cnt, break; } =20 - ring_buffer_consume(trace_buffer, iter->evt_cpu, NULL, NULL); + trace_remote_iter_move(iter); } =20 + trace_remote_iter_read_finished(iter); + goto copy_to_user; } =20 @@ -430,14 +621,127 @@ static const struct file_operations trace_pipe_fops = =3D { .release =3D trace_pipe_release, }; =20 +static void *trace_next(struct seq_file *m, void *v, loff_t *pos) +{ + struct trace_remote_iterator *iter =3D m->private; + + ++*pos; + + if (!iter || !trace_remote_iter_read_event(iter)) + return NULL; + + trace_remote_iter_move(iter); + iter->pos++; + + return iter; +} + +static void *trace_start(struct seq_file *m, loff_t *pos) +{ + struct trace_remote_iterator *iter =3D m->private; + loff_t i; + + if (!iter) + return NULL; + + trace_remote_iter_read_start(iter); + + if (!*pos) { + iter->pos =3D -1; + return trace_next(m, NULL, &i); + } + + i =3D iter->pos; + while (i < *pos) { + iter =3D trace_next(m, NULL, &i); + if (!iter) + return NULL; + } + + return iter; +} + +static int trace_show(struct seq_file *m, void *v) +{ + struct trace_remote_iterator *iter =3D v; + + trace_seq_init(&iter->seq); + + if (trace_remote_iter_print_event(iter)) { + seq_printf(m, "[EVENT %d PRINT TOO BIG]\n", iter->evt->id); + return 0; + } + + return trace_print_seq(m, &iter->seq); +} + +static void trace_stop(struct seq_file *m, void *v) +{ + struct trace_remote_iterator *iter =3D m->private; + + if (iter) + trace_remote_iter_read_finished(iter); +} + +static const struct seq_operations trace_sops =3D { + .start =3D trace_start, + .next =3D trace_next, + .show =3D trace_show, + .stop =3D trace_stop, +}; + +static int trace_open(struct inode *inode, struct file *filp) +{ + struct trace_remote *remote =3D inode->i_private; + struct trace_remote_iterator *iter =3D NULL; + int cpu =3D tracing_get_cpu(inode); + int ret; + + if (!(filp->f_mode & FMODE_READ)) + return 0; + + guard(mutex)(&remote->lock); + + iter =3D trace_remote_iter(remote, cpu, TRI_NONCONSUMING); + if (IS_ERR(iter)) + return PTR_ERR(iter); + + ret =3D seq_open(filp, &trace_sops); + if (ret) { + trace_remote_iter_free(iter); + return ret; + } + + ((struct seq_file *)filp->private_data)->private =3D (void *)iter; + + return 0; +} + +static int trace_release(struct inode *inode, struct file *filp) +{ + struct trace_remote_iterator *iter; + + if (!(filp->f_mode & FMODE_READ)) + return 0; + + iter =3D ((struct seq_file *)filp->private_data)->private; + seq_release(inode, filp); + + if (!iter) + return 0; + + guard(mutex)(&iter->remote->lock); + + trace_remote_iter_free(iter); + + return 0; +} + static ssize_t trace_write(struct file *filp, const char __user *ubuf, siz= e_t cnt, loff_t *ppos) { struct inode *inode =3D file_inode(filp); struct trace_remote *remote =3D inode->i_private; - int cpu =3D RING_BUFFER_ALL_CPUS; - - if (inode->i_cdev) - cpu =3D (long)inode->i_cdev - 1; + int cpu =3D tracing_get_cpu(inode); =20 guard(mutex)(&remote->lock); =20 @@ -447,7 +751,11 @@ static ssize_t trace_write(struct file *filp, const ch= ar __user *ubuf, size_t cn } =20 static const struct file_operations trace_fops =3D { + .open =3D trace_open, .write =3D trace_write, + .read =3D seq_read, + .read_iter =3D seq_read_iter, + .release =3D trace_release, }; =20 static int trace_remote_init_tracefs(const char *name, struct trace_remote= *remote) @@ -565,6 +873,7 @@ int trace_remote_register(const char *name, struct trac= e_remote_callbacks *cbs, remote->trace_buffer_size =3D 7 << 10; remote->poll_ms =3D 100; mutex_init(&remote->lock); + init_rwsem(&remote->reader_lock); =20 if (trace_remote_init_tracefs(name, remote)) { kfree(remote); --=20 2.53.0.473.g4a7958ca14-goog