mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Boris Brezillon <boris.brezillon@collabora.com>
To: Christian Gmeiner <christian.gmeiner@gmail.com>
Cc: Steven Price <steven.price@arm.com>,
	Liviu Dudau <liviu.dudau@arm.com>,
	Maarten Lankhorst <maarten.lankhorst@linux.intel.com>,
	Maxime Ripard <mripard@kernel.org>,
	Thomas Zimmermann <tzimmermann@suse.de>,
	David Airlie <airlied@gmail.com>, Simona Vetter <simona@ffwll.ch>,
	Daniel Almeida <daniel.almeida@collabora.com>,
	Alice Ryhl <aliceryhl@google.com>,
	Lukas Zapolskas <lukas.zapolskas@arm.com>,
	Paul Toadere <paul.toadere@arm.com>,
	dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org,
	rust-for-linux@vger.kernel.org,
	Christian Gmeiner <cgmeiner@igalia.com>
Subject: Re: [PATCH v2 2/3] drm/panthor: Report the CS fatal errors through GROUP_GET_STATE
Date: Thu, 19 Nov 2026 09:48:46 +0100	[thread overview]
Message-ID: <20261119094846.5cc0f99a@fedora1.home> (raw)
In-Reply-To: <20261104-panthor-fault-info-v2-v2-2-673b31f3840c@igalia.com>

Hi Christian,

On Wed, 04 Nov 2026 08:52:40 +0100
Christian Gmeiner <christian.gmeiner@gmail.com> wrote:

> From: Christian Gmeiner <cgmeiner@igalia.com>
> 
> Keep the raw CS_FATAL and CS_FATAL_INFO in the queue that hit them and
> return them through GROUP_GET_STATE in an array indexed by queue.
> Userspace decodes the values. No memory is allocated in the fatal path.
> 
> A queue stops at its first fatal error, so one slot per queue is
> enough. The slot is a struct drm_panthor_queue_fatal, which is the uAPI
> struct, so the ioctl can copy it with one assignment. The CS_FATAL
> event handler writes the slot under events_lock. The ioctl reads it
> under the same lock. The slot is never cleared, so the values can be
> read again after the call.
> 
> The ioctl copies the slots of all queues to a stack array while the
> locks are held and copies them to userspace after the locks are
> dropped. It fills at most one entry per queue of the group and leaves
> the rest of the user array untouched.
> 
> A queue can be flagged in fatal_queues without a CS_FATAL, for example
> when the group was killed by a VM fault. Its entry then has a zero
> exception. The VM fault itself is available through VM_GET_STATE.
> 
> Old userspace that passes the shorter struct still works, the DRM core
> zero-fills the missing tail. A zero count skips the array.
> 
> Link: https://lore.kernel.org/r/20251215115457.2137485-3-lukas.zapolskas@arm.com
> Link: https://lore.kernel.org/r/20251215115457.2137485-6-lukas.zapolskas@arm.com
> Signed-off-by: Christian Gmeiner <cgmeiner@igalia.com>
> ---
>  drivers/gpu/drm/panthor/panthor_drv.c   | 20 ++++++++++++++++++--
>  drivers/gpu/drm/panthor/panthor_sched.c | 32 +++++++++++++++++++++++++++++++-
>  drivers/gpu/drm/panthor/panthor_sched.h |  5 ++++-
>  include/uapi/drm/panthor_drm.h          | 30 ++++++++++++++++++++++++++++++
>  4 files changed, 83 insertions(+), 4 deletions(-)
> 
> diff --git a/drivers/gpu/drm/panthor/panthor_drv.c b/drivers/gpu/drm/panthor/panthor_drv.c
> index 7572cd7d6423..fb5fdf848dec 100644
> --- a/drivers/gpu/drm/panthor/panthor_drv.c
> +++ b/drivers/gpu/drm/panthor/panthor_drv.c
> @@ -181,7 +181,8 @@ panthor_get_uobj_array(const struct drm_panthor_obj_array *in, u32 min_stride,
>  		 PANTHOR_UOBJ_DECL(struct drm_panthor_queue_submit, syncs), \
>  		 PANTHOR_UOBJ_DECL(struct drm_panthor_queue_create, ringbuf_size), \
>  		 PANTHOR_UOBJ_DECL(struct drm_panthor_vm_bind_op, syncs), \
> -		 PANTHOR_UOBJ_DECL(struct drm_panthor_bo_sync_op, size))
> +		 PANTHOR_UOBJ_DECL(struct drm_panthor_bo_sync_op, size), \
> +		 PANTHOR_UOBJ_DECL(struct drm_panthor_queue_fatal, exception_info))
>  
>  /**
>   * PANTHOR_UOBJ_SET() - Copy a kernel object to a user object.
> @@ -1254,10 +1255,25 @@ static int panthor_ioctl_group_create(struct drm_device *ddev, void *data,
>  static int panthor_ioctl_group_get_state(struct drm_device *ddev, void *data,
>  					 struct drm_file *file)
>  {
> +	struct drm_panthor_queue_fatal fatals[MAX_CS_PER_CSG];
>  	struct panthor_file *pfile = file->driver_priv;
>  	struct drm_panthor_group_get_state *args = data;
> +	u64 usr_ptr = args->queue_fatals.array;
> +	u32 stride = args->queue_fatals.stride;
> +	u32 count;
> +	int ret;
>  
> -	return panthor_group_get_state(pfile, args);
> +	ret = panthor_group_get_state(pfile, args, fatals, &count);
> +	if (ret)
> +		return ret;
> +
> +	for (u32 i = 0; i < count; i++) {
> +		ret = PANTHOR_UOBJ_SET(usr_ptr + (u64)i * stride, stride, fatals[i]);
> +		if (ret)
> +			return ret;
> +	}

Is it time for a PANTHOR_UOBJ_SET_ARRAY() helper? I know there would be
just one user for now, but I'd rather not encourage people to hand-code
this, and I know that some new VM_BIND use cases will require us to
return data to the user through drm_panthor_vm_bind_op, which is passed
as an indirect array too.

> +
> +	return 0;
>  }
>  
>  static int panthor_ioctl_tiler_heap_create(struct drm_device *ddev, void *data,
> diff --git a/drivers/gpu/drm/panthor/panthor_sched.c b/drivers/gpu/drm/panthor/panthor_sched.c
> index a343c5180e01..40400b2e4551 100644
> --- a/drivers/gpu/drm/panthor/panthor_sched.c
> +++ b/drivers/gpu/drm/panthor/panthor_sched.c
> @@ -485,6 +485,15 @@ struct panthor_queue {
>  		/** @profiling.seqno: Index of the next available profiling information slot. */
>  		u32 seqno;
>  	} profiling;
> +
> +	/**
> +	 * @fatal: Last CS_FATAL reported on this queue.
> +	 *
> +	 * Never cleared, a later CS_FATAL overwrites it. A zero exception
> +	 * means no CS_FATAL was reported. Protected by
> +	 * panthor_scheduler::events_lock.
> +	 */
> +	struct drm_panthor_queue_fatal fatal;
>  };
>  
>  /**
> @@ -1412,10 +1421,20 @@ cs_slot_process_fatal_event_locked(struct panthor_device *ptdev,
>  	info = cs_iface->output->fatal_info;
>  
>  	if (group) {
> +		struct panthor_queue *queue = cs_id < group->queue_count ?
> +					      group->queues[cs_id] : NULL;
> +
>  		drm_warn(&ptdev->base, "CS_FATAL: pid=%d, comm=%s\n",
>  			 group->task_info.pid, group->task_info.comm);
>  
>  		atomic_or(BIT(cs_id), &group->fatal_queues);

We also update fatal_queues in the tiler OOM path if we get passed
inconsistent properties. Dunno if we should set execption=OUT_OF_MEMORY
in that case. fatal_queues is also forced "all-set" if the FW becomes
unresponsive in the tick update path, which could qualify as
FIRMWARE_INTERNAL_ERROR. My point being that, for any bit set in
fatal_queues, we should probably have a valid queue->fatal.exception
value set, even if it's not necessarily the HW telling us what went
wrong, so the UMD doesn't have to guess.

> +
> +		if (queue) {
> +			queue->fatal = (struct drm_panthor_queue_fatal){
> +				.exception = fatal,
> +				.exception_info = info,
> +			};
> +		}
>  	}
>  
>  	if (CS_EXCEPTION_TYPE(fatal) == DRM_PANTHOR_EXCEPTION_CS_UNRECOVERABLE) {
> @@ -3818,8 +3837,11 @@ static struct panthor_group *group_from_handle(struct panthor_group_pool *pool,
>  }
>  
>  int panthor_group_get_state(struct panthor_file *pfile,
> -			    struct drm_panthor_group_get_state *get_state)
> +			    struct drm_panthor_group_get_state *get_state,
> +			    struct drm_panthor_queue_fatal *fatals,
> +			    u32 *fatal_count)
>  {
> +	struct drm_panthor_obj_array queue_fatals = get_state->queue_fatals;
>  	struct panthor_group_pool *gpool = pfile->groups;
>  	struct panthor_device *ptdev = pfile->ptdev;
>  	struct panthor_scheduler *sched = ptdev->scheduler;
> @@ -3833,6 +3855,9 @@ int panthor_group_get_state(struct panthor_file *pfile,
>  		return -EINVAL;
>  
>  	memset(get_state, 0, sizeof(*get_state));
> +	get_state->queue_fatals = queue_fatals;
> +
> +	*fatal_count = min(queue_fatals.count, group->queue_count);
>  
>  	mutex_lock(&sched->lock);
>  	if (atomic_read(&group->timedout))
> @@ -3844,6 +3869,11 @@ int panthor_group_get_state(struct panthor_file *pfile,
>  
>  	if (group->innocent)
>  		get_state->state |= DRM_PANTHOR_GROUP_STATE_INNOCENT;
> +
> +	scoped_guard(spinlock, &sched->events_lock) {
> +		for (u32 i = 0; i < *fatal_count; i++)
> +			fatals[i] = group->queues[i]->fatal;
> +	}

I guess the fatal_queues state propagation should be done under that
lock, otherwise we might end up with inconsistent
fatals[]/fatal_queues values. That, or we re-order things so that
fatals[] gets updated before the atomic_or() in
cs_slot_process_fatal_event_locked().

>  	mutex_unlock(&sched->lock);
>  
>  	group_put(group);
> diff --git a/drivers/gpu/drm/panthor/panthor_sched.h b/drivers/gpu/drm/panthor/panthor_sched.h
> index d87cbdba4d40..dd3d31c06cf1 100644
> --- a/drivers/gpu/drm/panthor/panthor_sched.h
> +++ b/drivers/gpu/drm/panthor/panthor_sched.h
> @@ -14,6 +14,7 @@ struct drm_minor;
>  struct drm_panthor_group_create;
>  struct drm_panthor_queue_create;
>  struct drm_panthor_group_get_state;
> +struct drm_panthor_queue_fatal;
>  struct drm_panthor_queue_submit;
>  struct panthor_device;
>  struct panthor_file;
> @@ -26,7 +27,9 @@ int panthor_group_create(struct panthor_file *pfile,
>  			 u64 drm_client_id);
>  int panthor_group_destroy(struct panthor_file *pfile, u32 group_handle);
>  int panthor_group_get_state(struct panthor_file *pfile,
> -			    struct drm_panthor_group_get_state *get_state);
> +			    struct drm_panthor_group_get_state *get_state,
> +			    struct drm_panthor_queue_fatal *fatals,
> +			    u32 *fatal_count);
>  
>  struct drm_sched_job *
>  panthor_job_create(struct panthor_file *pfile,
> diff --git a/include/uapi/drm/panthor_drm.h b/include/uapi/drm/panthor_drm.h
> index 85e197d7a528..c9a681762b96 100644
> --- a/include/uapi/drm/panthor_drm.h
> +++ b/include/uapi/drm/panthor_drm.h
> @@ -1072,6 +1072,27 @@ enum drm_panthor_group_state_flags {
>  	DRM_PANTHOR_GROUP_STATE_INNOCENT = 1 << 2,
>  };
>  
> +/**
> + * struct drm_panthor_queue_fatal - Fatal error of a single queue.
> + */
> +struct drm_panthor_queue_fatal {
> +	/**
> +	 * @exception: Raw CS_FATAL value.
> +	 *
> +	 * Zero if no CS_FATAL was reported on this queue. A queue can be
> +	 * flagged in drm_panthor_group_get_state::fatal_queues without a
> +	 * CS_FATAL, for instance when the group was killed by a VM fault.

As I was saying above, I was hoping we could make it so any bit set in
fatal_queues gets a non-zero exception here, even if it's "fake". This
way, userspace doesn't have to guess what happened when a fatal event
is reported with no exception (is it tiler OOM handling failing? is it
a FW hang? and there's probably more of these situations to come with
newer gens).

> +	 * A later CS_FATAL overwrites the previous one.
> +	 */
> +	__u32 exception;
> +
> +	/** @pad: Will be zero on return. */
> +	__u32 pad;
> +
> +	/** @exception_info: Raw CS_FATAL_INFO value, valid if @exception is non-zero. */
> +	__u64 exception_info;
> +};
> +
>  /**
>   * struct drm_panthor_group_get_state - Arguments passed to DRM_IOCTL_PANTHOR_GROUP_GET_STATE
>   *
> @@ -1093,6 +1114,15 @@ struct drm_panthor_group_get_state {
>  
>  	/** @pad: MBZ */
>  	__u32 pad;
> +
> +	/**
> +	 * @queue_fatals: Array of struct drm_panthor_queue_fatal, indexed by queue.
> +	 *
> +	 * Entry N describes the queue at index N of the group creation array.
> +	 * The driver fills at most as many entries as the group has queues and
> +	 * leaves the rest untouched. A zero count skips the array.

Should we specify that these entries only need to be considered if the
associated bit is set in the fatal_queues field?

Other than these minor things, it looks good overall.

Regards,

Boris

  reply	other threads:[~2026-11-19  8:48 UTC|newest]

Thread overview: 7+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-04  7:52 [PATCH v2 0/3] drm/panthor: Report fault information to userspace Christian Gmeiner
2026-11-04  7:52 ` [PATCH v2 1/3] drm/panthor: Report the last VM fault through VM_GET_STATE Christian Gmeiner
2026-11-19  8:50   ` Boris Brezillon
2026-11-04  7:52 ` [PATCH v2 2/3] drm/panthor: Report the CS fatal errors through GROUP_GET_STATE Christian Gmeiner
2026-11-19  8:48   ` Boris Brezillon [this message]
2026-11-04  7:52 ` [PATCH v2 3/3] drm/panthor: Bump the driver version to 1.10 Christian Gmeiner
2026-11-19  8:51   ` Boris Brezillon

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261119094846.5cc0f99a@fedora1.home \
    --to=boris.brezillon@collabora.com \
    --cc=airlied@gmail.com \
    --cc=aliceryhl@google.com \
    --cc=cgmeiner@igalia.com \
    --cc=christian.gmeiner@gmail.com \
    --cc=daniel.almeida@collabora.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=liviu.dudau@arm.com \
    --cc=lukas.zapolskas@arm.com \
    --cc=maarten.lankhorst@linux.intel.com \
    --cc=mripard@kernel.org \
    --cc=paul.toadere@arm.com \
    --cc=rust-for-linux@vger.kernel.org \
    --cc=simona@ffwll.ch \
    --cc=steven.price@arm.com \
    --cc=tzimmermann@suse.de \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®