[PATCH 01/15] drm/i915/guc: Tidy guc_log_control

[PATCH 01/15] drm/i915/guc: Tidy guc_log_control

[Michał Winiarski]

We plan to decouple log runtime (mapping + relay) from verbosity control.
Let's tidy the code now to reduce the churn in the following patches.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
---
 drivers/gpu/drm/i915/i915_debugfs.c  | 11 ++----
 drivers/gpu/drm/i915/intel_guc_log.c | 75 +++++++++++++++++++-----------------
 drivers/gpu/drm/i915/intel_guc_log.h |  3 +-
 3 files changed, 46 insertions(+), 43 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 33fbf3965309..58983cafaece 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -2500,13 +2500,10 @@ static int i915_guc_log_control_get(void *data, u64 *val)
 {
 	struct drm_i915_private *dev_priv = data;
 
-	if (!HAS_GUC(dev_priv))
+	if (!USES_GUC(dev_priv))
 		return -ENODEV;
 
-	if (!dev_priv->guc.log.vma)
-		return -EINVAL;
-
-	*val = i915_modparams.guc_log_level;
+	*val = intel_guc_log_control_get(&dev_priv->guc);
 
 	return 0;
 }
@@ -2515,10 +2512,10 @@ static int i915_guc_log_control_set(void *data, u64 val)
 {
 	struct drm_i915_private *dev_priv = data;
 
-	if (!HAS_GUC(dev_priv))
+	if (!USES_GUC(dev_priv))
 		return -ENODEV;
 
-	return intel_guc_log_control(&dev_priv->guc, val);
+	return intel_guc_log_control_set(&dev_priv->guc, val);
 }
 
 DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_control_fops,
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index 7b5074e2120c..22a05320817b 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -657,52 +657,55 @@ void intel_guc_log_destroy(struct intel_guc *guc)
 	i915_vma_unpin_and_release(&guc->log.vma);
 }
 
-int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
+int intel_guc_log_control_get(struct intel_guc *guc)
+{
+	GEM_BUG_ON(!guc->log.vma);
+	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
+
+	return i915_modparams.guc_log_level;
+}
+
+#define GUC_LOG_IS_ENABLED(x)		(x > 0)
+#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
+int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
-	bool enable_logging = control_val > 0;
-	u32 verbosity;
 	int ret;
 
-	if (!guc->log.vma)
-		return -ENODEV;
+	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
+	GEM_BUG_ON(!guc->log.vma);
+	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
 
-	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN);
-	if (control_val > 1 + GUC_LOG_VERBOSITY_MAX)
+	/*
+	 * GuC is recognizing log levels starting from 0 to max, we're using 0
+	 * as indication that logging should be disablded.
+	 */
+	if (GUC_LOG_LEVEL_TO_VERBOSITY(val) < GUC_LOG_VERBOSITY_MIN ||
+	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
 		return -EINVAL;
 
-	/* This combination doesn't make sense & won't have any effect */
-	if (!enable_logging && !i915_modparams.guc_log_level)
-		return 0;
+	mutex_lock(&dev_priv->drm.struct_mutex);
 
-	verbosity = enable_logging ? control_val - 1 : 0;
+	if (i915_modparams.guc_log_level == val) {
+		ret = 0;
+		goto out_unlock;
+	}
 
-	ret = mutex_lock_interruptible(&dev_priv->drm.struct_mutex);
-	if (ret)
-		return ret;
 	intel_runtime_pm_get(dev_priv);
-	ret = guc_log_control(guc, enable_logging, verbosity);
+	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
+			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
 	intel_runtime_pm_put(dev_priv);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
+	if (ret)
+		goto out_unlock;
 
-	if (ret < 0) {
-		DRM_DEBUG_DRIVER("guc_logging_control action failed %d\n", ret);
-		return ret;
-	}
+	i915_modparams.guc_log_level = val;
 
-	if (enable_logging) {
-		i915_modparams.guc_log_level = 1 + verbosity;
+	mutex_unlock(&dev_priv->drm.struct_mutex);
 
-		/*
-		 * If log was disabled at boot time, then the relay channel file
-		 * wouldn't have been created by now and interrupts also would
-		 * not have been enabled. Try again now, just in case.
-		 */
+	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
 		ret = guc_log_late_setup(guc);
-		if (ret < 0) {
-			DRM_DEBUG_DRIVER("GuC log late setup failed %d\n", ret);
-			return ret;
-		}
+		if (ret)
+			goto out;
 
 		/* GuC logging is currently the only user of Guc2Host interrupts */
 		mutex_lock(&dev_priv->drm.struct_mutex);
@@ -710,7 +713,7 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
 		gen9_enable_guc_interrupts(dev_priv);
 		intel_runtime_pm_put(dev_priv);
 		mutex_unlock(&dev_priv->drm.struct_mutex);
-	} else {
+	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
 		/*
 		 * Once logging is disabled, GuC won't generate logs & send an
 		 * interrupt. But there could be some data in the log buffer
@@ -718,11 +721,13 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
 		 * buffer state and then collect the left over logs.
 		 */
 		guc_flush_logs(guc);
-
-		/* As logging is disabled, update log level to reflect that */
-		i915_modparams.guc_log_level = 0;
 	}
 
+	return 0;
+
+out_unlock:
+	mutex_unlock(&dev_priv->drm.struct_mutex);
+out:
 	return ret;
 }
 
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index dab0e949567a..141ce9ca22ce 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -64,7 +64,8 @@ void intel_guc_log_destroy(struct intel_guc *guc);
 void intel_guc_log_init_early(struct intel_guc *guc);
 int intel_guc_log_relay_create(struct intel_guc *guc);
 void intel_guc_log_relay_destroy(struct intel_guc *guc);
-int intel_guc_log_control(struct intel_guc *guc, u64 control_val);
+int intel_guc_log_control_get(struct intel_guc *guc);
+int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
 void i915_guc_log_register(struct drm_i915_private *dev_priv);
 void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
 
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 02/15] drm/i915/guc: Create common entry points for log register/unregister

[Michał Winiarski]

We have many functions responsible for allocating different parts of
runtime called from multiple places. Let's stick with keeping
everything in guc_log_register instead.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
---
 drivers/gpu/drm/i915/i915_drv.c      |   6 +-
 drivers/gpu/drm/i915/i915_gem.c      |   4 +-
 drivers/gpu/drm/i915/intel_guc_log.c | 148 ++++++++++++++---------------------
 drivers/gpu/drm/i915/intel_guc_log.h |   6 +-
 drivers/gpu/drm/i915/intel_uc.c      |  39 ++++-----
 drivers/gpu/drm/i915/intel_uc.h      |   6 +-
 6 files changed, 91 insertions(+), 118 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index aaa861b51024..719b2be73292 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -636,7 +636,7 @@ static void i915_gem_fini(struct drm_i915_private *dev_priv)
 	i915_gem_contexts_fini(dev_priv);
 	mutex_unlock(&dev_priv->drm.struct_mutex);
 
-	intel_uc_fini_misc(dev_priv);
+	intel_uc_fini_wq(dev_priv);
 	i915_gem_cleanup_userptr(dev_priv);
 
 	i915_gem_drain_freed_objects(dev_priv);
@@ -1237,7 +1237,7 @@ static void i915_driver_register(struct drm_i915_private *dev_priv)
 	/* Reveal our presence to userspace */
 	if (drm_dev_register(dev, 0) == 0) {
 		i915_debugfs_register(dev_priv);
-		i915_guc_log_register(dev_priv);
+		intel_uc_log_register(dev_priv);
 		i915_setup_sysfs(dev_priv);
 
 		/* Depends on sysfs having been initialized */
@@ -1297,7 +1297,7 @@ static void i915_driver_unregister(struct drm_i915_private *dev_priv)
 	i915_pmu_unregister(dev_priv);
 
 	i915_teardown_sysfs(dev_priv);
-	i915_guc_log_unregister(dev_priv);
+	intel_uc_log_unregister(dev_priv);
 	drm_dev_unregister(&dev_priv->drm);
 
 	i915_gem_shrinker_unregister(dev_priv);
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 14c855b1a3a4..4bf5f25b29e2 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -5279,7 +5279,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
 	if (ret)
 		return ret;
 
-	ret = intel_uc_init_misc(dev_priv);
+	ret = intel_uc_init_wq(dev_priv);
 	if (ret)
 		return ret;
 
@@ -5375,7 +5375,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
 	intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
 	mutex_unlock(&dev_priv->drm.struct_mutex);
 
-	intel_uc_fini_misc(dev_priv);
+	intel_uc_fini_wq(dev_priv);
 
 	if (ret != -EIO)
 		i915_gem_cleanup_userptr(dev_priv);
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index 22a05320817b..f1cab43d334e 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -441,7 +441,7 @@ void intel_guc_log_init_early(struct intel_guc *guc)
 	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
 }
 
-int intel_guc_log_relay_create(struct intel_guc *guc)
+int guc_log_relay_create(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 	struct rchan *guc_log_relay_chan;
@@ -494,7 +494,7 @@ int intel_guc_log_relay_create(struct intel_guc *guc)
 	return ret;
 }
 
-void intel_guc_log_relay_destroy(struct intel_guc *guc)
+void guc_log_relay_destroy(struct intel_guc *guc)
 {
 	mutex_lock(&guc->log.runtime.relay_lock);
 
@@ -512,49 +512,6 @@ void intel_guc_log_relay_destroy(struct intel_guc *guc)
 	mutex_unlock(&guc->log.runtime.relay_lock);
 }
 
-static int guc_log_late_setup(struct intel_guc *guc)
-{
-	struct drm_i915_private *dev_priv = guc_to_i915(guc);
-	int ret;
-
-	if (!guc_log_has_runtime(guc)) {
-		/*
-		 * If log was disabled at boot time, then setup needed to handle
-		 * log buffer flush interrupts would not have been done yet, so
-		 * do that now.
-		 */
-		ret = intel_guc_log_relay_create(guc);
-		if (ret)
-			goto err;
-
-		mutex_lock(&dev_priv->drm.struct_mutex);
-		intel_runtime_pm_get(dev_priv);
-		ret = guc_log_runtime_create(guc);
-		intel_runtime_pm_put(dev_priv);
-		mutex_unlock(&dev_priv->drm.struct_mutex);
-
-		if (ret)
-			goto err_relay;
-	}
-
-	ret = guc_log_relay_file_create(guc);
-	if (ret)
-		goto err_runtime;
-
-	return 0;
-
-err_runtime:
-	mutex_lock(&dev_priv->drm.struct_mutex);
-	guc_log_runtime_destroy(guc);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
-err_relay:
-	intel_guc_log_relay_destroy(guc);
-err:
-	/* logging will remain off */
-	i915_modparams.guc_log_level = 0;
-	return ret;
-}
-
 static void guc_log_capture_logs(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
@@ -574,16 +531,6 @@ static void guc_flush_logs(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 
-	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
-		return;
-
-	/* First disable the interrupts, will be renabled afterwards */
-	mutex_lock(&dev_priv->drm.struct_mutex);
-	intel_runtime_pm_get(dev_priv);
-	gen9_disable_guc_interrupts(dev_priv);
-	intel_runtime_pm_put(dev_priv);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
-
 	/*
 	 * Before initiating the forceful flush, wait for any pending/ongoing
 	 * flush to complete otherwise forceful flush may not actually happen.
@@ -626,12 +573,6 @@ int intel_guc_log_create(struct intel_guc *guc)
 
 	guc->log.vma = vma;
 
-	if (i915_modparams.guc_log_level) {
-		ret = guc_log_runtime_create(guc);
-		if (ret < 0)
-			goto err_vma;
-	}
-
 	/* each allocated unit is a page */
 	flags = GUC_LOG_VALID | GUC_LOG_NOTIFY_ON_HALF_FULL |
 		(GUC_LOG_DPC_PAGES << GUC_LOG_DPC_SHIFT) |
@@ -643,8 +584,6 @@ int intel_guc_log_create(struct intel_guc *guc)
 
 	return 0;
 
-err_vma:
-	i915_vma_unpin_and_release(&guc->log.vma);
 err:
 	/* logging will be off */
 	i915_modparams.guc_log_level = 0;
@@ -703,24 +642,14 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
 	mutex_unlock(&dev_priv->drm.struct_mutex);
 
 	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
-		ret = guc_log_late_setup(guc);
-		if (ret)
+		ret = intel_guc_log_register(guc);
+		if (ret) {
+			/* logging will remain off */
+			i915_modparams.guc_log_level = 0;
 			goto out;
-
-		/* GuC logging is currently the only user of Guc2Host interrupts */
-		mutex_lock(&dev_priv->drm.struct_mutex);
-		intel_runtime_pm_get(dev_priv);
-		gen9_enable_guc_interrupts(dev_priv);
-		intel_runtime_pm_put(dev_priv);
-		mutex_unlock(&dev_priv->drm.struct_mutex);
+		}
 	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
-		/*
-		 * Once logging is disabled, GuC won't generate logs & send an
-		 * interrupt. But there could be some data in the log buffer
-		 * which is yet to be captured. So request GuC to update the log
-		 * buffer state and then collect the left over logs.
-		 */
-		guc_flush_logs(guc);
+		intel_guc_log_unregister(guc);
 	}
 
 	return 0;
@@ -731,20 +660,63 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
 	return ret;
 }
 
-void i915_guc_log_register(struct drm_i915_private *dev_priv)
+int intel_guc_log_register(struct intel_guc *guc)
 {
-	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
-		return;
+	struct drm_i915_private *dev_priv = guc_to_i915(guc);
+	int ret;
+
+	GEM_BUG_ON(guc_log_has_runtime(guc));
+
+	/*
+	 * If log was disabled at boot time, then setup needed to handle
+	 * log buffer flush interrupts would not have been done yet, so
+	 * do that now.
+	 */
+	ret = guc_log_relay_create(guc);
+	if (ret)
+		goto err;
+
+	mutex_lock(&dev_priv->drm.struct_mutex);
+	ret = guc_log_runtime_create(guc);
+	mutex_unlock(&dev_priv->drm.struct_mutex);
+
+	if (ret)
+		goto err_relay;
+
+	ret = guc_log_relay_file_create(guc);
+	if (ret)
+		goto err_runtime;
 
-	guc_log_late_setup(&dev_priv->guc);
+	/* GuC logging is currently the only user of Guc2Host interrupts */
+	mutex_lock(&dev_priv->drm.struct_mutex);
+	intel_runtime_pm_get(dev_priv);
+	gen9_enable_guc_interrupts(dev_priv);
+	intel_runtime_pm_put(dev_priv);
+	mutex_unlock(&dev_priv->drm.struct_mutex);
+
+	return 0;
+
+err_runtime:
+	mutex_lock(&dev_priv->drm.struct_mutex);
+	guc_log_runtime_destroy(guc);
+	mutex_unlock(&dev_priv->drm.struct_mutex);
+err_relay:
+	guc_log_relay_destroy(guc);
+err:
+	return ret;
 }
 
-void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
+void intel_guc_log_unregister(struct intel_guc *guc)
 {
-	struct intel_guc *guc = &dev_priv->guc;
+	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 
-	if (!USES_GUC_SUBMISSION(dev_priv))
-		return;
+	/*
+	 * Once logging is disabled, GuC won't generate logs & send an
+	 * interrupt. But there could be some data in the log buffer
+	 * which is yet to be captured. So request GuC to update the log
+	 * buffer state and then collect the left over logs.
+	 */
+	guc_flush_logs(guc);
 
 	mutex_lock(&dev_priv->drm.struct_mutex);
 	/* GuC logging is currently the only user of Guc2Host interrupts */
@@ -755,5 +727,5 @@ void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
 	guc_log_runtime_destroy(guc);
 	mutex_unlock(&dev_priv->drm.struct_mutex);
 
-	intel_guc_log_relay_destroy(guc);
+	guc_log_relay_destroy(guc);
 }
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index 141ce9ca22ce..09dd2ef1933d 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -62,11 +62,9 @@ struct intel_guc_log {
 int intel_guc_log_create(struct intel_guc *guc);
 void intel_guc_log_destroy(struct intel_guc *guc);
 void intel_guc_log_init_early(struct intel_guc *guc);
-int intel_guc_log_relay_create(struct intel_guc *guc);
-void intel_guc_log_relay_destroy(struct intel_guc *guc);
 int intel_guc_log_control_get(struct intel_guc *guc);
 int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
-void i915_guc_log_register(struct drm_i915_private *dev_priv);
-void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
+int intel_guc_log_register(struct intel_guc *guc);
+void intel_guc_log_unregister(struct intel_guc *guc);
 
 #endif
diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
index 9f1bac6398fb..3f41ef525e26 100644
--- a/drivers/gpu/drm/i915/intel_uc.c
+++ b/drivers/gpu/drm/i915/intel_uc.c
@@ -219,6 +219,22 @@ static void guc_free_load_err_log(struct intel_guc *guc)
 		i915_gem_object_put(guc->load_err_log);
 }
 
+int intel_uc_log_register(struct drm_i915_private *dev_priv)
+{
+	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
+		return 0;
+
+	return intel_guc_log_register(&dev_priv->guc);
+}
+
+void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
+{
+	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
+		return;
+
+	intel_guc_log_unregister(&dev_priv->guc);
+}
+
 static int guc_enable_communication(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
@@ -240,7 +256,7 @@ static void guc_disable_communication(struct intel_guc *guc)
 	guc->send = intel_guc_send_nop;
 }
 
-int intel_uc_init_misc(struct drm_i915_private *dev_priv)
+int intel_uc_init_wq(struct drm_i915_private *dev_priv)
 {
 	struct intel_guc *guc = &dev_priv->guc;
 	int ret;
@@ -249,26 +265,13 @@ int intel_uc_init_misc(struct drm_i915_private *dev_priv)
 		return 0;
 
 	ret = intel_guc_init_wq(guc);
-	if (ret) {
-		DRM_ERROR("Couldn't allocate workqueues for GuC\n");
-		goto err;
-	}
-
-	ret = intel_guc_log_relay_create(guc);
-	if (ret) {
-		DRM_ERROR("Couldn't allocate relay for GuC log\n");
-		goto err_relay;
-	}
+	if (ret)
+		return ret;
 
 	return 0;
-
-err_relay:
-	intel_guc_fini_wq(guc);
-err:
-	return ret;
 }
 
-void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
+void intel_uc_fini_wq(struct drm_i915_private *dev_priv)
 {
 	struct intel_guc *guc = &dev_priv->guc;
 
@@ -276,8 +279,6 @@ void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
 		return;
 
 	intel_guc_fini_wq(guc);
-
-	intel_guc_log_relay_destroy(guc);
 }
 
 int intel_uc_init(struct drm_i915_private *dev_priv)
diff --git a/drivers/gpu/drm/i915/intel_uc.h b/drivers/gpu/drm/i915/intel_uc.h
index f2984e01e257..9bc22103396d 100644
--- a/drivers/gpu/drm/i915/intel_uc.h
+++ b/drivers/gpu/drm/i915/intel_uc.h
@@ -31,10 +31,12 @@
 void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
 void intel_uc_init_early(struct drm_i915_private *dev_priv);
 void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
+int intel_uc_log_register(struct drm_i915_private *dev_priv);
+void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
 void intel_uc_init_fw(struct drm_i915_private *dev_priv);
 void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
-int intel_uc_init_misc(struct drm_i915_private *dev_priv);
-void intel_uc_fini_misc(struct drm_i915_private *dev_priv);
+int intel_uc_init_wq(struct drm_i915_private *dev_priv);
+void intel_uc_fini_wq(struct drm_i915_private *dev_priv);
 int intel_uc_init_hw(struct drm_i915_private *dev_priv);
 void intel_uc_fini_hw(struct drm_i915_private *dev_priv);
 int intel_uc_init(struct drm_i915_private *dev_priv);
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 03/15] drm/i915/guc: Move GuC notification handling to separate function

[Michał Winiarski]

From: Michal Wajdeczko <michal.wajdeczko@intel.com>

To allow future code reuse. While here, fix comment style.

Suggested-by: Oscar Mateo <oscar.mateo@intel.com>
Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Oscar Mateo <oscar.mateo@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
---
 drivers/gpu/drm/i915/i915_irq.c  | 33 ++-------------------------------
 drivers/gpu/drm/i915/intel_guc.c | 37 +++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_guc.h |  1 +
 3 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 0a7ed990a8d1..023ba897e991 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -1759,37 +1759,8 @@ static void gen6_rps_irq_handler(struct drm_i915_private *dev_priv, u32 pm_iir)
 
 static void gen9_guc_irq_handler(struct drm_i915_private *dev_priv, u32 gt_iir)
 {
-	if (gt_iir & GEN9_GUC_TO_HOST_INT_EVENT) {
-		/* Sample the log buffer flush related bits & clear them out now
-		 * itself from the message identity register to minimize the
-		 * probability of losing a flush interrupt, when there are back
-		 * to back flush interrupts.
-		 * There can be a new flush interrupt, for different log buffer
-		 * type (like for ISR), whilst Host is handling one (for DPC).
-		 * Since same bit is used in message register for ISR & DPC, it
-		 * could happen that GuC sets the bit for 2nd interrupt but Host
-		 * clears out the bit on handling the 1st interrupt.
-		 */
-		u32 msg, flush;
-
-		msg = I915_READ(SOFT_SCRATCH(15));
-		flush = msg & (INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED |
-			       INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER);
-		if (flush) {
-			/* Clear the message bits that are handled */
-			I915_WRITE(SOFT_SCRATCH(15), msg & ~flush);
-
-			/* Handle flush interrupt in bottom half */
-			queue_work(dev_priv->guc.log.runtime.flush_wq,
-				   &dev_priv->guc.log.runtime.flush_work);
-
-			dev_priv->guc.log.flush_interrupt_count++;
-		} else {
-			/* Not clearing of unhandled event bits won't result in
-			 * re-triggering of the interrupt.
-			 */
-		}
-	}
+	if (gt_iir & GEN9_GUC_TO_HOST_INT_EVENT)
+		intel_guc_notification_handler(&dev_priv->guc);
 }
 
 static void i9xx_pipestat_irq_reset(struct drm_i915_private *dev_priv)
diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
index 21140ccd7a97..f622dd6009b6 100644
--- a/drivers/gpu/drm/i915/intel_guc.c
+++ b/drivers/gpu/drm/i915/intel_guc.c
@@ -364,6 +364,43 @@ int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len)
 	return ret;
 }
 
+void intel_guc_notification_handler(struct intel_guc *guc)
+{
+	struct drm_i915_private *dev_priv = guc_to_i915(guc);
+	u32 msg, flush;
+
+	/*
+	 * Sample the log buffer flush related bits & clear them out now
+	 * itself from the message identity register to minimize the
+	 * probability of losing a flush interrupt, when there are back
+	 * to back flush interrupts.
+	 * There can be a new flush interrupt, for different log buffer
+	 * type (like for ISR), whilst Host is handling one (for DPC).
+	 * Since same bit is used in message register for ISR & DPC, it
+	 * could happen that GuC sets the bit for 2nd interrupt but Host
+	 * clears out the bit on handling the 1st interrupt.
+	 */
+
+	msg = I915_READ(SOFT_SCRATCH(15));
+	flush = msg & (INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED |
+		       INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER);
+	if (flush) {
+		/* Clear the message bits that are handled */
+		I915_WRITE(SOFT_SCRATCH(15), msg & ~flush);
+
+		/* Handle flush interrupt in bottom half */
+		queue_work(guc->log.runtime.flush_wq,
+			   &guc->log.runtime.flush_work);
+
+		guc->log.flush_interrupt_count++;
+	} else {
+		/*
+		 * Not clearing of unhandled event bits won't result in
+		 * re-triggering of the interrupt.
+		 */
+	}
+}
+
 int intel_guc_sample_forcewake(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
diff --git a/drivers/gpu/drm/i915/intel_guc.h b/drivers/gpu/drm/i915/intel_guc.h
index 52856a97477d..5b905bae181d 100644
--- a/drivers/gpu/drm/i915/intel_guc.h
+++ b/drivers/gpu/drm/i915/intel_guc.h
@@ -125,6 +125,7 @@ int intel_guc_init(struct intel_guc *guc);
 void intel_guc_fini(struct intel_guc *guc);
 int intel_guc_send_nop(struct intel_guc *guc, const u32 *action, u32 len);
 int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len);
+void intel_guc_notification_handler(struct intel_guc *guc);
 int intel_guc_sample_forcewake(struct intel_guc *guc);
 int intel_guc_auth_huc(struct intel_guc *guc, u32 rsa_offset);
 int intel_guc_suspend(struct drm_i915_private *dev_priv);
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 04/15] drm/i915/guc: Keep GuC interrupts enabled when using GuC

[Michał Winiarski]

The GuC log contains a separate space used for crash dump.
We even get a separate notification for it. While we're not handling
crash differently yet, it makes sense to decouple the two right now to
simplify the following patches.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc.c     | 28 +++++++++++-----------------
 drivers/gpu/drm/i915/intel_guc.h     |  2 ++
 drivers/gpu/drm/i915/intel_guc_log.c | 29 ++++++++++++++++++-----------
 drivers/gpu/drm/i915/intel_uc.c      | 14 +++++---------
 4 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
index f622dd6009b6..41f2c3b3c482 100644
--- a/drivers/gpu/drm/i915/intel_guc.c
+++ b/drivers/gpu/drm/i915/intel_guc.c
@@ -67,6 +67,7 @@ void intel_guc_init_early(struct intel_guc *guc)
 	intel_guc_log_init_early(guc);
 
 	mutex_init(&guc->send_mutex);
+	spin_lock_init(&guc->irq_lock);
 	guc->send = intel_guc_send_nop;
 	guc->notify = gen8_guc_raise_irq;
 }
@@ -367,7 +368,7 @@ int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len)
 void intel_guc_notification_handler(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
-	u32 msg, flush;
+	u32 msg, val;
 
 	/*
 	 * Sample the log buffer flush related bits & clear them out now
@@ -380,24 +381,18 @@ void intel_guc_notification_handler(struct intel_guc *guc)
 	 * could happen that GuC sets the bit for 2nd interrupt but Host
 	 * clears out the bit on handling the 1st interrupt.
 	 */
-
-	msg = I915_READ(SOFT_SCRATCH(15));
-	flush = msg & (INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED |
-		       INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER);
-	if (flush) {
-		/* Clear the message bits that are handled */
-		I915_WRITE(SOFT_SCRATCH(15), msg & ~flush);
-
-		/* Handle flush interrupt in bottom half */
+	spin_lock(&guc->irq_lock);
+	val = I915_READ(SOFT_SCRATCH(15));
+	msg = val & guc->msg_enabled_mask;
+	I915_WRITE(SOFT_SCRATCH(15), val & ~msg);
+	spin_unlock(&guc->irq_lock);
+
+	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
+		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
 		queue_work(guc->log.runtime.flush_wq,
 			   &guc->log.runtime.flush_work);
 
 		guc->log.flush_interrupt_count++;
-	} else {
-		/*
-		 * Not clearing of unhandled event bits won't result in
-		 * re-triggering of the interrupt.
-		 */
 	}
 }
 
@@ -495,8 +490,7 @@ int intel_guc_resume(struct drm_i915_private *dev_priv)
 	if (guc->fw.load_status != INTEL_UC_FIRMWARE_SUCCESS)
 		return 0;
 
-	if (i915_modparams.guc_log_level)
-		gen9_enable_guc_interrupts(dev_priv);
+	gen9_enable_guc_interrupts(dev_priv);
 
 	data[0] = INTEL_GUC_ACTION_EXIT_S_STATE;
 	data[1] = GUC_POWER_D0;
diff --git a/drivers/gpu/drm/i915/intel_guc.h b/drivers/gpu/drm/i915/intel_guc.h
index 5b905bae181d..d629bc5d5c0f 100644
--- a/drivers/gpu/drm/i915/intel_guc.h
+++ b/drivers/gpu/drm/i915/intel_guc.h
@@ -53,7 +53,9 @@ struct intel_guc {
 	struct drm_i915_gem_object *load_err_log;
 
 	/* intel_guc_recv interrupt related state */
+	spinlock_t irq_lock;
 	bool interrupts_enabled;
+	unsigned int msg_enabled_mask;
 
 	struct i915_vma *ads_vma;
 	struct i915_vma *stage_desc_pool;
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index f1cab43d334e..09be7340652b 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -590,6 +590,22 @@ int intel_guc_log_create(struct intel_guc *guc)
 	return ret;
 }
 
+static void guc_log_flush_irq_enable(struct intel_guc *guc)
+{
+	spin_lock_irq(&guc->irq_lock);
+	guc->msg_enabled_mask |= INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
+				 INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED;
+	spin_unlock_irq(&guc->irq_lock);
+}
+
+static void guc_log_flush_irq_disable(struct intel_guc *guc)
+{
+	spin_lock_irq(&guc->irq_lock);
+	guc->msg_enabled_mask &= ~(INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
+				   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED);
+	spin_unlock_irq(&guc->irq_lock);
+}
+
 void intel_guc_log_destroy(struct intel_guc *guc)
 {
 	guc_log_runtime_destroy(guc);
@@ -687,12 +703,7 @@ int intel_guc_log_register(struct intel_guc *guc)
 	if (ret)
 		goto err_runtime;
 
-	/* GuC logging is currently the only user of Guc2Host interrupts */
-	mutex_lock(&dev_priv->drm.struct_mutex);
-	intel_runtime_pm_get(dev_priv);
-	gen9_enable_guc_interrupts(dev_priv);
-	intel_runtime_pm_put(dev_priv);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
+	guc_log_flush_irq_enable(guc);
 
 	return 0;
 
@@ -717,13 +728,9 @@ void intel_guc_log_unregister(struct intel_guc *guc)
 	 * buffer state and then collect the left over logs.
 	 */
 	guc_flush_logs(guc);
+	guc_log_flush_irq_disable(guc);
 
 	mutex_lock(&dev_priv->drm.struct_mutex);
-	/* GuC logging is currently the only user of Guc2Host interrupts */
-	intel_runtime_pm_get(dev_priv);
-	gen9_disable_guc_interrupts(dev_priv);
-	intel_runtime_pm_put(dev_priv);
-
 	guc_log_runtime_destroy(guc);
 	mutex_unlock(&dev_priv->drm.struct_mutex);
 
diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
index 3f41ef525e26..e9aba3c35264 100644
--- a/drivers/gpu/drm/i915/intel_uc.c
+++ b/drivers/gpu/drm/i915/intel_uc.c
@@ -239,6 +239,8 @@ static int guc_enable_communication(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 
+	gen9_enable_guc_interrupts(dev_priv);
+
 	if (HAS_GUC_CT(dev_priv))
 		return intel_guc_enable_ct(guc);
 
@@ -253,6 +255,8 @@ static void guc_disable_communication(struct intel_guc *guc)
 	if (HAS_GUC_CT(dev_priv))
 		intel_guc_disable_ct(guc);
 
+	gen9_disable_guc_interrupts(dev_priv);
+
 	guc->send = intel_guc_send_nop;
 }
 
@@ -391,12 +395,9 @@ int intel_uc_init_hw(struct drm_i915_private *dev_priv)
 	}
 
 	if (USES_GUC_SUBMISSION(dev_priv)) {
-		if (i915_modparams.guc_log_level)
-			gen9_enable_guc_interrupts(dev_priv);
-
 		ret = intel_guc_submission_enable(guc);
 		if (ret)
-			goto err_interrupts;
+			goto err_communication;
 	}
 
 	dev_info(dev_priv->drm.dev, "GuC firmware version %u.%u\n",
@@ -411,8 +412,6 @@ int intel_uc_init_hw(struct drm_i915_private *dev_priv)
 	/*
 	 * We've failed to load the firmware :(
 	 */
-err_interrupts:
-	gen9_disable_guc_interrupts(dev_priv);
 err_communication:
 	guc_disable_communication(guc);
 err_log_capture:
@@ -442,7 +441,4 @@ void intel_uc_fini_hw(struct drm_i915_private *dev_priv)
 		intel_guc_submission_disable(guc);
 
 	guc_disable_communication(guc);
-
-	if (USES_GUC_SUBMISSION(dev_priv))
-		gen9_disable_guc_interrupts(dev_priv);
 }
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 05/15] drm/i915/guc: Log runtime should consist of both mapping and relay

[Michał Winiarski]

Currently, we're treating relay and mapping of GuC log as a separate
concepts. We're also using inconsistent locking, sometimes using
relay_lock, sometimes using struct mutex.
Let's correct that. Anything touching the runtime is now serialized
using runtime.lock, while we're still using struct mutex as inner lock
for mapping.
We're still racy in setting the log level - but we'll take care of that
in the following patches.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc_log.c | 110 ++++++++++-------------------------
 drivers/gpu/drm/i915/intel_guc_log.h |   3 +-
 drivers/gpu/drm/i915/intel_uc.c      |  14 +++--
 3 files changed, 42 insertions(+), 85 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index 09be7340652b..567620464f52 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -153,10 +153,7 @@ static int guc_log_relay_file_create(struct intel_guc *guc)
 	struct dentry *log_dir;
 	int ret;
 
-	if (!i915_modparams.guc_log_level)
-		return 0;
-
-	mutex_lock(&guc->log.runtime.relay_lock);
+	lockdep_assert_held(&guc->log.runtime.lock);
 
 	/* For now create the log file in /sys/kernel/debug/dri/0 dir */
 	log_dir = dev_priv->drm.primary->debugfs_root;
@@ -175,28 +172,16 @@ static int guc_log_relay_file_create(struct intel_guc *guc)
 	 */
 	if (!log_dir) {
 		DRM_ERROR("Debugfs dir not available yet for GuC log file\n");
-		ret = -ENODEV;
-		goto out_unlock;
+		return -ENODEV;
 	}
 
 	ret = relay_late_setup_files(guc->log.runtime.relay_chan, "guc_log", log_dir);
 	if (ret < 0 && ret != -EEXIST) {
 		DRM_ERROR("Couldn't associate relay chan with file %d\n", ret);
-		goto out_unlock;
+		return ret;
 	}
 
-	ret = 0;
-
-out_unlock:
-	mutex_unlock(&guc->log.runtime.relay_lock);
-	return ret;
-}
-
-static bool guc_log_has_relay(struct intel_guc *guc)
-{
-	lockdep_assert_held(&guc->log.runtime.relay_lock);
-
-	return guc->log.runtime.relay_chan != NULL;
+	return 0;
 }
 
 static void guc_move_to_next_buf(struct intel_guc *guc)
@@ -207,9 +192,6 @@ static void guc_move_to_next_buf(struct intel_guc *guc)
 	 */
 	smp_wmb();
 
-	if (!guc_log_has_relay(guc))
-		return;
-
 	/* All data has been written, so now move the offset of sub buffer. */
 	relay_reserve(guc->log.runtime.relay_chan, guc->log.vma->obj->base.size);
 
@@ -219,9 +201,6 @@ static void guc_move_to_next_buf(struct intel_guc *guc)
 
 static void *guc_get_write_buffer(struct intel_guc *guc)
 {
-	if (!guc_log_has_relay(guc))
-		return NULL;
-
 	/*
 	 * Just get the base address of a new sub buffer and copy data into it
 	 * ourselves. NULL will be returned in no-overwrite mode, if all sub
@@ -288,7 +267,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 	/* Get the pointer to shared GuC log buffer */
 	log_buf_state = src_data = guc->log.runtime.buf_addr;
 
-	mutex_lock(&guc->log.runtime.relay_lock);
 
 	/* Get the pointer to local buffer to store the logs */
 	log_buf_snapshot_state = dst_data = guc_get_write_buffer(guc);
@@ -300,7 +278,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 		 */
 		DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
 		guc->log.capture_miss_count++;
-		mutex_unlock(&guc->log.runtime.relay_lock);
 
 		return;
 	}
@@ -372,8 +349,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 	}
 
 	guc_move_to_next_buf(guc);
-
-	mutex_unlock(&guc->log.runtime.relay_lock);
 }
 
 static void capture_logs_work(struct work_struct *work)
@@ -381,7 +356,9 @@ static void capture_logs_work(struct work_struct *work)
 	struct intel_guc *guc =
 		container_of(work, struct intel_guc, log.runtime.flush_work);
 
+	mutex_lock(&guc->log.runtime.lock);
 	guc_log_capture_logs(guc);
+	mutex_unlock(&guc->log.runtime.lock);
 }
 
 static bool guc_log_has_runtime(struct intel_guc *guc)
@@ -389,19 +366,16 @@ static bool guc_log_has_runtime(struct intel_guc *guc)
 	return guc->log.runtime.buf_addr != NULL;
 }
 
-static int guc_log_runtime_create(struct intel_guc *guc)
+static int guc_log_map(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 	void *vaddr;
 	int ret;
 
-	lockdep_assert_held(&dev_priv->drm.struct_mutex);
-
 	if (!guc->log.vma)
 		return -ENODEV;
 
-	GEM_BUG_ON(guc_log_has_runtime(guc));
-
+	mutex_lock(&dev_priv->drm.struct_mutex);
 	ret = i915_gem_object_set_to_wc_domain(guc->log.vma->obj, true);
 	if (ret)
 		return ret;
@@ -416,20 +390,16 @@ static int guc_log_runtime_create(struct intel_guc *guc)
 		DRM_ERROR("Couldn't map log buffer pages %d\n", ret);
 		return PTR_ERR(vaddr);
 	}
+	mutex_unlock(&dev_priv->drm.struct_mutex);
 
 	guc->log.runtime.buf_addr = vaddr;
 
 	return 0;
 }
 
-static void guc_log_runtime_destroy(struct intel_guc *guc)
+static void guc_log_unmap(struct intel_guc *guc)
 {
-	/*
-	 * It's possible that the runtime stuff was never allocated because
-	 * GuC log was disabled at the boot time.
-	 */
-	if (!guc_log_has_runtime(guc))
-		return;
+	lockdep_assert_held(&guc->log.runtime.lock);
 
 	i915_gem_object_unpin_map(guc->log.vma->obj);
 	guc->log.runtime.buf_addr = NULL;
@@ -437,7 +407,7 @@ static void guc_log_runtime_destroy(struct intel_guc *guc)
 
 void intel_guc_log_init_early(struct intel_guc *guc)
 {
-	mutex_init(&guc->log.runtime.relay_lock);
+	mutex_init(&guc->log.runtime.lock);
 	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
 }
 
@@ -448,12 +418,7 @@ int guc_log_relay_create(struct intel_guc *guc)
 	size_t n_subbufs, subbuf_size;
 	int ret;
 
-	if (!i915_modparams.guc_log_level)
-		return 0;
-
-	mutex_lock(&guc->log.runtime.relay_lock);
-
-	GEM_BUG_ON(guc_log_has_relay(guc));
+	lockdep_assert_held(&guc->log.runtime.lock);
 
 	 /* Keep the size of sub buffers same as shared log buffer */
 	subbuf_size = GUC_LOG_SIZE;
@@ -483,12 +448,9 @@ int guc_log_relay_create(struct intel_guc *guc)
 	GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
 	guc->log.runtime.relay_chan = guc_log_relay_chan;
 
-	mutex_unlock(&guc->log.runtime.relay_lock);
-
 	return 0;
 
 err:
-	mutex_unlock(&guc->log.runtime.relay_lock);
 	/* logging will be off */
 	i915_modparams.guc_log_level = 0;
 	return ret;
@@ -496,20 +458,10 @@ int guc_log_relay_create(struct intel_guc *guc)
 
 void guc_log_relay_destroy(struct intel_guc *guc)
 {
-	mutex_lock(&guc->log.runtime.relay_lock);
-
-	/*
-	 * It's possible that the relay was never allocated because
-	 * GuC log was disabled at the boot time.
-	 */
-	if (!guc_log_has_relay(guc))
-		goto out_unlock;
+	lockdep_assert_held(&guc->log.runtime.lock);
 
 	relay_close(guc->log.runtime.relay_chan);
 	guc->log.runtime.relay_chan = NULL;
-
-out_unlock:
-	mutex_unlock(&guc->log.runtime.relay_lock);
 }
 
 static void guc_log_capture_logs(struct intel_guc *guc)
@@ -608,7 +560,6 @@ static void guc_log_flush_irq_disable(struct intel_guc *guc)
 
 void intel_guc_log_destroy(struct intel_guc *guc)
 {
-	guc_log_runtime_destroy(guc);
 	i915_vma_unpin_and_release(&guc->log.vma);
 }
 
@@ -678,9 +629,10 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
 
 int intel_guc_log_register(struct intel_guc *guc)
 {
-	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 	int ret;
 
+	mutex_lock(&guc->log.runtime.lock);
+
 	GEM_BUG_ON(guc_log_has_runtime(guc));
 
 	/*
@@ -692,35 +644,33 @@ int intel_guc_log_register(struct intel_guc *guc)
 	if (ret)
 		goto err;
 
-	mutex_lock(&dev_priv->drm.struct_mutex);
-	ret = guc_log_runtime_create(guc);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
-
+	ret = guc_log_map(guc);
 	if (ret)
 		goto err_relay;
 
 	ret = guc_log_relay_file_create(guc);
 	if (ret)
-		goto err_runtime;
+		goto err_unmap;
 
 	guc_log_flush_irq_enable(guc);
 
+	mutex_unlock(&guc->log.runtime.lock);
+
 	return 0;
 
-err_runtime:
-	mutex_lock(&dev_priv->drm.struct_mutex);
-	guc_log_runtime_destroy(guc);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
+err_unmap:
+	guc_log_unmap(guc);
 err_relay:
 	guc_log_relay_destroy(guc);
 err:
+	mutex_unlock(&guc->log.runtime.lock);
+
 	return ret;
 }
 
 void intel_guc_log_unregister(struct intel_guc *guc)
 {
-	struct drm_i915_private *dev_priv = guc_to_i915(guc);
-
+	guc_log_flush_irq_disable(guc);
 	/*
 	 * Once logging is disabled, GuC won't generate logs & send an
 	 * interrupt. But there could be some data in the log buffer
@@ -728,11 +678,13 @@ void intel_guc_log_unregister(struct intel_guc *guc)
 	 * buffer state and then collect the left over logs.
 	 */
 	guc_flush_logs(guc);
-	guc_log_flush_irq_disable(guc);
 
-	mutex_lock(&dev_priv->drm.struct_mutex);
-	guc_log_runtime_destroy(guc);
-	mutex_unlock(&dev_priv->drm.struct_mutex);
+	mutex_lock(&guc->log.runtime.lock);
+
+	GEM_BUG_ON(!guc_log_has_runtime(guc));
 
+	guc_log_unmap(guc);
 	guc_log_relay_destroy(guc);
+
+	mutex_unlock(&guc->log.runtime.lock);
 }
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index 09dd2ef1933d..8c26cce77a98 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -48,8 +48,7 @@ struct intel_guc_log {
 		struct workqueue_struct *flush_wq;
 		struct work_struct flush_work;
 		struct rchan *relay_chan;
-		/* To serialize the access to relay_chan */
-		struct mutex relay_lock;
+		struct mutex lock;
 	} runtime;
 	/* logging related stats */
 	u32 capture_miss_count;
diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
index e9aba3c35264..55a9b5b673e0 100644
--- a/drivers/gpu/drm/i915/intel_uc.c
+++ b/drivers/gpu/drm/i915/intel_uc.c
@@ -221,18 +221,24 @@ static void guc_free_load_err_log(struct intel_guc *guc)
 
 int intel_uc_log_register(struct drm_i915_private *dev_priv)
 {
-	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
+	int ret = 0;
+
+	if (!USES_GUC(dev_priv))
 		return 0;
 
-	return intel_guc_log_register(&dev_priv->guc);
+	if (i915_modparams.guc_log_level)
+		ret = intel_guc_log_register(&dev_priv->guc);
+
+	return ret;
 }
 
 void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
 {
-	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
+	if (!USES_GUC(dev_priv))
 		return;
 
-	intel_guc_log_unregister(&dev_priv->guc);
+	if (i915_modparams.guc_log_level)
+		intel_guc_log_unregister(&dev_priv->guc);
 }
 
 static int guc_enable_communication(struct intel_guc *guc)
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 06/15] drm/i915/guc: Merge log relay file and channel creation

[Michał Winiarski]

We have all the information we need at relay_open call time.
Since there's no reason to split the process into relay_open and
relay_late_setup_files, let's remove the extra code.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc_log.c | 52 ++++--------------------------------
 1 file changed, 5 insertions(+), 47 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index 567620464f52..cbbdb400fa17 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -126,7 +126,7 @@ static struct dentry *create_buf_file_callback(const char *filename,
 	 * dentry of the file associated with the channel buffer and that file's
 	 * name need not be same as the filename passed as an argument.
 	 */
-	buf_file = debugfs_create_file("guc_log", mode,
+	buf_file = debugfs_create_file(filename, mode,
 				       parent, buf, &relay_file_operations);
 	return buf_file;
 }
@@ -147,43 +147,6 @@ static struct rchan_callbacks relay_callbacks = {
 	.remove_buf_file = remove_buf_file_callback,
 };
 
-static int guc_log_relay_file_create(struct intel_guc *guc)
-{
-	struct drm_i915_private *dev_priv = guc_to_i915(guc);
-	struct dentry *log_dir;
-	int ret;
-
-	lockdep_assert_held(&guc->log.runtime.lock);
-
-	/* For now create the log file in /sys/kernel/debug/dri/0 dir */
-	log_dir = dev_priv->drm.primary->debugfs_root;
-
-	/*
-	 * If /sys/kernel/debug/dri/0 location do not exist, then debugfs is
-	 * not mounted and so can't create the relay file.
-	 * The relay API seems to fit well with debugfs only, for availing relay
-	 * there are 3 requirements which can be met for debugfs file only in a
-	 * straightforward/clean manner :-
-	 * i)   Need the associated dentry pointer of the file, while opening the
-	 *      relay channel.
-	 * ii)  Should be able to use 'relay_file_operations' fops for the file.
-	 * iii) Set the 'i_private' field of file's inode to the pointer of
-	 *	relay channel buffer.
-	 */
-	if (!log_dir) {
-		DRM_ERROR("Debugfs dir not available yet for GuC log file\n");
-		return -ENODEV;
-	}
-
-	ret = relay_late_setup_files(guc->log.runtime.relay_chan, "guc_log", log_dir);
-	if (ret < 0 && ret != -EEXIST) {
-		DRM_ERROR("Couldn't associate relay chan with file %d\n", ret);
-		return ret;
-	}
-
-	return 0;
-}
-
 static void guc_move_to_next_buf(struct intel_guc *guc)
 {
 	/*
@@ -267,7 +230,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 	/* Get the pointer to shared GuC log buffer */
 	log_buf_state = src_data = guc->log.runtime.buf_addr;
 
-
 	/* Get the pointer to local buffer to store the logs */
 	log_buf_snapshot_state = dst_data = guc_get_write_buffer(guc);
 
@@ -436,8 +398,10 @@ int guc_log_relay_create(struct intel_guc *guc)
 	 * the GuC firmware logs, the channel will be linked with a file
 	 * later on when debugfs is registered.
 	 */
-	guc_log_relay_chan = relay_open(NULL, NULL, subbuf_size,
-					n_subbufs, &relay_callbacks, dev_priv);
+	guc_log_relay_chan = relay_open("guc_log",
+					dev_priv->drm.primary->debugfs_root,
+					subbuf_size, n_subbufs,
+					&relay_callbacks, dev_priv);
 	if (!guc_log_relay_chan) {
 		DRM_ERROR("Couldn't create relay chan for GuC logging\n");
 
@@ -648,18 +612,12 @@ int intel_guc_log_register(struct intel_guc *guc)
 	if (ret)
 		goto err_relay;
 
-	ret = guc_log_relay_file_create(guc);
-	if (ret)
-		goto err_unmap;
-
 	guc_log_flush_irq_enable(guc);
 
 	mutex_unlock(&guc->log.runtime.lock);
 
 	return 0;
 
-err_unmap:
-	guc_log_unmap(guc);
 err_relay:
 	guc_log_relay_destroy(guc);
 err:
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 07/15] drm/i915/guc: Flush directly in log unregister

[Michał Winiarski]

Having both guc_flush_logs and guc_log_flush functions is confusing.
While we could just rename things, guc_flush_logs implementation is
quite simple. Let's get rid of it and move its content to unregister.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc_log.c | 35 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index cbbdb400fa17..0800c5317510 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -443,25 +443,6 @@ static void guc_log_capture_logs(struct intel_guc *guc)
 	intel_runtime_pm_put(dev_priv);
 }
 
-static void guc_flush_logs(struct intel_guc *guc)
-{
-	struct drm_i915_private *dev_priv = guc_to_i915(guc);
-
-	/*
-	 * Before initiating the forceful flush, wait for any pending/ongoing
-	 * flush to complete otherwise forceful flush may not actually happen.
-	 */
-	flush_work(&guc->log.runtime.flush_work);
-
-	/* Ask GuC to update the log buffer state */
-	intel_runtime_pm_get(dev_priv);
-	guc_log_flush(guc);
-	intel_runtime_pm_put(dev_priv);
-
-	/* GuC would have updated log buffer by now, so capture it */
-	guc_log_capture_logs(guc);
-}
-
 int intel_guc_log_create(struct intel_guc *guc)
 {
 	struct i915_vma *vma;
@@ -628,14 +609,28 @@ int intel_guc_log_register(struct intel_guc *guc)
 
 void intel_guc_log_unregister(struct intel_guc *guc)
 {
+	struct drm_i915_private *dev_priv = guc_to_i915(guc);
+
 	guc_log_flush_irq_disable(guc);
+
+	/*
+	 * Before initiating the forceful flush, wait for any pending/ongoing
+	 * flush to complete otherwise forceful flush may not actually happen.
+	 */
+	flush_work(&guc->log.runtime.flush_work);
+
 	/*
 	 * Once logging is disabled, GuC won't generate logs & send an
 	 * interrupt. But there could be some data in the log buffer
 	 * which is yet to be captured. So request GuC to update the log
 	 * buffer state and then collect the left over logs.
 	 */
-	guc_flush_logs(guc);
+	intel_runtime_pm_get(dev_priv);
+	guc_log_flush(guc);
+	intel_runtime_pm_put(dev_priv);
+
+	/* GuC would have updated log buffer by now, so capture it */
+	guc_log_capture_logs(guc);
 
 	mutex_lock(&guc->log.runtime.lock);
 
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 08/15] drm/i915/guc: Split relay control and GuC log level

[Michał Winiarski]

Those two concepts are really separate. Since GuC is writing data into
its own buffer and we even provide a way for userspace to read directly
from it using i915_guc_log_dump debugfs, there's no real reason to tie
log level with relay creation.
Let's create a separate debugfs, giving userspace a way to create a
relay on demand, when it wants to read a continuous log rather than a
snapshot.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/i915_debugfs.c  | 56 ++++++++++++++++++++++----
 drivers/gpu/drm/i915/i915_drv.c      |  2 -
 drivers/gpu/drm/i915/intel_guc_log.c | 76 +++++++++++++++---------------------
 drivers/gpu/drm/i915/intel_guc_log.h |  9 +++--
 drivers/gpu/drm/i915/intel_uc.c      | 22 -----------
 drivers/gpu/drm/i915/intel_uc.h      |  2 -
 6 files changed, 86 insertions(+), 81 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 58983cafaece..4bd24bbe7966 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -2496,32 +2496,73 @@ static int i915_guc_log_dump(struct seq_file *m, void *data)
 	return 0;
 }
 
-static int i915_guc_log_control_get(void *data, u64 *val)
+static int i915_guc_log_level_get(void *data, u64 *val)
 {
 	struct drm_i915_private *dev_priv = data;
 
 	if (!USES_GUC(dev_priv))
 		return -ENODEV;
 
-	*val = intel_guc_log_control_get(&dev_priv->guc);
+	*val = intel_guc_log_level_get(&dev_priv->guc);
 
 	return 0;
 }
 
-static int i915_guc_log_control_set(void *data, u64 val)
+static int i915_guc_log_level_set(void *data, u64 val)
 {
 	struct drm_i915_private *dev_priv = data;
 
 	if (!USES_GUC(dev_priv))
 		return -ENODEV;
 
-	return intel_guc_log_control_set(&dev_priv->guc, val);
+	return intel_guc_log_level_set(&dev_priv->guc, val);
 }
 
-DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_control_fops,
-			i915_guc_log_control_get, i915_guc_log_control_set,
+DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_level_fops,
+			i915_guc_log_level_get, i915_guc_log_level_set,
 			"%lld\n");
 
+static int i915_guc_log_relay_open(struct inode *inode, struct file *file)
+{
+	struct drm_i915_private *dev_priv = inode->i_private;
+
+	if (!USES_GUC(dev_priv))
+		return -ENODEV;
+
+	file->private_data = dev_priv;
+
+	return intel_guc_log_relay_open(&dev_priv->guc);
+}
+
+static ssize_t
+i915_guc_log_relay_write(struct file *filp,
+			 const char __user *ubuf,
+			 size_t cnt,
+			 loff_t *ppos)
+{
+	struct drm_i915_private *dev_priv = filp->private_data;
+
+	intel_guc_log_relay_flush(&dev_priv->guc);
+
+	return cnt;
+}
+
+static int i915_guc_log_relay_release(struct inode *inode, struct file *file)
+{
+	struct drm_i915_private *dev_priv = inode->i_private;
+
+	intel_guc_log_relay_close(&dev_priv->guc);
+
+	return 0;
+}
+
+static const struct file_operations i915_guc_log_relay_fops = {
+	.owner = THIS_MODULE,
+	.open = i915_guc_log_relay_open,
+	.write = i915_guc_log_relay_write,
+	.release = i915_guc_log_relay_release,
+};
+
 static const char *psr2_live_status(u32 val)
 {
 	static const char * const live_status[] = {
@@ -4761,7 +4802,8 @@ static const struct i915_debugfs_files {
 	{"i915_dp_test_data", &i915_displayport_test_data_fops},
 	{"i915_dp_test_type", &i915_displayport_test_type_fops},
 	{"i915_dp_test_active", &i915_displayport_test_active_fops},
-	{"i915_guc_log_control", &i915_guc_log_control_fops},
+	{"i915_guc_log_level", &i915_guc_log_level_fops},
+	{"i915_guc_log_relay", &i915_guc_log_relay_fops},
 	{"i915_hpd_storm_ctl", &i915_hpd_storm_ctl_fops},
 	{"i915_ipc_status", &i915_ipc_status_fops},
 	{"i915_drrs_ctl", &i915_drrs_ctl_fops}
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 719b2be73292..7ebfe7525b65 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -1237,7 +1237,6 @@ static void i915_driver_register(struct drm_i915_private *dev_priv)
 	/* Reveal our presence to userspace */
 	if (drm_dev_register(dev, 0) == 0) {
 		i915_debugfs_register(dev_priv);
-		intel_uc_log_register(dev_priv);
 		i915_setup_sysfs(dev_priv);
 
 		/* Depends on sysfs having been initialized */
@@ -1297,7 +1296,6 @@ static void i915_driver_unregister(struct drm_i915_private *dev_priv)
 	i915_pmu_unregister(dev_priv);
 
 	i915_teardown_sysfs(dev_priv);
-	intel_uc_log_unregister(dev_priv);
 	drm_dev_unregister(&dev_priv->drm);
 
 	i915_gem_shrinker_unregister(dev_priv);
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index 0800c5317510..4dee65692f5f 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -508,7 +508,7 @@ void intel_guc_log_destroy(struct intel_guc *guc)
 	i915_vma_unpin_and_release(&guc->log.vma);
 }
 
-int intel_guc_log_control_get(struct intel_guc *guc)
+int intel_guc_log_level_get(struct intel_guc *guc)
 {
 	GEM_BUG_ON(!guc->log.vma);
 	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
@@ -518,7 +518,7 @@ int intel_guc_log_control_get(struct intel_guc *guc)
 
 #define GUC_LOG_IS_ENABLED(x)		(x > 0)
 #define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
-int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
+int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 	int ret;
@@ -535,7 +535,7 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
 	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
 		return -EINVAL;
 
-	mutex_lock(&dev_priv->drm.struct_mutex);
+	mutex_lock(&guc->log.runtime.lock);
 
 	if (i915_modparams.guc_log_level == val) {
 		ret = 0;
@@ -551,93 +551,81 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
 
 	i915_modparams.guc_log_level = val;
 
-	mutex_unlock(&dev_priv->drm.struct_mutex);
-
-	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
-		ret = intel_guc_log_register(guc);
-		if (ret) {
-			/* logging will remain off */
-			i915_modparams.guc_log_level = 0;
-			goto out;
-		}
-	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
-		intel_guc_log_unregister(guc);
-	}
-
-	return 0;
-
 out_unlock:
-	mutex_unlock(&dev_priv->drm.struct_mutex);
-out:
+	mutex_unlock(&guc->log.runtime.lock);
+
 	return ret;
 }
 
-int intel_guc_log_register(struct intel_guc *guc)
+int intel_guc_log_relay_open(struct intel_guc *guc)
 {
 	int ret;
 
 	mutex_lock(&guc->log.runtime.lock);
 
-	GEM_BUG_ON(guc_log_has_runtime(guc));
+	if (guc_log_has_runtime(guc)) {
+		ret = -EEXIST;
+		goto out_unlock;
+	}
 
-	/*
-	 * If log was disabled at boot time, then setup needed to handle
-	 * log buffer flush interrupts would not have been done yet, so
-	 * do that now.
-	 */
 	ret = guc_log_relay_create(guc);
 	if (ret)
-		goto err;
+		goto out_unlock;
 
 	ret = guc_log_map(guc);
 	if (ret)
-		goto err_relay;
+		goto out_relay;
+
+	mutex_unlock(&guc->log.runtime.lock);
 
 	guc_log_flush_irq_enable(guc);
 
-	mutex_unlock(&guc->log.runtime.lock);
+	/*
+	 * When GuC is logging without us relaying to userspace, we're ignoring
+	 * the flush notification. This means that we need to unconditionally
+	 * flush on relay enabling, since GuC only notifies us once.
+	 */
+	queue_work(guc->log.runtime.flush_wq, &guc->log.runtime.flush_work);
 
 	return 0;
 
-err_relay:
+out_relay:
 	guc_log_relay_destroy(guc);
-err:
+out_unlock:
 	mutex_unlock(&guc->log.runtime.lock);
 
 	return ret;
 }
 
-void intel_guc_log_unregister(struct intel_guc *guc)
+void intel_guc_log_relay_flush(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
 
-	guc_log_flush_irq_disable(guc);
-
 	/*
 	 * Before initiating the forceful flush, wait for any pending/ongoing
 	 * flush to complete otherwise forceful flush may not actually happen.
 	 */
 	flush_work(&guc->log.runtime.flush_work);
 
-	/*
-	 * Once logging is disabled, GuC won't generate logs & send an
-	 * interrupt. But there could be some data in the log buffer
-	 * which is yet to be captured. So request GuC to update the log
-	 * buffer state and then collect the left over logs.
-	 */
 	intel_runtime_pm_get(dev_priv);
 	guc_log_flush(guc);
 	intel_runtime_pm_put(dev_priv);
 
+	mutex_lock(&guc->log.runtime.lock);
 	/* GuC would have updated log buffer by now, so capture it */
 	guc_log_capture_logs(guc);
+	mutex_unlock(&guc->log.runtime.lock);
+}
 
-	mutex_lock(&guc->log.runtime.lock);
-
+void intel_guc_log_relay_close(struct intel_guc *guc)
+{
 	GEM_BUG_ON(!guc_log_has_runtime(guc));
 
+	guc_log_flush_irq_disable(guc);
+	flush_work(&guc->log.runtime.flush_work);
+
+	mutex_lock(&guc->log.runtime.lock);
 	guc_log_unmap(guc);
 	guc_log_relay_destroy(guc);
-
 	mutex_unlock(&guc->log.runtime.lock);
 }
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index 8c26cce77a98..df91f12a36ed 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -61,9 +61,10 @@ struct intel_guc_log {
 int intel_guc_log_create(struct intel_guc *guc);
 void intel_guc_log_destroy(struct intel_guc *guc);
 void intel_guc_log_init_early(struct intel_guc *guc);
-int intel_guc_log_control_get(struct intel_guc *guc);
-int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
-int intel_guc_log_register(struct intel_guc *guc);
-void intel_guc_log_unregister(struct intel_guc *guc);
+int intel_guc_log_level_get(struct intel_guc *guc);
+int intel_guc_log_level_set(struct intel_guc *guc, u64 control_val);
+int intel_guc_log_relay_open(struct intel_guc *guc);
+void intel_guc_log_relay_close(struct intel_guc *guc);
+void intel_guc_log_relay_flush(struct intel_guc *guc);
 
 #endif
diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
index 55a9b5b673e0..27e1f4c43b7b 100644
--- a/drivers/gpu/drm/i915/intel_uc.c
+++ b/drivers/gpu/drm/i915/intel_uc.c
@@ -219,28 +219,6 @@ static void guc_free_load_err_log(struct intel_guc *guc)
 		i915_gem_object_put(guc->load_err_log);
 }
 
-int intel_uc_log_register(struct drm_i915_private *dev_priv)
-{
-	int ret = 0;
-
-	if (!USES_GUC(dev_priv))
-		return 0;
-
-	if (i915_modparams.guc_log_level)
-		ret = intel_guc_log_register(&dev_priv->guc);
-
-	return ret;
-}
-
-void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
-{
-	if (!USES_GUC(dev_priv))
-		return;
-
-	if (i915_modparams.guc_log_level)
-		intel_guc_log_unregister(&dev_priv->guc);
-}
-
 static int guc_enable_communication(struct intel_guc *guc)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
diff --git a/drivers/gpu/drm/i915/intel_uc.h b/drivers/gpu/drm/i915/intel_uc.h
index 9bc22103396d..8a7249722ef1 100644
--- a/drivers/gpu/drm/i915/intel_uc.h
+++ b/drivers/gpu/drm/i915/intel_uc.h
@@ -31,8 +31,6 @@
 void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
 void intel_uc_init_early(struct drm_i915_private *dev_priv);
 void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
-int intel_uc_log_register(struct drm_i915_private *dev_priv);
-void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
 void intel_uc_init_fw(struct drm_i915_private *dev_priv);
 void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
 int intel_uc_init_wq(struct drm_i915_private *dev_priv);
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 09/15] drm/i915/guc: Move check for fast memcpy_wc to relay creation

[Michał Winiarski]

We only need those fast memcpy_wc when we're using relay to read
continuous GuC log. Let's prevent the user from creating a relay if we
know we won't be able to keep up with GuC.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc_log.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index 4dee65692f5f..d2aca10ab986 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -452,16 +452,6 @@ int intel_guc_log_create(struct intel_guc *guc)
 
 	GEM_BUG_ON(guc->log.vma);
 
-	/*
-	 * We require SSE 4.1 for fast reads from the GuC log buffer and
-	 * it should be present on the chipsets supporting GuC based
-	 * submisssions.
-	 */
-	if (WARN_ON(!i915_has_memcpy_from_wc())) {
-		ret = -EINVAL;
-		goto err;
-	}
-
 	vma = intel_guc_allocate_vma(guc, GUC_LOG_SIZE);
 	if (IS_ERR(vma)) {
 		ret = PTR_ERR(vma);
@@ -568,6 +558,16 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
 		goto out_unlock;
 	}
 
+	/*
+	 * We require SSE 4.1 for fast reads from the GuC log buffer and
+	 * it should be present on the chipsets supporting GuC based
+	 * submisssions.
+	 */
+	if (!i915_has_memcpy_from_wc()) {
+		ret = -EINVAL;
+		goto out_unlock;
+	}
+
 	ret = guc_log_relay_create(guc);
 	if (ret)
 		goto out_unlock;
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 10/15] drm/i915/guc: Get rid of GuC log runtime

[Michał Winiarski]

Keeping a separate runtime struct is only making the code dealing with
relay less clear to read. Let's get rid of it, keeping everything in the
log instead.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc.c     | 14 ++++----
 drivers/gpu/drm/i915/intel_guc_log.c | 68 ++++++++++++++++++------------------
 drivers/gpu/drm/i915/intel_guc_log.h | 13 +++----
 3 files changed, 46 insertions(+), 49 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
index 41f2c3b3c482..e3b6ae158a12 100644
--- a/drivers/gpu/drm/i915/intel_guc.c
+++ b/drivers/gpu/drm/i915/intel_guc.c
@@ -87,9 +87,9 @@ int intel_guc_init_wq(struct intel_guc *guc)
 	 * or scheduled later on resume. This way the handling of work
 	 * item can be kept same between system suspend & rpm suspend.
 	 */
-	guc->log.runtime.flush_wq = alloc_ordered_workqueue("i915-guc_log",
-						WQ_HIGHPRI | WQ_FREEZABLE);
-	if (!guc->log.runtime.flush_wq) {
+	guc->log.flush_wq = alloc_ordered_workqueue("i915-guc_log",
+						    WQ_HIGHPRI | WQ_FREEZABLE);
+	if (!guc->log.flush_wq) {
 		DRM_ERROR("Couldn't allocate workqueue for GuC log\n");
 		return -ENOMEM;
 	}
@@ -112,7 +112,7 @@ int intel_guc_init_wq(struct intel_guc *guc)
 		guc->preempt_wq = alloc_ordered_workqueue("i915-guc_preempt",
 							  WQ_HIGHPRI);
 		if (!guc->preempt_wq) {
-			destroy_workqueue(guc->log.runtime.flush_wq);
+			destroy_workqueue(guc->log.flush_wq);
 			DRM_ERROR("Couldn't allocate workqueue for GuC "
 				  "preemption\n");
 			return -ENOMEM;
@@ -130,7 +130,7 @@ void intel_guc_fini_wq(struct intel_guc *guc)
 	    USES_GUC_SUBMISSION(dev_priv))
 		destroy_workqueue(guc->preempt_wq);
 
-	destroy_workqueue(guc->log.runtime.flush_wq);
+	destroy_workqueue(guc->log.flush_wq);
 }
 
 static int guc_shared_data_create(struct intel_guc *guc)
@@ -389,8 +389,8 @@ void intel_guc_notification_handler(struct intel_guc *guc)
 
 	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
 		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
-		queue_work(guc->log.runtime.flush_wq,
-			   &guc->log.runtime.flush_work);
+		queue_work(guc->log.flush_wq,
+			   &guc->log.flush_work);
 
 		guc->log.flush_interrupt_count++;
 	}
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index d2aca10ab986..f95e18be1c5f 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -156,10 +156,10 @@ static void guc_move_to_next_buf(struct intel_guc *guc)
 	smp_wmb();
 
 	/* All data has been written, so now move the offset of sub buffer. */
-	relay_reserve(guc->log.runtime.relay_chan, guc->log.vma->obj->base.size);
+	relay_reserve(guc->log.relay_chan, guc->log.vma->obj->base.size);
 
 	/* Switch to the next sub buffer */
-	relay_flush(guc->log.runtime.relay_chan);
+	relay_flush(guc->log.relay_chan);
 }
 
 static void *guc_get_write_buffer(struct intel_guc *guc)
@@ -173,7 +173,7 @@ static void *guc_get_write_buffer(struct intel_guc *guc)
 	 * done without using relay_reserve() along with relay_write(). So its
 	 * better to use relay_reserve() alone.
 	 */
-	return relay_reserve(guc->log.runtime.relay_chan, 0);
+	return relay_reserve(guc->log.relay_chan, 0);
 }
 
 static bool guc_check_log_buf_overflow(struct intel_guc *guc,
@@ -224,11 +224,11 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 	void *src_data, *dst_data;
 	bool new_overflow;
 
-	if (WARN_ON(!guc->log.runtime.buf_addr))
+	if (WARN_ON(!guc->log.buf_addr))
 		return;
 
 	/* Get the pointer to shared GuC log buffer */
-	log_buf_state = src_data = guc->log.runtime.buf_addr;
+	log_buf_state = src_data = guc->log.buf_addr;
 
 	/* Get the pointer to local buffer to store the logs */
 	log_buf_snapshot_state = dst_data = guc_get_write_buffer(guc);
@@ -316,16 +316,16 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 static void capture_logs_work(struct work_struct *work)
 {
 	struct intel_guc *guc =
-		container_of(work, struct intel_guc, log.runtime.flush_work);
+		container_of(work, struct intel_guc, log.flush_work);
 
-	mutex_lock(&guc->log.runtime.lock);
+	mutex_lock(&guc->log.lock);
 	guc_log_capture_logs(guc);
-	mutex_unlock(&guc->log.runtime.lock);
+	mutex_unlock(&guc->log.lock);
 }
 
-static bool guc_log_has_runtime(struct intel_guc *guc)
+static bool guc_log_relay_enabled(struct intel_guc *guc)
 {
-	return guc->log.runtime.buf_addr != NULL;
+	return guc->log.buf_addr != NULL;
 }
 
 static int guc_log_map(struct intel_guc *guc)
@@ -354,23 +354,23 @@ static int guc_log_map(struct intel_guc *guc)
 	}
 	mutex_unlock(&dev_priv->drm.struct_mutex);
 
-	guc->log.runtime.buf_addr = vaddr;
+	guc->log.buf_addr = vaddr;
 
 	return 0;
 }
 
 static void guc_log_unmap(struct intel_guc *guc)
 {
-	lockdep_assert_held(&guc->log.runtime.lock);
+	lockdep_assert_held(&guc->log.lock);
 
 	i915_gem_object_unpin_map(guc->log.vma->obj);
-	guc->log.runtime.buf_addr = NULL;
+	guc->log.buf_addr = NULL;
 }
 
 void intel_guc_log_init_early(struct intel_guc *guc)
 {
-	mutex_init(&guc->log.runtime.lock);
-	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
+	mutex_init(&guc->log.lock);
+	INIT_WORK(&guc->log.flush_work, capture_logs_work);
 }
 
 int guc_log_relay_create(struct intel_guc *guc)
@@ -380,7 +380,7 @@ int guc_log_relay_create(struct intel_guc *guc)
 	size_t n_subbufs, subbuf_size;
 	int ret;
 
-	lockdep_assert_held(&guc->log.runtime.lock);
+	lockdep_assert_held(&guc->log.lock);
 
 	 /* Keep the size of sub buffers same as shared log buffer */
 	subbuf_size = GUC_LOG_SIZE;
@@ -410,7 +410,7 @@ int guc_log_relay_create(struct intel_guc *guc)
 	}
 
 	GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
-	guc->log.runtime.relay_chan = guc_log_relay_chan;
+	guc->log.relay_chan = guc_log_relay_chan;
 
 	return 0;
 
@@ -422,10 +422,10 @@ int guc_log_relay_create(struct intel_guc *guc)
 
 void guc_log_relay_destroy(struct intel_guc *guc)
 {
-	lockdep_assert_held(&guc->log.runtime.lock);
+	lockdep_assert_held(&guc->log.lock);
 
-	relay_close(guc->log.runtime.relay_chan);
-	guc->log.runtime.relay_chan = NULL;
+	relay_close(guc->log.relay_chan);
+	guc->log.relay_chan = NULL;
 }
 
 static void guc_log_capture_logs(struct intel_guc *guc)
@@ -525,7 +525,7 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
 	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
 		return -EINVAL;
 
-	mutex_lock(&guc->log.runtime.lock);
+	mutex_lock(&guc->log.lock);
 
 	if (i915_modparams.guc_log_level == val) {
 		ret = 0;
@@ -542,7 +542,7 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
 	i915_modparams.guc_log_level = val;
 
 out_unlock:
-	mutex_unlock(&guc->log.runtime.lock);
+	mutex_unlock(&guc->log.lock);
 
 	return ret;
 }
@@ -551,9 +551,9 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
 {
 	int ret;
 
-	mutex_lock(&guc->log.runtime.lock);
+	mutex_lock(&guc->log.lock);
 
-	if (guc_log_has_runtime(guc)) {
+	if (guc_log_relay_enabled(guc)) {
 		ret = -EEXIST;
 		goto out_unlock;
 	}
@@ -576,7 +576,7 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
 	if (ret)
 		goto out_relay;
 
-	mutex_unlock(&guc->log.runtime.lock);
+	mutex_unlock(&guc->log.lock);
 
 	guc_log_flush_irq_enable(guc);
 
@@ -585,14 +585,14 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
 	 * the flush notification. This means that we need to unconditionally
 	 * flush on relay enabling, since GuC only notifies us once.
 	 */
-	queue_work(guc->log.runtime.flush_wq, &guc->log.runtime.flush_work);
+	queue_work(guc->log.flush_wq, &guc->log.flush_work);
 
 	return 0;
 
 out_relay:
 	guc_log_relay_destroy(guc);
 out_unlock:
-	mutex_unlock(&guc->log.runtime.lock);
+	mutex_unlock(&guc->log.lock);
 
 	return ret;
 }
@@ -605,27 +605,27 @@ void intel_guc_log_relay_flush(struct intel_guc *guc)
 	 * Before initiating the forceful flush, wait for any pending/ongoing
 	 * flush to complete otherwise forceful flush may not actually happen.
 	 */
-	flush_work(&guc->log.runtime.flush_work);
+	flush_work(&guc->log.flush_work);
 
 	intel_runtime_pm_get(dev_priv);
 	guc_log_flush(guc);
 	intel_runtime_pm_put(dev_priv);
 
-	mutex_lock(&guc->log.runtime.lock);
+	mutex_lock(&guc->log.lock);
 	/* GuC would have updated log buffer by now, so capture it */
 	guc_log_capture_logs(guc);
-	mutex_unlock(&guc->log.runtime.lock);
+	mutex_unlock(&guc->log.lock);
 }
 
 void intel_guc_log_relay_close(struct intel_guc *guc)
 {
-	GEM_BUG_ON(!guc_log_has_runtime(guc));
+	GEM_BUG_ON(!guc_log_relay_enabled(guc));
 
 	guc_log_flush_irq_disable(guc);
-	flush_work(&guc->log.runtime.flush_work);
+	flush_work(&guc->log.flush_work);
 
-	mutex_lock(&guc->log.runtime.lock);
+	mutex_lock(&guc->log.lock);
 	guc_log_unmap(guc);
 	guc_log_relay_destroy(guc);
-	mutex_unlock(&guc->log.runtime.lock);
+	mutex_unlock(&guc->log.lock);
 }
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index df91f12a36ed..11f49ef41f01 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -42,14 +42,11 @@ struct intel_guc;
 struct intel_guc_log {
 	u32 flags;
 	struct i915_vma *vma;
-	/* The runtime stuff gets created only when GuC logging gets enabled */
-	struct {
-		void *buf_addr;
-		struct workqueue_struct *flush_wq;
-		struct work_struct flush_work;
-		struct rchan *relay_chan;
-		struct mutex lock;
-	} runtime;
+	void *buf_addr;
+	struct workqueue_struct *flush_wq;
+	struct work_struct flush_work;
+	struct rchan *relay_chan;
+	struct mutex lock;
 	/* logging related stats */
 	u32 capture_miss_count;
 	u32 flush_interrupt_count;
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 11/15] drm/i915/guc: Always print log stats in i915_guc_info when using GuC

[Michał Winiarski]

While some of the content in this file is related to GuC submission
only, that's not the case with log related statistics.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/i915_debugfs.c | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 4bd24bbe7966..866d44a091b3 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -2331,7 +2331,7 @@ static void i915_guc_log_info(struct seq_file *m,
 {
 	struct intel_guc *guc = &dev_priv->guc;
 
-	seq_puts(m, "\nGuC logging stats:\n");
+	seq_puts(m, "GuC logging stats:\n");
 
 	seq_printf(m, "\tISR:   flush count %10u, overflow count %10u\n",
 		   guc->log.flush_count[GUC_ISR_LOG_BUFFER],
@@ -2379,14 +2379,19 @@ static int i915_guc_info(struct seq_file *m, void *data)
 	struct drm_i915_private *dev_priv = node_to_i915(m->private);
 	const struct intel_guc *guc = &dev_priv->guc;
 
-	if (!USES_GUC_SUBMISSION(dev_priv))
+	if (!USES_GUC(dev_priv))
 		return -ENODEV;
 
+	i915_guc_log_info(m, dev_priv);
+
+	if (!USES_GUC_SUBMISSION(dev_priv))
+		return 0;
+
 	GEM_BUG_ON(!guc->execbuf_client);
 
-	seq_printf(m, "Doorbell map:\n");
+	seq_printf(m, "\nDoorbell map:\n");
 	seq_printf(m, "\t%*pb\n", GUC_NUM_DOORBELLS, guc->doorbell_bitmap);
-	seq_printf(m, "Doorbell next cacheline: 0x%x\n\n", guc->db_cacheline);
+	seq_printf(m, "Doorbell next cacheline: 0x%x\n", guc->db_cacheline);
 
 	seq_printf(m, "\nGuC execbuf client @ %p:\n", guc->execbuf_client);
 	i915_guc_client_info(m, dev_priv, guc->execbuf_client);
@@ -2396,8 +2401,6 @@ static int i915_guc_info(struct seq_file *m, void *data)
 		i915_guc_client_info(m, dev_priv, guc->preempt_client);
 	}
 
-	i915_guc_log_info(m, dev_priv);
-
 	/* Add more as required ... */
 
 	return 0;
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 12/15] drm/i915/guc: Don't print out relay statistics when relay is disabled

[Michał Winiarski]

If nobody has enabled the relay, we're not comunicating with GuC, which
means that the stats don't have any meaning. Let's also remove interrupt
counter and tidy the debugfs formatting.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/i915_debugfs.c  | 47 ++++++++++++++++++++++++------------
 drivers/gpu/drm/i915/intel_guc.c     |  5 +---
 drivers/gpu/drm/i915/intel_guc_log.c | 24 +++++++++---------
 drivers/gpu/drm/i915/intel_guc_log.h | 12 +++++----
 4 files changed, 51 insertions(+), 37 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 866d44a091b3..65f758f7c425 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -2326,30 +2326,45 @@ static int i915_guc_load_status_info(struct seq_file *m, void *data)
 	return 0;
 }
 
+static const char *
+stringify_guc_log_type(enum guc_log_buffer_type type)
+{
+	switch (type) {
+	case GUC_ISR_LOG_BUFFER:
+		return "ISR";
+	case GUC_DPC_LOG_BUFFER:
+		return "DPC";
+	case GUC_CRASH_DUMP_LOG_BUFFER:
+		return "CRASH";
+	default:
+		MISSING_CASE(type);
+	}
+
+	return "";
+}
+
 static void i915_guc_log_info(struct seq_file *m,
 			      struct drm_i915_private *dev_priv)
 {
 	struct intel_guc *guc = &dev_priv->guc;
+	enum guc_log_buffer_type type;
 
-	seq_puts(m, "GuC logging stats:\n");
-
-	seq_printf(m, "\tISR:   flush count %10u, overflow count %10u\n",
-		   guc->log.flush_count[GUC_ISR_LOG_BUFFER],
-		   guc->log.total_overflow_count[GUC_ISR_LOG_BUFFER]);
-
-	seq_printf(m, "\tDPC:   flush count %10u, overflow count %10u\n",
-		   guc->log.flush_count[GUC_DPC_LOG_BUFFER],
-		   guc->log.total_overflow_count[GUC_DPC_LOG_BUFFER]);
+	if (!intel_guc_log_relay_enabled(guc)) {
+		seq_puts(m, "GuC log relay disabled\n");
+		return;
+	}
 
-	seq_printf(m, "\tCRASH: flush count %10u, overflow count %10u\n",
-		   guc->log.flush_count[GUC_CRASH_DUMP_LOG_BUFFER],
-		   guc->log.total_overflow_count[GUC_CRASH_DUMP_LOG_BUFFER]);
+	seq_puts(m, "GuC logging stats:\n");
 
-	seq_printf(m, "\tTotal flush interrupt count: %u\n",
-		   guc->log.flush_interrupt_count);
+	seq_printf(m, "\tRelay full count: %u\n",
+		   guc->log.relay_full_count);
 
-	seq_printf(m, "\tCapture miss count: %u\n",
-		   guc->log.capture_miss_count);
+	for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
+		seq_printf(m, "\t%s:\tflush count %10u, overflow count %10u\n",
+			   stringify_guc_log_type(type),
+			   guc->log.stats[type].flush,
+			   guc->log.stats[type].overflow);
+	}
 }
 
 static void i915_guc_client_info(struct seq_file *m,
diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
index e3b6ae158a12..0500b4164254 100644
--- a/drivers/gpu/drm/i915/intel_guc.c
+++ b/drivers/gpu/drm/i915/intel_guc.c
@@ -388,12 +388,9 @@ void intel_guc_notification_handler(struct intel_guc *guc)
 	spin_unlock(&guc->irq_lock);
 
 	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
-		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
+		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED))
 		queue_work(guc->log.flush_wq,
 			   &guc->log.flush_work);
-
-		guc->log.flush_interrupt_count++;
-	}
 }
 
 int intel_guc_sample_forcewake(struct intel_guc *guc)
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index f95e18be1c5f..bdf6b3178488 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -176,22 +176,22 @@ static void *guc_get_write_buffer(struct intel_guc *guc)
 	return relay_reserve(guc->log.relay_chan, 0);
 }
 
-static bool guc_check_log_buf_overflow(struct intel_guc *guc,
+static bool guc_check_log_buf_overflow(struct intel_guc_log *log,
 				       enum guc_log_buffer_type type,
 				       unsigned int full_cnt)
 {
-	unsigned int prev_full_cnt = guc->log.prev_overflow_count[type];
+	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
 	bool overflow = false;
 
 	if (full_cnt != prev_full_cnt) {
 		overflow = true;
 
-		guc->log.prev_overflow_count[type] = full_cnt;
-		guc->log.total_overflow_count[type] += full_cnt - prev_full_cnt;
+		log->stats[type].overflow = full_cnt;
+		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
 
 		if (full_cnt < prev_full_cnt) {
 			/* buffer_full_cnt is a 4 bit counter */
-			guc->log.total_overflow_count[type] += 16;
+			log->stats[type].overflow += 16;
 		}
 		DRM_ERROR_RATELIMITED("GuC log buffer overflow\n");
 	}
@@ -224,7 +224,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 	void *src_data, *dst_data;
 	bool new_overflow;
 
-	if (WARN_ON(!guc->log.buf_addr))
+	if (WARN_ON(!intel_guc_log_relay_enabled(guc)))
 		return;
 
 	/* Get the pointer to shared GuC log buffer */
@@ -239,7 +239,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 		 * getting consumed by User at a slow rate.
 		 */
 		DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
-		guc->log.capture_miss_count++;
+		guc->log.relay_full_count++;
 
 		return;
 	}
@@ -262,8 +262,8 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
 		full_cnt = log_buf_state_local.buffer_full_cnt;
 
 		/* Bookkeeping stuff */
-		guc->log.flush_count[type] += log_buf_state_local.flush_to_file;
-		new_overflow = guc_check_log_buf_overflow(guc, type, full_cnt);
+		guc->log.stats[type].flush += log_buf_state_local.flush_to_file;
+		new_overflow = guc_check_log_buf_overflow(&guc->log, type, full_cnt);
 
 		/* Update the state of shared log buffer */
 		log_buf_state->read_ptr = write_offset;
@@ -323,7 +323,7 @@ static void capture_logs_work(struct work_struct *work)
 	mutex_unlock(&guc->log.lock);
 }
 
-static bool guc_log_relay_enabled(struct intel_guc *guc)
+bool intel_guc_log_relay_enabled(struct intel_guc *guc)
 {
 	return guc->log.buf_addr != NULL;
 }
@@ -553,7 +553,7 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
 
 	mutex_lock(&guc->log.lock);
 
-	if (guc_log_relay_enabled(guc)) {
+	if (intel_guc_log_relay_enabled(guc)) {
 		ret = -EEXIST;
 		goto out_unlock;
 	}
@@ -619,7 +619,7 @@ void intel_guc_log_relay_flush(struct intel_guc *guc)
 
 void intel_guc_log_relay_close(struct intel_guc *guc)
 {
-	GEM_BUG_ON(!guc_log_relay_enabled(guc));
+	GEM_BUG_ON(!intel_guc_log_relay_enabled(guc));
 
 	guc_log_flush_irq_disable(guc);
 	flush_work(&guc->log.flush_work);
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index 11f49ef41f01..a8ccb04e2b0a 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -48,11 +48,12 @@ struct intel_guc_log {
 	struct rchan *relay_chan;
 	struct mutex lock;
 	/* logging related stats */
-	u32 capture_miss_count;
-	u32 flush_interrupt_count;
-	u32 prev_overflow_count[GUC_MAX_LOG_BUFFER];
-	u32 total_overflow_count[GUC_MAX_LOG_BUFFER];
-	u32 flush_count[GUC_MAX_LOG_BUFFER];
+	u32 relay_full_count;
+	struct {
+		u32 sampled_overflow;
+		u32 overflow;
+		u32 flush;
+	} stats[GUC_MAX_LOG_BUFFER];
 };
 
 int intel_guc_log_create(struct intel_guc *guc);
@@ -63,5 +64,6 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 control_val);
 int intel_guc_log_relay_open(struct intel_guc *guc);
 void intel_guc_log_relay_close(struct intel_guc *guc);
 void intel_guc_log_relay_flush(struct intel_guc *guc);
+bool intel_guc_log_relay_enabled(struct intel_guc *guc);
 
 #endif
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 13/15] drm/i915/guc: Allow user to control default GuC logging

[Michał Winiarski]

While both naming and actual log enable logic in GuC interface are
confusing, we can simply expose the default log as yet another log
level.
GuC logic aside, from i915 point of view we now have the following GuC
log levels:
	0 Log disabled
	1 Non-verbose log
	2-5 Verbose log

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_guc.c      | 21 ++++++++++++---------
 drivers/gpu/drm/i915/intel_guc_fwif.h |  5 +++--
 drivers/gpu/drm/i915/intel_guc_log.c  |  9 +++++----
 drivers/gpu/drm/i915/intel_guc_log.h  | 11 +++++++++++
 drivers/gpu/drm/i915/intel_uc.c       | 14 +++++++++-----
 5 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
index 0500b4164254..83d813a6ff92 100644
--- a/drivers/gpu/drm/i915/intel_guc.c
+++ b/drivers/gpu/drm/i915/intel_guc.c
@@ -221,17 +221,20 @@ static u32 get_core_family(struct drm_i915_private *dev_priv)
 	}
 }
 
-static u32 get_log_verbosity_flags(void)
+static u32 get_log_control_flags(void)
 {
-	if (i915_modparams.guc_log_level > 0) {
-		u32 verbosity = i915_modparams.guc_log_level - 1;
+	u32 level = i915_modparams.guc_log_level;
+	u32 flags = 0;
 
-		GEM_BUG_ON(verbosity > GUC_LOG_VERBOSITY_MAX);
-		return verbosity << GUC_LOG_VERBOSITY_SHIFT;
-	}
+	GEM_BUG_ON(level < 0);
+
+	if (!GUC_LOG_IS_ENABLED(level))
+		flags = GUC_LOG_DEFAULT_DISABLED | GUC_LOG_DISABLED;
+	else if (GUC_LOG_IS_VERBOSE(level))
+		flags = GUC_LOG_LEVEL_TO_VERBOSITY(level) <<
+			GUC_LOG_VERBOSITY_SHIFT;
 
-	GEM_BUG_ON(i915_modparams.enable_guc < 0);
-	return GUC_LOG_DISABLED;
+	return flags;
 }
 
 /*
@@ -266,7 +269,7 @@ void intel_guc_init_params(struct intel_guc *guc)
 
 	params[GUC_CTL_LOG_PARAMS] = guc->log.flags;
 
-	params[GUC_CTL_DEBUG] = get_log_verbosity_flags();
+	params[GUC_CTL_DEBUG] = get_log_control_flags();
 
 	/* If GuC submission is enabled, set up additional parameters here */
 	if (USES_GUC_SUBMISSION(dev_priv)) {
diff --git a/drivers/gpu/drm/i915/intel_guc_fwif.h b/drivers/gpu/drm/i915/intel_guc_fwif.h
index 6a10aa6f04d3..4971685a2ea8 100644
--- a/drivers/gpu/drm/i915/intel_guc_fwif.h
+++ b/drivers/gpu/drm/i915/intel_guc_fwif.h
@@ -127,7 +127,7 @@
 #define   GUC_PROFILE_ENABLED		(1 << 7)
 #define   GUC_WQ_TRACK_ENABLED		(1 << 8)
 #define   GUC_ADS_ENABLED		(1 << 9)
-#define   GUC_DEBUG_RESERVED		(1 << 10)
+#define   GUC_LOG_DEFAULT_DISABLED	(1 << 10)
 #define   GUC_ADS_ADDR_SHIFT		11
 #define   GUC_ADS_ADDR_MASK		0xfffff800
 
@@ -539,7 +539,8 @@ union guc_log_control {
 		u32 logging_enabled:1;
 		u32 reserved1:3;
 		u32 verbosity:4;
-		u32 reserved2:24;
+		u32 default_logging:1;
+		u32 reserved2:23;
 	};
 	u32 value;
 } __packed;
diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
index bdf6b3178488..ade7dadc34b8 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.c
+++ b/drivers/gpu/drm/i915/intel_guc_log.c
@@ -58,11 +58,13 @@ static int guc_log_flush(struct intel_guc *guc)
 	return intel_guc_send(guc, action, ARRAY_SIZE(action));
 }
 
-static int guc_log_control(struct intel_guc *guc, bool enable, u32 verbosity)
+static int guc_log_control(struct intel_guc *guc, bool enable,
+			   bool default_logging, u32 verbosity)
 {
 	union guc_log_control control_val = {
 		.logging_enabled = enable,
 		.verbosity = verbosity,
+		.default_logging = default_logging,
 	};
 	u32 action[] = {
 		INTEL_GUC_ACTION_UK_LOG_ENABLE_LOGGING,
@@ -506,8 +508,6 @@ int intel_guc_log_level_get(struct intel_guc *guc)
 	return i915_modparams.guc_log_level;
 }
 
-#define GUC_LOG_IS_ENABLED(x)		(x > 0)
-#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
 int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
 {
 	struct drm_i915_private *dev_priv = guc_to_i915(guc);
@@ -533,7 +533,8 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
 	}
 
 	intel_runtime_pm_get(dev_priv);
-	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
+	ret = guc_log_control(guc, GUC_LOG_IS_VERBOSE(val),
+			      GUC_LOG_IS_ENABLED(val),
 			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
 	intel_runtime_pm_put(dev_priv);
 	if (ret)
diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
index a8ccb04e2b0a..a91d94da5543 100644
--- a/drivers/gpu/drm/i915/intel_guc_log.h
+++ b/drivers/gpu/drm/i915/intel_guc_log.h
@@ -39,6 +39,17 @@ struct intel_guc;
 #define GUC_LOG_SIZE	((1 + GUC_LOG_DPC_PAGES + 1 + GUC_LOG_ISR_PAGES + \
 			  1 + GUC_LOG_CRASH_PAGES + 1) << PAGE_SHIFT)
 
+/*
+ * While we're using plain log level in i915, GuC controls are much more...
+ * "elaborate"? We have a couple of bits for verbosity, separate bit for actual
+ * log enabling, and separate bit for default logging - which "conveniently"
+ * ignores the enable bit.
+ */
+#define GUC_LOG_IS_ENABLED(x)		(x > 0)
+#define GUC_LOG_IS_VERBOSE(x)		(x > 1)
+#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_VERBOSE(x) ? x - 2 : 0)
+#define GUC_LOG_VERBOSITY_TO_LEVEL(x)	(x + 2)
+
 struct intel_guc_log {
 	u32 flags;
 	struct i915_vma *vma;
diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
index 27e1f4c43b7b..9884a79c77bd 100644
--- a/drivers/gpu/drm/i915/intel_uc.c
+++ b/drivers/gpu/drm/i915/intel_uc.c
@@ -75,7 +75,8 @@ static int __get_default_guc_log_level(struct drm_i915_private *dev_priv)
 	if (HAS_GUC(dev_priv) && intel_uc_is_using_guc() &&
 	    (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
 	     IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)))
-		guc_log_level = 1 + GUC_LOG_VERBOSITY_MAX;
+		guc_log_level =
+			GUC_LOG_VERBOSITY_TO_LEVEL(GUC_LOG_VERBOSITY_MAX);
 
 	/* Any platform specific fine-tuning can be done here */
 
@@ -142,17 +143,20 @@ void intel_uc_sanitize_options(struct drm_i915_private *dev_priv)
 		i915_modparams.guc_log_level = 0;
 	}
 
-	if (i915_modparams.guc_log_level > 1 + GUC_LOG_VERBOSITY_MAX) {
+	if (i915_modparams.guc_log_level >
+	    GUC_LOG_VERBOSITY_TO_LEVEL(GUC_LOG_VERBOSITY_MAX)) {
 		DRM_WARN("Incompatible option detected: %s=%d, %s!\n",
 			 "guc_log_level", i915_modparams.guc_log_level,
 			 "verbosity too high");
-		i915_modparams.guc_log_level = 1 + GUC_LOG_VERBOSITY_MAX;
+		i915_modparams.guc_log_level =
+			GUC_LOG_VERBOSITY_TO_LEVEL(GUC_LOG_VERBOSITY_MAX);
 	}
 
-	DRM_DEBUG_DRIVER("guc_log_level=%d (enabled:%s verbosity:%d)\n",
+	DRM_DEBUG_DRIVER("guc_log_level=%d (enabled:%s, verbose:%s, verbosity:%d)\n",
 			 i915_modparams.guc_log_level,
 			 yesno(i915_modparams.guc_log_level),
-			 i915_modparams.guc_log_level - 1);
+			 yesno(GUC_LOG_IS_VERBOSE(i915_modparams.guc_log_level)),
+			 GUC_LOG_LEVEL_TO_VERBOSITY(i915_modparams.guc_log_level));
 
 	/* Make sure that sanitization was done */
 	GEM_BUG_ON(i915_modparams.enable_guc < 0);
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 14/15] drm/i915/guc: Default to non-verbose GuC logging

[Michał Winiarski]

Now that we've decoupled logging from relay, GuC log level is only
controlling the GuC behavior - there shouldn't be any impact on i915
behaviour. We're only going to see a single extra interrupt when log
will get half full.
That, and the fact that we're seeing igt/gem_exec_nop/basic-series
failing with non-verbose logging being disabled.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/i915/intel_uc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
index 9884a79c77bd..cd6203740c07 100644
--- a/drivers/gpu/drm/i915/intel_uc.c
+++ b/drivers/gpu/drm/i915/intel_uc.c
@@ -69,7 +69,7 @@ static int __get_platform_enable_guc(struct drm_i915_private *dev_priv)
 
 static int __get_default_guc_log_level(struct drm_i915_private *dev_priv)
 {
-	int guc_log_level = 0; /* disabled */
+	int guc_log_level = 1; /* non-verbose */
 
 	/* Enable if we're running on platform with GuC and debug config */
 	if (HAS_GUC(dev_priv) && intel_uc_is_using_guc() &&
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH 15/15] HAX enable guc and guc_log for CI

[Michał Winiarski]

---
 drivers/gpu/drm/i915/i915_params.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/i915/i915_params.h b/drivers/gpu/drm/i915/i915_params.h
index 430f5f9d0ff4..53037b5eff22 100644
--- a/drivers/gpu/drm/i915/i915_params.h
+++ b/drivers/gpu/drm/i915/i915_params.h
@@ -47,8 +47,8 @@ struct drm_printer;
 	param(int, disable_power_well, -1) \
 	param(int, enable_ips, 1) \
 	param(int, invert_brightness, 0) \
-	param(int, enable_guc, 0) \
-	param(int, guc_log_level, 0) \
+	param(int, enable_guc, -1) \
+	param(int, guc_log_level, -1) \
 	param(char *, guc_firmware_path, NULL) \
 	param(char *, huc_firmware_path, NULL) \
 	param(int, mmio_debug, 0) \
-- 
2.14.3

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

✗ Fi.CI.SPARSE: warning for series starting with [01/15] drm/i915/guc: Tidy guc_log_control

[Patchwork]

== Series Details ==

Series: series starting with [01/15] drm/i915/guc: Tidy guc_log_control
URL   : https://patchwork.freedesktop.org/series/39043/
State : warning

== Summary ==

$ dim sparse origin/drm-tip
Commit: drm/i915/guc: Tidy guc_log_control
Okay!

Commit: drm/i915/guc: Create common entry points for log register/unregister
+drivers/gpu/drm/i915/intel_guc_log.c:444:5: warning: symbol 'guc_log_relay_create' was not declared. Should it be static?
+drivers/gpu/drm/i915/intel_guc_log.c:497:6: warning: symbol 'guc_log_relay_destroy' was not declared. Should it be static?

Commit: drm/i915/guc: Move GuC notification handling to separate function
Okay!

Commit: drm/i915/guc: Keep GuC interrupts enabled when using GuC
Okay!

Commit: drm/i915/guc: Log runtime should consist of both mapping and relay
-O:drivers/gpu/drm/i915/intel_guc_log.c:497:6: warning: symbol 'guc_log_relay_destroy' was not declared. Should it be static?
+drivers/gpu/drm/i915/intel_guc_log.c:459:6: warning: symbol 'guc_log_relay_destroy' was not declared. Should it be static?

Commit: drm/i915/guc: Merge log relay file and channel creation
Okay!

Commit: drm/i915/guc: Flush directly in log unregister
Okay!

Commit: drm/i915/guc: Split relay control and GuC log level
Okay!

Commit: drm/i915/guc: Move check for fast memcpy_wc to relay creation
Okay!

Commit: drm/i915/guc: Get rid of GuC log runtime
-O:drivers/gpu/drm/i915/intel_guc_log.c:376:5: warning: symbol 'guc_log_relay_create' was not declared. Should it be static?
-O:drivers/gpu/drm/i915/intel_guc_log.c:423:6: warning: symbol 'guc_log_relay_destroy' was not declared. Should it be static?
+drivers/gpu/drm/i915/intel_guc_log.c:376:5: warning: symbol 'guc_log_relay_create' was not declared. Should it be static?
+drivers/gpu/drm/i915/intel_guc_log.c:423:6: warning: symbol 'guc_log_relay_destroy' was not declared. Should it be static?

Commit: drm/i915/guc: Always print log stats in i915_guc_info when using GuC
Okay!

Commit: drm/i915/guc: Don't print out relay statistics when relay is disabled
Okay!

Commit: drm/i915/guc: Allow user to control default GuC logging
Okay!

Commit: drm/i915/guc: Default to non-verbose GuC logging
Okay!

Commit: HAX enable guc and guc_log for CI
Okay!

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

✓ Fi.CI.BAT: success for series starting with [01/15] drm/i915/guc: Tidy guc_log_control

[Patchwork]

== Series Details ==

Series: series starting with [01/15] drm/i915/guc: Tidy guc_log_control
URL   : https://patchwork.freedesktop.org/series/39043/
State : success

== Summary ==

Series 39043v1 series starting with [01/15] drm/i915/guc: Tidy guc_log_control
https://patchwork.freedesktop.org/api/1.0/series/39043/revisions/1/mbox/

---- Possible new issues:

Test kms_force_connector_basic:
        Subgroup force-connector-state:
                skip       -> PASS       (fi-ivb-3520m)
        Subgroup force-edid:
                skip       -> PASS       (fi-ivb-3520m)
        Subgroup force-load-detect:
                skip       -> PASS       (fi-ivb-3520m)
        Subgroup prune-stale-modes:
                skip       -> PASS       (fi-ivb-3520m)

---- Known issues:

Test gem_mmap_gtt:
        Subgroup basic-small-bo-tiledx:
                pass       -> FAIL       (fi-gdg-551) fdo#102575
Test kms_pipe_crc_basic:
        Subgroup suspend-read-crc-pipe-c:
                incomplete -> PASS       (fi-bxt-dsi) fdo#103927

fdo#102575 https://bugs.freedesktop.org/show_bug.cgi?id=102575
fdo#103927 https://bugs.freedesktop.org/show_bug.cgi?id=103927

fi-bdw-5557u     total:288  pass:265  dwarn:0   dfail:0   fail:2   skip:21  time:433s
fi-bdw-gvtdvm    total:288  pass:264  dwarn:0   dfail:0   fail:0   skip:24  time:422s
fi-blb-e6850     total:288  pass:223  dwarn:1   dfail:0   fail:0   skip:64  time:373s
fi-bsw-n3050     total:288  pass:242  dwarn:0   dfail:0   fail:0   skip:46  time:480s
fi-bwr-2160      total:288  pass:183  dwarn:0   dfail:0   fail:0   skip:105 time:282s
fi-bxt-dsi       total:288  pass:258  dwarn:0   dfail:0   fail:0   skip:30  time:479s
fi-bxt-j4205     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:484s
fi-byt-j1900     total:288  pass:253  dwarn:0   dfail:0   fail:0   skip:35  time:463s
fi-byt-n2820     total:288  pass:249  dwarn:0   dfail:0   fail:0   skip:39  time:451s
fi-cfl-8700k     total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:396s
fi-cfl-s2        total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:566s
fi-cnl-y3        total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:572s
fi-elk-e7500     total:288  pass:229  dwarn:0   dfail:0   fail:0   skip:59  time:408s
fi-gdg-551       total:288  pass:179  dwarn:0   dfail:0   fail:1   skip:108 time:285s
fi-glk-1         total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:507s
fi-hsw-4770      total:288  pass:259  dwarn:0   dfail:0   fail:2   skip:27  time:407s
fi-ilk-650       total:288  pass:228  dwarn:0   dfail:0   fail:0   skip:60  time:406s
fi-ivb-3520m     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:452s
fi-ivb-3770      total:288  pass:255  dwarn:0   dfail:0   fail:0   skip:33  time:415s
fi-kbl-7500u     total:288  pass:263  dwarn:1   dfail:0   fail:0   skip:24  time:451s
fi-kbl-7560u     total:288  pass:269  dwarn:0   dfail:0   fail:0   skip:19  time:484s
fi-kbl-7567u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:448s
fi-kbl-r         total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:491s
fi-pnv-d510      total:288  pass:222  dwarn:1   dfail:0   fail:0   skip:65  time:581s
fi-skl-6260u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:422s
fi-skl-6600u     total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:499s
fi-skl-6700hq    total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:514s
fi-skl-6700k2    total:288  pass:264  dwarn:0   dfail:0   fail:0   skip:24  time:484s
fi-skl-6770hq    total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:476s
fi-skl-guc       total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:403s
fi-skl-gvtdvm    total:288  pass:265  dwarn:0   dfail:0   fail:0   skip:23  time:426s
fi-snb-2520m     total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:523s
fi-snb-2600      total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:388s

aea43a430276951b4e164501e2cf8da77f6b2171 drm-tip: 2018y-02m-27d-10h-49m-38s UTC integration manifest
bde0314dd456 HAX enable guc and guc_log for CI
50cbd6d95934 drm/i915/guc: Default to non-verbose GuC logging
65e605e11927 drm/i915/guc: Allow user to control default GuC logging
f0fd888f87f6 drm/i915/guc: Don't print out relay statistics when relay is disabled
9d58e4ac0366 drm/i915/guc: Always print log stats in i915_guc_info when using GuC
0395d64502af drm/i915/guc: Get rid of GuC log runtime
079743a1f59a drm/i915/guc: Move check for fast memcpy_wc to relay creation
646fae217a95 drm/i915/guc: Split relay control and GuC log level
8c2c0ef86d71 drm/i915/guc: Flush directly in log unregister
0eaa7cb72b6e drm/i915/guc: Merge log relay file and channel creation
712a23a3cbac drm/i915/guc: Log runtime should consist of both mapping and relay
e9ca940f8eec drm/i915/guc: Keep GuC interrupts enabled when using GuC
0664e85e3183 drm/i915/guc: Move GuC notification handling to separate function
2d2b04dad80a drm/i915/guc: Create common entry points for log register/unregister
a5e5299d3c9b drm/i915/guc: Tidy guc_log_control

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_8173/issues.html
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 01/15] drm/i915/guc: Tidy guc_log_control

[Michal Wajdeczko]

On Tue, 27 Feb 2018 13:52:16 +0100, Michał Winiarski  
<michal.winiarski@intel.com> wrote:

> We plan to decouple log runtime (mapping + relay) from verbosity control.
> Let's tidy the code now to reduce the churn in the following patches.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---

/snip/

> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -657,52 +657,55 @@ void intel_guc_log_destroy(struct intel_guc *guc)
>  	i915_vma_unpin_and_release(&guc->log.vma);
>  }
> -int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
> +int intel_guc_log_control_get(struct intel_guc *guc)

Can we add kernel-doc for this new function?

> +{
> +	GEM_BUG_ON(!guc->log.vma);
> +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
> +
> +	return i915_modparams.guc_log_level;
> +}
> +
> +#define GUC_LOG_IS_ENABLED(x)		(x > 0)

1) x must be wrapped into (x)
2) GUC_LOG_ prefix is misleading, maybe LOG_LEVEL_TO_ENABLED()

> +#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 :  
> 0)

1) x must be wrapped into (x)
2) try to avoid double evaluation of x

> +int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>  {
>  	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	bool enable_logging = control_val > 0;
> -	u32 verbosity;
>  	int ret;
> -	if (!guc->log.vma)
> -		return -ENODEV;
> +	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
> +	GEM_BUG_ON(!guc->log.vma);
> +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
> -	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN);
> -	if (control_val > 1 + GUC_LOG_VERBOSITY_MAX)
> +	/*
> +	 * GuC is recognizing log levels starting from 0 to max, we're using 0
> +	 * as indication that logging should be disablded.

typo

> +	 */
> +	if (GUC_LOG_LEVEL_TO_VERBOSITY(val) < GUC_LOG_VERBOSITY_MIN ||
> +	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)

try to use helper variable easier read:

int verbosity = LOG_LEVEL_TO_VERBOSITY(val);
if (verbosity < GUC_LOG_VERBOSITY_MIN || verbosity > GUC_LOG_VERBOSITY_MAX)

>  		return -EINVAL;
> -	/* This combination doesn't make sense & won't have any effect */
> -	if (!enable_logging && !i915_modparams.guc_log_level)
> -		return 0;
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> -	verbosity = enable_logging ? control_val - 1 : 0;
> +	if (i915_modparams.guc_log_level == val) {
> +		ret = 0;
> +		goto out_unlock;
> +	}
> -	ret = mutex_lock_interruptible(&dev_priv->drm.struct_mutex);
> -	if (ret)
> -		return ret;
>  	intel_runtime_pm_get(dev_priv);
> -	ret = guc_log_control(guc, enable_logging, verbosity);
> +	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
> +			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
>  	intel_runtime_pm_put(dev_priv);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> +	if (ret)
> +		goto out_unlock;
> -	if (ret < 0) {
> -		DRM_DEBUG_DRIVER("guc_logging_control action failed %d\n", ret);
> -		return ret;
> -	}
> +	i915_modparams.guc_log_level = val;
> -	if (enable_logging) {
> -		i915_modparams.guc_log_level = 1 + verbosity;
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> -		/*
> -		 * If log was disabled at boot time, then the relay channel file
> -		 * wouldn't have been created by now and interrupts also would
> -		 * not have been enabled. Try again now, just in case.
> -		 */
> +	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
>  		ret = guc_log_late_setup(guc);
> -		if (ret < 0) {
> -			DRM_DEBUG_DRIVER("GuC log late setup failed %d\n", ret);

why do you want to remove all these diagnostic messages?

> -			return ret;
> -		}
> +		if (ret)
> +			goto out;
> 		/* GuC logging is currently the only user of Guc2Host interrupts */
>  		mutex_lock(&dev_priv->drm.struct_mutex);
> @@ -710,7 +713,7 @@ int intel_guc_log_control(struct intel_guc *guc, u64  
> control_val)
>  		gen9_enable_guc_interrupts(dev_priv);
>  		intel_runtime_pm_put(dev_priv);
>  		mutex_unlock(&dev_priv->drm.struct_mutex);
> -	} else {
> +	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
>  		/*
>  		 * Once logging is disabled, GuC won't generate logs & send an
>  		 * interrupt. But there could be some data in the log buffer
> @@ -718,11 +721,13 @@ int intel_guc_log_control(struct intel_guc *guc,  
> u64 control_val)
>  		 * buffer state and then collect the left over logs.
>  		 */
>  		guc_flush_logs(guc);
> -
> -		/* As logging is disabled, update log level to reflect that */
> -		i915_modparams.guc_log_level = 0;
>  	}
> +	return 0;
> +
> +out_unlock:
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +out:
>  	return ret;
>  }
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h  
> b/drivers/gpu/drm/i915/intel_guc_log.h
> index dab0e949567a..141ce9ca22ce 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -64,7 +64,8 @@ void intel_guc_log_destroy(struct intel_guc *guc);
>  void intel_guc_log_init_early(struct intel_guc *guc);
>  int intel_guc_log_relay_create(struct intel_guc *guc);
>  void intel_guc_log_relay_destroy(struct intel_guc *guc);
> -int intel_guc_log_control(struct intel_guc *guc, u64 control_val);
> +int intel_guc_log_control_get(struct intel_guc *guc);
> +int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
>  void i915_guc_log_register(struct drm_i915_private *dev_priv);
>  void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 02/15] drm/i915/guc: Create common entry points for log register/unregister

[Michal Wajdeczko]

On Tue, 27 Feb 2018 13:52:17 +0100, Michał Winiarski  
<michal.winiarski@intel.com> wrote:

> We have many functions responsible for allocating different parts of
> runtime called from multiple places. Let's stick with keeping

s/runtime/GuC log runtime ?

> everything in guc_log_register instead.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>  drivers/gpu/drm/i915/i915_drv.c      |   6 +-
>  drivers/gpu/drm/i915/i915_gem.c      |   4 +-
>  drivers/gpu/drm/i915/intel_guc_log.c | 148  
> ++++++++++++++---------------------
>  drivers/gpu/drm/i915/intel_guc_log.h |   6 +-
>  drivers/gpu/drm/i915/intel_uc.c      |  39 ++++-----
>  drivers/gpu/drm/i915/intel_uc.h      |   6 +-
>  6 files changed, 91 insertions(+), 118 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_drv.c  
> b/drivers/gpu/drm/i915/i915_drv.c
> index aaa861b51024..719b2be73292 100644
> --- a/drivers/gpu/drm/i915/i915_drv.c
> +++ b/drivers/gpu/drm/i915/i915_drv.c
> @@ -636,7 +636,7 @@ static void i915_gem_fini(struct drm_i915_private  
> *dev_priv)
>  	i915_gem_contexts_fini(dev_priv);
>  	mutex_unlock(&dev_priv->drm.struct_mutex);
> -	intel_uc_fini_misc(dev_priv);
> +	intel_uc_fini_wq(dev_priv);
>  	i915_gem_cleanup_userptr(dev_priv);
> 	i915_gem_drain_freed_objects(dev_priv);
> @@ -1237,7 +1237,7 @@ static void i915_driver_register(struct  
> drm_i915_private *dev_priv)
>  	/* Reveal our presence to userspace */
>  	if (drm_dev_register(dev, 0) == 0) {
>  		i915_debugfs_register(dev_priv);
> -		i915_guc_log_register(dev_priv);
> +		intel_uc_log_register(dev_priv);

btw, maybe we should place this function little later after

	/* Depends on debugfs having been initialized */

>  		i915_setup_sysfs(dev_priv);
> 		/* Depends on sysfs having been initialized */
> @@ -1297,7 +1297,7 @@ static void i915_driver_unregister(struct  
> drm_i915_private *dev_priv)
>  	i915_pmu_unregister(dev_priv);
> 	i915_teardown_sysfs(dev_priv);
> -	i915_guc_log_unregister(dev_priv);
> +	intel_uc_log_unregister(dev_priv);
>  	drm_dev_unregister(&dev_priv->drm);
> 	i915_gem_shrinker_unregister(dev_priv);
> diff --git a/drivers/gpu/drm/i915/i915_gem.c  
> b/drivers/gpu/drm/i915/i915_gem.c
> index 14c855b1a3a4..4bf5f25b29e2 100644
> --- a/drivers/gpu/drm/i915/i915_gem.c
> +++ b/drivers/gpu/drm/i915/i915_gem.c
> @@ -5279,7 +5279,7 @@ int i915_gem_init(struct drm_i915_private  
> *dev_priv)
>  	if (ret)
>  		return ret;
> -	ret = intel_uc_init_misc(dev_priv);
> +	ret = intel_uc_init_wq(dev_priv);
>  	if (ret)
>  		return ret;
> @@ -5375,7 +5375,7 @@ int i915_gem_init(struct drm_i915_private  
> *dev_priv)
>  	intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
>  	mutex_unlock(&dev_priv->drm.struct_mutex);
> -	intel_uc_fini_misc(dev_priv);
> +	intel_uc_fini_wq(dev_priv);
> 	if (ret != -EIO)
>  		i915_gem_cleanup_userptr(dev_priv);
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c  
> b/drivers/gpu/drm/i915/intel_guc_log.c
> index 22a05320817b..f1cab43d334e 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -441,7 +441,7 @@ void intel_guc_log_init_early(struct intel_guc *guc)
>  	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
>  }
> -int intel_guc_log_relay_create(struct intel_guc *guc)
> +int guc_log_relay_create(struct intel_guc *guc)
>  {
>  	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>  	struct rchan *guc_log_relay_chan;
> @@ -494,7 +494,7 @@ int intel_guc_log_relay_create(struct intel_guc *guc)
>  	return ret;
>  }
> -void intel_guc_log_relay_destroy(struct intel_guc *guc)
> +void guc_log_relay_destroy(struct intel_guc *guc)
>  {
>  	mutex_lock(&guc->log.runtime.relay_lock);
> @@ -512,49 +512,6 @@ void intel_guc_log_relay_destroy(struct intel_guc  
> *guc)
>  	mutex_unlock(&guc->log.runtime.relay_lock);
>  }
> -static int guc_log_late_setup(struct intel_guc *guc)
> -{
> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	int ret;
> -
> -	if (!guc_log_has_runtime(guc)) {
> -		/*
> -		 * If log was disabled at boot time, then setup needed to handle
> -		 * log buffer flush interrupts would not have been done yet, so
> -		 * do that now.
> -		 */
> -		ret = intel_guc_log_relay_create(guc);
> -		if (ret)
> -			goto err;
> -
> -		mutex_lock(&dev_priv->drm.struct_mutex);
> -		intel_runtime_pm_get(dev_priv);
> -		ret = guc_log_runtime_create(guc);
> -		intel_runtime_pm_put(dev_priv);
> -		mutex_unlock(&dev_priv->drm.struct_mutex);
> -
> -		if (ret)
> -			goto err_relay;
> -	}
> -
> -	ret = guc_log_relay_file_create(guc);
> -	if (ret)
> -		goto err_runtime;
> -
> -	return 0;
> -
> -err_runtime:
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	guc_log_runtime_destroy(guc);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> -err_relay:
> -	intel_guc_log_relay_destroy(guc);
> -err:
> -	/* logging will remain off */
> -	i915_modparams.guc_log_level = 0;
> -	return ret;
> -}
> -
>  static void guc_log_capture_logs(struct intel_guc *guc)
>  {
>  	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> @@ -574,16 +531,6 @@ static void guc_flush_logs(struct intel_guc *guc)
>  {
>  	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
> -		return;
> -
> -	/* First disable the interrupts, will be renabled afterwards */
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	intel_runtime_pm_get(dev_priv);
> -	gen9_disable_guc_interrupts(dev_priv);
> -	intel_runtime_pm_put(dev_priv);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> -
>  	/*
>  	 * Before initiating the forceful flush, wait for any pending/ongoing
>  	 * flush to complete otherwise forceful flush may not actually happen.
> @@ -626,12 +573,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> 	guc->log.vma = vma;
> -	if (i915_modparams.guc_log_level) {
> -		ret = guc_log_runtime_create(guc);
> -		if (ret < 0)
> -			goto err_vma;
> -	}
> -
>  	/* each allocated unit is a page */
>  	flags = GUC_LOG_VALID | GUC_LOG_NOTIFY_ON_HALF_FULL |
>  		(GUC_LOG_DPC_PAGES << GUC_LOG_DPC_SHIFT) |
> @@ -643,8 +584,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> 	return 0;
> -err_vma:
> -	i915_vma_unpin_and_release(&guc->log.vma);
>  err:
>  	/* logging will be off */
>  	i915_modparams.guc_log_level = 0;
> @@ -703,24 +642,14 @@ int intel_guc_log_control_set(struct intel_guc  
> *guc, u64 val)
>  	mutex_unlock(&dev_priv->drm.struct_mutex);
> 	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
> -		ret = guc_log_late_setup(guc);
> -		if (ret)
> +		ret = intel_guc_log_register(guc);
> +		if (ret) {
> +			/* logging will remain off */
> +			i915_modparams.guc_log_level = 0;
>  			goto out;
> -
> -		/* GuC logging is currently the only user of Guc2Host interrupts */
> -		mutex_lock(&dev_priv->drm.struct_mutex);
> -		intel_runtime_pm_get(dev_priv);
> -		gen9_enable_guc_interrupts(dev_priv);
> -		intel_runtime_pm_put(dev_priv);
> -		mutex_unlock(&dev_priv->drm.struct_mutex);
> +		}
>  	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
> -		/*
> -		 * Once logging is disabled, GuC won't generate logs & send an
> -		 * interrupt. But there could be some data in the log buffer
> -		 * which is yet to be captured. So request GuC to update the log
> -		 * buffer state and then collect the left over logs.
> -		 */
> -		guc_flush_logs(guc);
> +		intel_guc_log_unregister(guc);
>  	}
> 	return 0;
> @@ -731,20 +660,63 @@ int intel_guc_log_control_set(struct intel_guc  
> *guc, u64 val)
>  	return ret;
>  }
> -void i915_guc_log_register(struct drm_i915_private *dev_priv)
> +int intel_guc_log_register(struct intel_guc *guc)
>  {
> -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
> -		return;
> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> +	int ret;
> +
> +	GEM_BUG_ON(guc_log_has_runtime(guc));
> +
> +	/*
> +	 * If log was disabled at boot time, then setup needed to handle
> +	 * log buffer flush interrupts would not have been done yet, so
> +	 * do that now.
> +	 */
> +	ret = guc_log_relay_create(guc);
> +	if (ret)
> +		goto err;
> +
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> +	ret = guc_log_runtime_create(guc);
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +
> +	if (ret)
> +		goto err_relay;
> +
> +	ret = guc_log_relay_file_create(guc);
> +	if (ret)
> +		goto err_runtime;
> -	guc_log_late_setup(&dev_priv->guc);
> +	/* GuC logging is currently the only user of Guc2Host interrupts */
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> +	intel_runtime_pm_get(dev_priv);
> +	gen9_enable_guc_interrupts(dev_priv);
> +	intel_runtime_pm_put(dev_priv);
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +
> +	return 0;
> +
> +err_runtime:
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> +	guc_log_runtime_destroy(guc);
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +err_relay:
> +	guc_log_relay_destroy(guc);
> +err:
> +	return ret;
>  }
> -void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
> +void intel_guc_log_unregister(struct intel_guc *guc)
>  {
> -	struct intel_guc *guc = &dev_priv->guc;
> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	if (!USES_GUC_SUBMISSION(dev_priv))
> -		return;
> +	/*
> +	 * Once logging is disabled, GuC won't generate logs & send an
> +	 * interrupt. But there could be some data in the log buffer
> +	 * which is yet to be captured. So request GuC to update the log
> +	 * buffer state and then collect the left over logs.
> +	 */
> +	guc_flush_logs(guc);
> 	mutex_lock(&dev_priv->drm.struct_mutex);
>  	/* GuC logging is currently the only user of Guc2Host interrupts */
> @@ -755,5 +727,5 @@ void i915_guc_log_unregister(struct drm_i915_private  
> *dev_priv)
>  	guc_log_runtime_destroy(guc);
>  	mutex_unlock(&dev_priv->drm.struct_mutex);
> -	intel_guc_log_relay_destroy(guc);
> +	guc_log_relay_destroy(guc);
>  }
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h  
> b/drivers/gpu/drm/i915/intel_guc_log.h
> index 141ce9ca22ce..09dd2ef1933d 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -62,11 +62,9 @@ struct intel_guc_log {
>  int intel_guc_log_create(struct intel_guc *guc);
>  void intel_guc_log_destroy(struct intel_guc *guc);
>  void intel_guc_log_init_early(struct intel_guc *guc);
> -int intel_guc_log_relay_create(struct intel_guc *guc);
> -void intel_guc_log_relay_destroy(struct intel_guc *guc);
>  int intel_guc_log_control_get(struct intel_guc *guc);
>  int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
> -void i915_guc_log_register(struct drm_i915_private *dev_priv);
> -void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
> +int intel_guc_log_register(struct intel_guc *guc);
> +void intel_guc_log_unregister(struct intel_guc *guc);
> #endif
> diff --git a/drivers/gpu/drm/i915/intel_uc.c  
> b/drivers/gpu/drm/i915/intel_uc.c
> index 9f1bac6398fb..3f41ef525e26 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -219,6 +219,22 @@ static void guc_free_load_err_log(struct intel_guc  
> *guc)
>  		i915_gem_object_put(guc->load_err_log);
>  }
> +int intel_uc_log_register(struct drm_i915_private *dev_priv)

What if we'll add more entries that need to be registered?

s/intel_uc_log_register/intel_uc_register ?

> +{
> +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +		return 0;
> +
> +	return intel_guc_log_register(&dev_priv->guc);
> +}
> +
> +void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
> +{
> +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +		return;
> +
> +	intel_guc_log_unregister(&dev_priv->guc);
> +}
> +
>  static int guc_enable_communication(struct intel_guc *guc)
>  {
>  	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> @@ -240,7 +256,7 @@ static void guc_disable_communication(struct  
> intel_guc *guc)
>  	guc->send = intel_guc_send_nop;
>  }
> -int intel_uc_init_misc(struct drm_i915_private *dev_priv)
> +int intel_uc_init_wq(struct drm_i915_private *dev_priv)

I would leave old name here, as wq will expose our internals ;)

>  {
>  	struct intel_guc *guc = &dev_priv->guc;
>  	int ret;
> @@ -249,26 +265,13 @@ int intel_uc_init_misc(struct drm_i915_private  
> *dev_priv)
>  		return 0;
> 	ret = intel_guc_init_wq(guc);
> -	if (ret) {
> -		DRM_ERROR("Couldn't allocate workqueues for GuC\n");
> -		goto err;
> -	}
> -
> -	ret = intel_guc_log_relay_create(guc);
> -	if (ret) {
> -		DRM_ERROR("Couldn't allocate relay for GuC log\n");
> -		goto err_relay;
> -	}
> +	if (ret)
> +		return ret;
> 	return 0;
> -
> -err_relay:
> -	intel_guc_fini_wq(guc);
> -err:
> -	return ret;
>  }
> -void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
> +void intel_uc_fini_wq(struct drm_i915_private *dev_priv)
>  {
>  	struct intel_guc *guc = &dev_priv->guc;
> @@ -276,8 +279,6 @@ void intel_uc_fini_misc(struct drm_i915_private  
> *dev_priv)
>  		return;
> 	intel_guc_fini_wq(guc);
> -
> -	intel_guc_log_relay_destroy(guc);
>  }
> int intel_uc_init(struct drm_i915_private *dev_priv)
> diff --git a/drivers/gpu/drm/i915/intel_uc.h  
> b/drivers/gpu/drm/i915/intel_uc.h
> index f2984e01e257..9bc22103396d 100644
> --- a/drivers/gpu/drm/i915/intel_uc.h
> +++ b/drivers/gpu/drm/i915/intel_uc.h
> @@ -31,10 +31,12 @@
>  void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
>  void intel_uc_init_early(struct drm_i915_private *dev_priv);
>  void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
> +int intel_uc_log_register(struct drm_i915_private *dev_priv);
> +void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
>  void intel_uc_init_fw(struct drm_i915_private *dev_priv);
>  void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
> -int intel_uc_init_misc(struct drm_i915_private *dev_priv);
> -void intel_uc_fini_misc(struct drm_i915_private *dev_priv);
> +int intel_uc_init_wq(struct drm_i915_private *dev_priv);
> +void intel_uc_fini_wq(struct drm_i915_private *dev_priv);
>  int intel_uc_init_hw(struct drm_i915_private *dev_priv);
>  void intel_uc_fini_hw(struct drm_i915_private *dev_priv);
>  int intel_uc_init(struct drm_i915_private *dev_priv);
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 05/15] drm/i915/guc: Log runtime should consist of both mapping and relay

[Michal Wajdeczko]

On Tue, 27 Feb 2018 13:52:20 +0100, Michał Winiarski  
<michal.winiarski@intel.com> wrote:

> Currently, we're treating relay and mapping of GuC log as a separate
> concepts. We're also using inconsistent locking, sometimes using
> relay_lock, sometimes using struct mutex.
> Let's correct that. Anything touching the runtime is now serialized
> using runtime.lock, while we're still using struct mutex as inner lock
> for mapping.
> We're still racy in setting the log level - but we'll take care of that
> in the following patches.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---

/snip/

> diff --git a/drivers/gpu/drm/i915/intel_uc.c  
> b/drivers/gpu/drm/i915/intel_uc.c
> index e9aba3c35264..55a9b5b673e0 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -221,18 +221,24 @@ static void guc_free_load_err_log(struct intel_guc  
> *guc)
> int intel_uc_log_register(struct drm_i915_private *dev_priv)
>  {
> -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +	int ret = 0;
> +
> +	if (!USES_GUC(dev_priv))
>  		return 0;
> -	return intel_guc_log_register(&dev_priv->guc);
> +	if (i915_modparams.guc_log_level)
> +		ret = intel_guc_log_register(&dev_priv->guc);
> +
> +	return ret;
>  }
> void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
>  {
> -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +	if (!USES_GUC(dev_priv))
>  		return;
> -	intel_guc_log_unregister(&dev_priv->guc);
> +	if (i915_modparams.guc_log_level)
> +		intel_guc_log_unregister(&dev_priv->guc);
>  }
> static int guc_enable_communication(struct intel_guc *guc)

this chunk can be done in patch 2/15
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 09/15] drm/i915/guc: Move check for fast memcpy_wc to relay creation

[Michal Wajdeczko]

On Tue, 27 Feb 2018 13:52:24 +0100, Michał Winiarski  
<michal.winiarski@intel.com> wrote:

> We only need those fast memcpy_wc when we're using relay to read
> continuous GuC log. Let's prevent the user from creating a relay if we
> know we won't be able to keep up with GuC.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
>  drivers/gpu/drm/i915/intel_guc_log.c | 20 ++++++++++----------
>  1 file changed, 10 insertions(+), 10 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c  
> b/drivers/gpu/drm/i915/intel_guc_log.c
> index 4dee65692f5f..d2aca10ab986 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -452,16 +452,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> 	GEM_BUG_ON(guc->log.vma);
> -	/*
> -	 * We require SSE 4.1 for fast reads from the GuC log buffer and
> -	 * it should be present on the chipsets supporting GuC based
> -	 * submisssions.
> -	 */
> -	if (WARN_ON(!i915_has_memcpy_from_wc())) {
> -		ret = -EINVAL;
> -		goto err;
> -	}
> -
>  	vma = intel_guc_allocate_vma(guc, GUC_LOG_SIZE);
>  	if (IS_ERR(vma)) {
>  		ret = PTR_ERR(vma);
> @@ -568,6 +558,16 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>  		goto out_unlock;
>  	}
> +	/*
> +	 * We require SSE 4.1 for fast reads from the GuC log buffer and
> +	 * it should be present on the chipsets supporting GuC based
> +	 * submisssions.
> +	 */
> +	if (!i915_has_memcpy_from_wc()) {
> +		ret = -EINVAL;

hmm, maybe -ENODEV as this is not user fault

> +		goto out_unlock;
> +	}
> +
>  	ret = guc_log_relay_create(guc);
>  	if (ret)
>  		goto out_unlock;
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 09/15] drm/i915/guc: Move check for fast memcpy_wc to relay creation

[Michał Winiarski]

On Tue, Feb 27, 2018 at 03:37:25PM +0100, Michal Wajdeczko wrote:
> On Tue, 27 Feb 2018 13:52:24 +0100, Michał Winiarski
> <michal.winiarski@intel.com> wrote:
> 
> > We only need those fast memcpy_wc when we're using relay to read
> > continuous GuC log. Let's prevent the user from creating a relay if we
> > know we won't be able to keep up with GuC.
> > 
> > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > ---
> >  drivers/gpu/drm/i915/intel_guc_log.c | 20 ++++++++++----------
> >  1 file changed, 10 insertions(+), 10 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.c
> > b/drivers/gpu/drm/i915/intel_guc_log.c
> > index 4dee65692f5f..d2aca10ab986 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.c
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> > @@ -452,16 +452,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> > 	GEM_BUG_ON(guc->log.vma);
> > -	/*
> > -	 * We require SSE 4.1 for fast reads from the GuC log buffer and
> > -	 * it should be present on the chipsets supporting GuC based
> > -	 * submisssions.
> > -	 */
> > -	if (WARN_ON(!i915_has_memcpy_from_wc())) {
> > -		ret = -EINVAL;
> > -		goto err;
> > -	}
> > -
> >  	vma = intel_guc_allocate_vma(guc, GUC_LOG_SIZE);
> >  	if (IS_ERR(vma)) {
> >  		ret = PTR_ERR(vma);
> > @@ -568,6 +558,16 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
> >  		goto out_unlock;
> >  	}
> > +	/*
> > +	 * We require SSE 4.1 for fast reads from the GuC log buffer and
> > +	 * it should be present on the chipsets supporting GuC based
> > +	 * submisssions.
> > +	 */
> > +	if (!i915_has_memcpy_from_wc()) {
> > +		ret = -EINVAL;
> 
> hmm, maybe -ENODEV as this is not user fault

ENODEV means that we're not using GuC.
-ENXIO?

-Michał

> 
> > +		goto out_unlock;
> > +	}
> > +
> >  	ret = guc_log_relay_create(guc);
> >  	if (ret)
> >  		goto out_unlock;
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

✗ Fi.CI.IGT: failure for series starting with [01/15] drm/i915/guc: Tidy guc_log_control

[Patchwork]

== Series Details ==

Series: series starting with [01/15] drm/i915/guc: Tidy guc_log_control
URL   : https://patchwork.freedesktop.org/series/39043/
State : failure

== Summary ==

---- Possible new issues:

Test drv_missed_irq:
                pass       -> SKIP       (shard-apl)
Test drv_selftest:
        Subgroup live_guc:
                pass       -> DMESG-WARN (shard-apl)
Test perf:
        Subgroup gen8-unprivileged-single-ctx-counters:
                pass       -> FAIL       (shard-apl)
Test pm_rpm:
        Subgroup basic-pci-d3-state:
                pass       -> FAIL       (shard-hsw)
        Subgroup cursor-dpms:
                pass       -> FAIL       (shard-hsw)
        Subgroup debugfs-read:
                pass       -> FAIL       (shard-hsw)

---- Known issues:

Test gem_eio:
        Subgroup in-flight:
                incomplete -> PASS       (shard-apl) fdo#104945
Test kms_chv_cursor_fail:
        Subgroup pipe-b-256x256-left-edge:
                pass       -> DMESG-WARN (shard-snb) fdo#105185
Test kms_cursor_legacy:
        Subgroup flip-vs-cursor-varying-size:
                pass       -> FAIL       (shard-hsw) fdo#102670
Test kms_flip:
        Subgroup flip-vs-expired-vblank:
                fail       -> PASS       (shard-hsw) fdo#102887
        Subgroup plain-flip-fb-recreate:
                pass       -> FAIL       (shard-hsw) fdo#100368 +1
Test perf:
        Subgroup enable-disable:
                fail       -> PASS       (shard-apl) fdo#103715
        Subgroup polling:
                pass       -> FAIL       (shard-hsw) fdo#102252

fdo#104945 https://bugs.freedesktop.org/show_bug.cgi?id=104945
fdo#105185 https://bugs.freedesktop.org/show_bug.cgi?id=105185
fdo#102670 https://bugs.freedesktop.org/show_bug.cgi?id=102670
fdo#102887 https://bugs.freedesktop.org/show_bug.cgi?id=102887
fdo#100368 https://bugs.freedesktop.org/show_bug.cgi?id=100368
fdo#103715 https://bugs.freedesktop.org/show_bug.cgi?id=103715
fdo#102252 https://bugs.freedesktop.org/show_bug.cgi?id=102252

shard-apl        total:3404 pass:1778 dwarn:2   dfail:0   fail:14  skip:1609 time:12335s
shard-hsw        total:3460 pass:1720 dwarn:1   dfail:0   fail:50  skip:1688 time:11952s
shard-snb        total:3362 pass:1316 dwarn:2   dfail:0   fail:2   skip:2042 time:6424s
Blacklisted hosts:
shard-kbl        total:3400 pass:1889 dwarn:2   dfail:1   fail:15  skip:1488 time:8621s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_8173/shards.html
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 01/15] drm/i915/guc: Tidy guc_log_control

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> We plan to decouple log runtime (mapping + relay) from verbosity control.
> Let's tidy the code now to reduce the churn in the following patches.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_debugfs.c  | 11 ++----
>   drivers/gpu/drm/i915/intel_guc_log.c | 75 +++++++++++++++++++-----------------
>   drivers/gpu/drm/i915/intel_guc_log.h |  3 +-
>   3 files changed, 46 insertions(+), 43 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index 33fbf3965309..58983cafaece 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -2500,13 +2500,10 @@ static int i915_guc_log_control_get(void *data, u64 *val)
Should we name this i915_guc_log_level_get instead? and other related 
functions too?
>   {
>   	struct drm_i915_private *dev_priv = data;
>   
> -	if (!HAS_GUC(dev_priv))
> +	if (!USES_GUC(dev_priv))
>   		return -ENODEV;
>   
> -	if (!dev_priv->guc.log.vma)
> -		return -EINVAL;
> -
> -	*val = i915_modparams.guc_log_level;
> +	*val = intel_guc_log_control_get(&dev_priv->guc);
>   
>   	return 0;
>   }
> @@ -2515,10 +2512,10 @@ static int i915_guc_log_control_set(void *data, u64 val)
>   {
>   	struct drm_i915_private *dev_priv = data;
>   
> -	if (!HAS_GUC(dev_priv))
> +	if (!USES_GUC(dev_priv))
>   		return -ENODEV;
>   
> -	return intel_guc_log_control(&dev_priv->guc, val);
> +	return intel_guc_log_control_set(&dev_priv->guc, val);
>   }
>   
>   DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_control_fops,
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index 7b5074e2120c..22a05320817b 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -657,52 +657,55 @@ void intel_guc_log_destroy(struct intel_guc *guc)
>   	i915_vma_unpin_and_release(&guc->log.vma);
>   }
>   
> -int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
> +int intel_guc_log_control_get(struct intel_guc *guc)
Should we be passing guc_log as parameter and implement guc_log_to_guc() 
function.
> +{
> +	GEM_BUG_ON(!guc->log.vma);
> +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
> +
> +	return i915_modparams.guc_log_level;
> +}
> +
> +#define GUC_LOG_IS_ENABLED(x)		(x > 0)
> +#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
This is bit misleading, can we make this macro return -1 if logging is 
to be disabled. That way guc_log_control can be invoked with
single signed 32bit parameter.
> +int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	bool enable_logging = control_val > 0;
> -	u32 verbosity;
>   	int ret;
>   
> -	if (!guc->log.vma)
> -		return -ENODEV;
> +	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
> +	GEM_BUG_ON(!guc->log.vma);
> +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
>   
> -	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN);
> -	if (control_val > 1 + GUC_LOG_VERBOSITY_MAX)
> +	/*
> +	 * GuC is recognizing log levels starting from 0 to max, we're using 0
> +	 * as indication that logging should be disablded.
> +	 */
> +	if (GUC_LOG_LEVEL_TO_VERBOSITY(val) < GUC_LOG_VERBOSITY_MIN ||
This check seems unnecessary as we currently don't have negative output 
for G_L_L_T_V macro.
If we add negative value there, will need to remove this check.
> +	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
>   		return -EINVAL;
>   
> -	/* This combination doesn't make sense & won't have any effect */
> -	if (!enable_logging && !i915_modparams.guc_log_level)
> -		return 0;
> +	mutex_lock(&dev_priv->drm.struct_mutex);
>   
> -	verbosity = enable_logging ? control_val - 1 : 0;
> +	if (i915_modparams.guc_log_level == val) {
> +		ret = 0;
> +		goto out_unlock;
> +	}
>   
> -	ret = mutex_lock_interruptible(&dev_priv->drm.struct_mutex);
> -	if (ret)
> -		return ret;
>   	intel_runtime_pm_get(dev_priv);
> -	ret = guc_log_control(guc, enable_logging, verbosity);
> +	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
> +			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
>   	intel_runtime_pm_put(dev_priv);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> +	if (ret)
> +		goto out_unlock;
>   
> -	if (ret < 0) {
> -		DRM_DEBUG_DRIVER("guc_logging_control action failed %d\n", ret);
> -		return ret;
> -	}
> +	i915_modparams.guc_log_level = val;
>   
> -	if (enable_logging) {
> -		i915_modparams.guc_log_level = 1 + verbosity;
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
> -		/*
> -		 * If log was disabled at boot time, then the relay channel file
> -		 * wouldn't have been created by now and interrupts also would
> -		 * not have been enabled. Try again now, just in case.
> -		 */
> +	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
>   		ret = guc_log_late_setup(guc);
> -		if (ret < 0) {
> -			DRM_DEBUG_DRIVER("GuC log late setup failed %d\n", ret);
> -			return ret;
> -		}
> +		if (ret)
> +			goto out;
>   
>   		/* GuC logging is currently the only user of Guc2Host interrupts */
>   		mutex_lock(&dev_priv->drm.struct_mutex);
> @@ -710,7 +713,7 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
>   		gen9_enable_guc_interrupts(dev_priv);
>   		intel_runtime_pm_put(dev_priv);
>   		mutex_unlock(&dev_priv->drm.struct_mutex);
> -	} else {
> +	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
>   		/*
>   		 * Once logging is disabled, GuC won't generate logs & send an
>   		 * interrupt. But there could be some data in the log buffer
> @@ -718,11 +721,13 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
>   		 * buffer state and then collect the left over logs.
>   		 */
>   		guc_flush_logs(guc);
> -
> -		/* As logging is disabled, update log level to reflect that */
> -		i915_modparams.guc_log_level = 0;
>   	}
>   
> +	return 0;
> +
> +out_unlock:
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +out:
>   	return ret;
>   }
>   
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index dab0e949567a..141ce9ca22ce 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -64,7 +64,8 @@ void intel_guc_log_destroy(struct intel_guc *guc);
>   void intel_guc_log_init_early(struct intel_guc *guc);
>   int intel_guc_log_relay_create(struct intel_guc *guc);
>   void intel_guc_log_relay_destroy(struct intel_guc *guc);
> -int intel_guc_log_control(struct intel_guc *guc, u64 control_val);
> +int intel_guc_log_control_get(struct intel_guc *guc);
> +int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
>   void i915_guc_log_register(struct drm_i915_private *dev_priv);
>   void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
>   

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 01/15] drm/i915/guc: Tidy guc_log_control

[Michał Winiarski]

On Fri, Mar 02, 2018 at 04:39:38PM +0530, Sagar Arun Kamble wrote:
> 
> 
> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> > We plan to decouple log runtime (mapping + relay) from verbosity control.
> > Let's tidy the code now to reduce the churn in the following patches.
> > 
> > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > ---
> >   drivers/gpu/drm/i915/i915_debugfs.c  | 11 ++----
> >   drivers/gpu/drm/i915/intel_guc_log.c | 75 +++++++++++++++++++-----------------
> >   drivers/gpu/drm/i915/intel_guc_log.h |  3 +-
> >   3 files changed, 46 insertions(+), 43 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> > index 33fbf3965309..58983cafaece 100644
> > --- a/drivers/gpu/drm/i915/i915_debugfs.c
> > +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> > @@ -2500,13 +2500,10 @@ static int i915_guc_log_control_get(void *data, u64 *val)
> Should we name this i915_guc_log_level_get instead? and other related
> functions too?

I chose symmetry here, note that the debugfs file is still named
i915_guc_log_control at this point. This changes later in the series though.

> >   {
> >   	struct drm_i915_private *dev_priv = data;
> > -	if (!HAS_GUC(dev_priv))
> > +	if (!USES_GUC(dev_priv))
> >   		return -ENODEV;
> > -	if (!dev_priv->guc.log.vma)
> > -		return -EINVAL;
> > -
> > -	*val = i915_modparams.guc_log_level;
> > +	*val = intel_guc_log_control_get(&dev_priv->guc);
> >   	return 0;
> >   }
> > @@ -2515,10 +2512,10 @@ static int i915_guc_log_control_set(void *data, u64 val)
> >   {
> >   	struct drm_i915_private *dev_priv = data;
> > -	if (!HAS_GUC(dev_priv))
> > +	if (!USES_GUC(dev_priv))
> >   		return -ENODEV;
> > -	return intel_guc_log_control(&dev_priv->guc, val);
> > +	return intel_guc_log_control_set(&dev_priv->guc, val);
> >   }
> >   DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_control_fops,
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> > index 7b5074e2120c..22a05320817b 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.c
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> > @@ -657,52 +657,55 @@ void intel_guc_log_destroy(struct intel_guc *guc)
> >   	i915_vma_unpin_and_release(&guc->log.vma);
> >   }
> > -int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
> > +int intel_guc_log_control_get(struct intel_guc *guc)
> Should we be passing guc_log as parameter and implement guc_log_to_guc()
> function.

This is the top-level interface exported for GuC users. In other words - callers
of this function shouldn't have to know about struct guc_log (and the fact that
it's located inside struct intel_guc).

> > +{
> > +	GEM_BUG_ON(!guc->log.vma);
> > +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
> > +
> > +	return i915_modparams.guc_log_level;
> > +}
> > +
> > +#define GUC_LOG_IS_ENABLED(x)		(x > 0)
> > +#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
> This is bit misleading, can we make this macro return -1 if logging is to be
> disabled. That way guc_log_control can be invoked with
> single signed 32bit parameter.

Note that guc_log_control is the function operating directly on GuC interface.
This Host2GuC action really takes 3 arguments (2 parameters here) - enable,
default_logging_enable, verbosity.
As a consequence, I'd like to avoid placing any logic there. The macros are
taking care of translation from guc_log_level modparam to values understood by
GuC (host2guc params).

I agree that the naming is confusing here.
I'll go with LOG_LEVEL_TO_ENABLED(x) and LOG_LEVEL_TO_VERBOSITY(x) in second
spin as suggested by Michał.

> > +int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
> >   {
> >   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > -	bool enable_logging = control_val > 0;
> > -	u32 verbosity;
> >   	int ret;
> > -	if (!guc->log.vma)
> > -		return -ENODEV;
> > +	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
> > +	GEM_BUG_ON(!guc->log.vma);
> > +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
> > -	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN);
> > -	if (control_val > 1 + GUC_LOG_VERBOSITY_MAX)
> > +	/*
> > +	 * GuC is recognizing log levels starting from 0 to max, we're using 0
> > +	 * as indication that logging should be disablded.
> > +	 */
> > +	if (GUC_LOG_LEVEL_TO_VERBOSITY(val) < GUC_LOG_VERBOSITY_MIN ||
> This check seems unnecessary as we currently don't have negative output for
> G_L_L_T_V macro.
> If we add negative value there, will need to remove this check.

Yeah, agree. That's an error on my part, I wanted to do input validation here.
This should probably be something more like:
if (val < VERBOSITY_TO_LOG_LEVEL(GUC_LOG_VERBOSITY_MIN) ||
    val > VERBOSITY_TO_LOG_LEVEL(GUC_LOG_VERBOSITY_MAX))

-Michał

> > +	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
> >   		return -EINVAL;
> > -	/* This combination doesn't make sense & won't have any effect */
> > -	if (!enable_logging && !i915_modparams.guc_log_level)
> > -		return 0;
> > +	mutex_lock(&dev_priv->drm.struct_mutex);
> > -	verbosity = enable_logging ? control_val - 1 : 0;
> > +	if (i915_modparams.guc_log_level == val) {
> > +		ret = 0;
> > +		goto out_unlock;
> > +	}
> > -	ret = mutex_lock_interruptible(&dev_priv->drm.struct_mutex);
> > -	if (ret)
> > -		return ret;
> >   	intel_runtime_pm_get(dev_priv);
> > -	ret = guc_log_control(guc, enable_logging, verbosity);
> > +	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
> > +			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
> >   	intel_runtime_pm_put(dev_priv);
> > -	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +	if (ret)
> > +		goto out_unlock;
> > -	if (ret < 0) {
> > -		DRM_DEBUG_DRIVER("guc_logging_control action failed %d\n", ret);
> > -		return ret;
> > -	}
> > +	i915_modparams.guc_log_level = val;
> > -	if (enable_logging) {
> > -		i915_modparams.guc_log_level = 1 + verbosity;
> > +	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -		/*
> > -		 * If log was disabled at boot time, then the relay channel file
> > -		 * wouldn't have been created by now and interrupts also would
> > -		 * not have been enabled. Try again now, just in case.
> > -		 */
> > +	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
> >   		ret = guc_log_late_setup(guc);
> > -		if (ret < 0) {
> > -			DRM_DEBUG_DRIVER("GuC log late setup failed %d\n", ret);
> > -			return ret;
> > -		}
> > +		if (ret)
> > +			goto out;
> >   		/* GuC logging is currently the only user of Guc2Host interrupts */
> >   		mutex_lock(&dev_priv->drm.struct_mutex);
> > @@ -710,7 +713,7 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
> >   		gen9_enable_guc_interrupts(dev_priv);
> >   		intel_runtime_pm_put(dev_priv);
> >   		mutex_unlock(&dev_priv->drm.struct_mutex);
> > -	} else {
> > +	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
> >   		/*
> >   		 * Once logging is disabled, GuC won't generate logs & send an
> >   		 * interrupt. But there could be some data in the log buffer
> > @@ -718,11 +721,13 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
> >   		 * buffer state and then collect the left over logs.
> >   		 */
> >   		guc_flush_logs(guc);
> > -
> > -		/* As logging is disabled, update log level to reflect that */
> > -		i915_modparams.guc_log_level = 0;
> >   	}
> > +	return 0;
> > +
> > +out_unlock:
> > +	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +out:
> >   	return ret;
> >   }
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> > index dab0e949567a..141ce9ca22ce 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.h
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> > @@ -64,7 +64,8 @@ void intel_guc_log_destroy(struct intel_guc *guc);
> >   void intel_guc_log_init_early(struct intel_guc *guc);
> >   int intel_guc_log_relay_create(struct intel_guc *guc);
> >   void intel_guc_log_relay_destroy(struct intel_guc *guc);
> > -int intel_guc_log_control(struct intel_guc *guc, u64 control_val);
> > +int intel_guc_log_control_get(struct intel_guc *guc);
> > +int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
> >   void i915_guc_log_register(struct drm_i915_private *dev_priv);
> >   void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
> 
> -- 
> Thanks,
> Sagar
> 
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 01/15] drm/i915/guc: Tidy guc_log_control

[Sagar Arun Kamble]

On 3/2/2018 5:22 PM, Michał Winiarski wrote:
> On Fri, Mar 02, 2018 at 04:39:38PM +0530, Sagar Arun Kamble wrote:
>>
>> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
>>> We plan to decouple log runtime (mapping + relay) from verbosity control.
>>> Let's tidy the code now to reduce the churn in the following patches.
>>>
>>> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
>>> Cc: Chris Wilson <chris@chris-wilson.co.uk>
>>> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
>>> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
>>> ---
>>>    drivers/gpu/drm/i915/i915_debugfs.c  | 11 ++----
>>>    drivers/gpu/drm/i915/intel_guc_log.c | 75 +++++++++++++++++++-----------------
>>>    drivers/gpu/drm/i915/intel_guc_log.h |  3 +-
>>>    3 files changed, 46 insertions(+), 43 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
>>> index 33fbf3965309..58983cafaece 100644
>>> --- a/drivers/gpu/drm/i915/i915_debugfs.c
>>> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
>>> @@ -2500,13 +2500,10 @@ static int i915_guc_log_control_get(void *data, u64 *val)
>> Should we name this i915_guc_log_level_get instead? and other related
>> functions too?
> I chose symmetry here, note that the debugfs file is still named
> i915_guc_log_control at this point. This changes later in the series though.
>
>>>    {
>>>    	struct drm_i915_private *dev_priv = data;
>>> -	if (!HAS_GUC(dev_priv))
>>> +	if (!USES_GUC(dev_priv))
>>>    		return -ENODEV;
>>> -	if (!dev_priv->guc.log.vma)
>>> -		return -EINVAL;
>>> -
>>> -	*val = i915_modparams.guc_log_level;
>>> +	*val = intel_guc_log_control_get(&dev_priv->guc);
>>>    	return 0;
>>>    }
>>> @@ -2515,10 +2512,10 @@ static int i915_guc_log_control_set(void *data, u64 val)
>>>    {
>>>    	struct drm_i915_private *dev_priv = data;
>>> -	if (!HAS_GUC(dev_priv))
>>> +	if (!USES_GUC(dev_priv))
>>>    		return -ENODEV;
>>> -	return intel_guc_log_control(&dev_priv->guc, val);
>>> +	return intel_guc_log_control_set(&dev_priv->guc, val);
>>>    }
>>>    DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_control_fops,
>>> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
>>> index 7b5074e2120c..22a05320817b 100644
>>> --- a/drivers/gpu/drm/i915/intel_guc_log.c
>>> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
>>> @@ -657,52 +657,55 @@ void intel_guc_log_destroy(struct intel_guc *guc)
>>>    	i915_vma_unpin_and_release(&guc->log.vma);
>>>    }
>>> -int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
>>> +int intel_guc_log_control_get(struct intel_guc *guc)
>> Should we be passing guc_log as parameter and implement guc_log_to_guc()
>> function.
> This is the top-level interface exported for GuC users. In other words - callers
> of this function shouldn't have to know about struct guc_log (and the fact that
> it's located inside struct intel_guc).
>
>>> +{
>>> +	GEM_BUG_ON(!guc->log.vma);
>>> +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
>>> +
>>> +	return i915_modparams.guc_log_level;
>>> +}
>>> +
>>> +#define GUC_LOG_IS_ENABLED(x)		(x > 0)
>>> +#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
>> This is bit misleading, can we make this macro return -1 if logging is to be
>> disabled. That way guc_log_control can be invoked with
>> single signed 32bit parameter.
> Note that guc_log_control is the function operating directly on GuC interface.
> This Host2GuC action really takes 3 arguments (2 parameters here) - enable,
> default_logging_enable, verbosity.
> As a consequence, I'd like to avoid placing any logic there. The macros are
> taking care of translation from guc_log_level modparam to values understood by
> GuC (host2guc params).
>
> I agree that the naming is confusing here.
> I'll go with LOG_LEVEL_TO_ENABLED(x) and LOG_LEVEL_TO_VERBOSITY(x) in second
> spin as suggested by Michał.
>
>>> +int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>>>    {
>>>    	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> -	bool enable_logging = control_val > 0;
>>> -	u32 verbosity;
>>>    	int ret;
>>> -	if (!guc->log.vma)
>>> -		return -ENODEV;
>>> +	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
>>> +	GEM_BUG_ON(!guc->log.vma);
>>> +	GEM_BUG_ON(i915_modparams.guc_log_level < 0);
>>> -	BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN);
>>> -	if (control_val > 1 + GUC_LOG_VERBOSITY_MAX)
>>> +	/*
>>> +	 * GuC is recognizing log levels starting from 0 to max, we're using 0
>>> +	 * as indication that logging should be disablded.
>>> +	 */
>>> +	if (GUC_LOG_LEVEL_TO_VERBOSITY(val) < GUC_LOG_VERBOSITY_MIN ||
>> This check seems unnecessary as we currently don't have negative output for
>> G_L_L_T_V macro.
>> If we add negative value there, will need to remove this check.
> Yeah, agree. That's an error on my part, I wanted to do input validation here.
> This should probably be something more like:
> if (val < VERBOSITY_TO_LOG_LEVEL(GUC_LOG_VERBOSITY_MIN) ||
I think we should drop the min side check because val will never be 
negative and if we want to keep the check
then it  should be

#define GUC_LOG_LEVEL_DISABED    0
if (val < GUC_LOG_LEVEL_DISABLED) ||

Since we want to invoke guc_log_control to disable the logging.
>      val > VERBOSITY_TO_LOG_LEVEL(GUC_LOG_VERBOSITY_MAX))
>
> -Michał
>
>>> +	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
>>>    		return -EINVAL;
>>> -	/* This combination doesn't make sense & won't have any effect */
>>> -	if (!enable_logging && !i915_modparams.guc_log_level)
>>> -		return 0;
>>> +	mutex_lock(&dev_priv->drm.struct_mutex);
>>> -	verbosity = enable_logging ? control_val - 1 : 0;
>>> +	if (i915_modparams.guc_log_level == val) {
>>> +		ret = 0;
>>> +		goto out_unlock;
>>> +	}
>>> -	ret = mutex_lock_interruptible(&dev_priv->drm.struct_mutex);
>>> -	if (ret)
>>> -		return ret;
>>>    	intel_runtime_pm_get(dev_priv);
>>> -	ret = guc_log_control(guc, enable_logging, verbosity);
>>> +	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
>>> +			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
>>>    	intel_runtime_pm_put(dev_priv);
>>> -	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +	if (ret)
>>> +		goto out_unlock;
>>> -	if (ret < 0) {
>>> -		DRM_DEBUG_DRIVER("guc_logging_control action failed %d\n", ret);
>>> -		return ret;
>>> -	}
>>> +	i915_modparams.guc_log_level = val;
>>> -	if (enable_logging) {
>>> -		i915_modparams.guc_log_level = 1 + verbosity;
>>> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -		/*
>>> -		 * If log was disabled at boot time, then the relay channel file
>>> -		 * wouldn't have been created by now and interrupts also would
>>> -		 * not have been enabled. Try again now, just in case.
>>> -		 */
>>> +	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
>>>    		ret = guc_log_late_setup(guc);
>>> -		if (ret < 0) {
>>> -			DRM_DEBUG_DRIVER("GuC log late setup failed %d\n", ret);
>>> -			return ret;
>>> -		}
>>> +		if (ret)
>>> +			goto out;
>>>    		/* GuC logging is currently the only user of Guc2Host interrupts */
>>>    		mutex_lock(&dev_priv->drm.struct_mutex);
>>> @@ -710,7 +713,7 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
>>>    		gen9_enable_guc_interrupts(dev_priv);
>>>    		intel_runtime_pm_put(dev_priv);
>>>    		mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -	} else {
>>> +	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
>>>    		/*
>>>    		 * Once logging is disabled, GuC won't generate logs & send an
>>>    		 * interrupt. But there could be some data in the log buffer
>>> @@ -718,11 +721,13 @@ int intel_guc_log_control(struct intel_guc *guc, u64 control_val)
>>>    		 * buffer state and then collect the left over logs.
>>>    		 */
>>>    		guc_flush_logs(guc);
>>> -
>>> -		/* As logging is disabled, update log level to reflect that */
>>> -		i915_modparams.guc_log_level = 0;
>>>    	}
>>> +	return 0;
>>> +
>>> +out_unlock:
>>> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +out:
>>>    	return ret;
>>>    }
>>> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
>>> index dab0e949567a..141ce9ca22ce 100644
>>> --- a/drivers/gpu/drm/i915/intel_guc_log.h
>>> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
>>> @@ -64,7 +64,8 @@ void intel_guc_log_destroy(struct intel_guc *guc);
>>>    void intel_guc_log_init_early(struct intel_guc *guc);
>>>    int intel_guc_log_relay_create(struct intel_guc *guc);
>>>    void intel_guc_log_relay_destroy(struct intel_guc *guc);
>>> -int intel_guc_log_control(struct intel_guc *guc, u64 control_val);
>>> +int intel_guc_log_control_get(struct intel_guc *guc);
>>> +int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
>>>    void i915_guc_log_register(struct drm_i915_private *dev_priv);
>>>    void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
>> -- 
>> Thanks,
>> Sagar
>>

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 02/15] drm/i915/guc: Create common entry points for log register/unregister

[Sagar Arun Kamble]

Overall change looks good. Could you please clarify on below:

intel_uc_log_register|unregister are removed in patch later in the 
series. Should we just stay with inner functions then to minimize changes?


Thanks
Sagar

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> We have many functions responsible for allocating different parts of
> runtime called from multiple places. Let's stick with keeping
> everything in guc_log_register instead.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_drv.c      |   6 +-
>   drivers/gpu/drm/i915/i915_gem.c      |   4 +-
>   drivers/gpu/drm/i915/intel_guc_log.c | 148 ++++++++++++++---------------------
>   drivers/gpu/drm/i915/intel_guc_log.h |   6 +-
>   drivers/gpu/drm/i915/intel_uc.c      |  39 ++++-----
>   drivers/gpu/drm/i915/intel_uc.h      |   6 +-
>   6 files changed, 91 insertions(+), 118 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
> index aaa861b51024..719b2be73292 100644
> --- a/drivers/gpu/drm/i915/i915_drv.c
> +++ b/drivers/gpu/drm/i915/i915_drv.c
> @@ -636,7 +636,7 @@ static void i915_gem_fini(struct drm_i915_private *dev_priv)
>   	i915_gem_contexts_fini(dev_priv);
>   	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
> -	intel_uc_fini_misc(dev_priv);
> +	intel_uc_fini_wq(dev_priv);
>   	i915_gem_cleanup_userptr(dev_priv);
>   
>   	i915_gem_drain_freed_objects(dev_priv);
> @@ -1237,7 +1237,7 @@ static void i915_driver_register(struct drm_i915_private *dev_priv)
>   	/* Reveal our presence to userspace */
>   	if (drm_dev_register(dev, 0) == 0) {
>   		i915_debugfs_register(dev_priv);
> -		i915_guc_log_register(dev_priv);
> +		intel_uc_log_register(dev_priv);
>   		i915_setup_sysfs(dev_priv);
>   
>   		/* Depends on sysfs having been initialized */
> @@ -1297,7 +1297,7 @@ static void i915_driver_unregister(struct drm_i915_private *dev_priv)
>   	i915_pmu_unregister(dev_priv);
>   
>   	i915_teardown_sysfs(dev_priv);
> -	i915_guc_log_unregister(dev_priv);
> +	intel_uc_log_unregister(dev_priv);
>   	drm_dev_unregister(&dev_priv->drm);
>   
>   	i915_gem_shrinker_unregister(dev_priv);
> diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
> index 14c855b1a3a4..4bf5f25b29e2 100644
> --- a/drivers/gpu/drm/i915/i915_gem.c
> +++ b/drivers/gpu/drm/i915/i915_gem.c
> @@ -5279,7 +5279,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
>   	if (ret)
>   		return ret;
>   
> -	ret = intel_uc_init_misc(dev_priv);
> +	ret = intel_uc_init_wq(dev_priv);
>   	if (ret)
>   		return ret;
>   
> @@ -5375,7 +5375,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
>   	intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
>   	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
> -	intel_uc_fini_misc(dev_priv);
> +	intel_uc_fini_wq(dev_priv);
>   
>   	if (ret != -EIO)
>   		i915_gem_cleanup_userptr(dev_priv);
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index 22a05320817b..f1cab43d334e 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -441,7 +441,7 @@ void intel_guc_log_init_early(struct intel_guc *guc)
>   	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
>   }
>   
> -int intel_guc_log_relay_create(struct intel_guc *guc)
> +int guc_log_relay_create(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>   	struct rchan *guc_log_relay_chan;
> @@ -494,7 +494,7 @@ int intel_guc_log_relay_create(struct intel_guc *guc)
>   	return ret;
>   }
>   
> -void intel_guc_log_relay_destroy(struct intel_guc *guc)
> +void guc_log_relay_destroy(struct intel_guc *guc)
>   {
>   	mutex_lock(&guc->log.runtime.relay_lock);
>   
> @@ -512,49 +512,6 @@ void intel_guc_log_relay_destroy(struct intel_guc *guc)
>   	mutex_unlock(&guc->log.runtime.relay_lock);
>   }
>   
> -static int guc_log_late_setup(struct intel_guc *guc)
> -{
> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	int ret;
> -
> -	if (!guc_log_has_runtime(guc)) {
> -		/*
> -		 * If log was disabled at boot time, then setup needed to handle
> -		 * log buffer flush interrupts would not have been done yet, so
> -		 * do that now.
> -		 */
> -		ret = intel_guc_log_relay_create(guc);
> -		if (ret)
> -			goto err;
> -
> -		mutex_lock(&dev_priv->drm.struct_mutex);
> -		intel_runtime_pm_get(dev_priv);
> -		ret = guc_log_runtime_create(guc);
> -		intel_runtime_pm_put(dev_priv);
> -		mutex_unlock(&dev_priv->drm.struct_mutex);
> -
> -		if (ret)
> -			goto err_relay;
> -	}
> -
> -	ret = guc_log_relay_file_create(guc);
> -	if (ret)
> -		goto err_runtime;
> -
> -	return 0;
> -
> -err_runtime:
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	guc_log_runtime_destroy(guc);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> -err_relay:
> -	intel_guc_log_relay_destroy(guc);
> -err:
> -	/* logging will remain off */
> -	i915_modparams.guc_log_level = 0;
> -	return ret;
> -}
> -
>   static void guc_log_capture_logs(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> @@ -574,16 +531,6 @@ static void guc_flush_logs(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>   
> -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
> -		return;
> -
> -	/* First disable the interrupts, will be renabled afterwards */
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	intel_runtime_pm_get(dev_priv);
> -	gen9_disable_guc_interrupts(dev_priv);
> -	intel_runtime_pm_put(dev_priv);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> -
>   	/*
>   	 * Before initiating the forceful flush, wait for any pending/ongoing
>   	 * flush to complete otherwise forceful flush may not actually happen.
> @@ -626,12 +573,6 @@ int intel_guc_log_create(struct intel_guc *guc)
>   
>   	guc->log.vma = vma;
>   
> -	if (i915_modparams.guc_log_level) {
> -		ret = guc_log_runtime_create(guc);
> -		if (ret < 0)
> -			goto err_vma;
> -	}
> -
>   	/* each allocated unit is a page */
>   	flags = GUC_LOG_VALID | GUC_LOG_NOTIFY_ON_HALF_FULL |
>   		(GUC_LOG_DPC_PAGES << GUC_LOG_DPC_SHIFT) |
> @@ -643,8 +584,6 @@ int intel_guc_log_create(struct intel_guc *guc)
>   
>   	return 0;
>   
> -err_vma:
> -	i915_vma_unpin_and_release(&guc->log.vma);
>   err:
>   	/* logging will be off */
>   	i915_modparams.guc_log_level = 0;
> @@ -703,24 +642,14 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>   	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
>   	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
> -		ret = guc_log_late_setup(guc);
> -		if (ret)
> +		ret = intel_guc_log_register(guc);
> +		if (ret) {
> +			/* logging will remain off */
> +			i915_modparams.guc_log_level = 0;
>   			goto out;
> -
> -		/* GuC logging is currently the only user of Guc2Host interrupts */
> -		mutex_lock(&dev_priv->drm.struct_mutex);
> -		intel_runtime_pm_get(dev_priv);
> -		gen9_enable_guc_interrupts(dev_priv);
> -		intel_runtime_pm_put(dev_priv);
> -		mutex_unlock(&dev_priv->drm.struct_mutex);
> +		}
>   	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
> -		/*
> -		 * Once logging is disabled, GuC won't generate logs & send an
> -		 * interrupt. But there could be some data in the log buffer
> -		 * which is yet to be captured. So request GuC to update the log
> -		 * buffer state and then collect the left over logs.
> -		 */
> -		guc_flush_logs(guc);
> +		intel_guc_log_unregister(guc);
>   	}
>   
>   	return 0;
> @@ -731,20 +660,63 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>   	return ret;
>   }
>   
> -void i915_guc_log_register(struct drm_i915_private *dev_priv)
> +int intel_guc_log_register(struct intel_guc *guc)
>   {
> -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
> -		return;
> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> +	int ret;
> +
> +	GEM_BUG_ON(guc_log_has_runtime(guc));
> +
> +	/*
> +	 * If log was disabled at boot time, then setup needed to handle
> +	 * log buffer flush interrupts would not have been done yet, so
> +	 * do that now.
> +	 */
> +	ret = guc_log_relay_create(guc);
> +	if (ret)
> +		goto err;
> +
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> +	ret = guc_log_runtime_create(guc);
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +
> +	if (ret)
> +		goto err_relay;
> +
> +	ret = guc_log_relay_file_create(guc);
> +	if (ret)
> +		goto err_runtime;
>   
> -	guc_log_late_setup(&dev_priv->guc);
> +	/* GuC logging is currently the only user of Guc2Host interrupts */
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> +	intel_runtime_pm_get(dev_priv);
> +	gen9_enable_guc_interrupts(dev_priv);
> +	intel_runtime_pm_put(dev_priv);
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +
> +	return 0;
> +
> +err_runtime:
> +	mutex_lock(&dev_priv->drm.struct_mutex);
> +	guc_log_runtime_destroy(guc);
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
> +err_relay:
> +	guc_log_relay_destroy(guc);
> +err:
> +	return ret;
>   }
>   
> -void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
> +void intel_guc_log_unregister(struct intel_guc *guc)
>   {
> -	struct intel_guc *guc = &dev_priv->guc;
> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>   
> -	if (!USES_GUC_SUBMISSION(dev_priv))
> -		return;
> +	/*
> +	 * Once logging is disabled, GuC won't generate logs & send an
> +	 * interrupt. But there could be some data in the log buffer
> +	 * which is yet to be captured. So request GuC to update the log
> +	 * buffer state and then collect the left over logs.
> +	 */
> +	guc_flush_logs(guc);
>   
>   	mutex_lock(&dev_priv->drm.struct_mutex);
>   	/* GuC logging is currently the only user of Guc2Host interrupts */
> @@ -755,5 +727,5 @@ void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
>   	guc_log_runtime_destroy(guc);
>   	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
> -	intel_guc_log_relay_destroy(guc);
> +	guc_log_relay_destroy(guc);
>   }
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index 141ce9ca22ce..09dd2ef1933d 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -62,11 +62,9 @@ struct intel_guc_log {
>   int intel_guc_log_create(struct intel_guc *guc);
>   void intel_guc_log_destroy(struct intel_guc *guc);
>   void intel_guc_log_init_early(struct intel_guc *guc);
> -int intel_guc_log_relay_create(struct intel_guc *guc);
> -void intel_guc_log_relay_destroy(struct intel_guc *guc);
>   int intel_guc_log_control_get(struct intel_guc *guc);
>   int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
> -void i915_guc_log_register(struct drm_i915_private *dev_priv);
> -void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
> +int intel_guc_log_register(struct intel_guc *guc);
> +void intel_guc_log_unregister(struct intel_guc *guc);
>   
>   #endif
> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> index 9f1bac6398fb..3f41ef525e26 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -219,6 +219,22 @@ static void guc_free_load_err_log(struct intel_guc *guc)
>   		i915_gem_object_put(guc->load_err_log);
>   }
>   
> +int intel_uc_log_register(struct drm_i915_private *dev_priv)
> +{
> +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +		return 0;
> +
> +	return intel_guc_log_register(&dev_priv->guc);
> +}
> +
> +void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
> +{
> +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +		return;
> +
> +	intel_guc_log_unregister(&dev_priv->guc);
> +}
> +
>   static int guc_enable_communication(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> @@ -240,7 +256,7 @@ static void guc_disable_communication(struct intel_guc *guc)
>   	guc->send = intel_guc_send_nop;
>   }
>   
> -int intel_uc_init_misc(struct drm_i915_private *dev_priv)
> +int intel_uc_init_wq(struct drm_i915_private *dev_priv)
>   {
>   	struct intel_guc *guc = &dev_priv->guc;
>   	int ret;
> @@ -249,26 +265,13 @@ int intel_uc_init_misc(struct drm_i915_private *dev_priv)
>   		return 0;
>   
>   	ret = intel_guc_init_wq(guc);
> -	if (ret) {
> -		DRM_ERROR("Couldn't allocate workqueues for GuC\n");
> -		goto err;
> -	}
> -
> -	ret = intel_guc_log_relay_create(guc);
> -	if (ret) {
> -		DRM_ERROR("Couldn't allocate relay for GuC log\n");
> -		goto err_relay;
> -	}
> +	if (ret)
> +		return ret;
>   
>   	return 0;
> -
> -err_relay:
> -	intel_guc_fini_wq(guc);
> -err:
> -	return ret;
>   }
>   
> -void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
> +void intel_uc_fini_wq(struct drm_i915_private *dev_priv)
>   {
>   	struct intel_guc *guc = &dev_priv->guc;
>   
> @@ -276,8 +279,6 @@ void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
>   		return;
>   
>   	intel_guc_fini_wq(guc);
> -
> -	intel_guc_log_relay_destroy(guc);
>   }
>   
>   int intel_uc_init(struct drm_i915_private *dev_priv)
> diff --git a/drivers/gpu/drm/i915/intel_uc.h b/drivers/gpu/drm/i915/intel_uc.h
> index f2984e01e257..9bc22103396d 100644
> --- a/drivers/gpu/drm/i915/intel_uc.h
> +++ b/drivers/gpu/drm/i915/intel_uc.h
> @@ -31,10 +31,12 @@
>   void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
>   void intel_uc_init_early(struct drm_i915_private *dev_priv);
>   void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
> +int intel_uc_log_register(struct drm_i915_private *dev_priv);
> +void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
>   void intel_uc_init_fw(struct drm_i915_private *dev_priv);
>   void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
> -int intel_uc_init_misc(struct drm_i915_private *dev_priv);
> -void intel_uc_fini_misc(struct drm_i915_private *dev_priv);
> +int intel_uc_init_wq(struct drm_i915_private *dev_priv);
> +void intel_uc_fini_wq(struct drm_i915_private *dev_priv);
>   int intel_uc_init_hw(struct drm_i915_private *dev_priv);
>   void intel_uc_fini_hw(struct drm_i915_private *dev_priv);
>   int intel_uc_init(struct drm_i915_private *dev_priv);

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 03/15] drm/i915/guc: Move GuC notification handling to separate function

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> From: Michal Wajdeczko <michal.wajdeczko@intel.com>
>
> To allow future code reuse. While here, fix comment style.
>
> Suggested-by: Oscar Mateo <oscar.mateo@intel.com>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Oscar Mateo <oscar.mateo@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_irq.c  | 33 ++-------------------------------
>   drivers/gpu/drm/i915/intel_guc.c | 37 +++++++++++++++++++++++++++++++++++++
>   drivers/gpu/drm/i915/intel_guc.h |  1 +
>   3 files changed, 40 insertions(+), 31 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
> index 0a7ed990a8d1..023ba897e991 100644
> --- a/drivers/gpu/drm/i915/i915_irq.c
> +++ b/drivers/gpu/drm/i915/i915_irq.c
> @@ -1759,37 +1759,8 @@ static void gen6_rps_irq_handler(struct drm_i915_private *dev_priv, u32 pm_iir)
>   
>   static void gen9_guc_irq_handler(struct drm_i915_private *dev_priv, u32 gt_iir)
>   {
> -	if (gt_iir & GEN9_GUC_TO_HOST_INT_EVENT) {
> -		/* Sample the log buffer flush related bits & clear them out now
> -		 * itself from the message identity register to minimize the
> -		 * probability of losing a flush interrupt, when there are back
> -		 * to back flush interrupts.
> -		 * There can be a new flush interrupt, for different log buffer
> -		 * type (like for ISR), whilst Host is handling one (for DPC).
> -		 * Since same bit is used in message register for ISR & DPC, it
> -		 * could happen that GuC sets the bit for 2nd interrupt but Host
> -		 * clears out the bit on handling the 1st interrupt.
> -		 */
> -		u32 msg, flush;
> -
> -		msg = I915_READ(SOFT_SCRATCH(15));
> -		flush = msg & (INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED |
> -			       INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER);
> -		if (flush) {
> -			/* Clear the message bits that are handled */
> -			I915_WRITE(SOFT_SCRATCH(15), msg & ~flush);
> -
> -			/* Handle flush interrupt in bottom half */
> -			queue_work(dev_priv->guc.log.runtime.flush_wq,
> -				   &dev_priv->guc.log.runtime.flush_work);
> -
> -			dev_priv->guc.log.flush_interrupt_count++;
> -		} else {
> -			/* Not clearing of unhandled event bits won't result in
> -			 * re-triggering of the interrupt.
> -			 */
> -		}
> -	}
> +	if (gt_iir & GEN9_GUC_TO_HOST_INT_EVENT)
> +		intel_guc_notification_handler(&dev_priv->guc);
There is GUC_NOTIFICATION_EVENT (which seems to be unused though) event 
whose name matches with proposed function name to some extent.
I think  we should change the name to "intel_guc_g2h_int_handler" or 
some other. Other events too are kind of notification to host.
Otherwise change looks good.
>   }
>   
>   static void i9xx_pipestat_irq_reset(struct drm_i915_private *dev_priv)
> diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> index 21140ccd7a97..f622dd6009b6 100644
> --- a/drivers/gpu/drm/i915/intel_guc.c
> +++ b/drivers/gpu/drm/i915/intel_guc.c
> @@ -364,6 +364,43 @@ int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len)
>   	return ret;
>   }
>   
> +void intel_guc_notification_handler(struct intel_guc *guc)
> +{
> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> +	u32 msg, flush;
> +
> +	/*
> +	 * Sample the log buffer flush related bits & clear them out now
> +	 * itself from the message identity register to minimize the
> +	 * probability of losing a flush interrupt, when there are back
> +	 * to back flush interrupts.
> +	 * There can be a new flush interrupt, for different log buffer
> +	 * type (like for ISR), whilst Host is handling one (for DPC).
> +	 * Since same bit is used in message register for ISR & DPC, it
> +	 * could happen that GuC sets the bit for 2nd interrupt but Host
> +	 * clears out the bit on handling the 1st interrupt.
> +	 */
> +
> +	msg = I915_READ(SOFT_SCRATCH(15));
> +	flush = msg & (INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED |
> +		       INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER);
> +	if (flush) {
> +		/* Clear the message bits that are handled */
> +		I915_WRITE(SOFT_SCRATCH(15), msg & ~flush);
> +
> +		/* Handle flush interrupt in bottom half */
> +		queue_work(guc->log.runtime.flush_wq,
> +			   &guc->log.runtime.flush_work);
> +
> +		guc->log.flush_interrupt_count++;
> +	} else {
> +		/*
> +		 * Not clearing of unhandled event bits won't result in
> +		 * re-triggering of the interrupt.
> +		 */
> +	}
> +}
> +
>   int intel_guc_sample_forcewake(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> diff --git a/drivers/gpu/drm/i915/intel_guc.h b/drivers/gpu/drm/i915/intel_guc.h
> index 52856a97477d..5b905bae181d 100644
> --- a/drivers/gpu/drm/i915/intel_guc.h
> +++ b/drivers/gpu/drm/i915/intel_guc.h
> @@ -125,6 +125,7 @@ int intel_guc_init(struct intel_guc *guc);
>   void intel_guc_fini(struct intel_guc *guc);
>   int intel_guc_send_nop(struct intel_guc *guc, const u32 *action, u32 len);
>   int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len);
> +void intel_guc_notification_handler(struct intel_guc *guc);
>   int intel_guc_sample_forcewake(struct intel_guc *guc);
>   int intel_guc_auth_huc(struct intel_guc *guc, u32 rsa_offset);
>   int intel_guc_suspend(struct drm_i915_private *dev_priv);

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 04/15] drm/i915/guc: Keep GuC interrupts enabled when using GuC

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> The GuC log contains a separate space used for crash dump.
> We even get a separate notification for it. While we're not handling
> crash differently yet, it makes sense to decouple the two right now to
> simplify the following patches.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/intel_guc.c     | 28 +++++++++++-----------------
>   drivers/gpu/drm/i915/intel_guc.h     |  2 ++
>   drivers/gpu/drm/i915/intel_guc_log.c | 29 ++++++++++++++++++-----------
>   drivers/gpu/drm/i915/intel_uc.c      | 14 +++++---------
>   4 files changed, 36 insertions(+), 37 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> index f622dd6009b6..41f2c3b3c482 100644
> --- a/drivers/gpu/drm/i915/intel_guc.c
> +++ b/drivers/gpu/drm/i915/intel_guc.c
> @@ -67,6 +67,7 @@ void intel_guc_init_early(struct intel_guc *guc)
>   	intel_guc_log_init_early(guc);
>   
>   	mutex_init(&guc->send_mutex);
> +	spin_lock_init(&guc->irq_lock);
>   	guc->send = intel_guc_send_nop;
>   	guc->notify = gen8_guc_raise_irq;
>   }
> @@ -367,7 +368,7 @@ int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len)
>   void intel_guc_notification_handler(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	u32 msg, flush;
> +	u32 msg, val;
>   
>   	/*
>   	 * Sample the log buffer flush related bits & clear them out now
> @@ -380,24 +381,18 @@ void intel_guc_notification_handler(struct intel_guc *guc)
>   	 * could happen that GuC sets the bit for 2nd interrupt but Host
>   	 * clears out the bit on handling the 1st interrupt.
>   	 */
> -
> -	msg = I915_READ(SOFT_SCRATCH(15));
> -	flush = msg & (INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED |
> -		       INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER);
> -	if (flush) {
> -		/* Clear the message bits that are handled */
> -		I915_WRITE(SOFT_SCRATCH(15), msg & ~flush);
> -
> -		/* Handle flush interrupt in bottom half */
> +	spin_lock(&guc->irq_lock);
> +	val = I915_READ(SOFT_SCRATCH(15));
> +	msg = val & guc->msg_enabled_mask;
> +	I915_WRITE(SOFT_SCRATCH(15), val & ~msg);
> +	spin_unlock(&guc->irq_lock);
> +
> +	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
> +		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
>   		queue_work(guc->log.runtime.flush_wq,
>   			   &guc->log.runtime.flush_work);
>   
>   		guc->log.flush_interrupt_count++;
> -	} else {
> -		/*
> -		 * Not clearing of unhandled event bits won't result in
> -		 * re-triggering of the interrupt.
> -		 */
>   	}
>   }
>   
> @@ -495,8 +490,7 @@ int intel_guc_resume(struct drm_i915_private *dev_priv)
>   	if (guc->fw.load_status != INTEL_UC_FIRMWARE_SUCCESS)
>   		return 0;
>   
> -	if (i915_modparams.guc_log_level)
> -		gen9_enable_guc_interrupts(dev_priv);
> +	gen9_enable_guc_interrupts(dev_priv);
>   
>   	data[0] = INTEL_GUC_ACTION_EXIT_S_STATE;
>   	data[1] = GUC_POWER_D0;
> diff --git a/drivers/gpu/drm/i915/intel_guc.h b/drivers/gpu/drm/i915/intel_guc.h
> index 5b905bae181d..d629bc5d5c0f 100644
> --- a/drivers/gpu/drm/i915/intel_guc.h
> +++ b/drivers/gpu/drm/i915/intel_guc.h
> @@ -53,7 +53,9 @@ struct intel_guc {
>   	struct drm_i915_gem_object *load_err_log;
>   
>   	/* intel_guc_recv interrupt related state */
> +	spinlock_t irq_lock;
>   	bool interrupts_enabled;
> +	unsigned int msg_enabled_mask;
>   
>   	struct i915_vma *ads_vma;
>   	struct i915_vma *stage_desc_pool;
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index f1cab43d334e..09be7340652b 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -590,6 +590,22 @@ int intel_guc_log_create(struct intel_guc *guc)
>   	return ret;
>   }
>   
> +static void guc_log_flush_irq_enable(struct intel_guc *guc)
> +{
> +	spin_lock_irq(&guc->irq_lock);
> +	guc->msg_enabled_mask |= INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
> +				 INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED;
> +	spin_unlock_irq(&guc->irq_lock);
> +}
> +
> +static void guc_log_flush_irq_disable(struct intel_guc *guc)
> +{
> +	spin_lock_irq(&guc->irq_lock);
> +	guc->msg_enabled_mask &= ~(INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
> +				   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED);
> +	spin_unlock_irq(&guc->irq_lock);
> +}
> +
>   void intel_guc_log_destroy(struct intel_guc *guc)
>   {
>   	guc_log_runtime_destroy(guc);
> @@ -687,12 +703,7 @@ int intel_guc_log_register(struct intel_guc *guc)
>   	if (ret)
>   		goto err_runtime;
>   
> -	/* GuC logging is currently the only user of Guc2Host interrupts */
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	intel_runtime_pm_get(dev_priv);
> -	gen9_enable_guc_interrupts(dev_priv);
> -	intel_runtime_pm_put(dev_priv);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> +	guc_log_flush_irq_enable(guc);
>   
>   	return 0;
>   
> @@ -717,13 +728,9 @@ void intel_guc_log_unregister(struct intel_guc *guc)
>   	 * buffer state and then collect the left over logs.
>   	 */
>   	guc_flush_logs(guc);
> +	guc_log_flush_irq_disable(guc);
>   
>   	mutex_lock(&dev_priv->drm.struct_mutex);
> -	/* GuC logging is currently the only user of Guc2Host interrupts */
> -	intel_runtime_pm_get(dev_priv);
> -	gen9_disable_guc_interrupts(dev_priv);
> -	intel_runtime_pm_put(dev_priv);
> -
>   	guc_log_runtime_destroy(guc);
>   	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> index 3f41ef525e26..e9aba3c35264 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -239,6 +239,8 @@ static int guc_enable_communication(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>   
> +	gen9_enable_guc_interrupts(dev_priv);
> +
>   	if (HAS_GUC_CT(dev_priv))
>   		return intel_guc_enable_ct(guc);
>   
> @@ -253,6 +255,8 @@ static void guc_disable_communication(struct intel_guc *guc)
>   	if (HAS_GUC_CT(dev_priv))
>   		intel_guc_disable_ct(guc);
>   
> +	gen9_disable_guc_interrupts(dev_priv);
> +
>   	guc->send = intel_guc_send_nop;
>   }
>   
> @@ -391,12 +395,9 @@ int intel_uc_init_hw(struct drm_i915_private *dev_priv)
>   	}
>   
>   	if (USES_GUC_SUBMISSION(dev_priv)) {
> -		if (i915_modparams.guc_log_level)
> -			gen9_enable_guc_interrupts(dev_priv);
> -
>   		ret = intel_guc_submission_enable(guc);
>   		if (ret)
> -			goto err_interrupts;
> +			goto err_communication;
>   	}
>   
>   	dev_info(dev_priv->drm.dev, "GuC firmware version %u.%u\n",
> @@ -411,8 +412,6 @@ int intel_uc_init_hw(struct drm_i915_private *dev_priv)
>   	/*
>   	 * We've failed to load the firmware :(
>   	 */
> -err_interrupts:
> -	gen9_disable_guc_interrupts(dev_priv);
>   err_communication:
>   	guc_disable_communication(guc);
>   err_log_capture:
> @@ -442,7 +441,4 @@ void intel_uc_fini_hw(struct drm_i915_private *dev_priv)
>   		intel_guc_submission_disable(guc);
>   
>   	guc_disable_communication(guc);
> -
> -	if (USES_GUC_SUBMISSION(dev_priv))
> -		gen9_disable_guc_interrupts(dev_priv);
>   }

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 05/15] drm/i915/guc: Log runtime should consist of both mapping and relay

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> Currently, we're treating relay and mapping of GuC log as a separate
> concepts. We're also using inconsistent locking, sometimes using
> relay_lock, sometimes using struct mutex.
> Let's correct that. Anything touching the runtime is now serialized
> using runtime.lock, while we're still using struct mutex as inner lock
> for mapping.
> We're still racy in setting the log level - but we'll take care of that
> in the following patches.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
>   drivers/gpu/drm/i915/intel_guc_log.c | 110 ++++++++++-------------------------
>   drivers/gpu/drm/i915/intel_guc_log.h |   3 +-
>   drivers/gpu/drm/i915/intel_uc.c      |  14 +++--
>   3 files changed, 42 insertions(+), 85 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index 09be7340652b..567620464f52 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -153,10 +153,7 @@ static int guc_log_relay_file_create(struct intel_guc *guc)
>   	struct dentry *log_dir;
>   	int ret;
>   
> -	if (!i915_modparams.guc_log_level)
> -		return 0;
> -
> -	mutex_lock(&guc->log.runtime.relay_lock);
> +	lockdep_assert_held(&guc->log.runtime.lock);
>   
>   	/* For now create the log file in /sys/kernel/debug/dri/0 dir */
>   	log_dir = dev_priv->drm.primary->debugfs_root;
> @@ -175,28 +172,16 @@ static int guc_log_relay_file_create(struct intel_guc *guc)
>   	 */
>   	if (!log_dir) {
>   		DRM_ERROR("Debugfs dir not available yet for GuC log file\n");
> -		ret = -ENODEV;
> -		goto out_unlock;
> +		return -ENODEV;
>   	}
>   
>   	ret = relay_late_setup_files(guc->log.runtime.relay_chan, "guc_log", log_dir);
>   	if (ret < 0 && ret != -EEXIST) {
>   		DRM_ERROR("Couldn't associate relay chan with file %d\n", ret);
> -		goto out_unlock;
> +		return ret;
>   	}
>   
> -	ret = 0;
> -
> -out_unlock:
> -	mutex_unlock(&guc->log.runtime.relay_lock);
> -	return ret;
> -}
> -
> -static bool guc_log_has_relay(struct intel_guc *guc)
> -{
> -	lockdep_assert_held(&guc->log.runtime.relay_lock);
> -
> -	return guc->log.runtime.relay_chan != NULL;
> +	return 0;
>   }
>   
>   static void guc_move_to_next_buf(struct intel_guc *guc)
> @@ -207,9 +192,6 @@ static void guc_move_to_next_buf(struct intel_guc *guc)
>   	 */
>   	smp_wmb();
>   
> -	if (!guc_log_has_relay(guc))
> -		return;
> -
>   	/* All data has been written, so now move the offset of sub buffer. */
>   	relay_reserve(guc->log.runtime.relay_chan, guc->log.vma->obj->base.size);
>   
> @@ -219,9 +201,6 @@ static void guc_move_to_next_buf(struct intel_guc *guc)
>   
>   static void *guc_get_write_buffer(struct intel_guc *guc)
>   {
> -	if (!guc_log_has_relay(guc))
> -		return NULL;
> -
>   	/*
>   	 * Just get the base address of a new sub buffer and copy data into it
>   	 * ourselves. NULL will be returned in no-overwrite mode, if all sub
> @@ -288,7 +267,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   	/* Get the pointer to shared GuC log buffer */
>   	log_buf_state = src_data = guc->log.runtime.buf_addr;
>   
> -	mutex_lock(&guc->log.runtime.relay_lock);
>   
>   	/* Get the pointer to local buffer to store the logs */
>   	log_buf_snapshot_state = dst_data = guc_get_write_buffer(guc);
> @@ -300,7 +278,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   		 */
>   		DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
>   		guc->log.capture_miss_count++;
> -		mutex_unlock(&guc->log.runtime.relay_lock);
>   
>   		return;
>   	}
> @@ -372,8 +349,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   	}
>   
>   	guc_move_to_next_buf(guc);
> -
> -	mutex_unlock(&guc->log.runtime.relay_lock);
>   }
>   
>   static void capture_logs_work(struct work_struct *work)
> @@ -381,7 +356,9 @@ static void capture_logs_work(struct work_struct *work)
>   	struct intel_guc *guc =
>   		container_of(work, struct intel_guc, log.runtime.flush_work);
>   
> +	mutex_lock(&guc->log.runtime.lock);
>   	guc_log_capture_logs(guc);
I think we should just lock guc_read_update_log_buffer as 
guc_log_flush_complete is independent action
> +	mutex_unlock(&guc->log.runtime.lock);
>   }
>   
>   static bool guc_log_has_runtime(struct intel_guc *guc)
> @@ -389,19 +366,16 @@ static bool guc_log_has_runtime(struct intel_guc *guc)
>   	return guc->log.runtime.buf_addr != NULL;
>   }
>   
> -static int guc_log_runtime_create(struct intel_guc *guc)
> +static int guc_log_map(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>   	void *vaddr;
>   	int ret;
>   
> -	lockdep_assert_held(&dev_priv->drm.struct_mutex);
> -
lockdep_assert for runtime.lock here?
>   	if (!guc->log.vma)
>   		return -ENODEV;
>   
> -	GEM_BUG_ON(guc_log_has_runtime(guc));
> -
> +	mutex_lock(&dev_priv->drm.struct_mutex);
>   	ret = i915_gem_object_set_to_wc_domain(guc->log.vma->obj, true);
>   	if (ret)
mutex not unlocked
>   		return ret;
> @@ -416,20 +390,16 @@ static int guc_log_runtime_create(struct intel_guc *guc)
>   		DRM_ERROR("Couldn't map log buffer pages %d\n", ret);
mutex not unlocked
>   		return PTR_ERR(vaddr);
>   	}
> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
>   	guc->log.runtime.buf_addr = vaddr;
>   
>   	return 0;
>   }
>   
> -static void guc_log_runtime_destroy(struct intel_guc *guc)
> +static void guc_log_unmap(struct intel_guc *guc)
>   {
> -	/*
> -	 * It's possible that the runtime stuff was never allocated because
> -	 * GuC log was disabled at the boot time.
> -	 */
> -	if (!guc_log_has_runtime(guc))
> -		return;
> +	lockdep_assert_held(&guc->log.runtime.lock);
struct_mutex locking here?
>   
>   	i915_gem_object_unpin_map(guc->log.vma->obj);
>   	guc->log.runtime.buf_addr = NULL;
> @@ -437,7 +407,7 @@ static void guc_log_runtime_destroy(struct intel_guc *guc)
>   
>   void intel_guc_log_init_early(struct intel_guc *guc)
>   {
> -	mutex_init(&guc->log.runtime.relay_lock);
> +	mutex_init(&guc->log.runtime.lock);
rename and move of members from runtime to log can precede this patch?
>   	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
>   }
>   
> @@ -448,12 +418,7 @@ int guc_log_relay_create(struct intel_guc *guc)
>   	size_t n_subbufs, subbuf_size;
>   	int ret;
>   
> -	if (!i915_modparams.guc_log_level)
> -		return 0;
> -
> -	mutex_lock(&guc->log.runtime.relay_lock);
> -
> -	GEM_BUG_ON(guc_log_has_relay(guc));
> +	lockdep_assert_held(&guc->log.runtime.lock);
>   
>   	 /* Keep the size of sub buffers same as shared log buffer */
>   	subbuf_size = GUC_LOG_SIZE;
> @@ -483,12 +448,9 @@ int guc_log_relay_create(struct intel_guc *guc)
>   	GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
>   	guc->log.runtime.relay_chan = guc_log_relay_chan;
>   
> -	mutex_unlock(&guc->log.runtime.relay_lock);
> -
>   	return 0;
>   
>   err:
> -	mutex_unlock(&guc->log.runtime.relay_lock);
>   	/* logging will be off */
>   	i915_modparams.guc_log_level = 0;
This log_level decoupling is not taken care
>   	return ret;
> @@ -496,20 +458,10 @@ int guc_log_relay_create(struct intel_guc *guc)
>   
>   void guc_log_relay_destroy(struct intel_guc *guc)
>   {
> -	mutex_lock(&guc->log.runtime.relay_lock);
> -
> -	/*
> -	 * It's possible that the relay was never allocated because
> -	 * GuC log was disabled at the boot time.
> -	 */
> -	if (!guc_log_has_relay(guc))
> -		goto out_unlock;
> +	lockdep_assert_held(&guc->log.runtime.lock);
>   
>   	relay_close(guc->log.runtime.relay_chan);
>   	guc->log.runtime.relay_chan = NULL;
> -
> -out_unlock:
> -	mutex_unlock(&guc->log.runtime.relay_lock);
>   }
>   
>   static void guc_log_capture_logs(struct intel_guc *guc)
> @@ -608,7 +560,6 @@ static void guc_log_flush_irq_disable(struct intel_guc *guc)
>   
>   void intel_guc_log_destroy(struct intel_guc *guc)
>   {
> -	guc_log_runtime_destroy(guc);
>   	i915_vma_unpin_and_release(&guc->log.vma);
>   }
>   
> @@ -678,9 +629,10 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>   
>   int intel_guc_log_register(struct intel_guc *guc)
>   {
> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>   	int ret;
>   
> +	mutex_lock(&guc->log.runtime.lock);
> +
>   	GEM_BUG_ON(guc_log_has_runtime(guc));
>   
>   	/*
> @@ -692,35 +644,33 @@ int intel_guc_log_register(struct intel_guc *guc)
>   	if (ret)
>   		goto err;
>   
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	ret = guc_log_runtime_create(guc);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> -
> +	ret = guc_log_map(guc);
>   	if (ret)
>   		goto err_relay;
>   
>   	ret = guc_log_relay_file_create(guc);
>   	if (ret)
> -		goto err_runtime;
> +		goto err_unmap;
>   
>   	guc_log_flush_irq_enable(guc);
>   
> +	mutex_unlock(&guc->log.runtime.lock);
> +
>   	return 0;
>   
> -err_runtime:
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	guc_log_runtime_destroy(guc);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> +err_unmap:
> +	guc_log_unmap(guc);
>   err_relay:
>   	guc_log_relay_destroy(guc);
>   err:
> +	mutex_unlock(&guc->log.runtime.lock);
> +
>   	return ret;
>   }
>   
>   void intel_guc_log_unregister(struct intel_guc *guc)
>   {
> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -
> +	guc_log_flush_irq_disable(guc);
This move could be part of earlier patch.
>   	/*
>   	 * Once logging is disabled, GuC won't generate logs & send an
>   	 * interrupt. But there could be some data in the log buffer
> @@ -728,11 +678,13 @@ void intel_guc_log_unregister(struct intel_guc *guc)
>   	 * buffer state and then collect the left over logs.
>   	 */
>   	guc_flush_logs(guc);
> -	guc_log_flush_irq_disable(guc);
>   
> -	mutex_lock(&dev_priv->drm.struct_mutex);
> -	guc_log_runtime_destroy(guc);
> -	mutex_unlock(&dev_priv->drm.struct_mutex);
> +	mutex_lock(&guc->log.runtime.lock);
> +
> +	GEM_BUG_ON(!guc_log_has_runtime(guc));
>   
> +	guc_log_unmap(guc);
>   	guc_log_relay_destroy(guc);
> +
> +	mutex_unlock(&guc->log.runtime.lock);
>   }
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index 09dd2ef1933d..8c26cce77a98 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -48,8 +48,7 @@ struct intel_guc_log {
>   		struct workqueue_struct *flush_wq;
>   		struct work_struct flush_work;
>   		struct rchan *relay_chan;
> -		/* To serialize the access to relay_chan */
Interesting, checkpatch does not complain about comment being removed 
for mutex lock :)
> -		struct mutex relay_lock;
> +		struct mutex lock;
>   	} runtime;
>   	/* logging related stats */
>   	u32 capture_miss_count;
> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> index e9aba3c35264..55a9b5b673e0 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -221,18 +221,24 @@ static void guc_free_load_err_log(struct intel_guc *guc)
>   
>   int intel_uc_log_register(struct drm_i915_private *dev_priv)
>   {
> -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +	int ret = 0;
> +
> +	if (!USES_GUC(dev_priv))
>   		return 0;
>   
> -	return intel_guc_log_register(&dev_priv->guc);
> +	if (i915_modparams.guc_log_level)
> +		ret = intel_guc_log_register(&dev_priv->guc);
> +
> +	return ret;
>   }
>   
>   void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
>   {
> -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> +	if (!USES_GUC(dev_priv))
>   		return;
>   
> -	intel_guc_log_unregister(&dev_priv->guc);
> +	if (i915_modparams.guc_log_level)
> +		intel_guc_log_unregister(&dev_priv->guc);
>   }
>   
>   static int guc_enable_communication(struct intel_guc *guc)

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 06/15] drm/i915/guc: Merge log relay file and channel creation

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> We have all the information we need at relay_open call time.
> Since there's no reason to split the process into relay_open and
> relay_late_setup_files, let's remove the extra code.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Looks good to me. Comment updates needed.
With that:
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/intel_guc_log.c | 52 ++++--------------------------------
>   1 file changed, 5 insertions(+), 47 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index 567620464f52..cbbdb400fa17 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -126,7 +126,7 @@ static struct dentry *create_buf_file_callback(const char *filename,
>   	 * dentry of the file associated with the channel buffer and that file's
>   	 * name need not be same as the filename passed as an argument.
>   	 */
Need to update comment as we are using channel filename now.
> -	buf_file = debugfs_create_file("guc_log", mode,
> +	buf_file = debugfs_create_file(filename, mode,
>   				       parent, buf, &relay_file_operations);
>   	return buf_file;
>   }
> @@ -147,43 +147,6 @@ static struct rchan_callbacks relay_callbacks = {
>   	.remove_buf_file = remove_buf_file_callback,
>   };
>   
> -static int guc_log_relay_file_create(struct intel_guc *guc)
> -{
> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -	struct dentry *log_dir;
> -	int ret;
> -
> -	lockdep_assert_held(&guc->log.runtime.lock);
> -
> -	/* For now create the log file in /sys/kernel/debug/dri/0 dir */
> -	log_dir = dev_priv->drm.primary->debugfs_root;
> -
> -	/*
> -	 * If /sys/kernel/debug/dri/0 location do not exist, then debugfs is
> -	 * not mounted and so can't create the relay file.
> -	 * The relay API seems to fit well with debugfs only, for availing relay
> -	 * there are 3 requirements which can be met for debugfs file only in a
> -	 * straightforward/clean manner :-
> -	 * i)   Need the associated dentry pointer of the file, while opening the
> -	 *      relay channel.
> -	 * ii)  Should be able to use 'relay_file_operations' fops for the file.
> -	 * iii) Set the 'i_private' field of file's inode to the pointer of
> -	 *	relay channel buffer.
> -	 */
> -	if (!log_dir) {
> -		DRM_ERROR("Debugfs dir not available yet for GuC log file\n");
> -		return -ENODEV;
> -	}
> -
> -	ret = relay_late_setup_files(guc->log.runtime.relay_chan, "guc_log", log_dir);
> -	if (ret < 0 && ret != -EEXIST) {
> -		DRM_ERROR("Couldn't associate relay chan with file %d\n", ret);
> -		return ret;
> -	}
> -
> -	return 0;
> -}
> -
>   static void guc_move_to_next_buf(struct intel_guc *guc)
>   {
>   	/*
> @@ -267,7 +230,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   	/* Get the pointer to shared GuC log buffer */
>   	log_buf_state = src_data = guc->log.runtime.buf_addr;
>   
> -
>   	/* Get the pointer to local buffer to store the logs */
>   	log_buf_snapshot_state = dst_data = guc_get_write_buffer(guc);
>   
> @@ -436,8 +398,10 @@ int guc_log_relay_create(struct intel_guc *guc)
>   	 * the GuC firmware logs, the channel will be linked with a file
>   	 * later on when debugfs is registered.
>   	 */
and comment here as well.
> -	guc_log_relay_chan = relay_open(NULL, NULL, subbuf_size,
> -					n_subbufs, &relay_callbacks, dev_priv);
> +	guc_log_relay_chan = relay_open("guc_log",
> +					dev_priv->drm.primary->debugfs_root,
> +					subbuf_size, n_subbufs,
> +					&relay_callbacks, dev_priv);
>   	if (!guc_log_relay_chan) {
>   		DRM_ERROR("Couldn't create relay chan for GuC logging\n");
>   
> @@ -648,18 +612,12 @@ int intel_guc_log_register(struct intel_guc *guc)
>   	if (ret)
>   		goto err_relay;
>   
> -	ret = guc_log_relay_file_create(guc);
> -	if (ret)
> -		goto err_unmap;
> -
>   	guc_log_flush_irq_enable(guc);
>   
>   	mutex_unlock(&guc->log.runtime.lock);
>   
>   	return 0;
>   
> -err_unmap:
> -	guc_log_unmap(guc);
>   err_relay:
>   	guc_log_relay_destroy(guc);
>   err:

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 07/15] drm/i915/guc: Flush directly in log unregister

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> Having both guc_flush_logs and guc_log_flush functions is confusing.
> While we could just rename things, guc_flush_logs implementation is
> quite simple. Let's get rid of it and move its content to unregister.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>

this patch reminds me of need to do guc_log_flush in capture_uc_state 
prior to reset in case user wants to read
updated log vma from error state. is this need valid?
> ---
>   drivers/gpu/drm/i915/intel_guc_log.c | 35 +++++++++++++++--------------------
>   1 file changed, 15 insertions(+), 20 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index cbbdb400fa17..0800c5317510 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -443,25 +443,6 @@ static void guc_log_capture_logs(struct intel_guc *guc)
>   	intel_runtime_pm_put(dev_priv);
>   }
>   
> -static void guc_flush_logs(struct intel_guc *guc)
> -{
> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> -
> -	/*
> -	 * Before initiating the forceful flush, wait for any pending/ongoing
> -	 * flush to complete otherwise forceful flush may not actually happen.
> -	 */
> -	flush_work(&guc->log.runtime.flush_work);
> -
> -	/* Ask GuC to update the log buffer state */
> -	intel_runtime_pm_get(dev_priv);
> -	guc_log_flush(guc);
> -	intel_runtime_pm_put(dev_priv);
> -
> -	/* GuC would have updated log buffer by now, so capture it */
> -	guc_log_capture_logs(guc);
> -}
> -
>   int intel_guc_log_create(struct intel_guc *guc)
>   {
>   	struct i915_vma *vma;
> @@ -628,14 +609,28 @@ int intel_guc_log_register(struct intel_guc *guc)
>   
>   void intel_guc_log_unregister(struct intel_guc *guc)
>   {
> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> +
>   	guc_log_flush_irq_disable(guc);
> +
> +	/*
> +	 * Before initiating the forceful flush, wait for any pending/ongoing
> +	 * flush to complete otherwise forceful flush may not actually happen.
> +	 */
> +	flush_work(&guc->log.runtime.flush_work);
> +
>   	/*
>   	 * Once logging is disabled, GuC won't generate logs & send an
>   	 * interrupt. But there could be some data in the log buffer
>   	 * which is yet to be captured. So request GuC to update the log
>   	 * buffer state and then collect the left over logs.
>   	 */
> -	guc_flush_logs(guc);
> +	intel_runtime_pm_get(dev_priv);
> +	guc_log_flush(guc);
> +	intel_runtime_pm_put(dev_priv);
> +
> +	/* GuC would have updated log buffer by now, so capture it */
> +	guc_log_capture_logs(guc);
>   
>   	mutex_lock(&guc->log.runtime.lock);
>   

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 07/15] drm/i915/guc: Flush directly in log unregister

[Michał Winiarski]

On Mon, Mar 05, 2018 at 05:28:33PM +0530, Sagar Arun Kamble wrote:
> 
> 
> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> > Having both guc_flush_logs and guc_log_flush functions is confusing.
> > While we could just rename things, guc_flush_logs implementation is
> > quite simple. Let's get rid of it and move its content to unregister.
> > 
> > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> 
> this patch reminds me of need to do guc_log_flush in capture_uc_state prior
> to reset in case user wants to read
> updated log vma from error state. is this need valid?

I don't think so - force flush Host to GuC is related to "bookkeeping" (think
metadata describing log buffer state - HEAD/TAIL pointers etc).
In error state we don't care - we're dumping the whole log vma.
In case of relay - we're moving data around, and we need to know what data to
move.

-Michał

> > ---
> >   drivers/gpu/drm/i915/intel_guc_log.c | 35 +++++++++++++++--------------------
> >   1 file changed, 15 insertions(+), 20 deletions(-)
> > 
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 02/15] drm/i915/guc: Create common entry points for log register/unregister

[Michał Winiarski]

On Mon, Mar 05, 2018 at 12:39:58PM +0530, Sagar Arun Kamble wrote:
> Overall change looks good. Could you please clarify on below:
> 
> intel_uc_log_register|unregister are removed in patch later in the series.
> Should we just stay with inner functions then to minimize changes?

I've done this to move (USES_GUC/guc_log_level) checks to the callers. Otherwise
it would need to stay in intel_guc_log_register, which would cause us to do more
changes in intel_guc_log_control_set later in the series (when we're actually
doing the decoupling).

-Michał

> 
> 
> Thanks
> Sagar
> 
> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> > We have many functions responsible for allocating different parts of
> > runtime called from multiple places. Let's stick with keeping
> > everything in guc_log_register instead.
> > 
> > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > ---
> >   drivers/gpu/drm/i915/i915_drv.c      |   6 +-
> >   drivers/gpu/drm/i915/i915_gem.c      |   4 +-
> >   drivers/gpu/drm/i915/intel_guc_log.c | 148 ++++++++++++++---------------------
> >   drivers/gpu/drm/i915/intel_guc_log.h |   6 +-
> >   drivers/gpu/drm/i915/intel_uc.c      |  39 ++++-----
> >   drivers/gpu/drm/i915/intel_uc.h      |   6 +-
> >   6 files changed, 91 insertions(+), 118 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
> > index aaa861b51024..719b2be73292 100644
> > --- a/drivers/gpu/drm/i915/i915_drv.c
> > +++ b/drivers/gpu/drm/i915/i915_drv.c
> > @@ -636,7 +636,7 @@ static void i915_gem_fini(struct drm_i915_private *dev_priv)
> >   	i915_gem_contexts_fini(dev_priv);
> >   	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -	intel_uc_fini_misc(dev_priv);
> > +	intel_uc_fini_wq(dev_priv);
> >   	i915_gem_cleanup_userptr(dev_priv);
> >   	i915_gem_drain_freed_objects(dev_priv);
> > @@ -1237,7 +1237,7 @@ static void i915_driver_register(struct drm_i915_private *dev_priv)
> >   	/* Reveal our presence to userspace */
> >   	if (drm_dev_register(dev, 0) == 0) {
> >   		i915_debugfs_register(dev_priv);
> > -		i915_guc_log_register(dev_priv);
> > +		intel_uc_log_register(dev_priv);
> >   		i915_setup_sysfs(dev_priv);
> >   		/* Depends on sysfs having been initialized */
> > @@ -1297,7 +1297,7 @@ static void i915_driver_unregister(struct drm_i915_private *dev_priv)
> >   	i915_pmu_unregister(dev_priv);
> >   	i915_teardown_sysfs(dev_priv);
> > -	i915_guc_log_unregister(dev_priv);
> > +	intel_uc_log_unregister(dev_priv);
> >   	drm_dev_unregister(&dev_priv->drm);
> >   	i915_gem_shrinker_unregister(dev_priv);
> > diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
> > index 14c855b1a3a4..4bf5f25b29e2 100644
> > --- a/drivers/gpu/drm/i915/i915_gem.c
> > +++ b/drivers/gpu/drm/i915/i915_gem.c
> > @@ -5279,7 +5279,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
> >   	if (ret)
> >   		return ret;
> > -	ret = intel_uc_init_misc(dev_priv);
> > +	ret = intel_uc_init_wq(dev_priv);
> >   	if (ret)
> >   		return ret;
> > @@ -5375,7 +5375,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
> >   	intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
> >   	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -	intel_uc_fini_misc(dev_priv);
> > +	intel_uc_fini_wq(dev_priv);
> >   	if (ret != -EIO)
> >   		i915_gem_cleanup_userptr(dev_priv);
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> > index 22a05320817b..f1cab43d334e 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.c
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> > @@ -441,7 +441,7 @@ void intel_guc_log_init_early(struct intel_guc *guc)
> >   	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
> >   }
> > -int intel_guc_log_relay_create(struct intel_guc *guc)
> > +int guc_log_relay_create(struct intel_guc *guc)
> >   {
> >   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> >   	struct rchan *guc_log_relay_chan;
> > @@ -494,7 +494,7 @@ int intel_guc_log_relay_create(struct intel_guc *guc)
> >   	return ret;
> >   }
> > -void intel_guc_log_relay_destroy(struct intel_guc *guc)
> > +void guc_log_relay_destroy(struct intel_guc *guc)
> >   {
> >   	mutex_lock(&guc->log.runtime.relay_lock);
> > @@ -512,49 +512,6 @@ void intel_guc_log_relay_destroy(struct intel_guc *guc)
> >   	mutex_unlock(&guc->log.runtime.relay_lock);
> >   }
> > -static int guc_log_late_setup(struct intel_guc *guc)
> > -{
> > -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > -	int ret;
> > -
> > -	if (!guc_log_has_runtime(guc)) {
> > -		/*
> > -		 * If log was disabled at boot time, then setup needed to handle
> > -		 * log buffer flush interrupts would not have been done yet, so
> > -		 * do that now.
> > -		 */
> > -		ret = intel_guc_log_relay_create(guc);
> > -		if (ret)
> > -			goto err;
> > -
> > -		mutex_lock(&dev_priv->drm.struct_mutex);
> > -		intel_runtime_pm_get(dev_priv);
> > -		ret = guc_log_runtime_create(guc);
> > -		intel_runtime_pm_put(dev_priv);
> > -		mutex_unlock(&dev_priv->drm.struct_mutex);
> > -
> > -		if (ret)
> > -			goto err_relay;
> > -	}
> > -
> > -	ret = guc_log_relay_file_create(guc);
> > -	if (ret)
> > -		goto err_runtime;
> > -
> > -	return 0;
> > -
> > -err_runtime:
> > -	mutex_lock(&dev_priv->drm.struct_mutex);
> > -	guc_log_runtime_destroy(guc);
> > -	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -err_relay:
> > -	intel_guc_log_relay_destroy(guc);
> > -err:
> > -	/* logging will remain off */
> > -	i915_modparams.guc_log_level = 0;
> > -	return ret;
> > -}
> > -
> >   static void guc_log_capture_logs(struct intel_guc *guc)
> >   {
> >   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > @@ -574,16 +531,6 @@ static void guc_flush_logs(struct intel_guc *guc)
> >   {
> >   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
> > -		return;
> > -
> > -	/* First disable the interrupts, will be renabled afterwards */
> > -	mutex_lock(&dev_priv->drm.struct_mutex);
> > -	intel_runtime_pm_get(dev_priv);
> > -	gen9_disable_guc_interrupts(dev_priv);
> > -	intel_runtime_pm_put(dev_priv);
> > -	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -
> >   	/*
> >   	 * Before initiating the forceful flush, wait for any pending/ongoing
> >   	 * flush to complete otherwise forceful flush may not actually happen.
> > @@ -626,12 +573,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> >   	guc->log.vma = vma;
> > -	if (i915_modparams.guc_log_level) {
> > -		ret = guc_log_runtime_create(guc);
> > -		if (ret < 0)
> > -			goto err_vma;
> > -	}
> > -
> >   	/* each allocated unit is a page */
> >   	flags = GUC_LOG_VALID | GUC_LOG_NOTIFY_ON_HALF_FULL |
> >   		(GUC_LOG_DPC_PAGES << GUC_LOG_DPC_SHIFT) |
> > @@ -643,8 +584,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> >   	return 0;
> > -err_vma:
> > -	i915_vma_unpin_and_release(&guc->log.vma);
> >   err:
> >   	/* logging will be off */
> >   	i915_modparams.guc_log_level = 0;
> > @@ -703,24 +642,14 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
> >   	mutex_unlock(&dev_priv->drm.struct_mutex);
> >   	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
> > -		ret = guc_log_late_setup(guc);
> > -		if (ret)
> > +		ret = intel_guc_log_register(guc);
> > +		if (ret) {
> > +			/* logging will remain off */
> > +			i915_modparams.guc_log_level = 0;
> >   			goto out;
> > -
> > -		/* GuC logging is currently the only user of Guc2Host interrupts */
> > -		mutex_lock(&dev_priv->drm.struct_mutex);
> > -		intel_runtime_pm_get(dev_priv);
> > -		gen9_enable_guc_interrupts(dev_priv);
> > -		intel_runtime_pm_put(dev_priv);
> > -		mutex_unlock(&dev_priv->drm.struct_mutex);
> > +		}
> >   	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
> > -		/*
> > -		 * Once logging is disabled, GuC won't generate logs & send an
> > -		 * interrupt. But there could be some data in the log buffer
> > -		 * which is yet to be captured. So request GuC to update the log
> > -		 * buffer state and then collect the left over logs.
> > -		 */
> > -		guc_flush_logs(guc);
> > +		intel_guc_log_unregister(guc);
> >   	}
> >   	return 0;
> > @@ -731,20 +660,63 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
> >   	return ret;
> >   }
> > -void i915_guc_log_register(struct drm_i915_private *dev_priv)
> > +int intel_guc_log_register(struct intel_guc *guc)
> >   {
> > -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
> > -		return;
> > +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > +	int ret;
> > +
> > +	GEM_BUG_ON(guc_log_has_runtime(guc));
> > +
> > +	/*
> > +	 * If log was disabled at boot time, then setup needed to handle
> > +	 * log buffer flush interrupts would not have been done yet, so
> > +	 * do that now.
> > +	 */
> > +	ret = guc_log_relay_create(guc);
> > +	if (ret)
> > +		goto err;
> > +
> > +	mutex_lock(&dev_priv->drm.struct_mutex);
> > +	ret = guc_log_runtime_create(guc);
> > +	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +
> > +	if (ret)
> > +		goto err_relay;
> > +
> > +	ret = guc_log_relay_file_create(guc);
> > +	if (ret)
> > +		goto err_runtime;
> > -	guc_log_late_setup(&dev_priv->guc);
> > +	/* GuC logging is currently the only user of Guc2Host interrupts */
> > +	mutex_lock(&dev_priv->drm.struct_mutex);
> > +	intel_runtime_pm_get(dev_priv);
> > +	gen9_enable_guc_interrupts(dev_priv);
> > +	intel_runtime_pm_put(dev_priv);
> > +	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +
> > +	return 0;
> > +
> > +err_runtime:
> > +	mutex_lock(&dev_priv->drm.struct_mutex);
> > +	guc_log_runtime_destroy(guc);
> > +	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +err_relay:
> > +	guc_log_relay_destroy(guc);
> > +err:
> > +	return ret;
> >   }
> > -void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
> > +void intel_guc_log_unregister(struct intel_guc *guc)
> >   {
> > -	struct intel_guc *guc = &dev_priv->guc;
> > +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > -	if (!USES_GUC_SUBMISSION(dev_priv))
> > -		return;
> > +	/*
> > +	 * Once logging is disabled, GuC won't generate logs & send an
> > +	 * interrupt. But there could be some data in the log buffer
> > +	 * which is yet to be captured. So request GuC to update the log
> > +	 * buffer state and then collect the left over logs.
> > +	 */
> > +	guc_flush_logs(guc);
> >   	mutex_lock(&dev_priv->drm.struct_mutex);
> >   	/* GuC logging is currently the only user of Guc2Host interrupts */
> > @@ -755,5 +727,5 @@ void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
> >   	guc_log_runtime_destroy(guc);
> >   	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -	intel_guc_log_relay_destroy(guc);
> > +	guc_log_relay_destroy(guc);
> >   }
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> > index 141ce9ca22ce..09dd2ef1933d 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.h
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> > @@ -62,11 +62,9 @@ struct intel_guc_log {
> >   int intel_guc_log_create(struct intel_guc *guc);
> >   void intel_guc_log_destroy(struct intel_guc *guc);
> >   void intel_guc_log_init_early(struct intel_guc *guc);
> > -int intel_guc_log_relay_create(struct intel_guc *guc);
> > -void intel_guc_log_relay_destroy(struct intel_guc *guc);
> >   int intel_guc_log_control_get(struct intel_guc *guc);
> >   int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
> > -void i915_guc_log_register(struct drm_i915_private *dev_priv);
> > -void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
> > +int intel_guc_log_register(struct intel_guc *guc);
> > +void intel_guc_log_unregister(struct intel_guc *guc);
> >   #endif
> > diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> > index 9f1bac6398fb..3f41ef525e26 100644
> > --- a/drivers/gpu/drm/i915/intel_uc.c
> > +++ b/drivers/gpu/drm/i915/intel_uc.c
> > @@ -219,6 +219,22 @@ static void guc_free_load_err_log(struct intel_guc *guc)
> >   		i915_gem_object_put(guc->load_err_log);
> >   }
> > +int intel_uc_log_register(struct drm_i915_private *dev_priv)
> > +{
> > +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> > +		return 0;
> > +
> > +	return intel_guc_log_register(&dev_priv->guc);
> > +}
> > +
> > +void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
> > +{
> > +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> > +		return;
> > +
> > +	intel_guc_log_unregister(&dev_priv->guc);
> > +}
> > +
> >   static int guc_enable_communication(struct intel_guc *guc)
> >   {
> >   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > @@ -240,7 +256,7 @@ static void guc_disable_communication(struct intel_guc *guc)
> >   	guc->send = intel_guc_send_nop;
> >   }
> > -int intel_uc_init_misc(struct drm_i915_private *dev_priv)
> > +int intel_uc_init_wq(struct drm_i915_private *dev_priv)
> >   {
> >   	struct intel_guc *guc = &dev_priv->guc;
> >   	int ret;
> > @@ -249,26 +265,13 @@ int intel_uc_init_misc(struct drm_i915_private *dev_priv)
> >   		return 0;
> >   	ret = intel_guc_init_wq(guc);
> > -	if (ret) {
> > -		DRM_ERROR("Couldn't allocate workqueues for GuC\n");
> > -		goto err;
> > -	}
> > -
> > -	ret = intel_guc_log_relay_create(guc);
> > -	if (ret) {
> > -		DRM_ERROR("Couldn't allocate relay for GuC log\n");
> > -		goto err_relay;
> > -	}
> > +	if (ret)
> > +		return ret;
> >   	return 0;
> > -
> > -err_relay:
> > -	intel_guc_fini_wq(guc);
> > -err:
> > -	return ret;
> >   }
> > -void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
> > +void intel_uc_fini_wq(struct drm_i915_private *dev_priv)
> >   {
> >   	struct intel_guc *guc = &dev_priv->guc;
> > @@ -276,8 +279,6 @@ void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
> >   		return;
> >   	intel_guc_fini_wq(guc);
> > -
> > -	intel_guc_log_relay_destroy(guc);
> >   }
> >   int intel_uc_init(struct drm_i915_private *dev_priv)
> > diff --git a/drivers/gpu/drm/i915/intel_uc.h b/drivers/gpu/drm/i915/intel_uc.h
> > index f2984e01e257..9bc22103396d 100644
> > --- a/drivers/gpu/drm/i915/intel_uc.h
> > +++ b/drivers/gpu/drm/i915/intel_uc.h
> > @@ -31,10 +31,12 @@
> >   void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
> >   void intel_uc_init_early(struct drm_i915_private *dev_priv);
> >   void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
> > +int intel_uc_log_register(struct drm_i915_private *dev_priv);
> > +void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
> >   void intel_uc_init_fw(struct drm_i915_private *dev_priv);
> >   void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
> > -int intel_uc_init_misc(struct drm_i915_private *dev_priv);
> > -void intel_uc_fini_misc(struct drm_i915_private *dev_priv);
> > +int intel_uc_init_wq(struct drm_i915_private *dev_priv);
> > +void intel_uc_fini_wq(struct drm_i915_private *dev_priv);
> >   int intel_uc_init_hw(struct drm_i915_private *dev_priv);
> >   void intel_uc_fini_hw(struct drm_i915_private *dev_priv);
> >   int intel_uc_init(struct drm_i915_private *dev_priv);
> 
> -- 
> Thanks,
> Sagar
> 
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 05/15] drm/i915/guc: Log runtime should consist of both mapping and relay

[Michał Winiarski]

On Mon, Mar 05, 2018 at 04:01:18PM +0530, Sagar Arun Kamble wrote:
> 
> 
> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> > Currently, we're treating relay and mapping of GuC log as a separate
> > concepts. We're also using inconsistent locking, sometimes using
> > relay_lock, sometimes using struct mutex.
> > Let's correct that. Anything touching the runtime is now serialized
> > using runtime.lock, while we're still using struct mutex as inner lock
> > for mapping.
> > We're still racy in setting the log level - but we'll take care of that
> > in the following patches.
> > 
> > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > ---
> >   drivers/gpu/drm/i915/intel_guc_log.c | 110 ++++++++++-------------------------
> >   drivers/gpu/drm/i915/intel_guc_log.h |   3 +-
> >   drivers/gpu/drm/i915/intel_uc.c      |  14 +++--
> >   3 files changed, 42 insertions(+), 85 deletions(-)
> > 

[SNIP]

> > @@ -372,8 +349,6 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
> >   	}
> >   	guc_move_to_next_buf(guc);
> > -
> > -	mutex_unlock(&guc->log.runtime.relay_lock);
> >   }
> >   static void capture_logs_work(struct work_struct *work)
> > @@ -381,7 +356,9 @@ static void capture_logs_work(struct work_struct *work)
> >   	struct intel_guc *guc =
> >   		container_of(work, struct intel_guc, log.runtime.flush_work);
> > +	mutex_lock(&guc->log.runtime.lock);
> >   	guc_log_capture_logs(guc);
> I think we should just lock guc_read_update_log_buffer as
> guc_log_flush_complete is independent action

Agreed - I'll change this and apply all the other suggestions to the locking.

> > +	mutex_unlock(&guc->log.runtime.lock);
> >   }
> >   static bool guc_log_has_runtime(struct intel_guc *guc)
> > @@ -389,19 +366,16 @@ static bool guc_log_has_runtime(struct intel_guc *guc)
> >   	return guc->log.runtime.buf_addr != NULL;
> >   }
> > -static int guc_log_runtime_create(struct intel_guc *guc)
> > +static int guc_log_map(struct intel_guc *guc)
> >   {
> >   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> >   	void *vaddr;
> >   	int ret;
> > -	lockdep_assert_held(&dev_priv->drm.struct_mutex);
> > -
> lockdep_assert for runtime.lock here?
> >   	if (!guc->log.vma)
> >   		return -ENODEV;
> > -	GEM_BUG_ON(guc_log_has_runtime(guc));
> > -
> > +	mutex_lock(&dev_priv->drm.struct_mutex);
> >   	ret = i915_gem_object_set_to_wc_domain(guc->log.vma->obj, true);
> >   	if (ret)
> mutex not unlocked
> >   		return ret;
> > @@ -416,20 +390,16 @@ static int guc_log_runtime_create(struct intel_guc *guc)
> >   		DRM_ERROR("Couldn't map log buffer pages %d\n", ret);
> mutex not unlocked
> >   		return PTR_ERR(vaddr);
> >   	}
> > +	mutex_unlock(&dev_priv->drm.struct_mutex);
> >   	guc->log.runtime.buf_addr = vaddr;
> >   	return 0;
> >   }
> > -static void guc_log_runtime_destroy(struct intel_guc *guc)
> > +static void guc_log_unmap(struct intel_guc *guc)
> >   {
> > -	/*
> > -	 * It's possible that the runtime stuff was never allocated because
> > -	 * GuC log was disabled at the boot time.
> > -	 */
> > -	if (!guc_log_has_runtime(guc))
> > -		return;
> > +	lockdep_assert_held(&guc->log.runtime.lock);
> struct_mutex locking here?

Except this one. AFACT, we don't really need struct mutex here. We need it only
for set_domain - I'll reduce the scope to set_domain on the map path.

> >   	i915_gem_object_unpin_map(guc->log.vma->obj);
> >   	guc->log.runtime.buf_addr = NULL;
> > @@ -437,7 +407,7 @@ static void guc_log_runtime_destroy(struct intel_guc *guc)
> >   void intel_guc_log_init_early(struct intel_guc *guc)
> >   {
> > -	mutex_init(&guc->log.runtime.relay_lock);
> > +	mutex_init(&guc->log.runtime.lock);
> rename and move of members from runtime to log can precede this patch?

How strongly do you feel about this one?
I wanted to tidy first (decouple things), rename later.

> >   	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
> >   }
> > @@ -448,12 +418,7 @@ int guc_log_relay_create(struct intel_guc *guc)
> >   	size_t n_subbufs, subbuf_size;
> >   	int ret;
> > -	if (!i915_modparams.guc_log_level)
> > -		return 0;
> > -
> > -	mutex_lock(&guc->log.runtime.relay_lock);
> > -
> > -	GEM_BUG_ON(guc_log_has_relay(guc));
> > +	lockdep_assert_held(&guc->log.runtime.lock);
> >   	 /* Keep the size of sub buffers same as shared log buffer */
> >   	subbuf_size = GUC_LOG_SIZE;
> > @@ -483,12 +448,9 @@ int guc_log_relay_create(struct intel_guc *guc)
> >   	GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
> >   	guc->log.runtime.relay_chan = guc_log_relay_chan;
> > -	mutex_unlock(&guc->log.runtime.relay_lock);
> > -
> >   	return 0;
> >   err:
> > -	mutex_unlock(&guc->log.runtime.relay_lock);
> >   	/* logging will be off */
> >   	i915_modparams.guc_log_level = 0;
> This log_level decoupling is not taken care

Yup, though it belongs in "drm/i915/guc: Split relay control and GuC log level",
I'll add it there.

> >   	return ret;
> > @@ -496,20 +458,10 @@ int guc_log_relay_create(struct intel_guc *guc)
> >   void guc_log_relay_destroy(struct intel_guc *guc)
> >   {
> > -	mutex_lock(&guc->log.runtime.relay_lock);
> > -
> > -	/*
> > -	 * It's possible that the relay was never allocated because
> > -	 * GuC log was disabled at the boot time.
> > -	 */
> > -	if (!guc_log_has_relay(guc))
> > -		goto out_unlock;
> > +	lockdep_assert_held(&guc->log.runtime.lock);
> >   	relay_close(guc->log.runtime.relay_chan);
> >   	guc->log.runtime.relay_chan = NULL;
> > -
> > -out_unlock:
> > -	mutex_unlock(&guc->log.runtime.relay_lock);
> >   }
> >   static void guc_log_capture_logs(struct intel_guc *guc)
> > @@ -608,7 +560,6 @@ static void guc_log_flush_irq_disable(struct intel_guc *guc)
> >   void intel_guc_log_destroy(struct intel_guc *guc)
> >   {
> > -	guc_log_runtime_destroy(guc);
> >   	i915_vma_unpin_and_release(&guc->log.vma);
> >   }
> > @@ -678,9 +629,10 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
> >   int intel_guc_log_register(struct intel_guc *guc)
> >   {
> > -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> >   	int ret;
> > +	mutex_lock(&guc->log.runtime.lock);
> > +
> >   	GEM_BUG_ON(guc_log_has_runtime(guc));
> >   	/*
> > @@ -692,35 +644,33 @@ int intel_guc_log_register(struct intel_guc *guc)
> >   	if (ret)
> >   		goto err;
> > -	mutex_lock(&dev_priv->drm.struct_mutex);
> > -	ret = guc_log_runtime_create(guc);
> > -	mutex_unlock(&dev_priv->drm.struct_mutex);
> > -
> > +	ret = guc_log_map(guc);
> >   	if (ret)
> >   		goto err_relay;
> >   	ret = guc_log_relay_file_create(guc);
> >   	if (ret)
> > -		goto err_runtime;
> > +		goto err_unmap;
> >   	guc_log_flush_irq_enable(guc);
> > +	mutex_unlock(&guc->log.runtime.lock);
> > +
> >   	return 0;
> > -err_runtime:
> > -	mutex_lock(&dev_priv->drm.struct_mutex);
> > -	guc_log_runtime_destroy(guc);
> > -	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +err_unmap:
> > +	guc_log_unmap(guc);
> >   err_relay:
> >   	guc_log_relay_destroy(guc);
> >   err:
> > +	mutex_unlock(&guc->log.runtime.lock);
> > +
> >   	return ret;
> >   }
> >   void intel_guc_log_unregister(struct intel_guc *guc)
> >   {
> > -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> > -
> > +	guc_log_flush_irq_disable(guc);
> This move could be part of earlier patch.
> >   	/*
> >   	 * Once logging is disabled, GuC won't generate logs & send an
> >   	 * interrupt. But there could be some data in the log buffer
> > @@ -728,11 +678,13 @@ void intel_guc_log_unregister(struct intel_guc *guc)
> >   	 * buffer state and then collect the left over logs.
> >   	 */
> >   	guc_flush_logs(guc);
> > -	guc_log_flush_irq_disable(guc);
> > -	mutex_lock(&dev_priv->drm.struct_mutex);
> > -	guc_log_runtime_destroy(guc);
> > -	mutex_unlock(&dev_priv->drm.struct_mutex);
> > +	mutex_lock(&guc->log.runtime.lock);
> > +
> > +	GEM_BUG_ON(!guc_log_has_runtime(guc));
> > +	guc_log_unmap(guc);
> >   	guc_log_relay_destroy(guc);
> > +
> > +	mutex_unlock(&guc->log.runtime.lock);
> >   }
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> > index 09dd2ef1933d..8c26cce77a98 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.h
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> > @@ -48,8 +48,7 @@ struct intel_guc_log {
> >   		struct workqueue_struct *flush_wq;
> >   		struct work_struct flush_work;
> >   		struct rchan *relay_chan;
> > -		/* To serialize the access to relay_chan */
> Interesting, checkpatch does not complain about comment being removed for
> mutex lock :)

Well, it's a member of intel_guc_log, and it protects other members of
intel_guc_log.

-Michał

> > -		struct mutex relay_lock;
> > +		struct mutex lock;
> >   	} runtime;
> >   	/* logging related stats */
> >   	u32 capture_miss_count;
> > diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> > index e9aba3c35264..55a9b5b673e0 100644
> > --- a/drivers/gpu/drm/i915/intel_uc.c
> > +++ b/drivers/gpu/drm/i915/intel_uc.c
> > @@ -221,18 +221,24 @@ static void guc_free_load_err_log(struct intel_guc *guc)
> >   int intel_uc_log_register(struct drm_i915_private *dev_priv)
> >   {
> > -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> > +	int ret = 0;
> > +
> > +	if (!USES_GUC(dev_priv))
> >   		return 0;
> > -	return intel_guc_log_register(&dev_priv->guc);
> > +	if (i915_modparams.guc_log_level)
> > +		ret = intel_guc_log_register(&dev_priv->guc);
> > +
> > +	return ret;
> >   }
> >   void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
> >   {
> > -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
> > +	if (!USES_GUC(dev_priv))
> >   		return;
> > -	intel_guc_log_unregister(&dev_priv->guc);
> > +	if (i915_modparams.guc_log_level)
> > +		intel_guc_log_unregister(&dev_priv->guc);
> >   }
> >   static int guc_enable_communication(struct intel_guc *guc)
> 
> -- 
> Thanks,
> Sagar
> 
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 07/15] drm/i915/guc: Flush directly in log unregister

[Sagar Arun Kamble]

On 3/5/2018 5:40 PM, Michał Winiarski wrote:
> On Mon, Mar 05, 2018 at 05:28:33PM +0530, Sagar Arun Kamble wrote:
>>
>> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
>>> Having both guc_flush_logs and guc_log_flush functions is confusing.
>>> While we could just rename things, guc_flush_logs implementation is
>>> quite simple. Let's get rid of it and move its content to unregister.
>>>
>>> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
>>> Cc: Chris Wilson <chris@chris-wilson.co.uk>
>>> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
>>> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
>>> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
>> Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
>>
>> this patch reminds me of need to do guc_log_flush in capture_uc_state prior
>> to reset in case user wants to read
>> updated log vma from error state. is this need valid?
> I don't think so - force flush Host to GuC is related to "bookkeeping" (think
> metadata describing log buffer state - HEAD/TAIL pointers etc).
> In error state we don't care - we're dumping the whole log vma.
But while decoding from log vma in error state we will need up to date 
read/write pointers.
Or is the error handling logic requires not to invoke any H2G post hang.

Agree that this change has to be taken up later based on consensus on 
requirement but just wanted
understand the scenario more.

Thanks,
Sagar
> In case of relay - we're moving data around, and we need to know what data to
> move.
>
> -Michał
>
>>> ---
>>>    drivers/gpu/drm/i915/intel_guc_log.c | 35 +++++++++++++++--------------------
>>>    1 file changed, 15 insertions(+), 20 deletions(-)
>>>

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 02/15] drm/i915/guc: Create common entry points for log register/unregister

[Sagar Arun Kamble]

On 3/5/2018 7:08 PM, Michał Winiarski wrote:
> On Mon, Mar 05, 2018 at 12:39:58PM +0530, Sagar Arun Kamble wrote:
>> Overall change looks good. Could you please clarify on below:
>>
>> intel_uc_log_register|unregister are removed in patch later in the series.
>> Should we just stay with inner functions then to minimize changes?
> I've done this to move (USES_GUC/guc_log_level) checks to the callers. Otherwise
> it would need to stay in intel_guc_log_register, which would cause us to do more
> changes in intel_guc_log_control_set later in the series (when we're actually
> doing the decoupling).
But AFAIU change in that patch (8/15) will be decoupling 
guc_log_register from USES_GUC/guc_log_level which would be fine I guess.
Your call :)
> -Michał
>
>>
>> Thanks
>> Sagar
>>
>> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
>>> We have many functions responsible for allocating different parts of
>>> runtime called from multiple places. Let's stick with keeping
>>> everything in guc_log_register instead.
>>>
>>> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
>>> Cc: Chris Wilson <chris@chris-wilson.co.uk>
>>> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
>>> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
>>> ---
>>>    drivers/gpu/drm/i915/i915_drv.c      |   6 +-
>>>    drivers/gpu/drm/i915/i915_gem.c      |   4 +-
>>>    drivers/gpu/drm/i915/intel_guc_log.c | 148 ++++++++++++++---------------------
>>>    drivers/gpu/drm/i915/intel_guc_log.h |   6 +-
>>>    drivers/gpu/drm/i915/intel_uc.c      |  39 ++++-----
>>>    drivers/gpu/drm/i915/intel_uc.h      |   6 +-
>>>    6 files changed, 91 insertions(+), 118 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
>>> index aaa861b51024..719b2be73292 100644
>>> --- a/drivers/gpu/drm/i915/i915_drv.c
>>> +++ b/drivers/gpu/drm/i915/i915_drv.c
>>> @@ -636,7 +636,7 @@ static void i915_gem_fini(struct drm_i915_private *dev_priv)
>>>    	i915_gem_contexts_fini(dev_priv);
>>>    	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -	intel_uc_fini_misc(dev_priv);
>>> +	intel_uc_fini_wq(dev_priv);
>>>    	i915_gem_cleanup_userptr(dev_priv);
>>>    	i915_gem_drain_freed_objects(dev_priv);
>>> @@ -1237,7 +1237,7 @@ static void i915_driver_register(struct drm_i915_private *dev_priv)
>>>    	/* Reveal our presence to userspace */
>>>    	if (drm_dev_register(dev, 0) == 0) {
>>>    		i915_debugfs_register(dev_priv);
>>> -		i915_guc_log_register(dev_priv);
>>> +		intel_uc_log_register(dev_priv);
>>>    		i915_setup_sysfs(dev_priv);
>>>    		/* Depends on sysfs having been initialized */
>>> @@ -1297,7 +1297,7 @@ static void i915_driver_unregister(struct drm_i915_private *dev_priv)
>>>    	i915_pmu_unregister(dev_priv);
>>>    	i915_teardown_sysfs(dev_priv);
>>> -	i915_guc_log_unregister(dev_priv);
>>> +	intel_uc_log_unregister(dev_priv);
>>>    	drm_dev_unregister(&dev_priv->drm);
>>>    	i915_gem_shrinker_unregister(dev_priv);
>>> diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
>>> index 14c855b1a3a4..4bf5f25b29e2 100644
>>> --- a/drivers/gpu/drm/i915/i915_gem.c
>>> +++ b/drivers/gpu/drm/i915/i915_gem.c
>>> @@ -5279,7 +5279,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
>>>    	if (ret)
>>>    		return ret;
>>> -	ret = intel_uc_init_misc(dev_priv);
>>> +	ret = intel_uc_init_wq(dev_priv);
>>>    	if (ret)
>>>    		return ret;
>>> @@ -5375,7 +5375,7 @@ int i915_gem_init(struct drm_i915_private *dev_priv)
>>>    	intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
>>>    	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -	intel_uc_fini_misc(dev_priv);
>>> +	intel_uc_fini_wq(dev_priv);
>>>    	if (ret != -EIO)
>>>    		i915_gem_cleanup_userptr(dev_priv);
>>> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
>>> index 22a05320817b..f1cab43d334e 100644
>>> --- a/drivers/gpu/drm/i915/intel_guc_log.c
>>> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
>>> @@ -441,7 +441,7 @@ void intel_guc_log_init_early(struct intel_guc *guc)
>>>    	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
>>>    }
>>> -int intel_guc_log_relay_create(struct intel_guc *guc)
>>> +int guc_log_relay_create(struct intel_guc *guc)
>>>    {
>>>    	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>>    	struct rchan *guc_log_relay_chan;
>>> @@ -494,7 +494,7 @@ int intel_guc_log_relay_create(struct intel_guc *guc)
>>>    	return ret;
>>>    }
>>> -void intel_guc_log_relay_destroy(struct intel_guc *guc)
>>> +void guc_log_relay_destroy(struct intel_guc *guc)
>>>    {
>>>    	mutex_lock(&guc->log.runtime.relay_lock);
>>> @@ -512,49 +512,6 @@ void intel_guc_log_relay_destroy(struct intel_guc *guc)
>>>    	mutex_unlock(&guc->log.runtime.relay_lock);
>>>    }
>>> -static int guc_log_late_setup(struct intel_guc *guc)
>>> -{
>>> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> -	int ret;
>>> -
>>> -	if (!guc_log_has_runtime(guc)) {
>>> -		/*
>>> -		 * If log was disabled at boot time, then setup needed to handle
>>> -		 * log buffer flush interrupts would not have been done yet, so
>>> -		 * do that now.
>>> -		 */
>>> -		ret = intel_guc_log_relay_create(guc);
>>> -		if (ret)
>>> -			goto err;
>>> -
>>> -		mutex_lock(&dev_priv->drm.struct_mutex);
>>> -		intel_runtime_pm_get(dev_priv);
>>> -		ret = guc_log_runtime_create(guc);
>>> -		intel_runtime_pm_put(dev_priv);
>>> -		mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -
>>> -		if (ret)
>>> -			goto err_relay;
>>> -	}
>>> -
>>> -	ret = guc_log_relay_file_create(guc);
>>> -	if (ret)
>>> -		goto err_runtime;
>>> -
>>> -	return 0;
>>> -
>>> -err_runtime:
>>> -	mutex_lock(&dev_priv->drm.struct_mutex);
>>> -	guc_log_runtime_destroy(guc);
>>> -	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -err_relay:
>>> -	intel_guc_log_relay_destroy(guc);
>>> -err:
>>> -	/* logging will remain off */
>>> -	i915_modparams.guc_log_level = 0;
>>> -	return ret;
>>> -}
>>> -
>>>    static void guc_log_capture_logs(struct intel_guc *guc)
>>>    {
>>>    	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> @@ -574,16 +531,6 @@ static void guc_flush_logs(struct intel_guc *guc)
>>>    {
>>>    	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
>>> -		return;
>>> -
>>> -	/* First disable the interrupts, will be renabled afterwards */
>>> -	mutex_lock(&dev_priv->drm.struct_mutex);
>>> -	intel_runtime_pm_get(dev_priv);
>>> -	gen9_disable_guc_interrupts(dev_priv);
>>> -	intel_runtime_pm_put(dev_priv);
>>> -	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -
>>>    	/*
>>>    	 * Before initiating the forceful flush, wait for any pending/ongoing
>>>    	 * flush to complete otherwise forceful flush may not actually happen.
>>> @@ -626,12 +573,6 @@ int intel_guc_log_create(struct intel_guc *guc)
>>>    	guc->log.vma = vma;
>>> -	if (i915_modparams.guc_log_level) {
>>> -		ret = guc_log_runtime_create(guc);
>>> -		if (ret < 0)
>>> -			goto err_vma;
>>> -	}
>>> -
>>>    	/* each allocated unit is a page */
>>>    	flags = GUC_LOG_VALID | GUC_LOG_NOTIFY_ON_HALF_FULL |
>>>    		(GUC_LOG_DPC_PAGES << GUC_LOG_DPC_SHIFT) |
>>> @@ -643,8 +584,6 @@ int intel_guc_log_create(struct intel_guc *guc)
>>>    	return 0;
>>> -err_vma:
>>> -	i915_vma_unpin_and_release(&guc->log.vma);
>>>    err:
>>>    	/* logging will be off */
>>>    	i915_modparams.guc_log_level = 0;
>>> @@ -703,24 +642,14 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>>>    	mutex_unlock(&dev_priv->drm.struct_mutex);
>>>    	if (GUC_LOG_IS_ENABLED(val) && !guc_log_has_runtime(guc)) {
>>> -		ret = guc_log_late_setup(guc);
>>> -		if (ret)
>>> +		ret = intel_guc_log_register(guc);
>>> +		if (ret) {
>>> +			/* logging will remain off */
>>> +			i915_modparams.guc_log_level = 0;
>>>    			goto out;
>>> -
>>> -		/* GuC logging is currently the only user of Guc2Host interrupts */
>>> -		mutex_lock(&dev_priv->drm.struct_mutex);
>>> -		intel_runtime_pm_get(dev_priv);
>>> -		gen9_enable_guc_interrupts(dev_priv);
>>> -		intel_runtime_pm_put(dev_priv);
>>> -		mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +		}
>>>    	} else if (!GUC_LOG_IS_ENABLED(val) && guc_log_has_runtime(guc)) {
>>> -		/*
>>> -		 * Once logging is disabled, GuC won't generate logs & send an
>>> -		 * interrupt. But there could be some data in the log buffer
>>> -		 * which is yet to be captured. So request GuC to update the log
>>> -		 * buffer state and then collect the left over logs.
>>> -		 */
>>> -		guc_flush_logs(guc);
>>> +		intel_guc_log_unregister(guc);
>>>    	}
>>>    	return 0;
>>> @@ -731,20 +660,63 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>>>    	return ret;
>>>    }
>>> -void i915_guc_log_register(struct drm_i915_private *dev_priv)
>>> +int intel_guc_log_register(struct intel_guc *guc)
>>>    {
>>> -	if (!USES_GUC_SUBMISSION(dev_priv) || !i915_modparams.guc_log_level)
>>> -		return;
>>> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> +	int ret;
>>> +
>>> +	GEM_BUG_ON(guc_log_has_runtime(guc));
>>> +
>>> +	/*
>>> +	 * If log was disabled at boot time, then setup needed to handle
>>> +	 * log buffer flush interrupts would not have been done yet, so
>>> +	 * do that now.
>>> +	 */
>>> +	ret = guc_log_relay_create(guc);
>>> +	if (ret)
>>> +		goto err;
>>> +
>>> +	mutex_lock(&dev_priv->drm.struct_mutex);
>>> +	ret = guc_log_runtime_create(guc);
>>> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +
>>> +	if (ret)
>>> +		goto err_relay;
>>> +
>>> +	ret = guc_log_relay_file_create(guc);
>>> +	if (ret)
>>> +		goto err_runtime;
>>> -	guc_log_late_setup(&dev_priv->guc);
>>> +	/* GuC logging is currently the only user of Guc2Host interrupts */
>>> +	mutex_lock(&dev_priv->drm.struct_mutex);
>>> +	intel_runtime_pm_get(dev_priv);
>>> +	gen9_enable_guc_interrupts(dev_priv);
>>> +	intel_runtime_pm_put(dev_priv);
>>> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +
>>> +	return 0;
>>> +
>>> +err_runtime:
>>> +	mutex_lock(&dev_priv->drm.struct_mutex);
>>> +	guc_log_runtime_destroy(guc);
>>> +	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +err_relay:
>>> +	guc_log_relay_destroy(guc);
>>> +err:
>>> +	return ret;
>>>    }
>>> -void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
>>> +void intel_guc_log_unregister(struct intel_guc *guc)
>>>    {
>>> -	struct intel_guc *guc = &dev_priv->guc;
>>> +	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> -	if (!USES_GUC_SUBMISSION(dev_priv))
>>> -		return;
>>> +	/*
>>> +	 * Once logging is disabled, GuC won't generate logs & send an
>>> +	 * interrupt. But there could be some data in the log buffer
>>> +	 * which is yet to be captured. So request GuC to update the log
>>> +	 * buffer state and then collect the left over logs.
>>> +	 */
>>> +	guc_flush_logs(guc);
>>>    	mutex_lock(&dev_priv->drm.struct_mutex);
>>>    	/* GuC logging is currently the only user of Guc2Host interrupts */
>>> @@ -755,5 +727,5 @@ void i915_guc_log_unregister(struct drm_i915_private *dev_priv)
>>>    	guc_log_runtime_destroy(guc);
>>>    	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -	intel_guc_log_relay_destroy(guc);
>>> +	guc_log_relay_destroy(guc);
>>>    }
>>> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
>>> index 141ce9ca22ce..09dd2ef1933d 100644
>>> --- a/drivers/gpu/drm/i915/intel_guc_log.h
>>> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
>>> @@ -62,11 +62,9 @@ struct intel_guc_log {
>>>    int intel_guc_log_create(struct intel_guc *guc);
>>>    void intel_guc_log_destroy(struct intel_guc *guc);
>>>    void intel_guc_log_init_early(struct intel_guc *guc);
>>> -int intel_guc_log_relay_create(struct intel_guc *guc);
>>> -void intel_guc_log_relay_destroy(struct intel_guc *guc);
>>>    int intel_guc_log_control_get(struct intel_guc *guc);
>>>    int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
>>> -void i915_guc_log_register(struct drm_i915_private *dev_priv);
>>> -void i915_guc_log_unregister(struct drm_i915_private *dev_priv);
>>> +int intel_guc_log_register(struct intel_guc *guc);
>>> +void intel_guc_log_unregister(struct intel_guc *guc);
>>>    #endif
>>> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
>>> index 9f1bac6398fb..3f41ef525e26 100644
>>> --- a/drivers/gpu/drm/i915/intel_uc.c
>>> +++ b/drivers/gpu/drm/i915/intel_uc.c
>>> @@ -219,6 +219,22 @@ static void guc_free_load_err_log(struct intel_guc *guc)
>>>    		i915_gem_object_put(guc->load_err_log);
>>>    }
>>> +int intel_uc_log_register(struct drm_i915_private *dev_priv)
>>> +{
>>> +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
>>> +		return 0;
>>> +
>>> +	return intel_guc_log_register(&dev_priv->guc);
>>> +}
>>> +
>>> +void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
>>> +{
>>> +	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
>>> +		return;
>>> +
>>> +	intel_guc_log_unregister(&dev_priv->guc);
>>> +}
>>> +
>>>    static int guc_enable_communication(struct intel_guc *guc)
>>>    {
>>>    	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> @@ -240,7 +256,7 @@ static void guc_disable_communication(struct intel_guc *guc)
>>>    	guc->send = intel_guc_send_nop;
>>>    }
>>> -int intel_uc_init_misc(struct drm_i915_private *dev_priv)
>>> +int intel_uc_init_wq(struct drm_i915_private *dev_priv)
>>>    {
>>>    	struct intel_guc *guc = &dev_priv->guc;
>>>    	int ret;
>>> @@ -249,26 +265,13 @@ int intel_uc_init_misc(struct drm_i915_private *dev_priv)
>>>    		return 0;
>>>    	ret = intel_guc_init_wq(guc);
>>> -	if (ret) {
>>> -		DRM_ERROR("Couldn't allocate workqueues for GuC\n");
>>> -		goto err;
>>> -	}
>>> -
>>> -	ret = intel_guc_log_relay_create(guc);
>>> -	if (ret) {
>>> -		DRM_ERROR("Couldn't allocate relay for GuC log\n");
>>> -		goto err_relay;
>>> -	}
>>> +	if (ret)
>>> +		return ret;
>>>    	return 0;
>>> -
>>> -err_relay:
>>> -	intel_guc_fini_wq(guc);
>>> -err:
>>> -	return ret;
>>>    }
>>> -void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
>>> +void intel_uc_fini_wq(struct drm_i915_private *dev_priv)
>>>    {
>>>    	struct intel_guc *guc = &dev_priv->guc;
>>> @@ -276,8 +279,6 @@ void intel_uc_fini_misc(struct drm_i915_private *dev_priv)
>>>    		return;
>>>    	intel_guc_fini_wq(guc);
>>> -
>>> -	intel_guc_log_relay_destroy(guc);
>>>    }
>>>    int intel_uc_init(struct drm_i915_private *dev_priv)
>>> diff --git a/drivers/gpu/drm/i915/intel_uc.h b/drivers/gpu/drm/i915/intel_uc.h
>>> index f2984e01e257..9bc22103396d 100644
>>> --- a/drivers/gpu/drm/i915/intel_uc.h
>>> +++ b/drivers/gpu/drm/i915/intel_uc.h
>>> @@ -31,10 +31,12 @@
>>>    void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
>>>    void intel_uc_init_early(struct drm_i915_private *dev_priv);
>>>    void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
>>> +int intel_uc_log_register(struct drm_i915_private *dev_priv);
>>> +void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
>>>    void intel_uc_init_fw(struct drm_i915_private *dev_priv);
>>>    void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
>>> -int intel_uc_init_misc(struct drm_i915_private *dev_priv);
>>> -void intel_uc_fini_misc(struct drm_i915_private *dev_priv);
>>> +int intel_uc_init_wq(struct drm_i915_private *dev_priv);
>>> +void intel_uc_fini_wq(struct drm_i915_private *dev_priv);
>>>    int intel_uc_init_hw(struct drm_i915_private *dev_priv);
>>>    void intel_uc_fini_hw(struct drm_i915_private *dev_priv);
>>>    int intel_uc_init(struct drm_i915_private *dev_priv);
>> -- 
>> Thanks,
>> Sagar
>>

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 05/15] drm/i915/guc: Log runtime should consist of both mapping and relay

[Sagar Arun Kamble]

On 3/5/2018 7:44 PM, Michał Winiarski wrote:
> On Mon, Mar 05, 2018 at 04:01:18PM +0530, Sagar Arun Kamble wrote:
>>
>> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
>>> Currently, we're treating relay and mapping of GuC log as a separate
>>> concepts. We're also using inconsistent locking, sometimes using
>>> relay_lock, sometimes using struct mutex.
>>> Let's correct that. Anything touching the runtime is now serialized
>>> using runtime.lock, while we're still using struct mutex as inner lock
>>> for mapping.
>>> We're still racy in setting the log level - but we'll take care of that
>>> in the following patches.
>>>
>>> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
>>> Cc: Chris Wilson <chris@chris-wilson.co.uk>
>>> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
>>> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
>>> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>> ---
>>>    drivers/gpu/drm/i915/intel_guc_log.c | 110 ++++++++++-------------------------
>>>    drivers/gpu/drm/i915/intel_guc_log.h |   3 +-
>>>    drivers/gpu/drm/i915/intel_uc.c      |  14 +++--
>>>    3 files changed, 42 insertions(+), 85 deletions(-)
>>>
> [SNIP]
<snip>
> How strongly do you feel about this one?
> I wanted to tidy first (decouple things), rename later.
fine. it's ok.
>>>    	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
>>>    }
>>> @@ -448,12 +418,7 @@ int guc_log_relay_create(struct intel_guc *guc)
>>>    	size_t n_subbufs, subbuf_size;
>>>    	int ret;
>>> -	if (!i915_modparams.guc_log_level)
>>> -		return 0;
>>> -
>>> -	mutex_lock(&guc->log.runtime.relay_lock);
>>> -
>>> -	GEM_BUG_ON(guc_log_has_relay(guc));
>>> +	lockdep_assert_held(&guc->log.runtime.lock);
>>>    	 /* Keep the size of sub buffers same as shared log buffer */
>>>    	subbuf_size = GUC_LOG_SIZE;
>>> @@ -483,12 +448,9 @@ int guc_log_relay_create(struct intel_guc *guc)
>>>    	GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
>>>    	guc->log.runtime.relay_chan = guc_log_relay_chan;
>>> -	mutex_unlock(&guc->log.runtime.relay_lock);
>>> -
>>>    	return 0;
>>>    err:
>>> -	mutex_unlock(&guc->log.runtime.relay_lock);
>>>    	/* logging will be off */
>>>    	i915_modparams.guc_log_level = 0;
>> This log_level decoupling is not taken care
> Yup, though it belongs in "drm/i915/guc: Split relay control and GuC log level",
> I'll add it there.
>
>>>    	return ret;
>>> @@ -496,20 +458,10 @@ int guc_log_relay_create(struct intel_guc *guc)
>>>    void guc_log_relay_destroy(struct intel_guc *guc)
>>>    {
>>> -	mutex_lock(&guc->log.runtime.relay_lock);
>>> -
>>> -	/*
>>> -	 * It's possible that the relay was never allocated because
>>> -	 * GuC log was disabled at the boot time.
>>> -	 */
>>> -	if (!guc_log_has_relay(guc))
>>> -		goto out_unlock;
>>> +	lockdep_assert_held(&guc->log.runtime.lock);
>>>    	relay_close(guc->log.runtime.relay_chan);
>>>    	guc->log.runtime.relay_chan = NULL;
>>> -
>>> -out_unlock:
>>> -	mutex_unlock(&guc->log.runtime.relay_lock);
>>>    }
>>>    static void guc_log_capture_logs(struct intel_guc *guc)
>>> @@ -608,7 +560,6 @@ static void guc_log_flush_irq_disable(struct intel_guc *guc)
>>>    void intel_guc_log_destroy(struct intel_guc *guc)
>>>    {
>>> -	guc_log_runtime_destroy(guc);
>>>    	i915_vma_unpin_and_release(&guc->log.vma);
>>>    }
>>> @@ -678,9 +629,10 @@ int intel_guc_log_control_set(struct intel_guc *guc, u64 val)
>>>    int intel_guc_log_register(struct intel_guc *guc)
>>>    {
>>> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>>    	int ret;
>>> +	mutex_lock(&guc->log.runtime.lock);
>>> +
>>>    	GEM_BUG_ON(guc_log_has_runtime(guc));
>>>    	/*
>>> @@ -692,35 +644,33 @@ int intel_guc_log_register(struct intel_guc *guc)
>>>    	if (ret)
>>>    		goto err;
>>> -	mutex_lock(&dev_priv->drm.struct_mutex);
>>> -	ret = guc_log_runtime_create(guc);
>>> -	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> -
>>> +	ret = guc_log_map(guc);
>>>    	if (ret)
>>>    		goto err_relay;
>>>    	ret = guc_log_relay_file_create(guc);
>>>    	if (ret)
>>> -		goto err_runtime;
>>> +		goto err_unmap;
>>>    	guc_log_flush_irq_enable(guc);
>>> +	mutex_unlock(&guc->log.runtime.lock);
>>> +
>>>    	return 0;
>>> -err_runtime:
>>> -	mutex_lock(&dev_priv->drm.struct_mutex);
>>> -	guc_log_runtime_destroy(guc);
>>> -	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +err_unmap:
>>> +	guc_log_unmap(guc);
>>>    err_relay:
>>>    	guc_log_relay_destroy(guc);
>>>    err:
>>> +	mutex_unlock(&guc->log.runtime.lock);
>>> +
>>>    	return ret;
>>>    }
>>>    void intel_guc_log_unregister(struct intel_guc *guc)
>>>    {
>>> -	struct drm_i915_private *dev_priv = guc_to_i915(guc);
>>> -
>>> +	guc_log_flush_irq_disable(guc);
>> This move could be part of earlier patch.
>>>    	/*
>>>    	 * Once logging is disabled, GuC won't generate logs & send an
>>>    	 * interrupt. But there could be some data in the log buffer
>>> @@ -728,11 +678,13 @@ void intel_guc_log_unregister(struct intel_guc *guc)
>>>    	 * buffer state and then collect the left over logs.
>>>    	 */
>>>    	guc_flush_logs(guc);
>>> -	guc_log_flush_irq_disable(guc);
>>> -	mutex_lock(&dev_priv->drm.struct_mutex);
>>> -	guc_log_runtime_destroy(guc);
>>> -	mutex_unlock(&dev_priv->drm.struct_mutex);
>>> +	mutex_lock(&guc->log.runtime.lock);
>>> +
>>> +	GEM_BUG_ON(!guc_log_has_runtime(guc));
>>> +	guc_log_unmap(guc);
>>>    	guc_log_relay_destroy(guc);
>>> +
>>> +	mutex_unlock(&guc->log.runtime.lock);
>>>    }
>>> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
>>> index 09dd2ef1933d..8c26cce77a98 100644
>>> --- a/drivers/gpu/drm/i915/intel_guc_log.h
>>> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
>>> @@ -48,8 +48,7 @@ struct intel_guc_log {
>>>    		struct workqueue_struct *flush_wq;
>>>    		struct work_struct flush_work;
>>>    		struct rchan *relay_chan;
>>> -		/* To serialize the access to relay_chan */
>> Interesting, checkpatch does not complain about comment being removed for
>> mutex lock :)
> Well, it's a member of intel_guc_log, and it protects other members of
> intel_guc_log.
Yes. I was saying that if we just define new lock without comment, 
checkpatch complains but
if we remove comment of earlier defined lock it doesn't :)
> -Michał
>
>>> -		struct mutex relay_lock;
>>> +		struct mutex lock;
>>>    	} runtime;
>>>    	/* logging related stats */
>>>    	u32 capture_miss_count;
>>> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
>>> index e9aba3c35264..55a9b5b673e0 100644
>>> --- a/drivers/gpu/drm/i915/intel_uc.c
>>> +++ b/drivers/gpu/drm/i915/intel_uc.c
>>> @@ -221,18 +221,24 @@ static void guc_free_load_err_log(struct intel_guc *guc)
>>>    int intel_uc_log_register(struct drm_i915_private *dev_priv)
>>>    {
>>> -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
>>> +	int ret = 0;
>>> +
>>> +	if (!USES_GUC(dev_priv))
>>>    		return 0;
>>> -	return intel_guc_log_register(&dev_priv->guc);
>>> +	if (i915_modparams.guc_log_level)
>>> +		ret = intel_guc_log_register(&dev_priv->guc);
>>> +
>>> +	return ret;
>>>    }
>>>    void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
>>>    {
>>> -	if (!USES_GUC(dev_priv) || !i915_modparams.guc_log_level)
>>> +	if (!USES_GUC(dev_priv))
>>>    		return;
>>> -	intel_guc_log_unregister(&dev_priv->guc);
>>> +	if (i915_modparams.guc_log_level)
>>> +		intel_guc_log_unregister(&dev_priv->guc);
>>>    }
>>>    static int guc_enable_communication(struct intel_guc *guc)
>> -- 
>> Thanks,
>> Sagar
>>

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 08/15] drm/i915/guc: Split relay control and GuC log level

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> Those two concepts are really separate. Since GuC is writing data into
> its own buffer and we even provide a way for userspace to read directly
> from it using i915_guc_log_dump debugfs, there's no real reason to tie
> log level with relay creation.
> Let's create a separate debugfs, giving userspace a way to create a
> relay on demand, when it wants to read a continuous log rather than a
> snapshot.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_debugfs.c  | 56 ++++++++++++++++++++++----
>   drivers/gpu/drm/i915/i915_drv.c      |  2 -
>   drivers/gpu/drm/i915/intel_guc_log.c | 76 +++++++++++++++---------------------
>   drivers/gpu/drm/i915/intel_guc_log.h |  9 +++--
>   drivers/gpu/drm/i915/intel_uc.c      | 22 -----------
>   drivers/gpu/drm/i915/intel_uc.h      |  2 -
>   6 files changed, 86 insertions(+), 81 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index 58983cafaece..4bd24bbe7966 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -2496,32 +2496,73 @@ static int i915_guc_log_dump(struct seq_file *m, void *data)
>   	return 0;
>   }
>   
> -static int i915_guc_log_control_get(void *data, u64 *val)
> +static int i915_guc_log_level_get(void *data, u64 *val)
>   {
>   	struct drm_i915_private *dev_priv = data;
s/dev_priv/i915 here and at other places
>   
>   	if (!USES_GUC(dev_priv))
>   		return -ENODEV;
>   
> -	*val = intel_guc_log_control_get(&dev_priv->guc);
> +	*val = intel_guc_log_level_get(&dev_priv->guc);
>   
>   	return 0;
>   }
>   
> -static int i915_guc_log_control_set(void *data, u64 val)
> +static int i915_guc_log_level_set(void *data, u64 val)
>   {
>   	struct drm_i915_private *dev_priv = data;
>   
>   	if (!USES_GUC(dev_priv))
>   		return -ENODEV;
>   
> -	return intel_guc_log_control_set(&dev_priv->guc, val);
> +	return intel_guc_log_level_set(&dev_priv->guc, val);
>   }
>   
> -DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_control_fops,
> -			i915_guc_log_control_get, i915_guc_log_control_set,
> +DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_level_fops,
> +			i915_guc_log_level_get, i915_guc_log_level_set,
>   			"%lld\n");
>   
> +static int i915_guc_log_relay_open(struct inode *inode, struct file *file)
> +{
> +	struct drm_i915_private *dev_priv = inode->i_private;
> +
> +	if (!USES_GUC(dev_priv))
> +		return -ENODEV;
> +
> +	file->private_data = dev_priv;
> +
write is passing guc struct so should we just set private_data to 
&dev_priv->guc?
> +	return intel_guc_log_relay_open(&dev_priv->guc);
> +}
> +
> +static ssize_t
> +i915_guc_log_relay_write(struct file *filp,
> +			 const char __user *ubuf,
> +			 size_t cnt,
> +			 loff_t *ppos)
> +{
> +	struct drm_i915_private *dev_priv = filp->private_data;
> +
> +	intel_guc_log_relay_flush(&dev_priv->guc);
> +
> +	return cnt;
> +}
<snip>
> +void intel_guc_log_relay_close(struct intel_guc *guc)
> +{
>   	GEM_BUG_ON(!guc_log_has_runtime(guc));
>   
guc_log_has_runtime() check has to be with runtime.lock mutex locked.

With comments addressed:
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> +	guc_log_flush_irq_disable(guc);
> +	flush_work(&guc->log.runtime.flush_work);
> +
> +	mutex_lock(&guc->log.runtime.lock);
>   	guc_log_unmap(guc);
>   	guc_log_relay_destroy(guc);
> -
>   	mutex_unlock(&guc->log.runtime.lock);
>   }
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index 8c26cce77a98..df91f12a36ed 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -61,9 +61,10 @@ struct intel_guc_log {
>   int intel_guc_log_create(struct intel_guc *guc);
>   void intel_guc_log_destroy(struct intel_guc *guc);
>   void intel_guc_log_init_early(struct intel_guc *guc);
> -int intel_guc_log_control_get(struct intel_guc *guc);
> -int intel_guc_log_control_set(struct intel_guc *guc, u64 control_val);
> -int intel_guc_log_register(struct intel_guc *guc);
> -void intel_guc_log_unregister(struct intel_guc *guc);
> +int intel_guc_log_level_get(struct intel_guc *guc);
> +int intel_guc_log_level_set(struct intel_guc *guc, u64 control_val);
> +int intel_guc_log_relay_open(struct intel_guc *guc);
> +void intel_guc_log_relay_close(struct intel_guc *guc);
> +void intel_guc_log_relay_flush(struct intel_guc *guc);
>   
>   #endif
> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> index 55a9b5b673e0..27e1f4c43b7b 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -219,28 +219,6 @@ static void guc_free_load_err_log(struct intel_guc *guc)
>   		i915_gem_object_put(guc->load_err_log);
>   }
>   
> -int intel_uc_log_register(struct drm_i915_private *dev_priv)
> -{
> -	int ret = 0;
> -
> -	if (!USES_GUC(dev_priv))
> -		return 0;
> -
> -	if (i915_modparams.guc_log_level)
> -		ret = intel_guc_log_register(&dev_priv->guc);
> -
> -	return ret;
> -}
> -
> -void intel_uc_log_unregister(struct drm_i915_private *dev_priv)
> -{
> -	if (!USES_GUC(dev_priv))
> -		return;
> -
> -	if (i915_modparams.guc_log_level)
> -		intel_guc_log_unregister(&dev_priv->guc);
> -}
> -
>   static int guc_enable_communication(struct intel_guc *guc)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> diff --git a/drivers/gpu/drm/i915/intel_uc.h b/drivers/gpu/drm/i915/intel_uc.h
> index 9bc22103396d..8a7249722ef1 100644
> --- a/drivers/gpu/drm/i915/intel_uc.h
> +++ b/drivers/gpu/drm/i915/intel_uc.h
> @@ -31,8 +31,6 @@
>   void intel_uc_sanitize_options(struct drm_i915_private *dev_priv);
>   void intel_uc_init_early(struct drm_i915_private *dev_priv);
>   void intel_uc_init_mmio(struct drm_i915_private *dev_priv);
> -int intel_uc_log_register(struct drm_i915_private *dev_priv);
> -void intel_uc_log_unregister(struct drm_i915_private *dev_priv);
>   void intel_uc_init_fw(struct drm_i915_private *dev_priv);
>   void intel_uc_fini_fw(struct drm_i915_private *dev_priv);
>   int intel_uc_init_wq(struct drm_i915_private *dev_priv);

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 09/15] drm/i915/guc: Move check for fast memcpy_wc to relay creation

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> We only need those fast memcpy_wc when we're using relay to read
> continuous GuC log. Let's prevent the user from creating a relay if we
> know we won't be able to keep up with GuC.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/intel_guc_log.c | 20 ++++++++++----------
>   1 file changed, 10 insertions(+), 10 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index 4dee65692f5f..d2aca10ab986 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -452,16 +452,6 @@ int intel_guc_log_create(struct intel_guc *guc)
>   
>   	GEM_BUG_ON(guc->log.vma);
>   
> -	/*
> -	 * We require SSE 4.1 for fast reads from the GuC log buffer and
> -	 * it should be present on the chipsets supporting GuC based
> -	 * submisssions.
> -	 */
> -	if (WARN_ON(!i915_has_memcpy_from_wc())) {
> -		ret = -EINVAL;
> -		goto err;
> -	}
> -
>   	vma = intel_guc_allocate_vma(guc, GUC_LOG_SIZE);
>   	if (IS_ERR(vma)) {
>   		ret = PTR_ERR(vma);
> @@ -568,6 +558,16 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>   		goto out_unlock;
>   	}
>   
> +	/*
> +	 * We require SSE 4.1 for fast reads from the GuC log buffer and
> +	 * it should be present on the chipsets supporting GuC based
> +	 * submisssions.
> +	 */
> +	if (!i915_has_memcpy_from_wc()) {
> +		ret = -EINVAL;
> +		goto out_unlock;
> +	}
> +
>   	ret = guc_log_relay_create(guc);
>   	if (ret)
>   		goto out_unlock;

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 11/15] drm/i915/guc: Always print log stats in i915_guc_info when using GuC

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> While some of the content in this file is related to GuC submission
> only, that's not the case with log related statistics.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_debugfs.c | 15 +++++++++------
>   1 file changed, 9 insertions(+), 6 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index 4bd24bbe7966..866d44a091b3 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -2331,7 +2331,7 @@ static void i915_guc_log_info(struct seq_file *m,
>   {
>   	struct intel_guc *guc = &dev_priv->guc;
>   
> -	seq_puts(m, "\nGuC logging stats:\n");
> +	seq_puts(m, "GuC logging stats:\n");
>   
>   	seq_printf(m, "\tISR:   flush count %10u, overflow count %10u\n",
>   		   guc->log.flush_count[GUC_ISR_LOG_BUFFER],
> @@ -2379,14 +2379,19 @@ static int i915_guc_info(struct seq_file *m, void *data)
>   	struct drm_i915_private *dev_priv = node_to_i915(m->private);
>   	const struct intel_guc *guc = &dev_priv->guc;
>   
> -	if (!USES_GUC_SUBMISSION(dev_priv))
> +	if (!USES_GUC(dev_priv))
>   		return -ENODEV;
>   
> +	i915_guc_log_info(m, dev_priv);
> +
> +	if (!USES_GUC_SUBMISSION(dev_priv))
> +		return 0;
> +
>   	GEM_BUG_ON(!guc->execbuf_client);
>   
> -	seq_printf(m, "Doorbell map:\n");
> +	seq_printf(m, "\nDoorbell map:\n");
>   	seq_printf(m, "\t%*pb\n", GUC_NUM_DOORBELLS, guc->doorbell_bitmap);
> -	seq_printf(m, "Doorbell next cacheline: 0x%x\n\n", guc->db_cacheline);
> +	seq_printf(m, "Doorbell next cacheline: 0x%x\n", guc->db_cacheline);
>   
>   	seq_printf(m, "\nGuC execbuf client @ %p:\n", guc->execbuf_client);
>   	i915_guc_client_info(m, dev_priv, guc->execbuf_client);
> @@ -2396,8 +2401,6 @@ static int i915_guc_info(struct seq_file *m, void *data)
>   		i915_guc_client_info(m, dev_priv, guc->preempt_client);
>   	}
>   
> -	i915_guc_log_info(m, dev_priv);
> -
>   	/* Add more as required ... */
>   
>   	return 0;

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 10/15] drm/i915/guc: Get rid of GuC log runtime

[Sagar Arun Kamble]

I think keeping the distinction between base/mandatory members and 
runtime/optional members is okay as they are handled differently.
What do others think?

another related query, should we alloc/dealloc guc_log work queue in 
relay_open/release?

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> Keeping a separate runtime struct is only making the code dealing with
> relay less clear to read. Let's get rid of it, keeping everything in the
> log instead.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
>   drivers/gpu/drm/i915/intel_guc.c     | 14 ++++----
>   drivers/gpu/drm/i915/intel_guc_log.c | 68 ++++++++++++++++++------------------
>   drivers/gpu/drm/i915/intel_guc_log.h | 13 +++----
>   3 files changed, 46 insertions(+), 49 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> index 41f2c3b3c482..e3b6ae158a12 100644
> --- a/drivers/gpu/drm/i915/intel_guc.c
> +++ b/drivers/gpu/drm/i915/intel_guc.c
> @@ -87,9 +87,9 @@ int intel_guc_init_wq(struct intel_guc *guc)
>   	 * or scheduled later on resume. This way the handling of work
>   	 * item can be kept same between system suspend & rpm suspend.
>   	 */
> -	guc->log.runtime.flush_wq = alloc_ordered_workqueue("i915-guc_log",
> -						WQ_HIGHPRI | WQ_FREEZABLE);
> -	if (!guc->log.runtime.flush_wq) {
> +	guc->log.flush_wq = alloc_ordered_workqueue("i915-guc_log",
> +						    WQ_HIGHPRI | WQ_FREEZABLE);
> +	if (!guc->log.flush_wq) {
>   		DRM_ERROR("Couldn't allocate workqueue for GuC log\n");
>   		return -ENOMEM;
>   	}
> @@ -112,7 +112,7 @@ int intel_guc_init_wq(struct intel_guc *guc)
>   		guc->preempt_wq = alloc_ordered_workqueue("i915-guc_preempt",
>   							  WQ_HIGHPRI);
>   		if (!guc->preempt_wq) {
> -			destroy_workqueue(guc->log.runtime.flush_wq);
> +			destroy_workqueue(guc->log.flush_wq);
>   			DRM_ERROR("Couldn't allocate workqueue for GuC "
>   				  "preemption\n");
>   			return -ENOMEM;
> @@ -130,7 +130,7 @@ void intel_guc_fini_wq(struct intel_guc *guc)
>   	    USES_GUC_SUBMISSION(dev_priv))
>   		destroy_workqueue(guc->preempt_wq);
>   
> -	destroy_workqueue(guc->log.runtime.flush_wq);
> +	destroy_workqueue(guc->log.flush_wq);
>   }
>   
>   static int guc_shared_data_create(struct intel_guc *guc)
> @@ -389,8 +389,8 @@ void intel_guc_notification_handler(struct intel_guc *guc)
>   
>   	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
>   		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
> -		queue_work(guc->log.runtime.flush_wq,
> -			   &guc->log.runtime.flush_work);
> +		queue_work(guc->log.flush_wq,
> +			   &guc->log.flush_work);
>   
>   		guc->log.flush_interrupt_count++;
>   	}
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index d2aca10ab986..f95e18be1c5f 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -156,10 +156,10 @@ static void guc_move_to_next_buf(struct intel_guc *guc)
>   	smp_wmb();
>   
>   	/* All data has been written, so now move the offset of sub buffer. */
> -	relay_reserve(guc->log.runtime.relay_chan, guc->log.vma->obj->base.size);
> +	relay_reserve(guc->log.relay_chan, guc->log.vma->obj->base.size);
>   
>   	/* Switch to the next sub buffer */
> -	relay_flush(guc->log.runtime.relay_chan);
> +	relay_flush(guc->log.relay_chan);
>   }
>   
>   static void *guc_get_write_buffer(struct intel_guc *guc)
> @@ -173,7 +173,7 @@ static void *guc_get_write_buffer(struct intel_guc *guc)
>   	 * done without using relay_reserve() along with relay_write(). So its
>   	 * better to use relay_reserve() alone.
>   	 */
> -	return relay_reserve(guc->log.runtime.relay_chan, 0);
> +	return relay_reserve(guc->log.relay_chan, 0);
>   }
>   
>   static bool guc_check_log_buf_overflow(struct intel_guc *guc,
> @@ -224,11 +224,11 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   	void *src_data, *dst_data;
>   	bool new_overflow;
>   
> -	if (WARN_ON(!guc->log.runtime.buf_addr))
> +	if (WARN_ON(!guc->log.buf_addr))
>   		return;
>   
>   	/* Get the pointer to shared GuC log buffer */
> -	log_buf_state = src_data = guc->log.runtime.buf_addr;
> +	log_buf_state = src_data = guc->log.buf_addr;
>   
>   	/* Get the pointer to local buffer to store the logs */
>   	log_buf_snapshot_state = dst_data = guc_get_write_buffer(guc);
> @@ -316,16 +316,16 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   static void capture_logs_work(struct work_struct *work)
>   {
>   	struct intel_guc *guc =
> -		container_of(work, struct intel_guc, log.runtime.flush_work);
> +		container_of(work, struct intel_guc, log.flush_work);
>   
> -	mutex_lock(&guc->log.runtime.lock);
> +	mutex_lock(&guc->log.lock);
>   	guc_log_capture_logs(guc);
> -	mutex_unlock(&guc->log.runtime.lock);
> +	mutex_unlock(&guc->log.lock);
>   }
>   
> -static bool guc_log_has_runtime(struct intel_guc *guc)
> +static bool guc_log_relay_enabled(struct intel_guc *guc)
>   {
> -	return guc->log.runtime.buf_addr != NULL;
> +	return guc->log.buf_addr != NULL;
>   }
>   
>   static int guc_log_map(struct intel_guc *guc)
> @@ -354,23 +354,23 @@ static int guc_log_map(struct intel_guc *guc)
>   	}
>   	mutex_unlock(&dev_priv->drm.struct_mutex);
>   
> -	guc->log.runtime.buf_addr = vaddr;
> +	guc->log.buf_addr = vaddr;
>   
>   	return 0;
>   }
>   
>   static void guc_log_unmap(struct intel_guc *guc)
>   {
> -	lockdep_assert_held(&guc->log.runtime.lock);
> +	lockdep_assert_held(&guc->log.lock);
>   
>   	i915_gem_object_unpin_map(guc->log.vma->obj);
> -	guc->log.runtime.buf_addr = NULL;
> +	guc->log.buf_addr = NULL;
>   }
>   
>   void intel_guc_log_init_early(struct intel_guc *guc)
>   {
> -	mutex_init(&guc->log.runtime.lock);
> -	INIT_WORK(&guc->log.runtime.flush_work, capture_logs_work);
> +	mutex_init(&guc->log.lock);
> +	INIT_WORK(&guc->log.flush_work, capture_logs_work);
>   }
>   
>   int guc_log_relay_create(struct intel_guc *guc)
> @@ -380,7 +380,7 @@ int guc_log_relay_create(struct intel_guc *guc)
>   	size_t n_subbufs, subbuf_size;
>   	int ret;
>   
> -	lockdep_assert_held(&guc->log.runtime.lock);
> +	lockdep_assert_held(&guc->log.lock);
>   
>   	 /* Keep the size of sub buffers same as shared log buffer */
>   	subbuf_size = GUC_LOG_SIZE;
> @@ -410,7 +410,7 @@ int guc_log_relay_create(struct intel_guc *guc)
>   	}
>   
>   	GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
> -	guc->log.runtime.relay_chan = guc_log_relay_chan;
> +	guc->log.relay_chan = guc_log_relay_chan;
>   
>   	return 0;
>   
> @@ -422,10 +422,10 @@ int guc_log_relay_create(struct intel_guc *guc)
>   
>   void guc_log_relay_destroy(struct intel_guc *guc)
>   {
> -	lockdep_assert_held(&guc->log.runtime.lock);
> +	lockdep_assert_held(&guc->log.lock);
>   
> -	relay_close(guc->log.runtime.relay_chan);
> -	guc->log.runtime.relay_chan = NULL;
> +	relay_close(guc->log.relay_chan);
> +	guc->log.relay_chan = NULL;
>   }
>   
>   static void guc_log_capture_logs(struct intel_guc *guc)
> @@ -525,7 +525,7 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
>   	    GUC_LOG_LEVEL_TO_VERBOSITY(val) > GUC_LOG_VERBOSITY_MAX)
>   		return -EINVAL;
>   
> -	mutex_lock(&guc->log.runtime.lock);
> +	mutex_lock(&guc->log.lock);
>   
>   	if (i915_modparams.guc_log_level == val) {
>   		ret = 0;
> @@ -542,7 +542,7 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
>   	i915_modparams.guc_log_level = val;
>   
>   out_unlock:
> -	mutex_unlock(&guc->log.runtime.lock);
> +	mutex_unlock(&guc->log.lock);
>   
>   	return ret;
>   }
> @@ -551,9 +551,9 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>   {
>   	int ret;
>   
> -	mutex_lock(&guc->log.runtime.lock);
> +	mutex_lock(&guc->log.lock);
>   
> -	if (guc_log_has_runtime(guc)) {
> +	if (guc_log_relay_enabled(guc)) {
>   		ret = -EEXIST;
>   		goto out_unlock;
>   	}
> @@ -576,7 +576,7 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>   	if (ret)
>   		goto out_relay;
>   
> -	mutex_unlock(&guc->log.runtime.lock);
> +	mutex_unlock(&guc->log.lock);
>   
>   	guc_log_flush_irq_enable(guc);
>   
> @@ -585,14 +585,14 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>   	 * the flush notification. This means that we need to unconditionally
>   	 * flush on relay enabling, since GuC only notifies us once.
>   	 */
> -	queue_work(guc->log.runtime.flush_wq, &guc->log.runtime.flush_work);
> +	queue_work(guc->log.flush_wq, &guc->log.flush_work);
>   
>   	return 0;
>   
>   out_relay:
>   	guc_log_relay_destroy(guc);
>   out_unlock:
> -	mutex_unlock(&guc->log.runtime.lock);
> +	mutex_unlock(&guc->log.lock);
>   
>   	return ret;
>   }
> @@ -605,27 +605,27 @@ void intel_guc_log_relay_flush(struct intel_guc *guc)
>   	 * Before initiating the forceful flush, wait for any pending/ongoing
>   	 * flush to complete otherwise forceful flush may not actually happen.
>   	 */
> -	flush_work(&guc->log.runtime.flush_work);
> +	flush_work(&guc->log.flush_work);
>   
>   	intel_runtime_pm_get(dev_priv);
>   	guc_log_flush(guc);
>   	intel_runtime_pm_put(dev_priv);
>   
> -	mutex_lock(&guc->log.runtime.lock);
> +	mutex_lock(&guc->log.lock);
>   	/* GuC would have updated log buffer by now, so capture it */
>   	guc_log_capture_logs(guc);
> -	mutex_unlock(&guc->log.runtime.lock);
> +	mutex_unlock(&guc->log.lock);
>   }
>   
>   void intel_guc_log_relay_close(struct intel_guc *guc)
>   {
> -	GEM_BUG_ON(!guc_log_has_runtime(guc));
> +	GEM_BUG_ON(!guc_log_relay_enabled(guc));
>   
>   	guc_log_flush_irq_disable(guc);
> -	flush_work(&guc->log.runtime.flush_work);
> +	flush_work(&guc->log.flush_work);
>   
> -	mutex_lock(&guc->log.runtime.lock);
> +	mutex_lock(&guc->log.lock);
>   	guc_log_unmap(guc);
>   	guc_log_relay_destroy(guc);
> -	mutex_unlock(&guc->log.runtime.lock);
> +	mutex_unlock(&guc->log.lock);
>   }
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index df91f12a36ed..11f49ef41f01 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -42,14 +42,11 @@ struct intel_guc;
>   struct intel_guc_log {
>   	u32 flags;
>   	struct i915_vma *vma;
> -	/* The runtime stuff gets created only when GuC logging gets enabled */
> -	struct {
> -		void *buf_addr;
> -		struct workqueue_struct *flush_wq;
> -		struct work_struct flush_work;
> -		struct rchan *relay_chan;
> -		struct mutex lock;
> -	} runtime;
> +	void *buf_addr;
> +	struct workqueue_struct *flush_wq;
> +	struct work_struct flush_work;
> +	struct rchan *relay_chan;
> +	struct mutex lock;
>   	/* logging related stats */
>   	u32 capture_miss_count;
>   	u32 flush_interrupt_count;

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 12/15] drm/i915/guc: Don't print out relay statistics when relay is disabled

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> If nobody has enabled the relay, we're not comunicating with GuC, which
> means that the stats don't have any meaning. Let's also remove interrupt
> counter
reason for this? I think this was needed for verifying log flushes.
>   and tidy the debugfs formatting.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_debugfs.c  | 47 ++++++++++++++++++++++++------------
>   drivers/gpu/drm/i915/intel_guc.c     |  5 +---
>   drivers/gpu/drm/i915/intel_guc_log.c | 24 +++++++++---------
>   drivers/gpu/drm/i915/intel_guc_log.h | 12 +++++----
>   4 files changed, 51 insertions(+), 37 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index 866d44a091b3..65f758f7c425 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -2326,30 +2326,45 @@ static int i915_guc_load_status_info(struct seq_file *m, void *data)
>   	return 0;
>   }
>   
> +static const char *
> +stringify_guc_log_type(enum guc_log_buffer_type type)
> +{
> +	switch (type) {
> +	case GUC_ISR_LOG_BUFFER:
> +		return "ISR";
> +	case GUC_DPC_LOG_BUFFER:
> +		return "DPC";
> +	case GUC_CRASH_DUMP_LOG_BUFFER:
> +		return "CRASH";
> +	default:
> +		MISSING_CASE(type);
> +	}
> +
> +	return "";
> +}
> +
>   static void i915_guc_log_info(struct seq_file *m,
>   			      struct drm_i915_private *dev_priv)
>   {
>   	struct intel_guc *guc = &dev_priv->guc;
> +	enum guc_log_buffer_type type;
>   
> -	seq_puts(m, "GuC logging stats:\n");
> -
> -	seq_printf(m, "\tISR:   flush count %10u, overflow count %10u\n",
> -		   guc->log.flush_count[GUC_ISR_LOG_BUFFER],
> -		   guc->log.total_overflow_count[GUC_ISR_LOG_BUFFER]);
> -
> -	seq_printf(m, "\tDPC:   flush count %10u, overflow count %10u\n",
> -		   guc->log.flush_count[GUC_DPC_LOG_BUFFER],
> -		   guc->log.total_overflow_count[GUC_DPC_LOG_BUFFER]);
> +	if (!intel_guc_log_relay_enabled(guc)) {
> +		seq_puts(m, "GuC log relay disabled\n");
> +		return;
> +	}
>   
> -	seq_printf(m, "\tCRASH: flush count %10u, overflow count %10u\n",
> -		   guc->log.flush_count[GUC_CRASH_DUMP_LOG_BUFFER],
> -		   guc->log.total_overflow_count[GUC_CRASH_DUMP_LOG_BUFFER]);
> +	seq_puts(m, "GuC logging stats:\n");
>   
> -	seq_printf(m, "\tTotal flush interrupt count: %u\n",
> -		   guc->log.flush_interrupt_count);
> +	seq_printf(m, "\tRelay full count: %u\n",
> +		   guc->log.relay_full_count);
>   
> -	seq_printf(m, "\tCapture miss count: %u\n",
> -		   guc->log.capture_miss_count);
> +	for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
> +		seq_printf(m, "\t%s:\tflush count %10u, overflow count %10u\n",
> +			   stringify_guc_log_type(type),
> +			   guc->log.stats[type].flush,
> +			   guc->log.stats[type].overflow);
> +	}
>   }
>   
>   static void i915_guc_client_info(struct seq_file *m,
> diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> index e3b6ae158a12..0500b4164254 100644
> --- a/drivers/gpu/drm/i915/intel_guc.c
> +++ b/drivers/gpu/drm/i915/intel_guc.c
> @@ -388,12 +388,9 @@ void intel_guc_notification_handler(struct intel_guc *guc)
>   	spin_unlock(&guc->irq_lock);
>   
>   	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
> -		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
> +		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED))
>   		queue_work(guc->log.flush_wq,
>   			   &guc->log.flush_work);
> -
> -		guc->log.flush_interrupt_count++;
> -	}
>   }
>   
>   int intel_guc_sample_forcewake(struct intel_guc *guc)
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index f95e18be1c5f..bdf6b3178488 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -176,22 +176,22 @@ static void *guc_get_write_buffer(struct intel_guc *guc)
>   	return relay_reserve(guc->log.relay_chan, 0);
>   }
>   
> -static bool guc_check_log_buf_overflow(struct intel_guc *guc,
> +static bool guc_check_log_buf_overflow(struct intel_guc_log *log,
>   				       enum guc_log_buffer_type type,
>   				       unsigned int full_cnt)
>   {
> -	unsigned int prev_full_cnt = guc->log.prev_overflow_count[type];
> +	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
>   	bool overflow = false;
>   
>   	if (full_cnt != prev_full_cnt) {
>   		overflow = true;
>   
> -		guc->log.prev_overflow_count[type] = full_cnt;
> -		guc->log.total_overflow_count[type] += full_cnt - prev_full_cnt;
> +		log->stats[type].overflow = full_cnt;
> +		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
>   
>   		if (full_cnt < prev_full_cnt) {
>   			/* buffer_full_cnt is a 4 bit counter */
> -			guc->log.total_overflow_count[type] += 16;
> +			log->stats[type].overflow += 16;
Should be
log->stats[type].sampled_overflow += 16;
>   		}
>   		DRM_ERROR_RATELIMITED("GuC log buffer overflow\n");
>   	}
> @@ -224,7 +224,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   	void *src_data, *dst_data;
>   	bool new_overflow;
>   
> -	if (WARN_ON(!guc->log.buf_addr))
> +	if (WARN_ON(!intel_guc_log_relay_enabled(guc)))
>   		return;
>   
>   	/* Get the pointer to shared GuC log buffer */
> @@ -239,7 +239,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   		 * getting consumed by User at a slow rate.
>   		 */
>   		DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
> -		guc->log.capture_miss_count++;
> +		guc->log.relay_full_count++;
>   
>   		return;
>   	}
> @@ -262,8 +262,8 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   		full_cnt = log_buf_state_local.buffer_full_cnt;
>   
>   		/* Bookkeeping stuff */
> -		guc->log.flush_count[type] += log_buf_state_local.flush_to_file;
> -		new_overflow = guc_check_log_buf_overflow(guc, type, full_cnt);
> +		guc->log.stats[type].flush += log_buf_state_local.flush_to_file;
> +		new_overflow = guc_check_log_buf_overflow(&guc->log, type, full_cnt);
>   
>   		/* Update the state of shared log buffer */
>   		log_buf_state->read_ptr = write_offset;
> @@ -323,7 +323,7 @@ static void capture_logs_work(struct work_struct *work)
>   	mutex_unlock(&guc->log.lock);
>   }
>   
> -static bool guc_log_relay_enabled(struct intel_guc *guc)
> +bool intel_guc_log_relay_enabled(struct intel_guc *guc)
>   {
>   	return guc->log.buf_addr != NULL;
>   }
> @@ -553,7 +553,7 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>   
>   	mutex_lock(&guc->log.lock);
>   
> -	if (guc_log_relay_enabled(guc)) {
> +	if (intel_guc_log_relay_enabled(guc)) {
>   		ret = -EEXIST;
>   		goto out_unlock;
>   	}
> @@ -619,7 +619,7 @@ void intel_guc_log_relay_flush(struct intel_guc *guc)
>   
>   void intel_guc_log_relay_close(struct intel_guc *guc)
>   {
> -	GEM_BUG_ON(!guc_log_relay_enabled(guc));
> +	GEM_BUG_ON(!intel_guc_log_relay_enabled(guc));
>   
>   	guc_log_flush_irq_disable(guc);
>   	flush_work(&guc->log.flush_work);
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index 11f49ef41f01..a8ccb04e2b0a 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -48,11 +48,12 @@ struct intel_guc_log {
>   	struct rchan *relay_chan;
>   	struct mutex lock;
>   	/* logging related stats */
> -	u32 capture_miss_count;
> -	u32 flush_interrupt_count;
> -	u32 prev_overflow_count[GUC_MAX_LOG_BUFFER];
> -	u32 total_overflow_count[GUC_MAX_LOG_BUFFER];
> -	u32 flush_count[GUC_MAX_LOG_BUFFER];
> +	u32 relay_full_count;
> +	struct {
> +		u32 sampled_overflow;
> +		u32 overflow;
> +		u32 flush;
> +	} stats[GUC_MAX_LOG_BUFFER];
>   };
>   
>   int intel_guc_log_create(struct intel_guc *guc);
> @@ -63,5 +64,6 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 control_val);
>   int intel_guc_log_relay_open(struct intel_guc *guc);
>   void intel_guc_log_relay_close(struct intel_guc *guc);
>   void intel_guc_log_relay_flush(struct intel_guc *guc);
> +bool intel_guc_log_relay_enabled(struct intel_guc *guc);
>   
>   #endif

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 13/15] drm/i915/guc: Allow user to control default GuC logging

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> While both naming and actual log enable logic in GuC interface are
> confusing, we can simply expose the default log as yet another log
> level.
> GuC logic aside, from i915 point of view we now have the following GuC
> log levels:
> 	0 Log disabled
> 	1 Non-verbose log
> 	2-5 Verbose log
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Change looks good.
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>

Firmware should have enabled default logging internally without user 
controls or should have created new verbosity level.
This was supposed to be fixed in the firmware based on the discussion 
here https://patchwork.freedesktop.org/patch/178281/
Until this gets fixed in firmware, this patch will be needed for 
multiple log captures.
> ---
>   drivers/gpu/drm/i915/intel_guc.c      | 21 ++++++++++++---------
>   drivers/gpu/drm/i915/intel_guc_fwif.h |  5 +++--
>   drivers/gpu/drm/i915/intel_guc_log.c  |  9 +++++----
>   drivers/gpu/drm/i915/intel_guc_log.h  | 11 +++++++++++
>   drivers/gpu/drm/i915/intel_uc.c       | 14 +++++++++-----
>   5 files changed, 40 insertions(+), 20 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> index 0500b4164254..83d813a6ff92 100644
> --- a/drivers/gpu/drm/i915/intel_guc.c
> +++ b/drivers/gpu/drm/i915/intel_guc.c
> @@ -221,17 +221,20 @@ static u32 get_core_family(struct drm_i915_private *dev_priv)
>   	}
>   }
>   
> -static u32 get_log_verbosity_flags(void)
> +static u32 get_log_control_flags(void)
>   {
> -	if (i915_modparams.guc_log_level > 0) {
> -		u32 verbosity = i915_modparams.guc_log_level - 1;
> +	u32 level = i915_modparams.guc_log_level;
> +	u32 flags = 0;
>   
> -		GEM_BUG_ON(verbosity > GUC_LOG_VERBOSITY_MAX);
> -		return verbosity << GUC_LOG_VERBOSITY_SHIFT;
> -	}
> +	GEM_BUG_ON(level < 0);
> +
> +	if (!GUC_LOG_IS_ENABLED(level))
> +		flags = GUC_LOG_DEFAULT_DISABLED | GUC_LOG_DISABLED;
> +	else if (GUC_LOG_IS_VERBOSE(level))
> +		flags = GUC_LOG_LEVEL_TO_VERBOSITY(level) <<
> +			GUC_LOG_VERBOSITY_SHIFT;
>   
> -	GEM_BUG_ON(i915_modparams.enable_guc < 0);
> -	return GUC_LOG_DISABLED;
> +	return flags;
>   }
>   
>   /*
> @@ -266,7 +269,7 @@ void intel_guc_init_params(struct intel_guc *guc)
>   
>   	params[GUC_CTL_LOG_PARAMS] = guc->log.flags;
>   
> -	params[GUC_CTL_DEBUG] = get_log_verbosity_flags();
> +	params[GUC_CTL_DEBUG] = get_log_control_flags();
>   
>   	/* If GuC submission is enabled, set up additional parameters here */
>   	if (USES_GUC_SUBMISSION(dev_priv)) {
> diff --git a/drivers/gpu/drm/i915/intel_guc_fwif.h b/drivers/gpu/drm/i915/intel_guc_fwif.h
> index 6a10aa6f04d3..4971685a2ea8 100644
> --- a/drivers/gpu/drm/i915/intel_guc_fwif.h
> +++ b/drivers/gpu/drm/i915/intel_guc_fwif.h
> @@ -127,7 +127,7 @@
>   #define   GUC_PROFILE_ENABLED		(1 << 7)
>   #define   GUC_WQ_TRACK_ENABLED		(1 << 8)
>   #define   GUC_ADS_ENABLED		(1 << 9)
> -#define   GUC_DEBUG_RESERVED		(1 << 10)
> +#define   GUC_LOG_DEFAULT_DISABLED	(1 << 10)
>   #define   GUC_ADS_ADDR_SHIFT		11
>   #define   GUC_ADS_ADDR_MASK		0xfffff800
>   
> @@ -539,7 +539,8 @@ union guc_log_control {
>   		u32 logging_enabled:1;
>   		u32 reserved1:3;
>   		u32 verbosity:4;
> -		u32 reserved2:24;
> +		u32 default_logging:1;
> +		u32 reserved2:23;
>   	};
>   	u32 value;
>   } __packed;
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index bdf6b3178488..ade7dadc34b8 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -58,11 +58,13 @@ static int guc_log_flush(struct intel_guc *guc)
>   	return intel_guc_send(guc, action, ARRAY_SIZE(action));
>   }
>   
> -static int guc_log_control(struct intel_guc *guc, bool enable, u32 verbosity)
> +static int guc_log_control(struct intel_guc *guc, bool enable,
> +			   bool default_logging, u32 verbosity)
>   {
>   	union guc_log_control control_val = {
>   		.logging_enabled = enable,
>   		.verbosity = verbosity,
> +		.default_logging = default_logging,
>   	};
>   	u32 action[] = {
>   		INTEL_GUC_ACTION_UK_LOG_ENABLE_LOGGING,
> @@ -506,8 +508,6 @@ int intel_guc_log_level_get(struct intel_guc *guc)
>   	return i915_modparams.guc_log_level;
>   }
>   
> -#define GUC_LOG_IS_ENABLED(x)		(x > 0)
> -#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_ENABLED(x) ? x - 1 : 0)
>   int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
>   {
>   	struct drm_i915_private *dev_priv = guc_to_i915(guc);
> @@ -533,7 +533,8 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 val)
>   	}
>   
>   	intel_runtime_pm_get(dev_priv);
> -	ret = guc_log_control(guc, GUC_LOG_IS_ENABLED(val),
> +	ret = guc_log_control(guc, GUC_LOG_IS_VERBOSE(val),
> +			      GUC_LOG_IS_ENABLED(val),
>   			      GUC_LOG_LEVEL_TO_VERBOSITY(val));
>   	intel_runtime_pm_put(dev_priv);
>   	if (ret)
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index a8ccb04e2b0a..a91d94da5543 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -39,6 +39,17 @@ struct intel_guc;
>   #define GUC_LOG_SIZE	((1 + GUC_LOG_DPC_PAGES + 1 + GUC_LOG_ISR_PAGES + \
>   			  1 + GUC_LOG_CRASH_PAGES + 1) << PAGE_SHIFT)
>   
> +/*
> + * While we're using plain log level in i915, GuC controls are much more...
> + * "elaborate"? We have a couple of bits for verbosity, separate bit for actual
> + * log enabling, and separate bit for default logging - which "conveniently"
> + * ignores the enable bit.
> + */
> +#define GUC_LOG_IS_ENABLED(x)		(x > 0)
> +#define GUC_LOG_IS_VERBOSE(x)		(x > 1)
> +#define GUC_LOG_LEVEL_TO_VERBOSITY(x)	(GUC_LOG_IS_VERBOSE(x) ? x - 2 : 0)
> +#define GUC_LOG_VERBOSITY_TO_LEVEL(x)	(x + 2)
> +
>   struct intel_guc_log {
>   	u32 flags;
>   	struct i915_vma *vma;
> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> index 27e1f4c43b7b..9884a79c77bd 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -75,7 +75,8 @@ static int __get_default_guc_log_level(struct drm_i915_private *dev_priv)
>   	if (HAS_GUC(dev_priv) && intel_uc_is_using_guc() &&
>   	    (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
>   	     IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)))
> -		guc_log_level = 1 + GUC_LOG_VERBOSITY_MAX;
> +		guc_log_level =
> +			GUC_LOG_VERBOSITY_TO_LEVEL(GUC_LOG_VERBOSITY_MAX);
>   
>   	/* Any platform specific fine-tuning can be done here */
>   
> @@ -142,17 +143,20 @@ void intel_uc_sanitize_options(struct drm_i915_private *dev_priv)
>   		i915_modparams.guc_log_level = 0;
>   	}
>   
> -	if (i915_modparams.guc_log_level > 1 + GUC_LOG_VERBOSITY_MAX) {
> +	if (i915_modparams.guc_log_level >
> +	    GUC_LOG_VERBOSITY_TO_LEVEL(GUC_LOG_VERBOSITY_MAX)) {
>   		DRM_WARN("Incompatible option detected: %s=%d, %s!\n",
>   			 "guc_log_level", i915_modparams.guc_log_level,
>   			 "verbosity too high");
> -		i915_modparams.guc_log_level = 1 + GUC_LOG_VERBOSITY_MAX;
> +		i915_modparams.guc_log_level =
> +			GUC_LOG_VERBOSITY_TO_LEVEL(GUC_LOG_VERBOSITY_MAX);
>   	}
>   
> -	DRM_DEBUG_DRIVER("guc_log_level=%d (enabled:%s verbosity:%d)\n",
> +	DRM_DEBUG_DRIVER("guc_log_level=%d (enabled:%s, verbose:%s, verbosity:%d)\n",
>   			 i915_modparams.guc_log_level,
>   			 yesno(i915_modparams.guc_log_level),
> -			 i915_modparams.guc_log_level - 1);
> +			 yesno(GUC_LOG_IS_VERBOSE(i915_modparams.guc_log_level)),
> +			 GUC_LOG_LEVEL_TO_VERBOSITY(i915_modparams.guc_log_level));
>   
>   	/* Make sure that sanitization was done */
>   	GEM_BUG_ON(i915_modparams.enable_guc < 0);

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 12/15] drm/i915/guc: Don't print out relay statistics when relay is disabled

[Michał Winiarski]

On Tue, Mar 06, 2018 at 04:51:27PM +0530, Sagar Arun Kamble wrote:
> 
> 
> On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> > If nobody has enabled the relay, we're not comunicating with GuC, which
> > means that the stats don't have any meaning. Let's also remove interrupt
> > counter
> reason for this? I think this was needed for verifying log flushes.

I'm simply not a fan of random debugfs counters.
Is someone really using this?
We do have individual flush counts, do we really need to count the interrupts?

> >   and tidy the debugfs formatting.
> > 
> > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > ---
> >   drivers/gpu/drm/i915/i915_debugfs.c  | 47 ++++++++++++++++++++++++------------
> >   drivers/gpu/drm/i915/intel_guc.c     |  5 +---
> >   drivers/gpu/drm/i915/intel_guc_log.c | 24 +++++++++---------
> >   drivers/gpu/drm/i915/intel_guc_log.h | 12 +++++----
> >   4 files changed, 51 insertions(+), 37 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> > index 866d44a091b3..65f758f7c425 100644
> > --- a/drivers/gpu/drm/i915/i915_debugfs.c
> > +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> > @@ -2326,30 +2326,45 @@ static int i915_guc_load_status_info(struct seq_file *m, void *data)
> >   	return 0;
> >   }
> > +static const char *
> > +stringify_guc_log_type(enum guc_log_buffer_type type)
> > +{
> > +	switch (type) {
> > +	case GUC_ISR_LOG_BUFFER:
> > +		return "ISR";
> > +	case GUC_DPC_LOG_BUFFER:
> > +		return "DPC";
> > +	case GUC_CRASH_DUMP_LOG_BUFFER:
> > +		return "CRASH";
> > +	default:
> > +		MISSING_CASE(type);
> > +	}
> > +
> > +	return "";
> > +}
> > +
> >   static void i915_guc_log_info(struct seq_file *m,
> >   			      struct drm_i915_private *dev_priv)
> >   {
> >   	struct intel_guc *guc = &dev_priv->guc;
> > +	enum guc_log_buffer_type type;
> > -	seq_puts(m, "GuC logging stats:\n");
> > -
> > -	seq_printf(m, "\tISR:   flush count %10u, overflow count %10u\n",
> > -		   guc->log.flush_count[GUC_ISR_LOG_BUFFER],
> > -		   guc->log.total_overflow_count[GUC_ISR_LOG_BUFFER]);
> > -
> > -	seq_printf(m, "\tDPC:   flush count %10u, overflow count %10u\n",
> > -		   guc->log.flush_count[GUC_DPC_LOG_BUFFER],
> > -		   guc->log.total_overflow_count[GUC_DPC_LOG_BUFFER]);
> > +	if (!intel_guc_log_relay_enabled(guc)) {
> > +		seq_puts(m, "GuC log relay disabled\n");
> > +		return;
> > +	}
> > -	seq_printf(m, "\tCRASH: flush count %10u, overflow count %10u\n",
> > -		   guc->log.flush_count[GUC_CRASH_DUMP_LOG_BUFFER],
> > -		   guc->log.total_overflow_count[GUC_CRASH_DUMP_LOG_BUFFER]);
> > +	seq_puts(m, "GuC logging stats:\n");
> > -	seq_printf(m, "\tTotal flush interrupt count: %u\n",
> > -		   guc->log.flush_interrupt_count);
> > +	seq_printf(m, "\tRelay full count: %u\n",
> > +		   guc->log.relay_full_count);
> > -	seq_printf(m, "\tCapture miss count: %u\n",
> > -		   guc->log.capture_miss_count);
> > +	for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
> > +		seq_printf(m, "\t%s:\tflush count %10u, overflow count %10u\n",
> > +			   stringify_guc_log_type(type),
> > +			   guc->log.stats[type].flush,
> > +			   guc->log.stats[type].overflow);
> > +	}
> >   }
> >   static void i915_guc_client_info(struct seq_file *m,
> > diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> > index e3b6ae158a12..0500b4164254 100644
> > --- a/drivers/gpu/drm/i915/intel_guc.c
> > +++ b/drivers/gpu/drm/i915/intel_guc.c
> > @@ -388,12 +388,9 @@ void intel_guc_notification_handler(struct intel_guc *guc)
> >   	spin_unlock(&guc->irq_lock);
> >   	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
> > -		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
> > +		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED))
> >   		queue_work(guc->log.flush_wq,
> >   			   &guc->log.flush_work);
> > -
> > -		guc->log.flush_interrupt_count++;
> > -	}
> >   }
> >   int intel_guc_sample_forcewake(struct intel_guc *guc)
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> > index f95e18be1c5f..bdf6b3178488 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.c
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> > @@ -176,22 +176,22 @@ static void *guc_get_write_buffer(struct intel_guc *guc)
> >   	return relay_reserve(guc->log.relay_chan, 0);
> >   }
> > -static bool guc_check_log_buf_overflow(struct intel_guc *guc,
> > +static bool guc_check_log_buf_overflow(struct intel_guc_log *log,
> >   				       enum guc_log_buffer_type type,
> >   				       unsigned int full_cnt)
> >   {
> > -	unsigned int prev_full_cnt = guc->log.prev_overflow_count[type];
> > +	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
> >   	bool overflow = false;
> >   	if (full_cnt != prev_full_cnt) {
> >   		overflow = true;
> > -		guc->log.prev_overflow_count[type] = full_cnt;
> > -		guc->log.total_overflow_count[type] += full_cnt - prev_full_cnt;
> > +		log->stats[type].overflow = full_cnt;
> > +		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
> >   		if (full_cnt < prev_full_cnt) {
> >   			/* buffer_full_cnt is a 4 bit counter */
> > -			guc->log.total_overflow_count[type] += 16;
> > +			log->stats[type].overflow += 16;
> Should be
> log->stats[type].sampled_overflow += 16;

Oops.

-Michał

> >   		}
> >   		DRM_ERROR_RATELIMITED("GuC log buffer overflow\n");
> >   	}
> > @@ -224,7 +224,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
> >   	void *src_data, *dst_data;
> >   	bool new_overflow;
> > -	if (WARN_ON(!guc->log.buf_addr))
> > +	if (WARN_ON(!intel_guc_log_relay_enabled(guc)))
> >   		return;
> >   	/* Get the pointer to shared GuC log buffer */
> > @@ -239,7 +239,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
> >   		 * getting consumed by User at a slow rate.
> >   		 */
> >   		DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
> > -		guc->log.capture_miss_count++;
> > +		guc->log.relay_full_count++;
> >   		return;
> >   	}
> > @@ -262,8 +262,8 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
> >   		full_cnt = log_buf_state_local.buffer_full_cnt;
> >   		/* Bookkeeping stuff */
> > -		guc->log.flush_count[type] += log_buf_state_local.flush_to_file;
> > -		new_overflow = guc_check_log_buf_overflow(guc, type, full_cnt);
> > +		guc->log.stats[type].flush += log_buf_state_local.flush_to_file;
> > +		new_overflow = guc_check_log_buf_overflow(&guc->log, type, full_cnt);
> >   		/* Update the state of shared log buffer */
> >   		log_buf_state->read_ptr = write_offset;
> > @@ -323,7 +323,7 @@ static void capture_logs_work(struct work_struct *work)
> >   	mutex_unlock(&guc->log.lock);
> >   }
> > -static bool guc_log_relay_enabled(struct intel_guc *guc)
> > +bool intel_guc_log_relay_enabled(struct intel_guc *guc)
> >   {
> >   	return guc->log.buf_addr != NULL;
> >   }
> > @@ -553,7 +553,7 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
> >   	mutex_lock(&guc->log.lock);
> > -	if (guc_log_relay_enabled(guc)) {
> > +	if (intel_guc_log_relay_enabled(guc)) {
> >   		ret = -EEXIST;
> >   		goto out_unlock;
> >   	}
> > @@ -619,7 +619,7 @@ void intel_guc_log_relay_flush(struct intel_guc *guc)
> >   void intel_guc_log_relay_close(struct intel_guc *guc)
> >   {
> > -	GEM_BUG_ON(!guc_log_relay_enabled(guc));
> > +	GEM_BUG_ON(!intel_guc_log_relay_enabled(guc));
> >   	guc_log_flush_irq_disable(guc);
> >   	flush_work(&guc->log.flush_work);
> > diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> > index 11f49ef41f01..a8ccb04e2b0a 100644
> > --- a/drivers/gpu/drm/i915/intel_guc_log.h
> > +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> > @@ -48,11 +48,12 @@ struct intel_guc_log {
> >   	struct rchan *relay_chan;
> >   	struct mutex lock;
> >   	/* logging related stats */
> > -	u32 capture_miss_count;
> > -	u32 flush_interrupt_count;
> > -	u32 prev_overflow_count[GUC_MAX_LOG_BUFFER];
> > -	u32 total_overflow_count[GUC_MAX_LOG_BUFFER];
> > -	u32 flush_count[GUC_MAX_LOG_BUFFER];
> > +	u32 relay_full_count;
> > +	struct {
> > +		u32 sampled_overflow;
> > +		u32 overflow;
> > +		u32 flush;
> > +	} stats[GUC_MAX_LOG_BUFFER];
> >   };
> >   int intel_guc_log_create(struct intel_guc *guc);
> > @@ -63,5 +64,6 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 control_val);
> >   int intel_guc_log_relay_open(struct intel_guc *guc);
> >   void intel_guc_log_relay_close(struct intel_guc *guc);
> >   void intel_guc_log_relay_flush(struct intel_guc *guc);
> > +bool intel_guc_log_relay_enabled(struct intel_guc *guc);
> >   #endif
> 
> -- 
> Thanks,
> Sagar
> 
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 12/15] drm/i915/guc: Don't print out relay statistics when relay is disabled

[Sagar Arun Kamble]

I think we should also clear the stats.count and relay_full_count on 
relay_open.

Thanks
Sagar

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> If nobody has enabled the relay, we're not comunicating with GuC, which
> means that the stats don't have any meaning. Let's also remove interrupt
> counter and tidy the debugfs formatting.
>
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_debugfs.c  | 47 ++++++++++++++++++++++++------------
>   drivers/gpu/drm/i915/intel_guc.c     |  5 +---
>   drivers/gpu/drm/i915/intel_guc_log.c | 24 +++++++++---------
>   drivers/gpu/drm/i915/intel_guc_log.h | 12 +++++----
>   4 files changed, 51 insertions(+), 37 deletions(-)
>
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index 866d44a091b3..65f758f7c425 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -2326,30 +2326,45 @@ static int i915_guc_load_status_info(struct seq_file *m, void *data)
>   	return 0;
>   }
>   
> +static const char *
> +stringify_guc_log_type(enum guc_log_buffer_type type)
> +{
> +	switch (type) {
> +	case GUC_ISR_LOG_BUFFER:
> +		return "ISR";
> +	case GUC_DPC_LOG_BUFFER:
> +		return "DPC";
> +	case GUC_CRASH_DUMP_LOG_BUFFER:
> +		return "CRASH";
> +	default:
> +		MISSING_CASE(type);
> +	}
> +
> +	return "";
> +}
> +
>   static void i915_guc_log_info(struct seq_file *m,
>   			      struct drm_i915_private *dev_priv)
>   {
>   	struct intel_guc *guc = &dev_priv->guc;
> +	enum guc_log_buffer_type type;
>   
> -	seq_puts(m, "GuC logging stats:\n");
> -
> -	seq_printf(m, "\tISR:   flush count %10u, overflow count %10u\n",
> -		   guc->log.flush_count[GUC_ISR_LOG_BUFFER],
> -		   guc->log.total_overflow_count[GUC_ISR_LOG_BUFFER]);
> -
> -	seq_printf(m, "\tDPC:   flush count %10u, overflow count %10u\n",
> -		   guc->log.flush_count[GUC_DPC_LOG_BUFFER],
> -		   guc->log.total_overflow_count[GUC_DPC_LOG_BUFFER]);
> +	if (!intel_guc_log_relay_enabled(guc)) {
> +		seq_puts(m, "GuC log relay disabled\n");
> +		return;
> +	}
>   
> -	seq_printf(m, "\tCRASH: flush count %10u, overflow count %10u\n",
> -		   guc->log.flush_count[GUC_CRASH_DUMP_LOG_BUFFER],
> -		   guc->log.total_overflow_count[GUC_CRASH_DUMP_LOG_BUFFER]);
> +	seq_puts(m, "GuC logging stats:\n");
>   
> -	seq_printf(m, "\tTotal flush interrupt count: %u\n",
> -		   guc->log.flush_interrupt_count);
> +	seq_printf(m, "\tRelay full count: %u\n",
> +		   guc->log.relay_full_count);
>   
> -	seq_printf(m, "\tCapture miss count: %u\n",
> -		   guc->log.capture_miss_count);
> +	for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
> +		seq_printf(m, "\t%s:\tflush count %10u, overflow count %10u\n",
> +			   stringify_guc_log_type(type),
> +			   guc->log.stats[type].flush,
> +			   guc->log.stats[type].overflow);
> +	}
>   }
>   
>   static void i915_guc_client_info(struct seq_file *m,
> diff --git a/drivers/gpu/drm/i915/intel_guc.c b/drivers/gpu/drm/i915/intel_guc.c
> index e3b6ae158a12..0500b4164254 100644
> --- a/drivers/gpu/drm/i915/intel_guc.c
> +++ b/drivers/gpu/drm/i915/intel_guc.c
> @@ -388,12 +388,9 @@ void intel_guc_notification_handler(struct intel_guc *guc)
>   	spin_unlock(&guc->irq_lock);
>   
>   	if (msg & (INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
> -		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED)) {
> +		   INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED))
>   		queue_work(guc->log.flush_wq,
>   			   &guc->log.flush_work);
> -
> -		guc->log.flush_interrupt_count++;
> -	}
>   }
>   
>   int intel_guc_sample_forcewake(struct intel_guc *guc)
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.c b/drivers/gpu/drm/i915/intel_guc_log.c
> index f95e18be1c5f..bdf6b3178488 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.c
> +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> @@ -176,22 +176,22 @@ static void *guc_get_write_buffer(struct intel_guc *guc)
>   	return relay_reserve(guc->log.relay_chan, 0);
>   }
>   
> -static bool guc_check_log_buf_overflow(struct intel_guc *guc,
> +static bool guc_check_log_buf_overflow(struct intel_guc_log *log,
>   				       enum guc_log_buffer_type type,
>   				       unsigned int full_cnt)
>   {
> -	unsigned int prev_full_cnt = guc->log.prev_overflow_count[type];
> +	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
>   	bool overflow = false;
>   
>   	if (full_cnt != prev_full_cnt) {
>   		overflow = true;
>   
> -		guc->log.prev_overflow_count[type] = full_cnt;
> -		guc->log.total_overflow_count[type] += full_cnt - prev_full_cnt;
> +		log->stats[type].overflow = full_cnt;
> +		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
>   
>   		if (full_cnt < prev_full_cnt) {
>   			/* buffer_full_cnt is a 4 bit counter */
> -			guc->log.total_overflow_count[type] += 16;
> +			log->stats[type].overflow += 16;
>   		}
>   		DRM_ERROR_RATELIMITED("GuC log buffer overflow\n");
>   	}
> @@ -224,7 +224,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   	void *src_data, *dst_data;
>   	bool new_overflow;
>   
> -	if (WARN_ON(!guc->log.buf_addr))
> +	if (WARN_ON(!intel_guc_log_relay_enabled(guc)))
>   		return;
>   
>   	/* Get the pointer to shared GuC log buffer */
> @@ -239,7 +239,7 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   		 * getting consumed by User at a slow rate.
>   		 */
>   		DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
> -		guc->log.capture_miss_count++;
> +		guc->log.relay_full_count++;
>   
>   		return;
>   	}
> @@ -262,8 +262,8 @@ static void guc_read_update_log_buffer(struct intel_guc *guc)
>   		full_cnt = log_buf_state_local.buffer_full_cnt;
>   
>   		/* Bookkeeping stuff */
> -		guc->log.flush_count[type] += log_buf_state_local.flush_to_file;
> -		new_overflow = guc_check_log_buf_overflow(guc, type, full_cnt);
> +		guc->log.stats[type].flush += log_buf_state_local.flush_to_file;
> +		new_overflow = guc_check_log_buf_overflow(&guc->log, type, full_cnt);
>   
>   		/* Update the state of shared log buffer */
>   		log_buf_state->read_ptr = write_offset;
> @@ -323,7 +323,7 @@ static void capture_logs_work(struct work_struct *work)
>   	mutex_unlock(&guc->log.lock);
>   }
>   
> -static bool guc_log_relay_enabled(struct intel_guc *guc)
> +bool intel_guc_log_relay_enabled(struct intel_guc *guc)
>   {
>   	return guc->log.buf_addr != NULL;
>   }
> @@ -553,7 +553,7 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
>   
>   	mutex_lock(&guc->log.lock);
>   
> -	if (guc_log_relay_enabled(guc)) {
> +	if (intel_guc_log_relay_enabled(guc)) {
>   		ret = -EEXIST;
>   		goto out_unlock;
>   	}
> @@ -619,7 +619,7 @@ void intel_guc_log_relay_flush(struct intel_guc *guc)
>   
>   void intel_guc_log_relay_close(struct intel_guc *guc)
>   {
> -	GEM_BUG_ON(!guc_log_relay_enabled(guc));
> +	GEM_BUG_ON(!intel_guc_log_relay_enabled(guc));
>   
>   	guc_log_flush_irq_disable(guc);
>   	flush_work(&guc->log.flush_work);
> diff --git a/drivers/gpu/drm/i915/intel_guc_log.h b/drivers/gpu/drm/i915/intel_guc_log.h
> index 11f49ef41f01..a8ccb04e2b0a 100644
> --- a/drivers/gpu/drm/i915/intel_guc_log.h
> +++ b/drivers/gpu/drm/i915/intel_guc_log.h
> @@ -48,11 +48,12 @@ struct intel_guc_log {
>   	struct rchan *relay_chan;
>   	struct mutex lock;
>   	/* logging related stats */
> -	u32 capture_miss_count;
> -	u32 flush_interrupt_count;
> -	u32 prev_overflow_count[GUC_MAX_LOG_BUFFER];
> -	u32 total_overflow_count[GUC_MAX_LOG_BUFFER];
> -	u32 flush_count[GUC_MAX_LOG_BUFFER];
> +	u32 relay_full_count;
> +	struct {
> +		u32 sampled_overflow;
> +		u32 overflow;
> +		u32 flush;
> +	} stats[GUC_MAX_LOG_BUFFER];
>   };
>   
>   int intel_guc_log_create(struct intel_guc *guc);
> @@ -63,5 +64,6 @@ int intel_guc_log_level_set(struct intel_guc *guc, u64 control_val);
>   int intel_guc_log_relay_open(struct intel_guc *guc);
>   void intel_guc_log_relay_close(struct intel_guc *guc);
>   void intel_guc_log_relay_flush(struct intel_guc *guc);
> +bool intel_guc_log_relay_enabled(struct intel_guc *guc);
>   
>   #endif

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 14/15] drm/i915/guc: Default to non-verbose GuC logging

[Sagar Arun Kamble]

On 2/27/2018 6:22 PM, Michał Winiarski wrote:
> Now that we've decoupled logging from relay, GuC log level is only
> controlling the GuC behavior - there shouldn't be any impact on i915
> behaviour. We're only going to see a single extra interrupt when log
> will get half full.
> That, and the fact that we're seeing igt/gem_exec_nop/basic-series
> failing with non-verbose logging being disabled.
Looks like gem_sync is now passing with non-verbose logging disabled :)
> Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Reviewed-by: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> ---
>   drivers/gpu/drm/i915/intel_uc.c | 2 +-
>   1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/drivers/gpu/drm/i915/intel_uc.c b/drivers/gpu/drm/i915/intel_uc.c
> index 9884a79c77bd..cd6203740c07 100644
> --- a/drivers/gpu/drm/i915/intel_uc.c
> +++ b/drivers/gpu/drm/i915/intel_uc.c
> @@ -69,7 +69,7 @@ static int __get_platform_enable_guc(struct drm_i915_private *dev_priv)
>   
>   static int __get_default_guc_log_level(struct drm_i915_private *dev_priv)
>   {
> -	int guc_log_level = 0; /* disabled */
> +	int guc_log_level = 1; /* non-verbose */
>   
>   	/* Enable if we're running on platform with GuC and debug config */
>   	if (HAS_GUC(dev_priv) && intel_uc_is_using_guc() &&

-- 
Thanks,
Sagar

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 05/15] drm/i915/guc: Log runtime should consist of both mapping and relay

[Chris Wilson]

Quoting Michał Winiarski (2018-02-27 12:52:20)
> -static int guc_log_runtime_create(struct intel_guc *guc)
> +static int guc_log_map(struct intel_guc *guc)
>  {
>         struct drm_i915_private *dev_priv = guc_to_i915(guc);
>         void *vaddr;
>         int ret;
>  
> -       lockdep_assert_held(&dev_priv->drm.struct_mutex);
> -
>         if (!guc->log.vma)
>                 return -ENODEV;
>  
> -       GEM_BUG_ON(guc_log_has_runtime(guc));
> -
> +       mutex_lock(&dev_priv->drm.struct_mutex);
>         ret = i915_gem_object_set_to_wc_domain(guc->log.vma->obj, true);
>         if (ret)
>                 return ret;
> @@ -416,20 +390,16 @@ static int guc_log_runtime_create(struct intel_guc *guc)
>                 DRM_ERROR("Couldn't map log buffer pages %d\n", ret);
>                 return PTR_ERR(vaddr);
>         }
> +       mutex_unlock(&dev_priv->drm.struct_mutex);

Whilst you are here, we don't need struct_mutex for
i915_gem_object_pin_map(), and we don't strictly need it for
set_to_wc_domain, but I haven't replaced that with
i915_gem_object_lock() yet.

If you could restrict the locking to set_to_wc_domain (and not introduce
an unbalanced lock on error return) that would be grand.

	mutex_lock(&dev_priv->drm.struct_mutex);
	ret = i915_gem_object_set_to_wc_domain(guc->log.vma->obj, true);
	mutex_unlock(&dev_priv->drm.struct_mutex);
	if (ret)
		return ret;
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 09/15] drm/i915/guc: Move check for fast memcpy_wc to relay creation

[Chris Wilson]

Quoting Michał Winiarski (2018-02-27 15:37:04)
> On Tue, Feb 27, 2018 at 03:37:25PM +0100, Michal Wajdeczko wrote:
> > On Tue, 27 Feb 2018 13:52:24 +0100, Michał Winiarski
> > <michal.winiarski@intel.com> wrote:
> > 
> > > We only need those fast memcpy_wc when we're using relay to read
> > > continuous GuC log. Let's prevent the user from creating a relay if we
> > > know we won't be able to keep up with GuC.
> > > 
> > > Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
> > > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > > Cc: Sagar Arun Kamble <sagar.a.kamble@intel.com>
> > > Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > ---
> > >  drivers/gpu/drm/i915/intel_guc_log.c | 20 ++++++++++----------
> > >  1 file changed, 10 insertions(+), 10 deletions(-)
> > > 
> > > diff --git a/drivers/gpu/drm/i915/intel_guc_log.c
> > > b/drivers/gpu/drm/i915/intel_guc_log.c
> > > index 4dee65692f5f..d2aca10ab986 100644
> > > --- a/drivers/gpu/drm/i915/intel_guc_log.c
> > > +++ b/drivers/gpu/drm/i915/intel_guc_log.c
> > > @@ -452,16 +452,6 @@ int intel_guc_log_create(struct intel_guc *guc)
> > >     GEM_BUG_ON(guc->log.vma);
> > > -   /*
> > > -    * We require SSE 4.1 for fast reads from the GuC log buffer and
> > > -    * it should be present on the chipsets supporting GuC based
> > > -    * submisssions.
> > > -    */
> > > -   if (WARN_ON(!i915_has_memcpy_from_wc())) {
> > > -           ret = -EINVAL;
> > > -           goto err;
> > > -   }
> > > -
> > >     vma = intel_guc_allocate_vma(guc, GUC_LOG_SIZE);
> > >     if (IS_ERR(vma)) {
> > >             ret = PTR_ERR(vma);
> > > @@ -568,6 +558,16 @@ int intel_guc_log_relay_open(struct intel_guc *guc)
> > >             goto out_unlock;
> > >     }
> > > +   /*
> > > +    * We require SSE 4.1 for fast reads from the GuC log buffer and
> > > +    * it should be present on the chipsets supporting GuC based
> > > +    * submisssions.
> > > +    */
> > > +   if (!i915_has_memcpy_from_wc()) {
> > > +           ret = -EINVAL;
> > 
> > hmm, maybe -ENODEV as this is not user fault
> 
> ENODEV means that we're not using GuC.
> -ENXIO?

Do we respond to the error at all? It should just result in the relay
not being available, right?

(i.e. are we just discussing the color of the bikeshed :)
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH 10/15] drm/i915/guc: Get rid of GuC log runtime

[Chris Wilson]

Quoting Michał Winiarski (2018-02-27 12:52:25)
> Keeping a separate runtime struct is only making the code dealing with
> relay less clear to read. Let's get rid of it, keeping everything in the
> log instead.

Or is just misnamed s/runtime/relay/, shorten a few member names for
precision and take advantage of locals to make the code readable?

I think having the substruct is reasonable for the purpose of
documenting the association between members and importantly denoting the
lock.
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx