[PATCH 1/3] drm: Add support for panic message output
Noralf Trønnes
noralf at tronnes.org
Sun Sep 11 18:47:40 UTC 2016
This adds support for outputting kernel messages on panic().
A circular buffer is used to collect kernel messages.
On panic() the notifier function loops over each DRM device and
it's crtc's to find suitable framebuffers. On the next
console->write(), the messages in the circular buffer are rendered
on each of the recorded framebuffers.
Only atomic drivers are supported.
Signed-off-by: Noralf Trønnes <noralf at tronnes.org>
---
drivers/gpu/drm/Kconfig | 1 +
drivers/gpu/drm/Makefile | 2 +-
drivers/gpu/drm/drm_drv.c | 3 +
drivers/gpu/drm/drm_framebuffer.c | 108 +++++++
drivers/gpu/drm/drm_internal.h | 4 +
drivers/gpu/drm/drm_panic.c | 640 ++++++++++++++++++++++++++++++++++++++
include/drm/drm_framebuffer.h | 40 +++
7 files changed, 797 insertions(+), 1 deletion(-)
create mode 100644 drivers/gpu/drm/drm_panic.c
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 4a888e6..7ded50a 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -13,6 +13,7 @@ menuconfig DRM
select I2C_ALGOBIT
select DMA_SHARED_BUFFER
select SYSFB
+ select FONT_SUPPORT
help
Kernel-level support for the Direct Rendering Infrastructure (DRI)
introduced in XFree86 4.0. If you say Y here, you need to select
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 3f2e43f..667685c 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -13,7 +13,7 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \
drm_trace_points.o drm_global.o drm_prime.o \
drm_rect.o drm_vma_manager.o drm_flip_work.o \
drm_modeset_lock.o drm_atomic.o drm_bridge.o \
- drm_framebuffer.o drm_connector.o drm_blend.o
+ drm_framebuffer.o drm_connector.o drm_blend.o drm_panic.o
drm-$(CONFIG_COMPAT) += drm_ioc32.o
drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index acf6a5f..fb36fba 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -845,6 +845,8 @@ static int __init drm_core_init(void)
goto err_p3;
}
+ drm_panic_init(drm_debugfs_root);
+
DRM_INFO("Initialized %s %d.%d.%d %s\n",
CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
return 0;
@@ -860,6 +862,7 @@ err_p1:
static void __exit drm_core_exit(void)
{
+ drm_panic_exit(drm_debugfs_root);
debugfs_remove(drm_debugfs_root);
drm_sysfs_destroy();
diff --git a/drivers/gpu/drm/drm_framebuffer.c b/drivers/gpu/drm/drm_framebuffer.c
index 30dc01e..84ee4f7 100644
--- a/drivers/gpu/drm/drm_framebuffer.c
+++ b/drivers/gpu/drm/drm_framebuffer.c
@@ -20,6 +20,7 @@
* OF THIS SOFTWARE.
*/
+#include <asm/unaligned.h>
#include <linux/export.h>
#include <drm/drmP.h>
#include <drm/drm_auth.h>
@@ -829,3 +830,110 @@ void drm_framebuffer_remove(struct drm_framebuffer *fb)
drm_framebuffer_unreference(fb);
}
EXPORT_SYMBOL(drm_framebuffer_remove);
+
+/**
+ * drm_framebuffer_panic_draw_xy - draw pixel on fb during panic()
+ * @fb: DRM framebuffer
+ * @vmap: Linear virtual mapping
+ * @x: X coordinate
+ * @y: Y coordinate
+ * @foreground: Foreground pixel
+ *
+ * This function can be used to draw a pixel during panic message rendering.
+ * It requires @vmap to be a linear mapping. This is the default implementation
+ * used if &drm_framebuffer_funcs->panic_draw_xy is not set.
+ */
+void drm_framebuffer_panic_draw_xy(struct drm_framebuffer *fb, void *vmap,
+ int x, int y, bool foreground)
+{
+ u8 *dst = vmap + fb->offsets[0] + (y * fb->pitches[0]);
+
+ switch (fb->pixel_format & ~DRM_FORMAT_BIG_ENDIAN) {
+ case DRM_FORMAT_C8:
+
+ case DRM_FORMAT_RGB332:
+ case DRM_FORMAT_BGR233:
+ dst += x;
+ *dst = foreground ? 0xff : 0x00;
+ break;
+
+ case DRM_FORMAT_XRGB4444:
+ case DRM_FORMAT_ARGB4444:
+ case DRM_FORMAT_XBGR4444:
+ case DRM_FORMAT_ABGR4444:
+ dst += x * sizeof(u16);
+ put_unaligned(foreground ? 0x0fff : 0x0000, (u16 *)dst);
+ break;
+
+ case DRM_FORMAT_RGBX4444:
+ case DRM_FORMAT_RGBA4444:
+ case DRM_FORMAT_BGRX4444:
+ case DRM_FORMAT_BGRA4444:
+ dst += x * sizeof(u16);
+ put_unaligned(foreground ? 0xfff0 : 0x0000, (u16 *)dst);
+ break;
+
+ case DRM_FORMAT_XRGB1555:
+ case DRM_FORMAT_ARGB1555:
+ case DRM_FORMAT_XBGR1555:
+ case DRM_FORMAT_ABGR1555:
+ dst += x * sizeof(u16);
+ put_unaligned(foreground ? 0x7fff : 0x0000, (u16 *)dst);
+ break;
+
+ case DRM_FORMAT_RGBX5551:
+ case DRM_FORMAT_RGBA5551:
+ case DRM_FORMAT_BGRX5551:
+ case DRM_FORMAT_BGRA5551:
+ dst += x * sizeof(u16);
+ put_unaligned(foreground ? 0xfffe : 0x0000, (u16 *)dst);
+ break;
+
+ case DRM_FORMAT_RGB565:
+ case DRM_FORMAT_BGR565:
+ dst += x * sizeof(u16);
+ put_unaligned(foreground ? 0xffff : 0x0000, (u16 *)dst);
+ break;
+
+ case DRM_FORMAT_RGB888:
+ case DRM_FORMAT_BGR888:
+ dst += x * 3;
+ dst[0] = foreground ? 0xff : 0x00;
+ dst[1] = foreground ? 0xff : 0x00;
+ dst[2] = foreground ? 0xff : 0x00;
+ break;
+
+ case DRM_FORMAT_XRGB8888:
+ case DRM_FORMAT_ARGB8888:
+ case DRM_FORMAT_XBGR8888:
+ case DRM_FORMAT_ABGR8888:
+ dst += x * sizeof(u32);
+ put_unaligned(foreground ? 0x00ffffff : 0x0, (u32 *)dst);
+ break;
+
+ case DRM_FORMAT_RGBX8888:
+ case DRM_FORMAT_RGBA8888:
+ case DRM_FORMAT_BGRX8888:
+ case DRM_FORMAT_BGRA8888:
+ dst += x * sizeof(u32);
+ put_unaligned(foreground ? 0xffffff00 : 0x0, (u32 *)dst);
+ break;
+
+ case DRM_FORMAT_XRGB2101010:
+ case DRM_FORMAT_ARGB2101010:
+ case DRM_FORMAT_XBGR2101010:
+ case DRM_FORMAT_ABGR2101010:
+ dst += x * sizeof(u32);
+ put_unaligned(foreground ? 0x3fffffff : 0x0, (u32 *)dst);
+ break;
+
+ case DRM_FORMAT_RGBX1010102:
+ case DRM_FORMAT_RGBA1010102:
+ case DRM_FORMAT_BGRX1010102:
+ case DRM_FORMAT_BGRA1010102:
+ dst += x * sizeof(u32);
+ put_unaligned(foreground ? 0xfffffffc : 0x0, (u32 *)dst);
+ break;
+ }
+}
+EXPORT_SYMBOL(drm_framebuffer_panic_draw_xy);
diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h
index b86dc9b..c47b6a6 100644
--- a/drivers/gpu/drm/drm_internal.h
+++ b/drivers/gpu/drm/drm_internal.h
@@ -90,6 +90,10 @@ int drm_gem_open_ioctl(struct drm_device *dev, void *data,
void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
+/* drm_panic.c */
+void drm_panic_init(struct dentry *debugfs_root);
+void drm_panic_exit(struct dentry *debugfs_root);
+
/* drm_debugfs.c */
#if defined(CONFIG_DEBUG_FS)
int drm_debugfs_init(struct drm_minor *minor, int minor_id,
diff --git a/drivers/gpu/drm/drm_panic.c b/drivers/gpu/drm/drm_panic.c
new file mode 100644
index 0000000..a6d4653
--- /dev/null
+++ b/drivers/gpu/drm/drm_panic.c
@@ -0,0 +1,640 @@
+/*
+ * Copyright 2016 Noralf Trønnes
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <drm/drmP.h>
+#include <drm/drm_atomic.h>
+#include <linux/console.h>
+#include <linux/debugfs.h>
+#include <linux/font.h>
+#include <linux/kernel.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+
+#include "drm_internal.h"
+
+struct drm_panic_fb {
+ struct drm_framebuffer *fb;
+ struct drm_plane *plane;
+ struct drm_crtc *crtc;
+ unsigned int width;
+ unsigned int height;
+ void *vmap;
+ const struct font_desc *font;
+ unsigned int cols;
+ unsigned int rows;
+ unsigned int xpos;
+ unsigned int ypos;
+};
+
+#define DRM_PANIC_MAX_FBS 64
+static struct drm_panic_fb drm_panic_fbs[DRM_PANIC_MAX_FBS];
+static unsigned int drm_panic_fbs_num;
+
+/* circular kernel message buffer */
+#define DRM_PANIC_MAX_KMSGS SZ_4K
+static char *drm_panic_kmsgs;
+static size_t drm_panic_kmsgs_pos;
+
+/* enables message rendering */
+static bool drm_panic_active;
+
+/*
+ * TODO
+ * This simple out-of-band logging has been very useful during the initial
+ * development. Not sure if we should keep it when the code has settled.
+ * It's roughly 80 lines.
+ */
+#define DRM_PANIC_LOG_SIZE 512
+
+static char *log_buf;
+static size_t log_pos;
+
+static __printf(1, 2) void drm_panic_log(const char *fmt, ...)
+{
+ unsigned int i;
+ char buf[128];
+ va_list args;
+ size_t len;
+
+ if (oops_in_progress || !log_buf || !IS_ENABLED(CONFIG_DEBUG_FS))
+ return;
+
+ va_start(args, fmt);
+
+ if (log_pos >= DRM_PANIC_LOG_SIZE)
+ log_pos = 0;
+
+ len = vscnprintf(buf, sizeof(buf), fmt, args);
+
+ for (i = 0; i < len; i++) {
+ log_buf[log_pos++] = buf[i];
+ if (log_pos >= DRM_PANIC_LOG_SIZE)
+ log_pos = 0;
+ }
+
+ va_end(args);
+}
+
+static void drm_panic_draw_xy(struct drm_panic_fb *pfb, int x, int y, bool fg)
+{
+ struct drm_framebuffer *fb = pfb->fb;
+
+ if (x < 0 || x >= pfb->width || y < 0 || y >= pfb->height)
+ return;
+
+ if (fb->funcs->panic_draw_xy)
+ fb->funcs->panic_draw_xy(fb, pfb->vmap, x, y, fg);
+ else
+ drm_framebuffer_panic_draw_xy(fb, pfb->vmap, x, y, fg);
+}
+
+static void drm_panic_render_char(struct drm_panic_fb *pfb, unsigned int x,
+ unsigned int y, char c)
+{
+ const struct font_desc *font = pfb->font;
+ unsigned int h, w, y_pix, x_pix;
+ u8 fontline;
+
+ for (h = 0; h < font->height; h++) {
+ fontline = *(u8 *)(font->data + c * font->height + h);
+ y_pix = y * font->height + h;
+
+ for (w = 0; w < font->width; w++) {
+ x_pix = x * font->width + w;
+
+ drm_panic_draw_xy(pfb, x_pix, y_pix,
+ fontline & BIT(7 - w));
+ }
+ }
+}
+
+static void drm_panic_render_rest_of_screen_blank(struct drm_panic_fb *pfb)
+{
+ unsigned int x, y, ypos;
+
+ ypos = pfb->xpos ? pfb->ypos + 1 : pfb->ypos;
+
+ for (y = ypos * pfb->font->height; y < pfb->height; y++)
+ for (x = 0; x < pfb->width; x++)
+ drm_panic_draw_xy(pfb, x, y, 0);
+}
+
+static void drm_panic_render_rest_of_line_blank(struct drm_panic_fb *pfb)
+{
+ unsigned int h, x, y = pfb->ypos * pfb->font->height;
+
+ for (h = 0; h < pfb->font->height; h++)
+ for (x = pfb->xpos * pfb->font->width; x < pfb->width; x++)
+ drm_panic_draw_xy(pfb, x, y + h, 0);
+}
+
+static void drm_panic_render(struct drm_panic_fb *pfb,
+ const char *text, unsigned int len)
+{
+ unsigned int i;
+
+ for (i = 0; i < len; i++) {
+ if (pfb->ypos >= pfb->rows)
+ return;
+
+ if (text[i] == '\n') {
+ drm_panic_render_rest_of_line_blank(pfb);
+ pfb->xpos = pfb->cols;
+ } else {
+ drm_panic_render_char(pfb, pfb->xpos++, pfb->ypos,
+ text[i]);
+ }
+
+ if (pfb->xpos >= pfb->cols) {
+ pfb->xpos = 0;
+ pfb->ypos++;
+ }
+ }
+}
+
+static void drm_panic_try_write_kmsgs(struct drm_panic_fb *pfb, char **str,
+ unsigned int *len, unsigned int *xpos,
+ unsigned int *ypos)
+{
+ char *s = *str + *len - 1;
+ unsigned int l = 0;
+
+ if (*len == 0)
+ return;
+
+ if (*ypos == pfb->rows && *s == '\n') {
+ s--;
+ l++;
+ (*ypos)--;
+ }
+
+ while (l < *len) {
+ if (*xpos == pfb->cols) {
+ *xpos = 0;
+ if (*ypos == 0) {
+ s++;
+ l--;
+ break;
+ }
+
+ (*ypos)--;
+ }
+
+ if (*s-- == '\n')
+ *xpos = pfb->cols;
+ else
+ (*xpos)++;
+
+ l++;
+ }
+
+ *len = l;
+ *str = s + 1;
+}
+
+static void drm_panic_write_kmsgs(struct drm_panic_fb *pfb)
+{
+ char *str1 = &drm_panic_kmsgs[drm_panic_kmsgs_pos];
+ unsigned int len1 = DRM_PANIC_MAX_KMSGS - drm_panic_kmsgs_pos;
+ char *str2 = drm_panic_kmsgs;
+ unsigned int len2 = drm_panic_kmsgs_pos;
+ unsigned int xpos = 0;
+ unsigned int ypos = pfb->rows;
+
+ pfb->xpos = 0;
+ pfb->ypos = 0;
+
+ /* if the buffer hasn't wrapped around */
+ if (drm_panic_kmsgs[drm_panic_kmsgs_pos] == '\0')
+ len1 = 0;
+
+ /* try writing backwards to find where to begin */
+ drm_panic_try_write_kmsgs(pfb, &str2, &len2, &xpos, &ypos);
+
+ if (ypos == 0)
+ len1 = 0;
+ else
+ drm_panic_try_write_kmsgs(pfb, &str1, &len1, &xpos, &ypos);
+
+ drm_panic_render(pfb, str1, len1);
+ drm_panic_render(pfb, str2, len2);
+ drm_panic_render_rest_of_screen_blank(pfb);
+}
+
+static void drm_panic_write(struct drm_panic_fb *pfb, const char *str,
+ unsigned int len)
+{
+ unsigned int xpos = pfb->xpos;
+ unsigned int ypos = pfb->ypos;
+ unsigned int i;
+
+ /* first time or screen is full: dump buffer */
+ if ((!pfb->xpos && !pfb->ypos) || pfb->ypos >= pfb->rows) {
+ drm_panic_write_kmsgs(pfb);
+ return;
+ }
+
+ /* see if there's room to append this string */
+ for (i = 0; i < len; i++) {
+ if (xpos == pfb->cols) {
+ xpos = 0;
+ ypos++;
+ }
+
+ if (str[i] == '\n')
+ xpos = pfb->cols;
+ else
+ xpos++;
+ }
+
+ if (ypos <= pfb->rows)
+ drm_panic_render(pfb, str, len);
+ else
+ drm_panic_write_kmsgs(pfb);
+}
+
+/*
+ * Calls to console.write() are serialized by console_lock().
+ * However, panic() calls console_flush_on_panic() which breaks the lock if
+ * necessary.
+ */
+static void drm_panic_console_write(struct console *con,
+ const char *str, unsigned int len)
+{
+ unsigned int i;
+
+ if (!len)
+ return;
+
+ if (drm_panic_kmsgs_pos >= DRM_PANIC_MAX_KMSGS)
+ drm_panic_kmsgs_pos = 0;
+
+ for (i = 0; i < len; i++) {
+ drm_panic_kmsgs[drm_panic_kmsgs_pos++] = str[i];
+ if (drm_panic_kmsgs_pos >= DRM_PANIC_MAX_KMSGS)
+ drm_panic_kmsgs_pos = 0;
+ }
+
+ if (drm_panic_active)
+ for (i = 0; i < drm_panic_fbs_num; i++)
+ drm_panic_write(&drm_panic_fbs[i], str, len);
+}
+
+static struct console drm_panic_console = {
+ .name = "drmpanic",
+ .write = drm_panic_console_write,
+ .flags = CON_PRINTBUFFER | CON_ENABLED,
+ .index = 0,
+};
+
+static bool drm_panic_add_fb(struct drm_crtc *crtc, struct drm_plane *plane)
+{
+ unsigned int width = drm_rect_width(&plane->state->src) >> 16;
+ unsigned int height = drm_rect_height(&plane->state->src) >> 16;
+ struct drm_framebuffer *fb = plane->fb;
+ const struct font_desc *font;
+ struct drm_panic_fb *pfb;
+ void *vmap;
+
+ if (!width || !height || !fb || !fb->funcs || !fb->funcs->panic_vmap)
+ return false;
+
+ /* only 8-bit wide fonts are supported */
+ font = get_default_font(width, height, BIT(7), -1);
+ if (!font) {
+ drm_panic_log("Couldn't get font\n");
+ return false;
+ }
+
+ vmap = fb->funcs->panic_vmap(fb);
+ if (!vmap) {
+ drm_panic_log("panic_vmap() returned NULL\n");
+ return false;
+ }
+
+ pfb = &drm_panic_fbs[drm_panic_fbs_num++];
+ pfb->plane = plane;
+ pfb->crtc = crtc;
+ pfb->fb = fb;
+ pfb->width = width;
+ pfb->height = height;
+ pfb->vmap = vmap;
+ pfb->font = font;
+ pfb->cols = pfb->width / font->width;
+ pfb->rows = pfb->height / font->height;
+
+ drm_panic_log(" [FB:%d] %ux%u->%ux%u, %s, format=0x%08x\n",
+ fb->base.id, pfb->width, pfb->height, pfb->cols,
+ pfb->rows, font->name, fb->pixel_format);
+
+ return true;
+}
+
+static void drm_panic_add(struct drm_device *drm)
+{
+ struct drm_plane *plane;
+ struct drm_crtc *crtc;
+
+ if (!drm || !drm->driver ||
+ !(drm->driver->driver_features & DRIVER_ATOMIC))
+ return;
+
+ drm_panic_log("%s on minor %d\n", drm->driver->name,
+ drm->primary ? drm->primary->index : -1);
+
+ drm_for_each_crtc(crtc, drm) {
+ drm_panic_log(" %s\n", crtc->name);
+
+ if (drm_panic_fbs_num >= DRM_PANIC_MAX_FBS)
+ return;
+
+ if (!ww_mutex_trylock(&crtc->mutex.mutex))
+ continue;
+
+ if (!crtc->enabled || !crtc->primary)
+ goto crtc_unlock;
+
+ if (!crtc->state || !crtc->state->active)
+ goto crtc_unlock;
+
+ plane = crtc->primary;
+ if (!ww_mutex_trylock(&plane->mutex.mutex))
+ goto crtc_unlock;
+
+ if (!plane->state || !plane->state->visible)
+ goto plane_unlock;
+
+ if (drm_panic_add_fb(crtc, plane))
+ continue;
+
+plane_unlock:
+ ww_mutex_unlock(&plane->mutex.mutex);
+crtc_unlock:
+ ww_mutex_unlock(&crtc->mutex.mutex);
+ }
+}
+
+static int drm_panic_class_iter(struct device *dev, void *data)
+{
+ struct drm_minor *minor;
+
+ minor = dev_get_drvdata(dev);
+
+ if (minor && minor->type == DRM_MINOR_PRIMARY)
+ drm_panic_add(minor->dev);
+
+ return 0;
+}
+
+/*
+ * The panic() function makes sure that only one CPU is allowed to run it's
+ * code, but a new panic can be triggered during it's processing.
+ *
+ * Prior to calling the panic handlers, panic() calls smp_send_stop(). If
+ * that went well, there's only one CPU running, but this is no guarantee.
+ */
+static int drm_panic_handler(struct notifier_block *this, unsigned long ev,
+ void *ptr)
+{
+ drm_panic_log("%s\n", __func__);
+
+ /*
+ * TODO
+ * Maybe we need better protection here against reentrance in case
+ * panic_vmap() triggered a new panic.
+ */
+
+ /* Nested panic */
+ if (drm_panic_fbs_num)
+ return NOTIFY_DONE;
+
+ class_for_each_device(drm_class, NULL, NULL, drm_panic_class_iter);
+
+ if (drm_panic_fbs_num)
+ drm_panic_active = true;
+
+ return NOTIFY_DONE;
+}
+
+static struct notifier_block drm_panic_block = {
+ .notifier_call = drm_panic_handler,
+};
+
+static void drm_panic_test(void)
+{
+ /* simulate calling panic_notifier_list */
+ drm_panic_handler(NULL, 0, NULL);
+}
+
+static void drm_panic_test_cleanup(void)
+{
+ struct drm_panic_fb *pfb;
+ unsigned int i;
+
+ drm_panic_active = false;
+
+ for (i = 0; i < drm_panic_fbs_num; i++) {
+ pfb = &drm_panic_fbs[i];
+ if (pfb->fb->funcs->panic_vunmap)
+ pfb->fb->funcs->panic_vunmap(pfb->fb, pfb->vmap);
+ ww_mutex_unlock(&pfb->plane->mutex.mutex);
+ ww_mutex_unlock(&pfb->crtc->mutex.mutex);
+ }
+
+ drm_panic_fbs_num = 0;
+ memset(drm_panic_fbs, 0, DRM_PANIC_MAX_FBS * sizeof(*drm_panic_fbs));
+}
+
+/*
+ * Partial replication of panic() for testing purposes. Some symbols are
+ * only available when builtin (they're not exported).
+ */
+static void drm_panic_fake_panic(unsigned int level)
+{
+#ifndef MODULE
+ int old_loglevel = console_loglevel;
+
+ if (level > 1)
+ local_irq_disable();
+
+ console_verbose();
+
+ if (level > 2)
+ bust_spinlocks(1);
+
+ pr_emerg("Kernel panic - not syncing: FAKING=%u, oops_in_progress=%d\n",
+ level, oops_in_progress);
+
+ dump_stack();
+ drm_panic_test();
+
+ if (level > 2)
+ bust_spinlocks(0);
+
+ console_flush_on_panic();
+
+ pr_emerg("---[ end Kernel panic - not syncing: FAKING\n");
+
+ if (level > 1)
+ local_irq_enable();
+
+ console_loglevel = old_loglevel;
+
+#else /* MODULE */
+
+ if (level > 1)
+ local_irq_disable();
+
+ pr_emerg("Kernel panic - not syncing: FAKING=%u\n", level);
+ dump_stack();
+ drm_panic_test();
+ pr_emerg("---[ end Kernel panic - not syncing: FAKING\n");
+
+ if (level > 1)
+ local_irq_enable();
+
+#endif /* MODULE */
+
+ drm_panic_test_cleanup();
+}
+
+static void drm_panic_clear_kmsgs(void)
+{
+ console_lock();
+ memset(drm_panic_kmsgs, 0, DRM_PANIC_MAX_KMSGS);
+ drm_panic_kmsgs_pos = 0;
+ console_unlock();
+}
+
+/*
+ * Fake/simulate panic() at different levels:
+ * 1: only trigger panic handling internally
+ * 2: add local_irq_disable()
+ * 3: add bust_spinlocks();
+ *
+ * Test rendering code:
+ * 100: clear kmsgs buffer
+ * 101: call panic handler for testing
+ * 102: cleanup after testing
+ *
+ * The real deal:
+ * 200: don't fake it, do call panic()
+ */
+static ssize_t drm_panic_file_panic_write(struct file *file,
+ const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ unsigned long long val;
+ ssize_t ret = 0;
+ char buf[24];
+ size_t size;
+
+ size = min(sizeof(buf) - 1, count);
+ if (copy_from_user(buf, user_buf, size))
+ return -EFAULT;
+
+ buf[size] = '\0';
+ ret = kstrtoull(buf, 0, &val);
+ if (ret)
+ return ret;
+
+ if (val && val < 4)
+ drm_panic_fake_panic(val);
+ else if (val == 100)
+ drm_panic_clear_kmsgs();
+ else if (val == 101)
+ drm_panic_test();
+ else if (val == 102)
+ drm_panic_test_cleanup();
+ else if (val == 200)
+ panic("TESTING");
+ else
+ return -EINVAL;
+
+ return count;
+}
+
+static const struct file_operations drm_panic_panic_ops = {
+ .write = drm_panic_file_panic_write,
+ .open = simple_open,
+ .llseek = default_llseek,
+};
+
+static int drm_panic_log_show(struct seq_file *m, void *v)
+{
+ size_t pos = log_pos;
+
+ if (log_buf[0] == '\0')
+ return 0;
+
+ if (!pos) {
+ seq_write(m, log_buf, DRM_PANIC_LOG_SIZE);
+ } else if (log_buf[pos] == '\0') {
+ seq_write(m, log_buf, pos);
+ } else {
+ seq_write(m, log_buf + pos, DRM_PANIC_LOG_SIZE - pos);
+ seq_write(m, log_buf, pos);
+ }
+
+ return 0;
+}
+
+static int drm_panic_log_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, drm_panic_log_show, NULL);
+}
+
+static const struct file_operations drm_panic_log_ops = {
+ .owner = THIS_MODULE,
+ .open = drm_panic_log_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+static struct dentry *drm_panic_d_panic;
+static struct dentry *drm_panic_d_log;
+
+void __init drm_panic_init(struct dentry *debugfs_root)
+{
+ drm_panic_kmsgs = kzalloc(DRM_PANIC_MAX_KMSGS, GFP_KERNEL);
+ if (!drm_panic_kmsgs) {
+ DRM_ERROR("Failed to setup panic handler\n");
+ return;
+ }
+
+ drm_panic_d_panic = debugfs_create_file("panic-test", 0200,
+ debugfs_root, NULL,
+ &drm_panic_panic_ops);
+
+ drm_panic_d_log = debugfs_create_file("panic-log", 0444, debugfs_root,
+ NULL, &drm_panic_log_ops);
+ if (!IS_ERR_OR_NULL(drm_panic_d_log))
+ log_buf = kzalloc(DRM_PANIC_LOG_SIZE, GFP_KERNEL);
+
+ register_console(&drm_panic_console);
+ atomic_notifier_chain_register(&panic_notifier_list, &drm_panic_block);
+}
+
+void __exit drm_panic_exit(struct dentry *debugfs_root)
+{
+ if (!drm_panic_kmsgs)
+ return;
+
+ debugfs_remove(drm_panic_d_log);
+ debugfs_remove(drm_panic_d_panic);
+ kfree(log_buf);
+ log_buf = NULL;
+
+ atomic_notifier_chain_unregister(&panic_notifier_list,
+ &drm_panic_block);
+ unregister_console(&drm_panic_console);
+ kfree(drm_panic_kmsgs);
+}
diff --git a/include/drm/drm_framebuffer.h b/include/drm/drm_framebuffer.h
index 50deb40..33f4022 100644
--- a/include/drm/drm_framebuffer.h
+++ b/include/drm/drm_framebuffer.h
@@ -90,6 +90,44 @@ struct drm_framebuffer_funcs {
struct drm_file *file_priv, unsigned flags,
unsigned color, struct drm_clip_rect *clips,
unsigned num_clips);
+
+ /**
+ * @panic_vmap:
+ *
+ * Optional callback for panic handling.
+ *
+ * For vmapping the selected framebuffer in a panic context. Must
+ * be super careful about locking (only trylocking allowed).
+ *
+ * RETURNS:
+ *
+ * NULL if it didn't work out, otherwise an opaque cookie which is
+ * passed to @panic_draw_xy. It can be anything: vmap area, structure
+ * with more details, just a few flags, ...
+ */
+ void *(*panic_vmap)(struct drm_framebuffer *fb);
+
+ /**
+ * @panic_vunmap:
+ *
+ * Optional callback for cleaning up after panic testing.
+ *
+ * Crtc and plane locks are released after this callback has run.
+ * vmap is the cookie returned by @panic_vmap.
+ */
+ void (*panic_vunmap)(struct drm_framebuffer *fb, void *vmap);
+
+ /**
+ * @panic_draw_xy:
+ *
+ * Optional callback for drawing pixels during panic.
+ *
+ * For drawing pixels onto a framebuffer prepared with @panic_vmap.
+ * vmap is the cookie returned by @panic_vmap.
+ * If it's not set, drm_framebuffer_panic_draw_xy() is used.
+ */
+ void (*panic_draw_xy)(struct drm_framebuffer *fb, void *vmap,
+ int x, int y, bool foreground);
};
/**
@@ -214,6 +252,8 @@ struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
void drm_framebuffer_remove(struct drm_framebuffer *fb);
void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
+void drm_framebuffer_panic_draw_xy(struct drm_framebuffer *fb, void *vmap,
+ int x, int y, bool foreground);
/**
* drm_framebuffer_reference - incr the fb refcnt
--
2.8.2
More information about the dri-devel
mailing list