From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-17.3 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A4671C4361B for ; Tue, 15 Dec 2020 14:22:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 61532224D2 for ; Tue, 15 Dec 2020 14:22:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728926AbgLOOV7 (ORCPT ); Tue, 15 Dec 2020 09:21:59 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:20749 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729236AbgLOOVr (ORCPT ); Tue, 15 Dec 2020 09:21:47 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1608042017; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=QstGKZZqt4qW9A5l49mbx7byJNnvydjQeGXbzx5OckQ=; b=FKP1C+PHskWb1OoKzGp3/FaRMcan9KZk3XczvlZCqfIceCzTHS9IunEqTERW9IYlGQsfVR ZPDNIH5kUMvBimKAIbmUO8hF9NhbkO/cK3ad9cNbHQ0G3b+nQZZJZLL4nU91qdZaaS7IYf csB8GR2058OV+wEZ3V/wKymBs7gJ4Ug= Received: from mail-ej1-f69.google.com (mail-ej1-f69.google.com [209.85.218.69]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-489-GqsF0l2oMv21dVFWP_LK9A-1; Tue, 15 Dec 2020 09:20:16 -0500 X-MC-Unique: GqsF0l2oMv21dVFWP_LK9A-1 Received: by mail-ej1-f69.google.com with SMTP id k3so6029474ejr.16 for ; Tue, 15 Dec 2020 06:20:15 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=QstGKZZqt4qW9A5l49mbx7byJNnvydjQeGXbzx5OckQ=; b=kQvxaKWqs3CQDz7pKzaQouNs75GIb71yf2gD/UQE3C3dNDLHpxLknbWisr58cC4+2/ faDcdbauGPSsAxtJDP3YjCuPcwbzMEPomqsHzwLCZV1MXeEtnGILymg5zFpYtyjUCCON 1wURGsxX7PelV5vrO2Rb89TyWx1JYCqmKX7MvJ8+uZqkoS76UNC8JMA4cJFYdzE9Sf3k MynelUqLWSPd93igvvs8C2wN53WJ7QSniyRICmg06M2NZd4s0hB8jT7DiQhlj+ie6zI7 ojH0oGAtEPvbo+2vuf3GdtTWCT8Krhb2jlYarIj8Q0Dz9F69QrAWeuBcw1X+rTcNdh98 CPqw== X-Gm-Message-State: AOAM5310qEf+kP4bcM7FrXgs6mP9wzO9aunKSX2G13BaN98W7RYd2eS3 Mr+NI2J0gZOKkAq3faJvqBmJ8RpRvQ7ee9aUH9s/73svQCMGXJ7V8v9KaWm2Dxr0mf7W97qDqat m8mWSbrS67RX9vdE247aHwcFI X-Received: by 2002:a17:906:1542:: with SMTP id c2mr26464540ejd.382.1608042014427; Tue, 15 Dec 2020 06:20:14 -0800 (PST) X-Google-Smtp-Source: ABdhPJw+6/Qx7DU2a/MXeC9xVqGDh1aykz604eHZci7cqhGh3m1Cy73BKUSo2KczA4kjELcn/oAmVQ== X-Received: by 2002:a17:906:1542:: with SMTP id c2mr26464497ejd.382.1608042013942; Tue, 15 Dec 2020 06:20:13 -0800 (PST) Received: from x1.localdomain (2001-1c00-0c0c-fe00-d2ea-f29d-118b-24dc.cable.dynamic.v6.ziggo.nl. [2001:1c00:c0c:fe00:d2ea:f29d:118b:24dc]) by smtp.gmail.com with ESMTPSA id s24sm1477387ejb.20.2020.12.15.06.20.12 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 15 Dec 2020 06:20:13 -0800 (PST) Subject: Re: [PATCH v2 4/9] platform/surface: aggregator: Add trace points To: Maximilian Luz , linux-kernel@vger.kernel.org Cc: Mark Gross , Andy Shevchenko , =?UTF-8?Q?Barnab=c3=a1s_P=c5=91cze?= , Arnd Bergmann , Greg Kroah-Hartman , Steven Rostedt , Ingo Molnar , =?UTF-8?Q?Bla=c5=be_Hrastnik?= , Dorian Stoll , platform-driver-x86@vger.kernel.org References: <20201203212640.663931-1-luzmaximilian@gmail.com> <20201203212640.663931-5-luzmaximilian@gmail.com> From: Hans de Goede Message-ID: <6e8ebfcc-0fe3-59bd-2115-ac37b61fffcd@redhat.com> Date: Tue, 15 Dec 2020 15:20:12 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.4.0 MIME-Version: 1.0 In-Reply-To: <20201203212640.663931-5-luzmaximilian@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, On 12/3/20 10:26 PM, Maximilian Luz wrote: > Add trace points to the Surface Aggregator subsystem core. These trace > points can be used to track packets, requests, and allocations. They are > further intended for debugging and testing/validation, specifically in > combination with the error injection capabilities introduced in the > subsequent commit. > > Signed-off-by: Maximilian Luz Thanks, patch looks good to me: Reviewed-by: Hans de Goede Regards, Hans > --- > > Changes in v1 (from RFC): > - add copyright line > - change SPDX identifier to GPL-2.0+ (was GPL-2.0-or-later) > - pack tracing structs > > Changes in v2: > - add compiletime check on SSAM_PTR_UID_LEN > - fix ssam_trace_get_command_field_u8() macro > - use dedicated trace event class for timeout reaper > - use printk specifier for hex prefix instead of hard-coding it > - unify comment style > - run checkpatch --strict, fix warnings and style issues > > --- > drivers/platform/surface/aggregator/Makefile | 3 + > .../platform/surface/aggregator/controller.c | 5 + > drivers/platform/surface/aggregator/core.c | 3 + > .../surface/aggregator/ssh_packet_layer.c | 26 +- > .../surface/aggregator/ssh_request_layer.c | 18 + > drivers/platform/surface/aggregator/trace.h | 601 ++++++++++++++++++ > 6 files changed, 655 insertions(+), 1 deletion(-) > create mode 100644 drivers/platform/surface/aggregator/trace.h > > diff --git a/drivers/platform/surface/aggregator/Makefile b/drivers/platform/surface/aggregator/Makefile > index faad18d4a7f2..b8b24c8ec310 100644 > --- a/drivers/platform/surface/aggregator/Makefile > +++ b/drivers/platform/surface/aggregator/Makefile > @@ -1,6 +1,9 @@ > # SPDX-License-Identifier: GPL-2.0+ > # Copyright (C) 2019-2020 Maximilian Luz > > +# For include/trace/define_trace.h to include trace.h > +CFLAGS_core.o = -I$(src) > + > obj-$(CONFIG_SURFACE_AGGREGATOR) += surface_aggregator.o > > surface_aggregator-objs := core.o > diff --git a/drivers/platform/surface/aggregator/controller.c b/drivers/platform/surface/aggregator/controller.c > index 89ffd8e45787..09302bfba530 100644 > --- a/drivers/platform/surface/aggregator/controller.c > +++ b/drivers/platform/surface/aggregator/controller.c > @@ -31,6 +31,8 @@ > #include "ssh_msgb.h" > #include "ssh_request_layer.h" > > +#include "trace.h" > + > > /* -- Safe counters. -------------------------------------------------------- */ > > @@ -569,6 +571,7 @@ static void __ssam_event_item_free_generic(struct ssam_event_item *item) > */ > static void ssam_event_item_free(struct ssam_event_item *item) > { > + trace_ssam_event_item_free(item); > item->ops.free(item); > } > > @@ -604,6 +607,8 @@ static struct ssam_event_item *ssam_event_item_alloc(size_t len, gfp_t flags) > } > > item->event.length = len; > + > + trace_ssam_event_item_alloc(item, len); > return item; > } > > diff --git a/drivers/platform/surface/aggregator/core.c b/drivers/platform/surface/aggregator/core.c > index 1a53d7ce66a1..b5d44ab61f06 100644 > --- a/drivers/platform/surface/aggregator/core.c > +++ b/drivers/platform/surface/aggregator/core.c > @@ -24,6 +24,9 @@ > #include > #include "controller.h" > > +#define CREATE_TRACE_POINTS > +#include "trace.h" > + > > /* -- Static controller reference. ------------------------------------------ */ > > diff --git a/drivers/platform/surface/aggregator/ssh_packet_layer.c b/drivers/platform/surface/aggregator/ssh_packet_layer.c > index 8bc19837cde0..f5ec58a1faa2 100644 > --- a/drivers/platform/surface/aggregator/ssh_packet_layer.c > +++ b/drivers/platform/surface/aggregator/ssh_packet_layer.c > @@ -25,6 +25,8 @@ > #include "ssh_packet_layer.h" > #include "ssh_parser.h" > > +#include "trace.h" > + > /* > * To simplify reasoning about the code below, we define a few concepts. The > * system below is similar to a state-machine for packets, however, there are > @@ -227,6 +229,8 @@ static void __ssh_ptl_packet_release(struct kref *kref) > { > struct ssh_packet *p = container_of(kref, struct ssh_packet, refcnt); > > + trace_ssam_packet_release(p); > + > ptl_dbg_cond(p->ptl, "ptl: releasing packet %p\n", p); > p->ops->release(p); > } > @@ -355,6 +359,7 @@ static int ssh_ctrl_packet_alloc(struct ssh_packet **packet, > buffer->ptr = (u8 *)(*packet + 1); > buffer->len = SSH_MSG_LEN_CTRL; > > + trace_ssam_ctrl_packet_alloc(*packet, buffer->len); > return 0; > } > > @@ -364,6 +369,7 @@ static int ssh_ctrl_packet_alloc(struct ssh_packet **packet, > */ > static void ssh_ctrl_packet_free(struct ssh_packet *p) > { > + trace_ssam_ctrl_packet_free(p); > kmem_cache_free(ssh_ctrl_packet_cache, p); > } > > @@ -395,7 +401,12 @@ static void ssh_packet_next_try(struct ssh_packet *p) > u8 base = ssh_packet_priority_get_base(p->priority); > u8 try = ssh_packet_priority_get_try(p->priority); > > - p->priority = __SSH_PACKET_PRIORITY(base, try + 1); > + /* > + * Ensure that we write the priority in one go via WRITE_ONCE() so we > + * can access it via READ_ONCE() for tracing. Note that other access > + * is guarded by the queue lock, so no need to use READ_ONCE() there. > + */ > + WRITE_ONCE(p->priority, __SSH_PACKET_PRIORITY(base, try + 1)); > } > > /* Must be called with queue lock held. */ > @@ -553,6 +564,7 @@ static void __ssh_ptl_complete(struct ssh_packet *p, int status) > { > struct ssh_ptl *ptl = READ_ONCE(p->ptl); > > + trace_ssam_packet_complete(p, status); > ptl_dbg_cond(ptl, "ptl: completing packet %p (status: %d)\n", p, status); > > if (p->ops->complete) > @@ -1007,6 +1019,8 @@ int ssh_ptl_submit(struct ssh_ptl *ptl, struct ssh_packet *p) > struct ssh_ptl *ptl_old; > int status; > > + trace_ssam_packet_submit(p); > + > /* Validate packet fields. */ > if (test_bit(SSH_PACKET_TY_FLUSH_BIT, &p->state)) { > if (p->data.ptr || test_bit(SSH_PACKET_TY_SEQUENCED_BIT, &p->state)) > @@ -1056,6 +1070,8 @@ static int __ssh_ptl_resubmit(struct ssh_packet *packet) > int status; > u8 try; > > + trace_ssam_packet_resubmit(packet); > + > spin_lock(&packet->ptl->queue.lock); > > /* Check if the packet is out of tries. */ > @@ -1139,6 +1155,8 @@ void ssh_ptl_cancel(struct ssh_packet *p) > if (test_and_set_bit(SSH_PACKET_SF_CANCELED_BIT, &p->state)) > return; > > + trace_ssam_packet_cancel(p); > + > /* > * Lock packet and commit with memory barrier. If this packet has > * already been locked, it's going to be removed and completed by > @@ -1191,6 +1209,8 @@ static void ssh_ptl_timeout_reap(struct work_struct *work) > bool resub = false; > int status; > > + trace_ssam_ptl_timeout_reap(atomic_read(&ptl->pending.count)); > + > /* > * Mark reaper as "not pending". This is done before checking any > * packets to avoid lost-update type problems. > @@ -1213,6 +1233,8 @@ static void ssh_ptl_timeout_reap(struct work_struct *work) > continue; > } > > + trace_ssam_packet_timeout(p); > + > status = __ssh_ptl_resubmit(p); > > /* > @@ -1405,6 +1427,8 @@ static size_t ssh_ptl_rx_eval(struct ssh_ptl *ptl, struct ssam_span *source) > if (!frame) /* Not enough data. */ > return aligned.ptr - source->ptr; > > + trace_ssam_rx_frame_received(frame); > + > switch (frame->type) { > case SSH_FRAME_TYPE_ACK: > ssh_ptl_acknowledge(ptl, frame->seq); > diff --git a/drivers/platform/surface/aggregator/ssh_request_layer.c b/drivers/platform/surface/aggregator/ssh_request_layer.c > index 80bea8e781d3..e91d2ed4c173 100644 > --- a/drivers/platform/surface/aggregator/ssh_request_layer.c > +++ b/drivers/platform/surface/aggregator/ssh_request_layer.c > @@ -22,6 +22,8 @@ > #include "ssh_packet_layer.h" > #include "ssh_request_layer.h" > > +#include "trace.h" > + > /* > * SSH_RTL_REQUEST_TIMEOUT - Request timeout. > * > @@ -144,6 +146,8 @@ static void ssh_rtl_complete_with_status(struct ssh_request *rqst, int status) > { > struct ssh_rtl *rtl = ssh_request_rtl(rqst); > > + trace_ssam_request_complete(rqst, status); > + > /* rtl/ptl may not be set if we're canceling before submitting. */ > rtl_dbg_cond(rtl, "rtl: completing request (rqid: %#06x, status: %d)\n", > ssh_request_get_rqid_safe(rqst), status); > @@ -157,6 +161,8 @@ static void ssh_rtl_complete_with_rsp(struct ssh_request *rqst, > { > struct ssh_rtl *rtl = ssh_request_rtl(rqst); > > + trace_ssam_request_complete(rqst, 0); > + > rtl_dbg(rtl, "rtl: completing request with response (rqid: %#06x)\n", > ssh_request_get_rqid(rqst)); > > @@ -329,6 +335,8 @@ static void ssh_rtl_tx_work_fn(struct work_struct *work) > */ > int ssh_rtl_submit(struct ssh_rtl *rtl, struct ssh_request *rqst) > { > + trace_ssam_request_submit(rqst); > + > /* > * Ensure that requests expecting a response are sequenced. If this > * invariant ever changes, see the comment in ssh_rtl_complete() on what > @@ -439,6 +447,8 @@ static void ssh_rtl_complete(struct ssh_rtl *rtl, > struct ssh_request *p, *n; > u16 rqid = get_unaligned_le16(&command->rqid); > > + trace_ssam_rx_response_received(command, command_data->len); > + > /* > * Get request from pending based on request ID and mark it as response > * received and locked. > @@ -688,6 +698,8 @@ bool ssh_rtl_cancel(struct ssh_request *rqst, bool pending) > if (test_and_set_bit(SSH_REQUEST_SF_CANCELED_BIT, &rqst->state)) > return true; > > + trace_ssam_request_cancel(rqst); > + > if (pending) > canceled = ssh_rtl_cancel_pending(rqst); > else > @@ -779,6 +791,8 @@ static void ssh_rtl_timeout_reap(struct work_struct *work) > ktime_t timeout = rtl->rtx_timeout.timeout; > ktime_t next = KTIME_MAX; > > + trace_ssam_rtl_timeout_reap(atomic_read(&rtl->pending.count)); > + > /* > * Mark reaper as "not pending". This is done before checking any > * requests to avoid lost-update type problems. > @@ -822,6 +836,8 @@ static void ssh_rtl_timeout_reap(struct work_struct *work) > > /* Cancel and complete the request. */ > list_for_each_entry_safe(r, n, &claimed, node) { > + trace_ssam_request_timeout(r); > + > /* > * At this point we've removed the packet from pending. This > * means that we've obtained the last (only) reference of the > @@ -849,6 +865,8 @@ static void ssh_rtl_timeout_reap(struct work_struct *work) > static void ssh_rtl_rx_event(struct ssh_rtl *rtl, const struct ssh_command *cmd, > const struct ssam_span *data) > { > + trace_ssam_rx_event_received(cmd, data->len); > + > rtl_dbg(rtl, "rtl: handling event (rqid: %#06x)\n", > get_unaligned_le16(&cmd->rqid)); > > diff --git a/drivers/platform/surface/aggregator/trace.h b/drivers/platform/surface/aggregator/trace.h > new file mode 100644 > index 000000000000..dcca8007d876 > --- /dev/null > +++ b/drivers/platform/surface/aggregator/trace.h > @@ -0,0 +1,601 @@ > +/* SPDX-License-Identifier: GPL-2.0+ */ > +/* > + * Trace points for SSAM/SSH. > + * > + * Copyright (C) 2020 Maximilian Luz > + */ > + > +#undef TRACE_SYSTEM > +#define TRACE_SYSTEM surface_aggregator > + > +#if !defined(_SURFACE_AGGREGATOR_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) > +#define _SURFACE_AGGREGATOR_TRACE_H > + > +#include > + > +#include > +#include > + > +TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_SEQ); > +TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_NSQ); > +TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_ACK); > +TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_NAK); > + > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_LOCKED_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_QUEUED_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_PENDING_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTING_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTED_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_ACKED_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_CANCELED_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_SF_COMPLETED_BIT); > + > +TRACE_DEFINE_ENUM(SSH_PACKET_TY_FLUSH_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_TY_SEQUENCED_BIT); > +TRACE_DEFINE_ENUM(SSH_PACKET_TY_BLOCKING_BIT); > + > +TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_SF_MASK); > +TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_TY_MASK); > + > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_LOCKED_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_QUEUED_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_PENDING_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTING_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTED_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_RSPRCVD_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_CANCELED_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_SF_COMPLETED_BIT); > + > +TRACE_DEFINE_ENUM(SSH_REQUEST_TY_FLUSH_BIT); > +TRACE_DEFINE_ENUM(SSH_REQUEST_TY_HAS_RESPONSE_BIT); > + > +TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_SF_MASK); > +TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_TY_MASK); > + > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_SAM); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAT); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_TMP); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_PMC); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_FAN); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_PoM); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_DBG); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_KBD); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_FWU); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_UNI); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_LPC); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCL); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_SFL); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_KIP); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_EXT); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_BLD); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAS); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_SEN); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_SRQ); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_MCU); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_HID); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCH); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_BKL); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_TAM); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_ACC); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_UFI); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_USC); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_PEN); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_VID); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_AUD); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_SMC); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_KPD); > +TRACE_DEFINE_ENUM(SSAM_SSH_TC_REG); > + > +#define SSAM_PTR_UID_LEN 9 > +#define SSAM_U8_FIELD_NOT_APPLICABLE ((u16)-1) > +#define SSAM_SEQ_NOT_APPLICABLE ((u16)-1) > +#define SSAM_RQID_NOT_APPLICABLE ((u32)-1) > +#define SSAM_SSH_TC_NOT_APPLICABLE 0 > + > +#ifndef _SURFACE_AGGREGATOR_TRACE_HELPERS > +#define _SURFACE_AGGREGATOR_TRACE_HELPERS > + > +/** > + * ssam_trace_ptr_uid() - Convert the pointer to a non-pointer UID string. > + * @ptr: The pointer to convert. > + * @uid_str: A buffer of length SSAM_PTR_UID_LEN where the UID will be stored. > + * > + * Converts the given pointer into a UID string that is safe to be shared > + * with userspace and logs, i.e. doesn't give away the real memory location. > + */ > +static inline void ssam_trace_ptr_uid(const void *ptr, char *uid_str) > +{ > + char buf[2 * sizeof(void *) + 1]; > + > + BUILD_BUG_ON(ARRAY_SIZE(buf) < SSAM_PTR_UID_LEN); > + > + snprintf(buf, ARRAY_SIZE(buf), "%p", ptr); > + memcpy(uid_str, &buf[ARRAY_SIZE(buf) - SSAM_PTR_UID_LEN], > + SSAM_PTR_UID_LEN); > +} > + > +/** > + * ssam_trace_get_packet_seq() - Read the packet's sequence ID. > + * @p: The packet. > + * > + * Return: Returns the packet's sequence ID (SEQ) field if present, or > + * %SSAM_SEQ_NOT_APPLICABLE if not (e.g. flush packet). > + */ > +static inline u16 ssam_trace_get_packet_seq(const struct ssh_packet *p) > +{ > + if (!p->data.ptr || p->data.len < SSH_MESSAGE_LENGTH(0)) > + return SSAM_SEQ_NOT_APPLICABLE; > + > + return p->data.ptr[SSH_MSGOFFSET_FRAME(seq)]; > +} > + > +/** > + * ssam_trace_get_request_id() - Read the packet's request ID. > + * @p: The packet. > + * > + * Return: Returns the packet's request ID (RQID) field if the packet > + * represents a request with command data, or %SSAM_RQID_NOT_APPLICABLE if not > + * (e.g. flush request, control packet). > + */ > +static inline u32 ssam_trace_get_request_id(const struct ssh_packet *p) > +{ > + if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) > + return SSAM_RQID_NOT_APPLICABLE; > + > + return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(rqid)]); > +} > + > +/** > + * ssam_trace_get_request_tc() - Read the packet's request target category. > + * @p: The packet. > + * > + * Return: Returns the packet's request target category (TC) field if the > + * packet represents a request with command data, or %SSAM_TC_NOT_APPLICABLE > + * if not (e.g. flush request, control packet). > + */ > +static inline u32 ssam_trace_get_request_tc(const struct ssh_packet *p) > +{ > + if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) > + return SSAM_SSH_TC_NOT_APPLICABLE; > + > + return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tc)]); > +} > + > +#endif /* _SURFACE_AGGREGATOR_TRACE_HELPERS */ > + > +#define ssam_trace_get_command_field_u8(packet, field) \ > + ((!(packet) || (packet)->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) \ > + ? 0 : (packet)->data.ptr[SSH_MSGOFFSET_COMMAND(field)]) > + > +#define ssam_show_generic_u8_field(value) \ > + __print_symbolic(value, \ > + { SSAM_U8_FIELD_NOT_APPLICABLE, "N/A" } \ > + ) > + > +#define ssam_show_frame_type(ty) \ > + __print_symbolic(ty, \ > + { SSH_FRAME_TYPE_DATA_SEQ, "DSEQ" }, \ > + { SSH_FRAME_TYPE_DATA_NSQ, "DNSQ" }, \ > + { SSH_FRAME_TYPE_ACK, "ACK" }, \ > + { SSH_FRAME_TYPE_NAK, "NAK" } \ > + ) > + > +#define ssam_show_packet_type(type) \ > + __print_flags(flags & SSH_PACKET_FLAGS_TY_MASK, "", \ > + { BIT(SSH_PACKET_TY_FLUSH_BIT), "F" }, \ > + { BIT(SSH_PACKET_TY_SEQUENCED_BIT), "S" }, \ > + { BIT(SSH_PACKET_TY_BLOCKING_BIT), "B" } \ > + ) > + > +#define ssam_show_packet_state(state) \ > + __print_flags(flags & SSH_PACKET_FLAGS_SF_MASK, "", \ > + { BIT(SSH_PACKET_SF_LOCKED_BIT), "L" }, \ > + { BIT(SSH_PACKET_SF_QUEUED_BIT), "Q" }, \ > + { BIT(SSH_PACKET_SF_PENDING_BIT), "P" }, \ > + { BIT(SSH_PACKET_SF_TRANSMITTING_BIT), "S" }, \ > + { BIT(SSH_PACKET_SF_TRANSMITTED_BIT), "T" }, \ > + { BIT(SSH_PACKET_SF_ACKED_BIT), "A" }, \ > + { BIT(SSH_PACKET_SF_CANCELED_BIT), "C" }, \ > + { BIT(SSH_PACKET_SF_COMPLETED_BIT), "F" } \ > + ) > + > +#define ssam_show_packet_seq(seq) \ > + __print_symbolic(seq, \ > + { SSAM_SEQ_NOT_APPLICABLE, "N/A" } \ > + ) > + > +#define ssam_show_request_type(flags) \ > + __print_flags((flags) & SSH_REQUEST_FLAGS_TY_MASK, "", \ > + { BIT(SSH_REQUEST_TY_FLUSH_BIT), "F" }, \ > + { BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT), "R" } \ > + ) > + > +#define ssam_show_request_state(flags) \ > + __print_flags((flags) & SSH_REQUEST_FLAGS_SF_MASK, "", \ > + { BIT(SSH_REQUEST_SF_LOCKED_BIT), "L" }, \ > + { BIT(SSH_REQUEST_SF_QUEUED_BIT), "Q" }, \ > + { BIT(SSH_REQUEST_SF_PENDING_BIT), "P" }, \ > + { BIT(SSH_REQUEST_SF_TRANSMITTING_BIT), "S" }, \ > + { BIT(SSH_REQUEST_SF_TRANSMITTED_BIT), "T" }, \ > + { BIT(SSH_REQUEST_SF_RSPRCVD_BIT), "A" }, \ > + { BIT(SSH_REQUEST_SF_CANCELED_BIT), "C" }, \ > + { BIT(SSH_REQUEST_SF_COMPLETED_BIT), "F" } \ > + ) > + > +#define ssam_show_request_id(rqid) \ > + __print_symbolic(rqid, \ > + { SSAM_RQID_NOT_APPLICABLE, "N/A" } \ > + ) > + > +#define ssam_show_ssh_tc(rqid) \ > + __print_symbolic(rqid, \ > + { SSAM_SSH_TC_NOT_APPLICABLE, "N/A" }, \ > + { SSAM_SSH_TC_SAM, "SAM" }, \ > + { SSAM_SSH_TC_BAT, "BAT" }, \ > + { SSAM_SSH_TC_TMP, "TMP" }, \ > + { SSAM_SSH_TC_PMC, "PMC" }, \ > + { SSAM_SSH_TC_FAN, "FAN" }, \ > + { SSAM_SSH_TC_PoM, "PoM" }, \ > + { SSAM_SSH_TC_DBG, "DBG" }, \ > + { SSAM_SSH_TC_KBD, "KBD" }, \ > + { SSAM_SSH_TC_FWU, "FWU" }, \ > + { SSAM_SSH_TC_UNI, "UNI" }, \ > + { SSAM_SSH_TC_LPC, "LPC" }, \ > + { SSAM_SSH_TC_TCL, "TCL" }, \ > + { SSAM_SSH_TC_SFL, "SFL" }, \ > + { SSAM_SSH_TC_KIP, "KIP" }, \ > + { SSAM_SSH_TC_EXT, "EXT" }, \ > + { SSAM_SSH_TC_BLD, "BLD" }, \ > + { SSAM_SSH_TC_BAS, "BAS" }, \ > + { SSAM_SSH_TC_SEN, "SEN" }, \ > + { SSAM_SSH_TC_SRQ, "SRQ" }, \ > + { SSAM_SSH_TC_MCU, "MCU" }, \ > + { SSAM_SSH_TC_HID, "HID" }, \ > + { SSAM_SSH_TC_TCH, "TCH" }, \ > + { SSAM_SSH_TC_BKL, "BKL" }, \ > + { SSAM_SSH_TC_TAM, "TAM" }, \ > + { SSAM_SSH_TC_ACC, "ACC" }, \ > + { SSAM_SSH_TC_UFI, "UFI" }, \ > + { SSAM_SSH_TC_USC, "USC" }, \ > + { SSAM_SSH_TC_PEN, "PEN" }, \ > + { SSAM_SSH_TC_VID, "VID" }, \ > + { SSAM_SSH_TC_AUD, "AUD" }, \ > + { SSAM_SSH_TC_SMC, "SMC" }, \ > + { SSAM_SSH_TC_KPD, "KPD" }, \ > + { SSAM_SSH_TC_REG, "REG" } \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_frame_class, > + TP_PROTO(const struct ssh_frame *frame), > + > + TP_ARGS(frame), > + > + TP_STRUCT__entry( > + __field(u8, type) > + __field(u8, seq) > + __field(u16, len) > + ), > + > + TP_fast_assign( > + __entry->type = frame->type; > + __entry->seq = frame->seq; > + __entry->len = get_unaligned_le16(&frame->len); > + ), > + > + TP_printk("ty=%s, seq=%#04x, len=%u", > + ssam_show_frame_type(__entry->type), > + __entry->seq, > + __entry->len > + ) > +); > + > +#define DEFINE_SSAM_FRAME_EVENT(name) \ > + DEFINE_EVENT(ssam_frame_class, ssam_##name, \ > + TP_PROTO(const struct ssh_frame *frame), \ > + TP_ARGS(frame) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_command_class, > + TP_PROTO(const struct ssh_command *cmd, u16 len), > + > + TP_ARGS(cmd, len), > + > + TP_STRUCT__entry( > + __field(u16, rqid) > + __field(u16, len) > + __field(u8, tc) > + __field(u8, cid) > + __field(u8, iid) > + ), > + > + TP_fast_assign( > + __entry->rqid = get_unaligned_le16(&cmd->rqid); > + __entry->tc = cmd->tc; > + __entry->cid = cmd->cid; > + __entry->iid = cmd->iid; > + __entry->len = len; > + ), > + > + TP_printk("rqid=%#06x, tc=%s, cid=%#04x, iid=%#04x, len=%u", > + __entry->rqid, > + ssam_show_ssh_tc(__entry->tc), > + __entry->cid, > + __entry->iid, > + __entry->len > + ) > +); > + > +#define DEFINE_SSAM_COMMAND_EVENT(name) \ > + DEFINE_EVENT(ssam_command_class, ssam_##name, \ > + TP_PROTO(const struct ssh_command *cmd, u16 len), \ > + TP_ARGS(cmd, len) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_packet_class, > + TP_PROTO(const struct ssh_packet *packet), > + > + TP_ARGS(packet), > + > + TP_STRUCT__entry( > + __field(unsigned long, state) > + __array(char, uid, SSAM_PTR_UID_LEN) > + __field(u8, priority) > + __field(u16, length) > + __field(u16, seq) > + ), > + > + TP_fast_assign( > + __entry->state = READ_ONCE(packet->state); > + ssam_trace_ptr_uid(packet, __entry->uid); > + __entry->priority = READ_ONCE(packet->priority); > + __entry->length = packet->data.len; > + __entry->seq = ssam_trace_get_packet_seq(packet); > + ), > + > + TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s", > + __entry->uid, > + ssam_show_packet_seq(__entry->seq), > + ssam_show_packet_type(__entry->state), > + __entry->priority, > + __entry->length, > + ssam_show_packet_state(__entry->state) > + ) > +); > + > +#define DEFINE_SSAM_PACKET_EVENT(name) \ > + DEFINE_EVENT(ssam_packet_class, ssam_##name, \ > + TP_PROTO(const struct ssh_packet *packet), \ > + TP_ARGS(packet) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_packet_status_class, > + TP_PROTO(const struct ssh_packet *packet, int status), > + > + TP_ARGS(packet, status), > + > + TP_STRUCT__entry( > + __field(unsigned long, state) > + __field(int, status) > + __array(char, uid, SSAM_PTR_UID_LEN) > + __field(u8, priority) > + __field(u16, length) > + __field(u16, seq) > + ), > + > + TP_fast_assign( > + __entry->state = READ_ONCE(packet->state); > + __entry->status = status; > + ssam_trace_ptr_uid(packet, __entry->uid); > + __entry->priority = READ_ONCE(packet->priority); > + __entry->length = packet->data.len; > + __entry->seq = ssam_trace_get_packet_seq(packet); > + ), > + > + TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s, status=%d", > + __entry->uid, > + ssam_show_packet_seq(__entry->seq), > + ssam_show_packet_type(__entry->state), > + __entry->priority, > + __entry->length, > + ssam_show_packet_state(__entry->state), > + __entry->status > + ) > +); > + > +#define DEFINE_SSAM_PACKET_STATUS_EVENT(name) \ > + DEFINE_EVENT(ssam_packet_status_class, ssam_##name, \ > + TP_PROTO(const struct ssh_packet *packet, int status), \ > + TP_ARGS(packet, status) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_request_class, > + TP_PROTO(const struct ssh_request *request), > + > + TP_ARGS(request), > + > + TP_STRUCT__entry( > + __field(unsigned long, state) > + __field(u32, rqid) > + __array(char, uid, SSAM_PTR_UID_LEN) > + __field(u8, tc) > + __field(u16, cid) > + __field(u16, iid) > + ), > + > + TP_fast_assign( > + const struct ssh_packet *p = &request->packet; > + > + /* Use packet for UID so we can match requests to packets. */ > + __entry->state = READ_ONCE(request->state); > + __entry->rqid = ssam_trace_get_request_id(p); > + ssam_trace_ptr_uid(p, __entry->uid); > + __entry->tc = ssam_trace_get_request_tc(p); > + __entry->cid = ssam_trace_get_command_field_u8(p, cid); > + __entry->iid = ssam_trace_get_command_field_u8(p, iid); > + ), > + > + TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s", > + __entry->uid, > + ssam_show_request_id(__entry->rqid), > + ssam_show_request_type(__entry->state), > + ssam_show_request_state(__entry->state), > + ssam_show_ssh_tc(__entry->tc), > + ssam_show_generic_u8_field(__entry->cid), > + ssam_show_generic_u8_field(__entry->iid) > + ) > +); > + > +#define DEFINE_SSAM_REQUEST_EVENT(name) \ > + DEFINE_EVENT(ssam_request_class, ssam_##name, \ > + TP_PROTO(const struct ssh_request *request), \ > + TP_ARGS(request) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_request_status_class, > + TP_PROTO(const struct ssh_request *request, int status), > + > + TP_ARGS(request, status), > + > + TP_STRUCT__entry( > + __field(unsigned long, state) > + __field(u32, rqid) > + __field(int, status) > + __array(char, uid, SSAM_PTR_UID_LEN) > + __field(u8, tc) > + __field(u16, cid) > + __field(u16, iid) > + ), > + > + TP_fast_assign( > + const struct ssh_packet *p = &request->packet; > + > + /* Use packet for UID so we can match requests to packets. */ > + __entry->state = READ_ONCE(request->state); > + __entry->rqid = ssam_trace_get_request_id(p); > + __entry->status = status; > + ssam_trace_ptr_uid(p, __entry->uid); > + __entry->tc = ssam_trace_get_request_tc(p); > + __entry->cid = ssam_trace_get_command_field_u8(p, cid); > + __entry->iid = ssam_trace_get_command_field_u8(p, iid); > + ), > + > + TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s, status=%d", > + __entry->uid, > + ssam_show_request_id(__entry->rqid), > + ssam_show_request_type(__entry->state), > + ssam_show_request_state(__entry->state), > + ssam_show_ssh_tc(__entry->tc), > + ssam_show_generic_u8_field(__entry->cid), > + ssam_show_generic_u8_field(__entry->iid), > + __entry->status > + ) > +); > + > +#define DEFINE_SSAM_REQUEST_STATUS_EVENT(name) \ > + DEFINE_EVENT(ssam_request_status_class, ssam_##name, \ > + TP_PROTO(const struct ssh_request *request, int status),\ > + TP_ARGS(request, status) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_alloc_class, > + TP_PROTO(void *ptr, size_t len), > + > + TP_ARGS(ptr, len), > + > + TP_STRUCT__entry( > + __field(size_t, len) > + __array(char, uid, SSAM_PTR_UID_LEN) > + ), > + > + TP_fast_assign( > + __entry->len = len; > + ssam_trace_ptr_uid(ptr, __entry->uid); > + ), > + > + TP_printk("uid=%s, len=%zu", __entry->uid, __entry->len) > +); > + > +#define DEFINE_SSAM_ALLOC_EVENT(name) \ > + DEFINE_EVENT(ssam_alloc_class, ssam_##name, \ > + TP_PROTO(void *ptr, size_t len), \ > + TP_ARGS(ptr, len) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_free_class, > + TP_PROTO(void *ptr), > + > + TP_ARGS(ptr), > + > + TP_STRUCT__entry( > + __array(char, uid, SSAM_PTR_UID_LEN) > + ), > + > + TP_fast_assign( > + ssam_trace_ptr_uid(ptr, __entry->uid); > + ), > + > + TP_printk("uid=%s", __entry->uid) > +); > + > +#define DEFINE_SSAM_FREE_EVENT(name) \ > + DEFINE_EVENT(ssam_free_class, ssam_##name, \ > + TP_PROTO(void *ptr), \ > + TP_ARGS(ptr) \ > + ) > + > +DECLARE_EVENT_CLASS(ssam_pending_class, > + TP_PROTO(unsigned int pending), > + > + TP_ARGS(pending), > + > + TP_STRUCT__entry( > + __field(unsigned int, pending) > + ), > + > + TP_fast_assign( > + __entry->pending = pending; > + ), > + > + TP_printk("pending=%u", __entry->pending) > +); > + > +#define DEFINE_SSAM_PENDING_EVENT(name) \ > + DEFINE_EVENT(ssam_pending_class, ssam_##name, \ > + TP_PROTO(unsigned int pending), \ > + TP_ARGS(pending) \ > + ) > + > +DEFINE_SSAM_FRAME_EVENT(rx_frame_received); > +DEFINE_SSAM_COMMAND_EVENT(rx_response_received); > +DEFINE_SSAM_COMMAND_EVENT(rx_event_received); > + > +DEFINE_SSAM_PACKET_EVENT(packet_release); > +DEFINE_SSAM_PACKET_EVENT(packet_submit); > +DEFINE_SSAM_PACKET_EVENT(packet_resubmit); > +DEFINE_SSAM_PACKET_EVENT(packet_timeout); > +DEFINE_SSAM_PACKET_EVENT(packet_cancel); > +DEFINE_SSAM_PACKET_STATUS_EVENT(packet_complete); > +DEFINE_SSAM_PENDING_EVENT(ptl_timeout_reap); > + > +DEFINE_SSAM_REQUEST_EVENT(request_submit); > +DEFINE_SSAM_REQUEST_EVENT(request_timeout); > +DEFINE_SSAM_REQUEST_EVENT(request_cancel); > +DEFINE_SSAM_REQUEST_STATUS_EVENT(request_complete); > +DEFINE_SSAM_PENDING_EVENT(rtl_timeout_reap); > + > +DEFINE_SSAM_ALLOC_EVENT(ctrl_packet_alloc); > +DEFINE_SSAM_FREE_EVENT(ctrl_packet_free); > + > +DEFINE_SSAM_ALLOC_EVENT(event_item_alloc); > +DEFINE_SSAM_FREE_EVENT(event_item_free); > + > +#endif /* _SURFACE_AGGREGATOR_TRACE_H */ > + > +/* This part must be outside protection */ > +#undef TRACE_INCLUDE_PATH > +#undef TRACE_INCLUDE_FILE > + > +#define TRACE_INCLUDE_PATH . > +#define TRACE_INCLUDE_FILE trace > + > +#include > -- > 2.29.2 >