console: Add persistent scrollback buffers for all VGA consoles

Add a scrollback buffers for each VGA console. The benefit is that
the scrollback history is not flushed when switching between consoles
but is persistent.
The buffers are allocated on demand when a new console is opened.

This breaks tools like clear_console that rely on flushing the
scrollback history by switching back and forth between consoles
which is why this feature is disabled by default.
Use the escape sequence \e[3J instead for flushing the buffer.

Signed-off-by: Manuel Schölling <manuel.schoelling@gmx.de>
Reviewed-by: Andrey Utkin <andrey_utkin@fastmail.com>
Tested-by: Andrey Utkin <andrey_utkin@fastmail.com>
Tested-by: Adam Borowski <kilobyte@angband.pl>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index c3f1fb9ee8203cbb307605d8e7deca7ed5a7399a..f500e58f7636188c1e255997aaa169b588d34b2c 100644 (file)
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -43,9 +43,28 @@ config VGACON_SOFT_SCROLLBACK_SIZE
        range 1 1024
        default "64"
        help
-         Enter the amount of System RAM to allocate for the scrollback
-        buffer.  Each 64KB will give you approximately 16 80x25
-        screenfuls of scrollback buffer
+         Enter the amount of System RAM to allocate for scrollback
+         buffers of VGA consoles. Each 64KB will give you approximately
+         16 80x25 screenfuls of scrollback buffer.
+
+config VGACON_SOFT_SCROLLBACK_PERSISTENT
+       bool "Persistent Scrollback History for each console"
+       depends on VGACON_SOFT_SCROLLBACK
+       default n
+       help
+         Say Y here if the scrollback history should persist when switching
+         between consoles. Otherwise, the scrollback history will be flushed
+         each time the console is switched.
+
+         This feature might break your tool of choice to flush the scrollback
+         buffer, e.g. clear(1) will work fine but Debian's clear_console(1)
+         will be broken, which might cause security issues.
+         You can use the escape sequence \e[3J instead if this feature is
+         activated.
+
+         Note that a buffer of VGACON_SOFT_SCROLLBACK_SIZE is taken for each
+         created tty device.
+         So if you use a RAM-constrained system, say N here.
 
 config MDA_CONSOLE
        depends on !M68K && !PARISC && ISA

diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 9a7c2bbc5326fb42a70d58e054c059a28110257a..ca23d222e02992e9a573823d6ed28256221d129a 100644 (file)
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -162,7 +162,7 @@ static inline void vga_set_mem_top(struct vc_data *c)
 
 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
 /* software scrollback */
-static struct vgacon_scrollback_info {
+struct vgacon_scrollback_info {
        void *data;
        int tail;
        int size;
@@ -171,74 +171,110 @@ static struct vgacon_scrollback_info {
        int cur;
        int save;
        int restore;
-} vgacon_scrollback;
+};
+
+static struct vgacon_scrollback_info *vgacon_scrollback_cur;
+#ifdef CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT
+static struct vgacon_scrollback_info vgacon_scrollbacks[MAX_NR_CONSOLES];
+#else
+static struct vgacon_scrollback_info vgacon_scrollbacks[1];
+#endif
 
-static void vgacon_scrollback_reset(size_t reset_size)
+static void vgacon_scrollback_reset(int vc_num, size_t reset_size)
 {
-       if (vgacon_scrollback.data && reset_size > 0)
-               memset(vgacon_scrollback.data, 0, reset_size);
+       struct vgacon_scrollback_info *scrollback = &vgacon_scrollbacks[vc_num];
+
+       if (scrollback->data && reset_size > 0)
+               memset(scrollback->data, 0, reset_size);
 
-       vgacon_scrollback.cnt  = 0;
-       vgacon_scrollback.tail = 0;
-       vgacon_scrollback.cur  = 0;
+       scrollback->cnt  = 0;
+       scrollback->tail = 0;
+       scrollback->cur  = 0;
 }
 
-static void vgacon_scrollback_init(int pitch)
+static void vgacon_scrollback_init(int vc_num)
 {
-       int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
-
-       if (vgacon_scrollback.data) {
-               vgacon_scrollback.cnt  = 0;
-               vgacon_scrollback.tail = 0;
-               vgacon_scrollback.cur  = 0;
-               vgacon_scrollback.rows = rows - 1;
-               vgacon_scrollback.size = rows * pitch;
+       int pitch = vga_video_num_columns * 2;
+       size_t size = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024;
+       int rows = size / pitch;
+       void *data;
+
+       data = kmalloc_array(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE, 1024,
+                            GFP_NOWAIT);
+
+       vgacon_scrollbacks[vc_num].data = data;
+       vgacon_scrollback_cur = &vgacon_scrollbacks[vc_num];
+
+       vgacon_scrollback_cur->rows = rows - 1;
+       vgacon_scrollback_cur->size = rows * pitch;
+
+       vgacon_scrollback_reset(vc_num, size);
+}
+
+static void vgacon_scrollback_switch(int vc_num)
+{
+#ifndef CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT
+       vc_num = 0;
+#endif
+
+       if (!vgacon_scrollbacks[vc_num].data) {
+               vgacon_scrollback_init(vc_num);
+       } else {
+#ifdef CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT
+               vgacon_scrollback_cur = &vgacon_scrollbacks[vc_num];
+#else
+               size_t size = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024;
+
+               vgacon_scrollback_reset(vc_num, size);
+#endif
        }
 }
 
 static void vgacon_scrollback_startup(void)
 {
-       vgacon_scrollback.data = kcalloc(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE,
-               1024, GFP_NOWAIT);
-       vgacon_scrollback_init(vga_video_num_columns * 2);
+       vgacon_scrollback_cur = &vgacon_scrollbacks[0];
+       vgacon_scrollback_init(0);
 }
 
 static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
 {
        void *p;
 
-       if (!vgacon_scrollback.size || c->vc_num != fg_console)
+       if (!vgacon_scrollback_cur->data || !vgacon_scrollback_cur->size ||
+           c->vc_num != fg_console)
                return;
 
        p = (void *) (c->vc_origin + t * c->vc_size_row);
 
        while (count--) {
-               scr_memcpyw(vgacon_scrollback.data + vgacon_scrollback.tail,
+               scr_memcpyw(vgacon_scrollback_cur->data +
+                           vgacon_scrollback_cur->tail,
                            p, c->vc_size_row);
-               vgacon_scrollback.cnt++;
+
+               vgacon_scrollback_cur->cnt++;
                p += c->vc_size_row;
-               vgacon_scrollback.tail += c->vc_size_row;
+               vgacon_scrollback_cur->tail += c->vc_size_row;
 
-               if (vgacon_scrollback.tail >= vgacon_scrollback.size)
-                       vgacon_scrollback.tail = 0;
+               if (vgacon_scrollback_cur->tail >= vgacon_scrollback_cur->size)
+                       vgacon_scrollback_cur->tail = 0;
 
-               if (vgacon_scrollback.cnt > vgacon_scrollback.rows)
-                       vgacon_scrollback.cnt = vgacon_scrollback.rows;
+               if (vgacon_scrollback_cur->cnt > vgacon_scrollback_cur->rows)
+                       vgacon_scrollback_cur->cnt = vgacon_scrollback_cur->rows;
 
-               vgacon_scrollback.cur = vgacon_scrollback.cnt;
+               vgacon_scrollback_cur->cur = vgacon_scrollback_cur->cnt;
        }
 }
 
 static void vgacon_restore_screen(struct vc_data *c)
 {
-       vgacon_scrollback.save = 0;
+       vgacon_scrollback_cur->save = 0;
 
-       if (!vga_is_gfx && !vgacon_scrollback.restore) {
+       if (!vga_is_gfx && !vgacon_scrollback_cur->restore) {
                scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
                            c->vc_screenbuf_size > vga_vram_size ?
                            vga_vram_size : c->vc_screenbuf_size);
-               vgacon_scrollback.restore = 1;
-               vgacon_scrollback.cur = vgacon_scrollback.cnt;
+               vgacon_scrollback_cur->restore = 1;
+               vgacon_scrollback_cur->cur = vgacon_scrollback_cur->cnt;
        }
 }
 
@@ -252,41 +288,41 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
                return;
        }
 
-       if (!vgacon_scrollback.data)
+       if (!vgacon_scrollback_cur->data)
                return;
 
-       if (!vgacon_scrollback.save) {
+       if (!vgacon_scrollback_cur->save) {
                vgacon_cursor(c, CM_ERASE);
                vgacon_save_screen(c);
-               vgacon_scrollback.save = 1;
+               vgacon_scrollback_cur->save = 1;
        }
 
-       vgacon_scrollback.restore = 0;
-       start = vgacon_scrollback.cur + lines;
+       vgacon_scrollback_cur->restore = 0;
+       start = vgacon_scrollback_cur->cur + lines;
        end = start + abs(lines);
 
        if (start < 0)
                start = 0;
 
-       if (start > vgacon_scrollback.cnt)
-               start = vgacon_scrollback.cnt;
+       if (start > vgacon_scrollback_cur->cnt)
+               start = vgacon_scrollback_cur->cnt;
 
        if (end < 0)
                end = 0;
 
-       if (end > vgacon_scrollback.cnt)
-               end = vgacon_scrollback.cnt;
+       if (end > vgacon_scrollback_cur->cnt)
+               end = vgacon_scrollback_cur->cnt;
 
-       vgacon_scrollback.cur = start;
+       vgacon_scrollback_cur->cur = start;
        count = end - start;
-       soff = vgacon_scrollback.tail - ((vgacon_scrollback.cnt - end) *
-                                        c->vc_size_row);
+       soff = vgacon_scrollback_cur->tail -
+               ((vgacon_scrollback_cur->cnt - end) * c->vc_size_row);
        soff -= count * c->vc_size_row;
 
        if (soff < 0)
-               soff += vgacon_scrollback.size;
+               soff += vgacon_scrollback_cur->size;
 
-       count = vgacon_scrollback.cnt - start;
+       count = vgacon_scrollback_cur->cnt - start;
 
        if (count > c->vc_rows)
                count = c->vc_rows;
@@ -300,13 +336,13 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
 
                count *= c->vc_size_row;
                /* how much memory to end of buffer left? */
-               copysize = min(count, vgacon_scrollback.size - soff);
-               scr_memcpyw(d, vgacon_scrollback.data + soff, copysize);
+               copysize = min(count, vgacon_scrollback_cur->size - soff);
+               scr_memcpyw(d, vgacon_scrollback_cur->data + soff, copysize);
                d += copysize;
                count -= copysize;
 
                if (count) {
-                       scr_memcpyw(d, vgacon_scrollback.data, count);
+                       scr_memcpyw(d, vgacon_scrollback_cur->data, count);
                        d += count;
                }
 
@@ -320,13 +356,13 @@ static void vgacon_flush_scrollback(struct vc_data *c)
 {
        size_t size = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024;
 
-       if (c->vc_num == fg_console)
-               vgacon_scrollback_reset(size);
+       vgacon_scrollback_reset(c->vc_num, size);
 }
 #else
 #define vgacon_scrollback_startup(...) do { } while (0)
 #define vgacon_scrollback_init(...)    do { } while (0)
 #define vgacon_scrollback_update(...)  do { } while (0)
+#define vgacon_scrollback_switch(...)  do { } while (0)
 
 static void vgacon_restore_screen(struct vc_data *c)
 {
@@ -805,7 +841,7 @@ static int vgacon_switch(struct vc_data *c)
                        vgacon_doresize(c, c->vc_cols, c->vc_rows);
        }
 
-       vgacon_scrollback_init(c->vc_size_row);
+       vgacon_scrollback_switch(c->vc_num);
        return 0;               /* Redrawing not needed */
 }