Skip to contentSkip to conversation

drm/msm/dpu: make "vblank timeout" more useful

PATCH Superseded Dmitry Baryshkov 2 participants 9 messages Feb 8, 2024 – Feb 20, 2024

Subsystems (3)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 drm/msm/dpu: make "vblank timeout" more useful

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
 drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
index d0f56c5c4cce..a8d6165b3c0a 100644
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
 		(hw_ctl->ops.get_flush_register(hw_ctl) == 0),
 		msecs_to_jiffies(50));
 	if (ret <= 0) {
-		DPU_ERROR("vblank timeout\n");
+		DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+		msm_disp_snapshot_state(phys_enc->parent->dev);
 		return -ETIMEDOUT;
 	}
 

---
base-commit: 39676dfe52331dba909c617f213fdb21015c8d10
change-id: 20240106-fd-dpu-debug-timeout-e917f0bc8063

Best regards,

Signature · 1 line
Dmitry Baryshkov <[email protected]>
#1 lore raw
Quoted 21 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
  drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
  1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -0
index d0f56c5c4cce..a8d6165b3c0a 100644

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 6 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
  		(hw_ctl->ops.get_flush_register(hw_ctl) == 0),
  		msecs_to_jiffies(50));
  	if (ret <= 0) {
-		DPU_ERROR("vblank timeout\n");
+		DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+		msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Short-term solution is you can go with a vblank_timeout_cnt and reset it in the enable() like other similar error counters.

long-term solution is we need to centralize these error locations to one single dpu_encoder_error_handler() with a single counter and the error handler will print out the error code along with the snapshot instead of the snapshot being called from all over the place.

Quoted 9 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -1
  		return -ETIMEDOUT;
  	}
 
 
---

base-commit: 39676dfe52331dba909c617f213fdb21015c8d10
change-id: 20240106-fd-dpu-debug-timeout-e917f0bc8063

Best regards,

#2 lore raw
Quoted 20 lines · Abhinav Kumar
Quoted 16 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
  drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
  1 file changed, 2 insertions(+), 1 deletion(-)
Quoted 15 lines

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 11 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
index d0f56c5c4cce..a8d6165b3c0a 100644
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
              (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
              msecs_to_jiffies(50));
      if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Quoted 20 lines

Short-term solution is you can go with a vblank_timeout_cnt and reset it in the enable() like other similar error counters.

long-term solution is we need to centralize these error locations to one single dpu_encoder_error_handler() with a single counter and the error handler will print out the error code along with the snapshot instead of the snapshot being called from all over the place.

Quoted 9 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -1
              return -ETIMEDOUT;
      }
 
 
---

base-commit: 39676dfe52331dba909c617f213fdb21015c8d10
change-id: 20240106-fd-dpu-debug-timeout-e917f0bc8063

Best regards,

Signature · 2 lines
With best wishes
Dmitry
#3 lore raw
Quoted 37 lines · Dmitry Baryshkov
Quoted 20 lines · Abhinav Kumar
Quoted 16 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
   drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
   1 file changed, 2 insertions(+), 1 deletion(-)
Quoted 15 lines

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 11 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
index d0f56c5c4cce..a8d6165b3c0a 100644
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
               (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
               msecs_to_jiffies(50));
       if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Quoted 4 lines

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Yes, true but at the same time this makes it hard to capture a good dump as potentially every vblank you could timeout so this destroy/create cycle wont end.

Quoted 23 lines
Quoted 20 lines

Short-term solution is you can go with a vblank_timeout_cnt and reset it in the enable() like other similar error counters.

long-term solution is we need to centralize these error locations to one single dpu_encoder_error_handler() with a single counter and the error handler will print out the error code along with the snapshot instead of the snapshot being called from all over the place.

Quoted 9 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -1
               return -ETIMEDOUT;
       }
 
 
---

base-commit: 39676dfe52331dba909c617f213fdb21015c8d10
change-id: 20240106-fd-dpu-debug-timeout-e917f0bc8063

Best regards,

#4 lore raw
Quoted 41 lines · Abhinav Kumar
Quoted 37 lines · Dmitry Baryshkov
Quoted 35 lines · Abhinav Kumar
Quoted 21 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
   drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
   1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -0
index d0f56c5c4cce..a8d6165b3c0a 100644

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 6 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
               (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
               msecs_to_jiffies(50));
       if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Quoted 8 lines
Quoted 4 lines

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Yes, true but at the same time this makes it hard to capture a good dump as potentially every vblank you could timeout so this destroy/create cycle wont end.

Excuse me, maybe I miss something. On the first timeout the snapshot is created. It is held by the kernel until it is fully read out from the userspace. Other snapshots will not interfere with this snapshot.

Or are you worried that snapshotting takes time, so taking a snapshot will also interfere with the vblank timings for the next vblank?

Signature · 2 lines
With best wishes
Dmitry
#5 lore raw
Quoted 47 lines · Dmitry Baryshkov
Quoted 46 lines · Abhinav Kumar
Quoted 41 lines · Dmitry Baryshkov
Quoted 20 lines · Abhinav Kumar
Quoted 16 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
    drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
    1 file changed, 2 insertions(+), 1 deletion(-)
Quoted 15 lines

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 11 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
index d0f56c5c4cce..a8d6165b3c0a 100644
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
                (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
                msecs_to_jiffies(50));
        if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Quoted 8 lines
Quoted 3 lines

Yes, true but at the same time this makes it hard to capture a good dump as potentially every vblank you could timeout so this destroy/create cycle wont end.

Excuse me, maybe I miss something. On the first timeout the snapshot is created. It is held by the kernel until it is fully read out from the userspace. Other snapshots will not interfere with this snapshot.

For every new snapshot a new devcoredump device will be created which should remain till it has been read. But now this will be created every blank. IMO, this is really too much data for no reason.

Subsequent vblank timeouts are not going to give any new information compared to the existing snapshot of the first vblank timeout thats why we should just create the snapshot when the first error happens and stop.

For other frame done timeouts, infact subsequent timeouts without any sort of recovery in between are quite misleading because hardware was already not able to fetch the previous frame so it will most likely not fetch the next one either till it has recovered. Typically thats why these vblank timeouts happen in a flurry as the hardware never really recovered from the first timeout.

Quoted 3 lines

Or are you worried that snapshotting takes time, so taking a snapshot will also interfere with the vblank timings for the next vblank?

Yes this is another point.

#6 lore raw
Quoted 55 lines · Abhinav Kumar
Quoted 51 lines · Dmitry Baryshkov
Quoted 49 lines · Abhinav Kumar
Quoted 37 lines · Dmitry Baryshkov
Quoted 20 lines · Abhinav Kumar
Quoted 16 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
    drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
    1 file changed, 2 insertions(+), 1 deletion(-)
Quoted 15 lines

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 11 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
index d0f56c5c4cce..a8d6165b3c0a 100644
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
                (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
                msecs_to_jiffies(50));
        if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Quoted 4 lines

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Yes, true but at the same time this makes it hard to capture a good dump as potentially every vblank you could timeout so this destroy/create cycle wont end.

Quoted 8 lines
Quoted 4 lines

Excuse me, maybe I miss something. On the first timeout the snapshot is created. It is held by the kernel until it is fully read out from the userspace. Other snapshots will not interfere with this snapshot.

For every new snapshot a new devcoredump device will be created which should remain till it has been read. But now this will be created every blank. IMO, this is really too much data for no reason.

No-no-no. If there is a devcoredump for a device, the next one will not be created. See dev_coredumpm().
So all the snapshots will be created and then destroyed immediately.

Quoted 17 lines

Subsequent vblank timeouts are not going to give any new information compared to the existing snapshot of the first vblank timeout thats why we should just create the snapshot when the first error happens and stop.

For other frame done timeouts, infact subsequent timeouts without any sort of recovery in between are quite misleading because hardware was already not able to fetch the previous frame so it will most likely not fetch the next one either till it has recovered. Typically thats why these vblank timeouts happen in a flurry as the hardware never really recovered from the first timeout.

Quoted 3 lines

Or are you worried that snapshotting takes time, so taking a snapshot will also interfere with the vblank timings for the next vblank?

Yes this is another point.

Signature · 2 lines
With best wishes
Dmitry
#7 lore raw
Quoted 61 lines · Dmitry Baryshkov
Quoted 60 lines · Abhinav Kumar
Quoted 55 lines · Dmitry Baryshkov
Quoted 41 lines · Abhinav Kumar
Quoted 37 lines · Dmitry Baryshkov
Quoted 35 lines · Abhinav Kumar
Quoted 21 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
     drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
     1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -0
index d0f56c5c4cce..a8d6165b3c0a 100644

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 6 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
                 (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
                 msecs_to_jiffies(50));
         if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Quoted 8 lines
Quoted 4 lines

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Yes, true but at the same time this makes it hard to capture a good dump as potentially every vblank you could timeout so this destroy/create cycle wont end.

Excuse me, maybe I miss something. On the first timeout the snapshot is created. It is held by the kernel until it is fully read out from the userspace. Other snapshots will not interfere with this snapshot.

Quoted 8 lines
Quoted 3 lines

For every new snapshot a new devcoredump device will be created which should remain till it has been read. But now this will be created every blank. IMO, this is really too much data for no reason.

No-no-no. If there is a devcoredump for a device, the next one will not be created. See dev_coredumpm().
So all the snapshots will be created and then destroyed immediately.

hmm ... I have certainly seen devcd_count go higher than one (but not more than 2). I am wondering whether this was because of some race condition of the previous destroy / new create.

But anyway, this part is clear now. thanks.

Quoted 12 lines
Quoted 12 lines

Subsequent vblank timeouts are not going to give any new information compared to the existing snapshot of the first vblank timeout thats why we should just create the snapshot when the first error happens and stop.

For other frame done timeouts, infact subsequent timeouts without any sort of recovery in between are quite misleading because hardware was already not able to fetch the previous frame so it will most likely not fetch the next one either till it has recovered. Typically thats why these vblank timeouts happen in a flurry as the hardware never really recovered from the first timeout.

Quoted 6 lines
Quoted 5 lines
Quoted 3 lines

Or are you worried that snapshotting takes time, so taking a snapshot will also interfere with the vblank timings for the next vblank?

Yes this is another point.

snapshots will still be captured every vblank timeout and reading through the entire DPU reg space every vblank timeout is certainly something we can avoid.

#8 lore raw
Quoted 96 lines · Abhinav Kumar
Quoted 61 lines · Dmitry Baryshkov
Quoted 60 lines · Abhinav Kumar
Quoted 55 lines · Dmitry Baryshkov
Quoted 41 lines · Abhinav Kumar
Quoted 37 lines · Dmitry Baryshkov
Quoted 35 lines · Abhinav Kumar
Quoted 21 lines · Dmitry Baryshkov

We have several reports of vblank timeout messages. However after some debugging it was found that there might be different causes to that. To allow us to identify the DPU block that gets stuck, include the actual CTL_FLUSH value into the timeout message and trigger the devcore snapshot capture.

---
Changes in v2:
- Added a call to msm_disp_snapshot_state() to trigger devcore dump
(Abhinav)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
     drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 3 ++-
     1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +0 -0
index d0f56c5c4cce..a8d6165b3c0a 100644

drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c static int dpu_encoder_phys_vid_wait_for_commit_done( · line 493

Quoted 6 lines
drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +2 -1
@@ -489,7 +489,8 @@ static int dpu_encoder_phys_vid_wait_for_commit_done(
                 (hw_ctl->ops.get_flush_register(hw_ctl) == 0),
                 msecs_to_jiffies(50));
         if (ret <= 0) {
-             DPU_ERROR("vblank timeout\n");
+             DPU_ERROR("vblank timeout: %x\n", hw_ctl->ops.get_flush_register(hw_ctl));
+             msm_disp_snapshot_state(phys_enc->parent->dev);

There is no rate limiting in this piece of code unfortunately. So this will flood the number of snapshots.

Quoted 8 lines
Quoted 4 lines

Well... Yes and no. The devcoredump will destroy other snapshots if there is a pending one. So only the console will be flooded and only in case when MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE is enabled.

Yes, true but at the same time this makes it hard to capture a good dump as potentially every vblank you could timeout so this destroy/create cycle wont end.

Excuse me, maybe I miss something. On the first timeout the snapshot is created. It is held by the kernel until it is fully read out from the userspace. Other snapshots will not interfere with this snapshot.

Quoted 8 lines
Quoted 3 lines

For every new snapshot a new devcoredump device will be created which should remain till it has been read. But now this will be created every blank. IMO, this is really too much data for no reason.

No-no-no. If there is a devcoredump for a device, the next one will not be created. See dev_coredumpm().
So all the snapshots will be created and then destroyed immediately.

hmm ... I have certainly seen devcd_count go higher than one (but not more than 2). I am wondering whether this was because of some race condition of the previous destroy / new create.

But anyway, this part is clear now. thanks.

Quoted 16 lines
Quoted 16 lines

Subsequent vblank timeouts are not going to give any new information compared to the existing snapshot of the first vblank timeout thats why we should just create the snapshot when the first error happens and stop.

For other frame done timeouts, infact subsequent timeouts without any sort of recovery in between are quite misleading because hardware was already not able to fetch the previous frame so it will most likely not fetch the next one either till it has recovered. Typically thats why these vblank timeouts happen in a flurry as the hardware never really recovered from the first timeout.

Quoted 3 lines

Or are you worried that snapshotting takes time, so taking a snapshot will also interfere with the vblank timings for the next vblank?

Quoted 6 lines
Quoted 2 lines
Quoted 1 line

Yes this is another point.

snapshots will still be captured every vblank timeout and reading through the entire DPU reg space every vblank timeout is certainly something we can avoid.

Ack.

Signature · 2 lines
With best wishes
Dmitry