Skip to content

Commit 6f3d9d0

Browse files
YsuOSdigetx
YsuOS
authored and
digetx
committed
drm/virtio: Add drm_panic support
Virtio gpu supports the drm_panic module, which displays a message to the screen when a kernel panic occurs. It is supported where it has vmapped shmem BO. Signed-off-by: Jocelyn Falempe <jfalempe@redhat.com> Signed-off-by: Ryosuke Yasuoka <ryasuoka@redhat.com> Tested-by: Dmitry Osipenko <dmitry.osipenko@collabora.com> Reviewed-by: Dmitry Osipenko <dmitry.osipenko@collabora.com> Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com> Link: https://patchwork.freedesktop.org/patch/msgid/20250206104300.416014-1-ryasuoka@redhat.com
1 parent 05345ce commit 6f3d9d0

4 files changed

Lines changed: 272 additions & 0 deletions

File tree

‎drivers/gpu/drm/virtio/virtgpu_drv.h‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -310,6 +310,7 @@ int virtio_gpu_mode_dumb_create(struct drm_file *file_priv,
310310
struct drm_device *dev,
311311
struct drm_mode_create_dumb *args);
312312

313+
struct virtio_gpu_object_array *virtio_gpu_panic_array_alloc(void);
313314
struct virtio_gpu_object_array *virtio_gpu_array_alloc(u32 nents);
314315
struct virtio_gpu_object_array*
315316
virtio_gpu_array_from_handles(struct drm_file *drm_file, u32 *handles, u32 nents);
@@ -334,12 +335,21 @@ void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev,
334335
struct virtio_gpu_fence *fence);
335336
void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev,
336337
struct virtio_gpu_object *bo);
338+
int virtio_gpu_panic_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev,
339+
uint64_t offset,
340+
uint32_t width, uint32_t height,
341+
uint32_t x, uint32_t y,
342+
struct virtio_gpu_object_array *objs);
337343
void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev,
338344
uint64_t offset,
339345
uint32_t width, uint32_t height,
340346
uint32_t x, uint32_t y,
341347
struct virtio_gpu_object_array *objs,
342348
struct virtio_gpu_fence *fence);
349+
void virtio_gpu_panic_cmd_resource_flush(struct virtio_gpu_device *vgdev,
350+
uint32_t resource_id,
351+
uint32_t x, uint32_t y,
352+
uint32_t width, uint32_t height);
343353
void virtio_gpu_cmd_resource_flush(struct virtio_gpu_device *vgdev,
344354
uint32_t resource_id,
345355
uint32_t x, uint32_t y,
@@ -408,6 +418,7 @@ void virtio_gpu_ctrl_ack(struct virtqueue *vq);
408418
void virtio_gpu_cursor_ack(struct virtqueue *vq);
409419
void virtio_gpu_dequeue_ctrl_func(struct work_struct *work);
410420
void virtio_gpu_dequeue_cursor_func(struct work_struct *work);
421+
void virtio_gpu_panic_notify(struct virtio_gpu_device *vgdev);
411422
void virtio_gpu_notify(struct virtio_gpu_device *vgdev);
412423

413424
int

‎drivers/gpu/drm/virtio/virtgpu_gem.c‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -148,6 +148,20 @@ void virtio_gpu_gem_object_close(struct drm_gem_object *obj,
148148
virtio_gpu_notify(vgdev);
149149
}
150150

151+
/* For drm panic */
152+
struct virtio_gpu_object_array *virtio_gpu_panic_array_alloc(void)
153+
{
154+
struct virtio_gpu_object_array *objs;
155+
156+
objs = kmalloc(sizeof(struct virtio_gpu_object_array), GFP_ATOMIC);
157+
if (!objs)
158+
return NULL;
159+
160+
objs->nents = 0;
161+
objs->total = 1;
162+
return objs;
163+
}
164+
151165
struct virtio_gpu_object_array *virtio_gpu_array_alloc(u32 nents)
152166
{
153167
struct virtio_gpu_object_array *objs;

‎drivers/gpu/drm/virtio/virtgpu_plane.c‎

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,8 @@
2828
#include <drm/drm_fourcc.h>
2929
#include <drm/drm_gem_atomic_helper.h>
3030
#include <linux/virtio_dma_buf.h>
31+
#include <drm/drm_managed.h>
32+
#include <drm/drm_panic.h>
3133

3234
#include "virtgpu_drv.h"
3335

@@ -127,6 +129,30 @@ static int virtio_gpu_plane_atomic_check(struct drm_plane *plane,
127129
return ret;
128130
}
129131

132+
/* For drm panic */
133+
static int virtio_gpu_panic_update_dumb_bo(struct virtio_gpu_device *vgdev,
134+
struct drm_plane_state *state,
135+
struct drm_rect *rect)
136+
{
137+
struct virtio_gpu_object *bo =
138+
gem_to_virtio_gpu_obj(state->fb->obj[0]);
139+
struct virtio_gpu_object_array *objs;
140+
uint32_t w = rect->x2 - rect->x1;
141+
uint32_t h = rect->y2 - rect->y1;
142+
uint32_t x = rect->x1;
143+
uint32_t y = rect->y1;
144+
uint32_t off = x * state->fb->format->cpp[0] +
145+
y * state->fb->pitches[0];
146+
147+
objs = virtio_gpu_panic_array_alloc();
148+
if (!objs)
149+
return -ENOMEM;
150+
virtio_gpu_array_add_obj(objs, &bo->base.base);
151+
152+
return virtio_gpu_panic_cmd_transfer_to_host_2d(vgdev, off, w, h, x, y,
153+
objs);
154+
}
155+
130156
static void virtio_gpu_update_dumb_bo(struct virtio_gpu_device *vgdev,
131157
struct drm_plane_state *state,
132158
struct drm_rect *rect)
@@ -150,6 +176,24 @@ static void virtio_gpu_update_dumb_bo(struct virtio_gpu_device *vgdev,
150176
objs, NULL);
151177
}
152178

179+
/* For drm_panic */
180+
static void virtio_gpu_panic_resource_flush(struct drm_plane *plane,
181+
uint32_t x, uint32_t y,
182+
uint32_t width, uint32_t height)
183+
{
184+
struct drm_device *dev = plane->dev;
185+
struct virtio_gpu_device *vgdev = dev->dev_private;
186+
struct virtio_gpu_framebuffer *vgfb;
187+
struct virtio_gpu_object *bo;
188+
189+
vgfb = to_virtio_gpu_framebuffer(plane->state->fb);
190+
bo = gem_to_virtio_gpu_obj(vgfb->base.obj[0]);
191+
192+
virtio_gpu_panic_cmd_resource_flush(vgdev, bo->hw_res_handle, x, y,
193+
width, height);
194+
virtio_gpu_panic_notify(vgdev);
195+
}
196+
153197
static void virtio_gpu_resource_flush(struct drm_plane *plane,
154198
uint32_t x, uint32_t y,
155199
uint32_t width, uint32_t height)
@@ -446,11 +490,63 @@ static void virtio_gpu_cursor_plane_update(struct drm_plane *plane,
446490
virtio_gpu_cursor_ping(vgdev, output);
447491
}
448492

493+
static int virtio_drm_get_scanout_buffer(struct drm_plane *plane,
494+
struct drm_scanout_buffer *sb)
495+
{
496+
struct virtio_gpu_object *bo;
497+
498+
if (!plane->state || !plane->state->fb || !plane->state->visible)
499+
return -ENODEV;
500+
501+
bo = gem_to_virtio_gpu_obj(plane->state->fb->obj[0]);
502+
503+
/* Only support mapped shmem bo */
504+
if (virtio_gpu_is_vram(bo) || bo->base.base.import_attach || !bo->base.vaddr)
505+
return -ENODEV;
506+
507+
iosys_map_set_vaddr(&sb->map[0], bo->base.vaddr);
508+
509+
sb->format = plane->state->fb->format;
510+
sb->height = plane->state->fb->height;
511+
sb->width = plane->state->fb->width;
512+
sb->pitch[0] = plane->state->fb->pitches[0];
513+
return 0;
514+
}
515+
516+
static void virtio_panic_flush(struct drm_plane *plane)
517+
{
518+
struct virtio_gpu_object *bo;
519+
struct drm_device *dev = plane->dev;
520+
struct virtio_gpu_device *vgdev = dev->dev_private;
521+
struct drm_rect rect;
522+
523+
rect.x1 = 0;
524+
rect.y1 = 0;
525+
rect.x2 = plane->state->fb->width;
526+
rect.y2 = plane->state->fb->height;
527+
528+
bo = gem_to_virtio_gpu_obj(plane->state->fb->obj[0]);
529+
530+
if (bo->dumb) {
531+
if (virtio_gpu_panic_update_dumb_bo(vgdev, plane->state,
532+
&rect))
533+
return;
534+
}
535+
536+
virtio_gpu_panic_resource_flush(plane,
537+
plane->state->src_x >> 16,
538+
plane->state->src_y >> 16,
539+
plane->state->src_w >> 16,
540+
plane->state->src_h >> 16);
541+
}
542+
449543
static const struct drm_plane_helper_funcs virtio_gpu_primary_helper_funcs = {
450544
.prepare_fb = virtio_gpu_plane_prepare_fb,
451545
.cleanup_fb = virtio_gpu_plane_cleanup_fb,
452546
.atomic_check = virtio_gpu_plane_atomic_check,
453547
.atomic_update = virtio_gpu_primary_plane_update,
548+
.get_scanout_buffer = virtio_drm_get_scanout_buffer,
549+
.panic_flush = virtio_panic_flush,
454550
};
455551

456552
static const struct drm_plane_helper_funcs virtio_gpu_cursor_helper_funcs = {

‎drivers/gpu/drm/virtio/virtgpu_vq.c‎

Lines changed: 151 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -86,6 +86,22 @@ void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev)
8686
vgdev->vbufs = NULL;
8787
}
8888

89+
/* For drm_panic */
90+
static struct virtio_gpu_vbuffer*
91+
virtio_gpu_panic_get_vbuf(struct virtio_gpu_device *vgdev, int size)
92+
{
93+
struct virtio_gpu_vbuffer *vbuf;
94+
95+
vbuf = kmem_cache_zalloc(vgdev->vbufs, GFP_ATOMIC);
96+
97+
vbuf->buf = (void *)vbuf + sizeof(*vbuf);
98+
vbuf->size = size;
99+
vbuf->resp_cb = NULL;
100+
vbuf->resp_size = sizeof(struct virtio_gpu_ctrl_hdr);
101+
vbuf->resp_buf = (void *)vbuf->buf + size;
102+
return vbuf;
103+
}
104+
89105
static struct virtio_gpu_vbuffer*
90106
virtio_gpu_get_vbuf(struct virtio_gpu_device *vgdev,
91107
int size, int resp_size, void *resp_buf,
@@ -137,6 +153,18 @@ virtio_gpu_alloc_cursor(struct virtio_gpu_device *vgdev,
137153
return (struct virtio_gpu_update_cursor *)vbuf->buf;
138154
}
139155

156+
/* For drm_panic */
157+
static void *virtio_gpu_panic_alloc_cmd_resp(struct virtio_gpu_device *vgdev,
158+
struct virtio_gpu_vbuffer **vbuffer_p,
159+
int cmd_size)
160+
{
161+
struct virtio_gpu_vbuffer *vbuf;
162+
163+
vbuf = virtio_gpu_panic_get_vbuf(vgdev, cmd_size);
164+
*vbuffer_p = vbuf;
165+
return (struct virtio_gpu_command *)vbuf->buf;
166+
}
167+
140168
static void *virtio_gpu_alloc_cmd_resp(struct virtio_gpu_device *vgdev,
141169
virtio_gpu_resp_cb cb,
142170
struct virtio_gpu_vbuffer **vbuffer_p,
@@ -311,6 +339,34 @@ static struct sg_table *vmalloc_to_sgt(char *data, uint32_t size, int *sg_ents)
311339
return sgt;
312340
}
313341

342+
/* For drm_panic */
343+
static int virtio_gpu_panic_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
344+
struct virtio_gpu_vbuffer *vbuf,
345+
int elemcnt,
346+
struct scatterlist **sgs,
347+
int outcnt,
348+
int incnt)
349+
{
350+
struct virtqueue *vq = vgdev->ctrlq.vq;
351+
int ret;
352+
353+
if (vgdev->has_indirect)
354+
elemcnt = 1;
355+
356+
if (vq->num_free < elemcnt)
357+
return -ENOMEM;
358+
359+
ret = virtqueue_add_sgs(vq, sgs, outcnt, incnt, vbuf, GFP_ATOMIC);
360+
WARN_ON(ret);
361+
362+
vbuf->seqno = ++vgdev->ctrlq.seqno;
363+
trace_virtio_gpu_cmd_queue(vq, virtio_gpu_vbuf_ctrl_hdr(vbuf), vbuf->seqno);
364+
365+
atomic_inc(&vgdev->pending_commands);
366+
367+
return 0;
368+
}
369+
314370
static int virtio_gpu_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
315371
struct virtio_gpu_vbuffer *vbuf,
316372
struct virtio_gpu_fence *fence,
@@ -368,6 +424,32 @@ static int virtio_gpu_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
368424
return 0;
369425
}
370426

427+
/* For drm_panic */
428+
static int virtio_gpu_panic_queue_ctrl_buffer(struct virtio_gpu_device *vgdev,
429+
struct virtio_gpu_vbuffer *vbuf)
430+
{
431+
struct scatterlist *sgs[3], vcmd, vresp;
432+
int elemcnt = 0, outcnt = 0, incnt = 0;
433+
434+
/* set up vcmd */
435+
sg_init_one(&vcmd, vbuf->buf, vbuf->size);
436+
elemcnt++;
437+
sgs[outcnt] = &vcmd;
438+
outcnt++;
439+
440+
/* set up vresp */
441+
if (vbuf->resp_size) {
442+
sg_init_one(&vresp, vbuf->resp_buf, vbuf->resp_size);
443+
elemcnt++;
444+
sgs[outcnt + incnt] = &vresp;
445+
incnt++;
446+
}
447+
448+
return virtio_gpu_panic_queue_ctrl_sgs(vgdev, vbuf,
449+
elemcnt, sgs,
450+
outcnt, incnt);
451+
}
452+
371453
static int virtio_gpu_queue_fenced_ctrl_buffer(struct virtio_gpu_device *vgdev,
372454
struct virtio_gpu_vbuffer *vbuf,
373455
struct virtio_gpu_fence *fence)
@@ -422,6 +504,21 @@ static int virtio_gpu_queue_fenced_ctrl_buffer(struct virtio_gpu_device *vgdev,
422504
return ret;
423505
}
424506

507+
/* For drm_panic */
508+
void virtio_gpu_panic_notify(struct virtio_gpu_device *vgdev)
509+
{
510+
bool notify;
511+
512+
if (!atomic_read(&vgdev->pending_commands))
513+
return;
514+
515+
atomic_set(&vgdev->pending_commands, 0);
516+
notify = virtqueue_kick_prepare(vgdev->ctrlq.vq);
517+
518+
if (notify)
519+
virtqueue_notify(vgdev->ctrlq.vq);
520+
}
521+
425522
void virtio_gpu_notify(struct virtio_gpu_device *vgdev)
426523
{
427524
bool notify;
@@ -567,6 +664,29 @@ void virtio_gpu_cmd_set_scanout(struct virtio_gpu_device *vgdev,
567664
virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
568665
}
569666

667+
/* For drm_panic */
668+
void virtio_gpu_panic_cmd_resource_flush(struct virtio_gpu_device *vgdev,
669+
uint32_t resource_id,
670+
uint32_t x, uint32_t y,
671+
uint32_t width, uint32_t height)
672+
{
673+
struct virtio_gpu_resource_flush *cmd_p;
674+
struct virtio_gpu_vbuffer *vbuf;
675+
676+
cmd_p = virtio_gpu_panic_alloc_cmd_resp(vgdev, &vbuf, sizeof(*cmd_p));
677+
memset(cmd_p, 0, sizeof(*cmd_p));
678+
vbuf->objs = NULL;
679+
680+
cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_FLUSH);
681+
cmd_p->resource_id = cpu_to_le32(resource_id);
682+
cmd_p->r.width = cpu_to_le32(width);
683+
cmd_p->r.height = cpu_to_le32(height);
684+
cmd_p->r.x = cpu_to_le32(x);
685+
cmd_p->r.y = cpu_to_le32(y);
686+
687+
virtio_gpu_panic_queue_ctrl_buffer(vgdev, vbuf);
688+
}
689+
570690
void virtio_gpu_cmd_resource_flush(struct virtio_gpu_device *vgdev,
571691
uint32_t resource_id,
572692
uint32_t x, uint32_t y,
@@ -591,6 +711,37 @@ void virtio_gpu_cmd_resource_flush(struct virtio_gpu_device *vgdev,
591711
virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
592712
}
593713

714+
/* For drm_panic */
715+
int virtio_gpu_panic_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev,
716+
uint64_t offset,
717+
uint32_t width, uint32_t height,
718+
uint32_t x, uint32_t y,
719+
struct virtio_gpu_object_array *objs)
720+
{
721+
struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
722+
struct virtio_gpu_transfer_to_host_2d *cmd_p;
723+
struct virtio_gpu_vbuffer *vbuf;
724+
bool use_dma_api = !virtio_has_dma_quirk(vgdev->vdev);
725+
726+
if (virtio_gpu_is_shmem(bo) && use_dma_api)
727+
dma_sync_sgtable_for_device(vgdev->vdev->dev.parent,
728+
bo->base.sgt, DMA_TO_DEVICE);
729+
730+
cmd_p = virtio_gpu_panic_alloc_cmd_resp(vgdev, &vbuf, sizeof(*cmd_p));
731+
memset(cmd_p, 0, sizeof(*cmd_p));
732+
vbuf->objs = objs;
733+
734+
cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D);
735+
cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
736+
cmd_p->offset = cpu_to_le64(offset);
737+
cmd_p->r.width = cpu_to_le32(width);
738+
cmd_p->r.height = cpu_to_le32(height);
739+
cmd_p->r.x = cpu_to_le32(x);
740+
cmd_p->r.y = cpu_to_le32(y);
741+
742+
return virtio_gpu_panic_queue_ctrl_buffer(vgdev, vbuf);
743+
}
744+
594745
void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev,
595746
uint64_t offset,
596747
uint32_t width, uint32_t height,

0 commit comments

Comments
 (0)