From patchwork Thu Aug 9 10:12:13 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Tvrtko Ursulin X-Patchwork-Id: 10561171 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 714D114C0 for ; Thu, 9 Aug 2018 10:12:22 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 528B32A907 for ; Thu, 9 Aug 2018 10:12:22 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 46A5B2A95B; Thu, 9 Aug 2018 10:12:22 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 7C0D22A907 for ; Thu, 9 Aug 2018 10:12:21 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id E07676E6C5; Thu, 9 Aug 2018 10:12:20 +0000 (UTC) X-Original-To: Intel-gfx@lists.freedesktop.org Delivered-To: Intel-gfx@lists.freedesktop.org Received: from mail-wr1-x443.google.com (mail-wr1-x443.google.com [IPv6:2a00:1450:4864:20::443]) by gabe.freedesktop.org (Postfix) with ESMTPS id 97B966E6C5 for ; Thu, 9 Aug 2018 10:12:19 +0000 (UTC) Received: by mail-wr1-x443.google.com with SMTP id h10-v6so4646497wre.6 for ; Thu, 09 Aug 2018 03:12:19 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=IcLvozoITeSCE4OzN2FmIGq5UeZz2bnOh27c4KTTP9c=; b=gHfLgFZ1L5xTkArANISzjYfjCwG4i8U+vo5SxrtW2NyastQfAomTex9b2jLEYrNRpM BMCKEVt76MdpjeeVRngnvVrcYuIUMRdKHZPJyw5hlB8Lx1HQtqB2hmG5UL/STBjgAjwV 8rScbb4bV+EpLrP8dOF5WNB4EP5YpO8zX+ZjsrTaK/ifz9F1h0KPYeQ0TyIYJGrw1MsA o24afKxja/lAolxzUKFyjWG+uTpZyk0mYac6zpBi2CZodVjSVWIGvTY189DdKTohCxmh D+uG7zEO1fWdHMaLMuOmsAkk/daEcfS7PIPmANFMGwi42d1bklb9vz6cKDQUrNRmAgno MicA== X-Gm-Message-State: AOUpUlEBzB5GOp3IqqSk45br/Fl3UdgxLe75tmRMgDGGE42qyaRkKT4z 9YnTUcCUp4LXEYtayw9DEEQevmfMMNc= X-Google-Smtp-Source: AA+uWPzqdCR1UB0XR12b1gAfsrS7AnVbJE/+y3mEUzTmHpVNEIqyU+bkcg55mbW1INO59ZnyY+Ju0w== X-Received: by 2002:adf:fdcd:: with SMTP id i13-v6mr968258wrs.276.1533809538083; Thu, 09 Aug 2018 03:12:18 -0700 (PDT) Received: from localhost.localdomain ([95.146.151.194]) by smtp.gmail.com with ESMTPSA id l72-v6sm19376370wma.17.2018.08.09.03.12.17 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 09 Aug 2018 03:12:17 -0700 (PDT) From: Tvrtko Ursulin X-Google-Original-From: Tvrtko Ursulin To: Intel-gfx@lists.freedesktop.org Date: Thu, 9 Aug 2018 11:12:13 +0100 Message-Id: <20180809101213.3392-1-tvrtko.ursulin@linux.intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <153380905568.11393.6527769185070092426@skylake-alporthouse-com> References: <153380905568.11393.6527769185070092426@skylake-alporthouse-com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v5] drm/i915/tracing: Enable user interrupts while intel_engine_notify is active X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Virus-Scanned: ClamAV using ClamSMTP From: Tvrtko Ursulin Keep the user interrupt enabled and emit intel_engine_notify tracepoint every time as long as it is enabled. Premise is that if someone is listening, they want to see interrupts logged. We use tracepoint (de)registration callbacks to enable user interrupts on all devices (future proofing and avoiding ugly global pointers) and all engines. And in the user interrupt handler we make sure trace_intel_engine_notify is called even when there are no waiters. v2: * Improve makefile. (Chris Wilson) * Simplify by dropping the pointeless global driver list. (Chris Wilson) * Emit tracepoint when there are no waiters, not just the user interrupt. * Commit message tidy. v3: * Favour one return from notify_ring. Chris Wilson: * Reword commit message a bit for clarity. * Add RPM references to driver (un)registration paths. * Rename list link member. * Handle !CONFIG_TRACEPOINTS in the header. v4: * I forgot to add comments while removing the RFC status. * License header tidy. * Forward declaration of drm_i915_private is enough. (Chris Wilson) v5: * Fix !CONFIG_TRACEPOINTS header fail. (Chris Wilson) * Rememberd to add suggested by tag! Signed-off-by: Tvrtko Ursulin Suggested-by: Chris Wilson Cc: Chris Wilson Cc: Dmitry Rogozhkin Cc: John Harrison Cc: svetlana.kukanova@intel.com Reviewed-by: Chris Wilson --- drivers/gpu/drm/i915/Makefile | 3 + drivers/gpu/drm/i915/i915_drv.c | 5 + drivers/gpu/drm/i915/i915_drv.h | 2 + drivers/gpu/drm/i915/i915_irq.c | 5 +- drivers/gpu/drm/i915/i915_trace.h | 50 +++++----- drivers/gpu/drm/i915/i915_tracing.c | 137 ++++++++++++++++++++++++++++ drivers/gpu/drm/i915/i915_tracing.h | 30 ++++++ 7 files changed, 207 insertions(+), 25 deletions(-) create mode 100644 drivers/gpu/drm/i915/i915_tracing.c create mode 100644 drivers/gpu/drm/i915/i915_tracing.h diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 5794f102f9b8..dfc940b32078 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -182,6 +182,9 @@ i915-y += i915_perf.o \ i915_oa_cnl.o \ i915_oa_icl.o +# tracing +i915-$(CONFIG_TRACEPOINTS) += i915_tracing.o + ifeq ($(CONFIG_DRM_I915_GVT),y) i915-y += intel_gvt.o include $(src)/gvt/Makefile diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 9dce55182c3a..03e224ebc28c 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -1281,6 +1281,9 @@ static void i915_driver_register(struct drm_i915_private *dev_priv) */ if (INTEL_INFO(dev_priv)->num_pipes) drm_kms_helper_poll_init(dev); + + /* Notify our tracepoints driver has been registered. */ + i915_tracing_register(dev_priv); } /** @@ -1292,6 +1295,8 @@ static void i915_driver_unregister(struct drm_i915_private *dev_priv) intel_fbdev_unregister(dev_priv); intel_audio_deinit(dev_priv); + i915_tracing_unregister(dev_priv); + /* * After flushing the fbdev (incl. a late async config which will * have delayed queuing of a hotplug event), then flush the hotplug diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 0b10a30b7d96..00d9e9f65739 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -2141,6 +2141,8 @@ struct drm_i915_private { struct i915_pmu pmu; + struct list_head tracing_link; + /* * NOTE: This is the dri1/ums dungeon, don't add stuff here. Your patch * will be rejected. Instead look for a better place. diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c index 8084e35b25c5..0f007a46249e 100644 --- a/drivers/gpu/drm/i915/i915_irq.c +++ b/drivers/gpu/drm/i915/i915_irq.c @@ -1157,10 +1157,10 @@ static void notify_ring(struct intel_engine_cs *engine) const u32 seqno = intel_engine_get_seqno(engine); struct i915_request *rq = NULL; struct task_struct *tsk = NULL; - struct intel_wait *wait; + struct intel_wait *wait = NULL; if (unlikely(!engine->breadcrumbs.irq_armed)) - return; + goto out; rcu_read_lock(); @@ -1219,6 +1219,7 @@ static void notify_ring(struct intel_engine_cs *engine) rcu_read_unlock(); +out: trace_intel_engine_notify(engine, wait); } diff --git a/drivers/gpu/drm/i915/i915_trace.h b/drivers/gpu/drm/i915/i915_trace.h index b50c6b829715..212e7fc1e80e 100644 --- a/drivers/gpu/drm/i915/i915_trace.h +++ b/drivers/gpu/drm/i915/i915_trace.h @@ -8,6 +8,7 @@ #include #include "i915_drv.h" +#include "i915_tracing.h" #include "intel_drv.h" #include "intel_ringbuffer.h" @@ -780,29 +781,32 @@ trace_i915_request_out(struct i915_request *rq) #endif #endif -TRACE_EVENT(intel_engine_notify, - TP_PROTO(struct intel_engine_cs *engine, bool waiters), - TP_ARGS(engine, waiters), - - TP_STRUCT__entry( - __field(u32, dev) - __field(u16, class) - __field(u16, instance) - __field(u32, seqno) - __field(bool, waiters) - ), - - TP_fast_assign( - __entry->dev = engine->i915->drm.primary->index; - __entry->class = engine->uabi_class; - __entry->instance = engine->instance; - __entry->seqno = intel_engine_get_seqno(engine); - __entry->waiters = waiters; - ), - - TP_printk("dev=%u, engine=%u:%u, seqno=%u, waiters=%u", - __entry->dev, __entry->class, __entry->instance, - __entry->seqno, __entry->waiters) +TRACE_EVENT_FN(intel_engine_notify, + TP_PROTO(struct intel_engine_cs *engine, bool waiters), + TP_ARGS(engine, waiters), + + TP_STRUCT__entry( + __field(u32, dev) + __field(u16, class) + __field(u16, instance) + __field(u32, seqno) + __field(bool, waiters) + ), + + TP_fast_assign( + __entry->dev = engine->i915->drm.primary->index; + __entry->class = engine->uabi_class; + __entry->instance = engine->instance; + __entry->seqno = intel_engine_get_seqno(engine); + __entry->waiters = waiters; + ), + + TP_printk("dev=%u, engine=%u:%u, seqno=%u, waiters=%u", + __entry->dev, __entry->class, __entry->instance, + __entry->seqno, __entry->waiters), + + intel_engine_notify_tracepoint_register, + intel_engine_notify_tracepoint_unregister ); DEFINE_EVENT(i915_request, i915_request_retire, diff --git a/drivers/gpu/drm/i915/i915_tracing.c b/drivers/gpu/drm/i915/i915_tracing.c new file mode 100644 index 000000000000..86c68173d61b --- /dev/null +++ b/drivers/gpu/drm/i915/i915_tracing.c @@ -0,0 +1,137 @@ +/* + * SPDX-License-Identifier: GPL-2.0 + * + * Copyright © 2018 Intel Corporation + * + */ + +#include "i915_tracing.h" + +#include "i915_drv.h" +#include "intel_ringbuffer.h" + +static DEFINE_MUTEX(driver_list_lock); +static LIST_HEAD(driver_list); +static bool notify_enabled; + +static void __i915_enable_notify(struct drm_i915_private *i915) +{ + struct intel_engine_cs *engine; + enum intel_engine_id id; + + intel_runtime_pm_get(i915); + + for_each_engine(engine, i915, id) + intel_engine_pin_breadcrumbs_irq(engine); + + intel_runtime_pm_put(i915); +} + +static void __i915_disable_notify(struct drm_i915_private *i915) +{ + struct intel_engine_cs *engine; + enum intel_engine_id id; + + intel_runtime_pm_get(i915); + + for_each_engine(engine, i915, id) + intel_engine_unpin_breadcrumbs_irq(engine); + + intel_runtime_pm_put(i915); +} + +/** + * i915_tracing_register - registers driver tracepoints support + * @i915: the drm_i915_private device + * + * Registers the tracepoints support from the driver registration path. + * + * Puts the driver on the local list and enables the unconditional notifications + * for the intel_engine_notify tracepoint if they should be enabled. + */ +void i915_tracing_register(struct drm_i915_private *i915) +{ + INIT_LIST_HEAD(&i915->tracing_link); + + mutex_lock(&driver_list_lock); + + list_add_tail(&i915->tracing_link, &driver_list); + + if (notify_enabled) + __i915_enable_notify(i915); + + mutex_unlock(&driver_list_lock); +} + +/** + * i915_tracing_unregister - unregisters driver tracepoints support + * @i915: the drm_i915_private device + * + * Un-registers the tracepoints support from the driver un-registration path. + * + * Removes the driver from the local list and disables the unconditional + * notifications for the intel_engine_notify tracepoint if they were enabled. + */ +void i915_tracing_unregister(struct drm_i915_private *i915) +{ + mutex_lock(&driver_list_lock); + + if (notify_enabled) + __i915_disable_notify(i915); + + list_del(&i915->tracing_link); + + mutex_unlock(&driver_list_lock); +} + +/** + * intel_engine_notify_tracepoint_register - tracepoint registration callback + * + * This is called as the intel_engine_notify registration callback, ie. when + * the tracepoint is first activated. + */ +int intel_engine_notify_tracepoint_register(void) +{ + struct drm_i915_private *i915; + + mutex_lock(&driver_list_lock); + + GEM_BUG_ON(notify_enabled); + + /* + * Enable user interrupts / constant intel_engine_notify notifications. + */ + list_for_each_entry(i915, &driver_list, tracing_link) + __i915_enable_notify(i915); + + notify_enabled = true; + + mutex_unlock(&driver_list_lock); + + return 0; +} + +/** + * intel_engine_notify_tracepoint_unregister - tracepoint unregistration callback + * + * This is called as the intel_engine_notify unregistration callback, ie. when + * the last listener of this tracepoint goes away. + */ +void intel_engine_notify_tracepoint_unregister(void) +{ + struct drm_i915_private *i915; + + mutex_lock(&driver_list_lock); + + GEM_BUG_ON(!notify_enabled); + + /* + * Disable user interrupts / constant intel_engine_notify notifications. + */ + list_for_each_entry(i915, &driver_list, tracing_link) + __i915_disable_notify(i915); + + notify_enabled = false; + + mutex_unlock(&driver_list_lock); +} diff --git a/drivers/gpu/drm/i915/i915_tracing.h b/drivers/gpu/drm/i915/i915_tracing.h new file mode 100644 index 000000000000..31ed3e535159 --- /dev/null +++ b/drivers/gpu/drm/i915/i915_tracing.h @@ -0,0 +1,30 @@ +/* + * SPDX-License-Identifier: GPL-2.0 + * + * Copyright © 2018 Intel Corporation + * + */ +#ifndef _I915_TRACING_H_ +#define _I915_TRACING_H_ + +struct drm_i915_private; + +#if IS_ENABLED(CONFIG_TRACEPOINTS) + +void i915_tracing_register(struct drm_i915_private *i915); +void i915_tracing_unregister(struct drm_i915_private *i915); + +int intel_engine_notify_tracepoint_register(void); +void intel_engine_notify_tracepoint_unregister(void); + +#else + +static inline void i915_tracing_register(struct drm_i915_private *i915) { } +static inline void i915_tracing_unregister(struct drm_i915_private *i915) { } + +static inline int intel_engine_notify_tracepoint_register(void) { return 0; } +static inline void intel_engine_notify_tracepoint_unregister(void) { } + +#endif + +#endif