2017-11-06 20:11:51 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Hopefully this will be a rather complete VT102 implementation.
|
|
|
|
|
*
|
|
|
|
|
* Beeping thanks to John T Kohl.
|
|
|
|
|
*
|
|
|
|
|
* Virtual Consoles, Screen Blanking, Screen Dumping, Color, Graphics
|
|
|
|
|
* Chars, and VT100 enhancements by Peter MacDonald.
|
|
|
|
|
*
|
|
|
|
|
* Copy and paste function by Andrew Haylett,
|
|
|
|
|
* some enhancements by Alessandro Rubini.
|
|
|
|
|
*
|
|
|
|
|
* Code to check for different video-cards mostly by Galen Hunt,
|
|
|
|
|
* <g-hunt@ee.utah.edu>
|
|
|
|
|
*
|
|
|
|
|
* Rudimentary ISO 10646/Unicode/UTF-8 character set support by
|
|
|
|
|
* Markus Kuhn, <mskuhn@immd4.informatik.uni-erlangen.de>.
|
|
|
|
|
*
|
|
|
|
|
* Dynamic allocation of consoles, aeb@cwi.nl, May 1994
|
|
|
|
|
* Resizing of consoles, aeb, 940926
|
|
|
|
|
*
|
|
|
|
|
* Code for xterm like mouse click reporting by Peter Orbaek 20-Jul-94
|
|
|
|
|
* <poe@daimi.aau.dk>
|
|
|
|
|
*
|
|
|
|
|
* User-defined bell sound, new setterm control sequences and printk
|
|
|
|
|
* redirection by Martin Mares <mj@k332.feld.cvut.cz> 19-Nov-95
|
|
|
|
|
*
|
|
|
|
|
* APM screenblank bug fixed Takashi Manabe <manabe@roy.dsl.tutics.tut.jp>
|
|
|
|
|
*
|
|
|
|
|
* Merge with the abstract console driver by Geert Uytterhoeven
|
|
|
|
|
* <geert@linux-m68k.org>, Jan 1997.
|
|
|
|
|
*
|
|
|
|
|
* Original m68k console driver modifications by
|
|
|
|
|
*
|
|
|
|
|
* - Arno Griffioen <arno@usn.nl>
|
|
|
|
|
* - David Carter <carter@cs.bris.ac.uk>
|
|
|
|
|
*
|
|
|
|
|
* The abstract console driver provides a generic interface for a text
|
|
|
|
|
* console. It supports VGA text mode, frame buffer based graphical consoles
|
|
|
|
|
* and special graphics processors that are only accessible through some
|
|
|
|
|
* registers (e.g. a TMS340x0 GSP).
|
|
|
|
|
*
|
|
|
|
|
* The interface to the hardware is specified using a special structure
|
|
|
|
|
* (struct consw) which contains function pointers to console operations
|
|
|
|
|
* (see <linux/console.h> for more information).
|
|
|
|
|
*
|
|
|
|
|
* Support for changeable cursor shape
|
|
|
|
|
* by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>, August 1997
|
|
|
|
|
*
|
|
|
|
|
* Ported to i386 and con_scrolldelta fixed
|
|
|
|
|
* by Emmanuel Marty <core@ggi-project.org>, April 1998
|
|
|
|
|
*
|
|
|
|
|
* Resurrected character buffers in videoram plus lots of other trickery
|
|
|
|
|
* by Martin Mares <mj@atrey.karlin.mff.cuni.cz>, July 1998
|
|
|
|
|
*
|
|
|
|
|
* Removed old-style timers, introduced console_timer, made timer
|
2008-10-16 09:01:59 +04:00
|
|
|
* deletion SMP-safe. 17Jun00, Andrew Morton
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
|
* Removed console_lock, enabled interrupts across all console operations
|
|
|
|
|
* 13 March 2001, Andrew Morton
|
2006-09-29 12:59:53 +04:00
|
|
|
*
|
|
|
|
|
* Fixed UTF-8 mode so alternate charset modes always work according
|
|
|
|
|
* to control sequences interpreted in do_con_trol function
|
|
|
|
|
* preserving backward VT100 semigraphics compatibility,
|
|
|
|
|
* malformed UTF sequences represented as sequences of replacement glyphs,
|
|
|
|
|
* original codes or '?' as a last resort if replacement glyph is undefined
|
|
|
|
|
* by Adam Tla/lka <atlka@pg.gda.pl>, Aug 2006
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/types.h>
|
2017-02-08 20:51:30 +03:00
|
|
|
#include <linux/sched/signal.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/tty.h>
|
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/kd.h>
|
|
|
|
|
#include <linux/slab.h>
|
2020-03-29 05:25:11 +03:00
|
|
|
#include <linux/vmalloc.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/major.h>
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
|
#include <linux/console.h>
|
|
|
|
|
#include <linux/init.h>
|
2007-05-08 11:39:49 +04:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/vt_kern.h>
|
|
|
|
|
#include <linux/selection.h>
|
|
|
|
|
#include <linux/tiocl.h>
|
|
|
|
|
#include <linux/kbd_kern.h>
|
|
|
|
|
#include <linux/consolemap.h>
|
|
|
|
|
#include <linux/timer.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
|
#include <linux/pm.h>
|
|
|
|
|
#include <linux/font.h>
|
|
|
|
|
#include <linux/bitops.h>
|
2007-10-19 10:39:17 +04:00
|
|
|
#include <linux/notifier.h>
|
2008-10-13 13:41:42 +04:00
|
|
|
#include <linux/device.h>
|
|
|
|
|
#include <linux/io.h>
|
|
|
|
|
#include <linux/uaccess.h>
|
2010-08-05 18:22:30 +04:00
|
|
|
#include <linux/kdb.h>
|
2010-06-15 18:24:16 +04:00
|
|
|
#include <linux/ctype.h>
|
2017-09-16 11:03:05 +03:00
|
|
|
#include <linux/bsearch.h>
|
2018-07-19 07:05:25 +03:00
|
|
|
#include <linux/gcd.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
#define MAX_NR_CON_DRIVER 16
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
#define CON_DRIVER_FLAG_MODULE 1
|
2006-10-03 12:14:49 +04:00
|
|
|
#define CON_DRIVER_FLAG_INIT 2
|
|
|
|
|
#define CON_DRIVER_FLAG_ATTR 4
|
2015-04-01 21:06:16 +03:00
|
|
|
#define CON_DRIVER_FLAG_ZOMBIE 8
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
struct con_driver {
|
|
|
|
|
const struct consw *con;
|
|
|
|
|
const char *desc;
|
2006-08-08 09:19:37 +04:00
|
|
|
struct device *dev;
|
2006-06-26 11:27:12 +04:00
|
|
|
int node;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
int first;
|
|
|
|
|
int last;
|
|
|
|
|
int flag;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct con_driver registered_con_driver[MAX_NR_CON_DRIVER];
|
2005-04-17 02:20:36 +04:00
|
|
|
const struct consw *conswitchp;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Here is the default bell parameters: 750HZ, 1/8th of a second
|
|
|
|
|
*/
|
|
|
|
|
#define DEFAULT_BELL_PITCH 750
|
|
|
|
|
#define DEFAULT_BELL_DURATION (HZ/8)
|
2015-03-26 16:54:39 +03:00
|
|
|
#define DEFAULT_CURSOR_BLINK_MS 200
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
struct vc vc_cons [MAX_NR_CONSOLES];
|
|
|
|
|
|
|
|
|
|
#ifndef VT_SINGLE_DRIVER
|
|
|
|
|
static const struct consw *con_driver_map[MAX_NR_CONSOLES];
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static int con_open(struct tty_struct *, struct file *);
|
|
|
|
|
static void vc_init(struct vc_data *vc, unsigned int rows,
|
|
|
|
|
unsigned int cols, int do_clear);
|
|
|
|
|
static void gotoxy(struct vc_data *vc, int new_x, int new_y);
|
|
|
|
|
static void save_cur(struct vc_data *vc);
|
|
|
|
|
static void reset_terminal(struct vc_data *vc, int do_clear);
|
|
|
|
|
static void con_flush_chars(struct tty_struct *tty);
|
2006-12-07 07:38:38 +03:00
|
|
|
static int set_vesa_blanking(char __user *p);
|
2005-04-17 02:20:36 +04:00
|
|
|
static void set_cursor(struct vc_data *vc);
|
|
|
|
|
static void hide_cursor(struct vc_data *vc);
|
2006-11-22 17:55:48 +03:00
|
|
|
static void console_callback(struct work_struct *ignored);
|
2015-04-01 21:06:16 +03:00
|
|
|
static void con_driver_unregister_callback(struct work_struct *ignored);
|
2017-08-28 21:28:21 +03:00
|
|
|
static void blank_screen_t(struct timer_list *unused);
|
2005-04-17 02:20:36 +04:00
|
|
|
static void set_palette(struct vc_data *vc);
|
|
|
|
|
|
2014-11-11 19:20:56 +03:00
|
|
|
#define vt_get_kmsg_redirect() vt_kmsg_redirect(-1)
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static int printable; /* Is console ready for printing? */
|
2007-10-18 14:04:34 +04:00
|
|
|
int default_utf8 = true;
|
2007-05-08 11:38:09 +04:00
|
|
|
module_param(default_utf8, int, S_IRUGO | S_IWUSR);
|
2009-11-13 23:14:11 +03:00
|
|
|
int global_cursor_default = -1;
|
|
|
|
|
module_param(global_cursor_default, int, S_IRUGO | S_IWUSR);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-06-15 10:48:57 +03:00
|
|
|
static int cur_default = CUR_UNDERLINE;
|
2009-12-16 03:45:39 +03:00
|
|
|
module_param(cur_default, int, S_IRUGO | S_IWUSR);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* ignore_poke: don't unblank the screen when things are typed. This is
|
|
|
|
|
* mainly for the privacy of braille terminal users.
|
|
|
|
|
*/
|
|
|
|
|
static int ignore_poke;
|
|
|
|
|
|
|
|
|
|
int do_poke_blanked_console;
|
|
|
|
|
int console_blanked;
|
|
|
|
|
|
|
|
|
|
static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
|
|
|
|
|
static int vesa_off_interval;
|
2017-03-22 18:07:20 +03:00
|
|
|
static int blankinterval;
|
2009-06-17 02:33:52 +04:00
|
|
|
core_param(consoleblank, blankinterval, int, 0444);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-11-22 17:55:48 +03:00
|
|
|
static DECLARE_WORK(console_work, console_callback);
|
2015-04-01 21:06:16 +03:00
|
|
|
static DECLARE_WORK(con_driver_unregister_work, con_driver_unregister_callback);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* fg_console is the current virtual console,
|
|
|
|
|
* last_console is the last used one,
|
|
|
|
|
* want_console is the console we want to switch to,
|
2010-08-05 18:22:30 +04:00
|
|
|
* saved_* variants are for save/restore around kernel debugger enter/leave
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
int fg_console;
|
|
|
|
|
int last_console;
|
|
|
|
|
int want_console = -1;
|
2010-08-17 00:58:30 +04:00
|
|
|
static int saved_fg_console;
|
|
|
|
|
static int saved_last_console;
|
|
|
|
|
static int saved_want_console;
|
|
|
|
|
static int saved_vc_mode;
|
2010-08-17 00:58:31 +04:00
|
|
|
static int saved_console_blanked;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For each existing display, we have a pointer to console currently visible
|
|
|
|
|
* on that display, allowing consoles other than fg_console to be refreshed
|
|
|
|
|
* appropriately. Unless the low-level driver supplies its own display_fg
|
|
|
|
|
* variable, we use this one for the "master display".
|
|
|
|
|
*/
|
|
|
|
|
static struct vc_data *master_display_fg;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Unfortunately, we need to delay tty echo when we're currently writing to the
|
|
|
|
|
* console since the code is (and always was) not re-entrant, so we schedule
|
|
|
|
|
* all flip requests to process context with schedule-task() and run it from
|
|
|
|
|
* console_callback().
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For the same reason, we defer scrollback to the console callback.
|
|
|
|
|
*/
|
|
|
|
|
static int scrollback_delta;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Hook so that the power management routines can (un)blank
|
|
|
|
|
* the console on our behalf.
|
|
|
|
|
*/
|
|
|
|
|
int (*console_blank_hook)(int);
|
|
|
|
|
|
2017-10-05 02:27:04 +03:00
|
|
|
static DEFINE_TIMER(console_timer, blank_screen_t);
|
2005-04-17 02:20:36 +04:00
|
|
|
static int blank_state;
|
|
|
|
|
static int blank_timer_expired;
|
|
|
|
|
enum {
|
|
|
|
|
blank_off = 0,
|
|
|
|
|
blank_normal_wait,
|
|
|
|
|
blank_vesa_wait,
|
|
|
|
|
};
|
|
|
|
|
|
2010-12-01 20:51:05 +03:00
|
|
|
/*
|
|
|
|
|
* /sys/class/tty/tty0/
|
|
|
|
|
*
|
|
|
|
|
* the attribute 'active' contains the name of the current vc
|
|
|
|
|
* console and it supports poll() to detect vc switches
|
|
|
|
|
*/
|
|
|
|
|
static struct device *tty0dev;
|
|
|
|
|
|
2007-10-19 10:39:17 +04:00
|
|
|
/*
|
|
|
|
|
* Notifier list for console events.
|
|
|
|
|
*/
|
|
|
|
|
static ATOMIC_NOTIFIER_HEAD(vt_notifier_list);
|
|
|
|
|
|
|
|
|
|
int register_vt_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return atomic_notifier_chain_register(&vt_notifier_list, nb);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(register_vt_notifier);
|
|
|
|
|
|
|
|
|
|
int unregister_vt_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return atomic_notifier_chain_unregister(&vt_notifier_list, nb);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(unregister_vt_notifier);
|
|
|
|
|
|
|
|
|
|
static void notify_write(struct vc_data *vc, unsigned int unicode)
|
|
|
|
|
{
|
2011-07-30 16:01:59 +04:00
|
|
|
struct vt_notifier_param param = { .vc = vc, .c = unicode };
|
2007-10-19 10:39:17 +04:00
|
|
|
atomic_notifier_call_chain(&vt_notifier_list, VT_WRITE, ¶m);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void notify_update(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
struct vt_notifier_param param = { .vc = vc };
|
|
|
|
|
atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, ¶m);
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* Low-Level Functions
|
|
|
|
|
*/
|
|
|
|
|
|
2016-06-23 14:34:35 +03:00
|
|
|
static inline bool con_is_fg(const struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
return vc->vc_num == fg_console;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool con_should_update(const struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
return con_is_visible(vc) && !console_blanked;
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-08-18 11:56:51 +03:00
|
|
|
static inline unsigned short *screenpos(const struct vc_data *vc, int offset,
|
2020-08-18 11:56:53 +03:00
|
|
|
bool viewed)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
unsigned short *p;
|
|
|
|
|
|
|
|
|
|
if (!viewed)
|
|
|
|
|
p = (unsigned short *)(vc->vc_origin + offset);
|
|
|
|
|
else if (!vc->vc_sw->con_screen_pos)
|
|
|
|
|
p = (unsigned short *)(vc->vc_visible_origin + offset);
|
|
|
|
|
else
|
|
|
|
|
p = vc->vc_sw->con_screen_pos(vc, offset);
|
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-02 00:52:54 +04:00
|
|
|
/* Called from the keyboard irq path.. */
|
2005-04-17 02:20:36 +04:00
|
|
|
static inline void scrolldelta(int lines)
|
|
|
|
|
{
|
2010-06-02 00:52:54 +04:00
|
|
|
/* FIXME */
|
|
|
|
|
/* scrolldelta needs some kind of consistency lock, but the BKL was
|
|
|
|
|
and still is not protecting versus the scheduled back end */
|
2005-04-17 02:20:36 +04:00
|
|
|
scrollback_delta += lines;
|
|
|
|
|
schedule_console_callback();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void schedule_console_callback(void)
|
|
|
|
|
{
|
|
|
|
|
schedule_work(&console_work);
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
/*
|
|
|
|
|
* Code to manage unicode-based screen buffers
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifdef NO_VC_UNI_SCREEN
|
|
|
|
|
/* this disables and optimizes related code away at compile time */
|
|
|
|
|
#define get_vc_uniscr(vc) NULL
|
|
|
|
|
#else
|
|
|
|
|
#define get_vc_uniscr(vc) vc->vc_uni_screen
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-07-18 04:02:41 +03:00
|
|
|
#define VC_UNI_SCREEN_DEBUG 0
|
|
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
typedef uint32_t char32_t;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Our screen buffer is preceded by an array of line pointers so that
|
|
|
|
|
* scrolling only implies some pointer shuffling.
|
|
|
|
|
*/
|
|
|
|
|
struct uni_screen {
|
|
|
|
|
char32_t *lines[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct uni_screen *vc_uniscr_alloc(unsigned int cols, unsigned int rows)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr;
|
|
|
|
|
void *p;
|
|
|
|
|
unsigned int memsize, i;
|
|
|
|
|
|
|
|
|
|
/* allocate everything in one go */
|
|
|
|
|
memsize = cols * rows * sizeof(char32_t);
|
|
|
|
|
memsize += rows * sizeof(char32_t *);
|
2020-03-29 05:25:11 +03:00
|
|
|
p = vmalloc(memsize);
|
2018-06-27 06:56:40 +03:00
|
|
|
if (!p)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* initial line pointers */
|
|
|
|
|
uniscr = p;
|
|
|
|
|
p = uniscr->lines + rows;
|
|
|
|
|
for (i = 0; i < rows; i++) {
|
|
|
|
|
uniscr->lines[i] = p;
|
|
|
|
|
p += cols * sizeof(char32_t);
|
|
|
|
|
}
|
|
|
|
|
return uniscr;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-02 18:01:07 +03:00
|
|
|
static void vc_uniscr_free(struct uni_screen *uniscr)
|
|
|
|
|
{
|
|
|
|
|
vfree(uniscr);
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
static void vc_uniscr_set(struct vc_data *vc, struct uni_screen *new_uniscr)
|
|
|
|
|
{
|
2020-05-02 18:01:07 +03:00
|
|
|
vc_uniscr_free(vc->vc_uni_screen);
|
2018-06-27 06:56:40 +03:00
|
|
|
vc->vc_uni_screen = new_uniscr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_putc(struct vc_data *vc, char32_t uc)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr)
|
2020-06-15 10:48:33 +03:00
|
|
|
uniscr->lines[vc->state.y][vc->state.x] = uc;
|
2018-06-27 06:56:40 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_insert(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr) {
|
2020-06-15 10:48:33 +03:00
|
|
|
char32_t *ln = uniscr->lines[vc->state.y];
|
|
|
|
|
unsigned int x = vc->state.x, cols = vc->vc_cols;
|
2018-06-27 06:56:40 +03:00
|
|
|
|
|
|
|
|
memmove(&ln[x + nr], &ln[x], (cols - x - nr) * sizeof(*ln));
|
|
|
|
|
memset32(&ln[x], ' ', nr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_delete(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr) {
|
2020-06-15 10:48:33 +03:00
|
|
|
char32_t *ln = uniscr->lines[vc->state.y];
|
|
|
|
|
unsigned int x = vc->state.x, cols = vc->vc_cols;
|
2018-06-27 06:56:40 +03:00
|
|
|
|
|
|
|
|
memcpy(&ln[x], &ln[x + nr], (cols - x - nr) * sizeof(*ln));
|
|
|
|
|
memset32(&ln[cols - nr], ' ', nr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_clear_line(struct vc_data *vc, unsigned int x,
|
|
|
|
|
unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr) {
|
2020-06-15 10:48:33 +03:00
|
|
|
char32_t *ln = uniscr->lines[vc->state.y];
|
2018-06-27 06:56:40 +03:00
|
|
|
|
|
|
|
|
memset32(&ln[x], ' ', nr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_clear_lines(struct vc_data *vc, unsigned int y,
|
|
|
|
|
unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr) {
|
|
|
|
|
unsigned int cols = vc->vc_cols;
|
|
|
|
|
|
|
|
|
|
while (nr--)
|
|
|
|
|
memset32(uniscr->lines[y++], ' ', cols);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
|
|
|
|
|
enum con_scroll dir, unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr) {
|
2018-07-19 07:05:25 +03:00
|
|
|
unsigned int i, j, k, sz, d, clear;
|
|
|
|
|
|
|
|
|
|
sz = b - t;
|
|
|
|
|
clear = b - nr;
|
|
|
|
|
d = nr;
|
|
|
|
|
if (dir == SM_DOWN) {
|
|
|
|
|
clear = t;
|
|
|
|
|
d = sz - nr;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < gcd(d, sz); i++) {
|
|
|
|
|
char32_t *tmp = uniscr->lines[t + i];
|
|
|
|
|
j = i;
|
|
|
|
|
while (1) {
|
|
|
|
|
k = j + d;
|
|
|
|
|
if (k >= sz)
|
|
|
|
|
k -= sz;
|
|
|
|
|
if (k == i)
|
|
|
|
|
break;
|
|
|
|
|
uniscr->lines[t + j] = uniscr->lines[t + k];
|
|
|
|
|
j = k;
|
|
|
|
|
}
|
|
|
|
|
uniscr->lines[t + j] = tmp;
|
2018-06-27 06:56:40 +03:00
|
|
|
}
|
|
|
|
|
vc_uniscr_clear_lines(vc, clear, nr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void vc_uniscr_copy_area(struct uni_screen *dst,
|
|
|
|
|
unsigned int dst_cols,
|
|
|
|
|
unsigned int dst_rows,
|
|
|
|
|
struct uni_screen *src,
|
|
|
|
|
unsigned int src_cols,
|
|
|
|
|
unsigned int src_top_row,
|
|
|
|
|
unsigned int src_bot_row)
|
|
|
|
|
{
|
|
|
|
|
unsigned int dst_row = 0;
|
|
|
|
|
|
|
|
|
|
if (!dst)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
while (src_top_row < src_bot_row) {
|
|
|
|
|
char32_t *src_line = src->lines[src_top_row];
|
|
|
|
|
char32_t *dst_line = dst->lines[dst_row];
|
|
|
|
|
|
|
|
|
|
memcpy(dst_line, src_line, src_cols * sizeof(char32_t));
|
|
|
|
|
if (dst_cols - src_cols)
|
|
|
|
|
memset32(dst_line + src_cols, ' ', dst_cols - src_cols);
|
|
|
|
|
src_top_row++;
|
|
|
|
|
dst_row++;
|
|
|
|
|
}
|
|
|
|
|
while (dst_row < dst_rows) {
|
|
|
|
|
char32_t *dst_line = dst->lines[dst_row];
|
|
|
|
|
|
|
|
|
|
memset32(dst_line, ' ', dst_cols);
|
|
|
|
|
dst_row++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-27 06:56:41 +03:00
|
|
|
/*
|
|
|
|
|
* Called from vcs_read() to make sure unicode screen retrieval is possible.
|
|
|
|
|
* This will initialize the unicode screen buffer if not already done.
|
|
|
|
|
* This returns 0 if OK, or a negative error code otherwise.
|
|
|
|
|
* In particular, -ENODATA is returned if the console is not in UTF-8 mode.
|
|
|
|
|
*/
|
|
|
|
|
int vc_uniscr_check(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr;
|
|
|
|
|
unsigned short *p;
|
|
|
|
|
int x, y, mask;
|
|
|
|
|
|
|
|
|
|
if (__is_defined(NO_VC_UNI_SCREEN))
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (!vc->vc_utf)
|
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
|
|
if (vc->vc_uni_screen)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
uniscr = vc_uniscr_alloc(vc->vc_cols, vc->vc_rows);
|
|
|
|
|
if (!uniscr)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Let's populate it initially with (imperfect) reverse translation.
|
|
|
|
|
* This is the next best thing we can do short of having it enabled
|
|
|
|
|
* from the start even when no users rely on this functionality. True
|
|
|
|
|
* unicode content will be available after a complete screen refresh.
|
|
|
|
|
*/
|
|
|
|
|
p = (unsigned short *)vc->vc_origin;
|
|
|
|
|
mask = vc->vc_hi_font_mask | 0xff;
|
|
|
|
|
for (y = 0; y < vc->vc_rows; y++) {
|
|
|
|
|
char32_t *line = uniscr->lines[y];
|
|
|
|
|
for (x = 0; x < vc->vc_cols; x++) {
|
|
|
|
|
u16 glyph = scr_readw(p++) & mask;
|
|
|
|
|
line[x] = inverse_translate(vc, glyph, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vc->vc_uni_screen = uniscr;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Called from vcs_read() to get the unicode data from the screen.
|
|
|
|
|
* This must be preceded by a successful call to vc_uniscr_check() once
|
|
|
|
|
* the console lock has been taken.
|
|
|
|
|
*/
|
2020-08-18 11:56:53 +03:00
|
|
|
void vc_uniscr_copy_line(const struct vc_data *vc, void *dest, bool viewed,
|
2018-06-27 06:56:41 +03:00
|
|
|
unsigned int row, unsigned int col, unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
2018-06-27 06:56:42 +03:00
|
|
|
int offset = row * vc->vc_size_row + col * 2;
|
|
|
|
|
unsigned long pos;
|
2018-06-27 06:56:41 +03:00
|
|
|
|
|
|
|
|
BUG_ON(!uniscr);
|
2018-06-27 06:56:42 +03:00
|
|
|
|
|
|
|
|
pos = (unsigned long)screenpos(vc, offset, viewed);
|
|
|
|
|
if (pos >= vc->vc_origin && pos < vc->vc_scr_end) {
|
|
|
|
|
/*
|
|
|
|
|
* Desired position falls in the main screen buffer.
|
|
|
|
|
* However the actual row/col might be different if
|
|
|
|
|
* scrollback is active.
|
|
|
|
|
*/
|
|
|
|
|
row = (pos - vc->vc_origin) / vc->vc_size_row;
|
|
|
|
|
col = ((pos - vc->vc_origin) % vc->vc_size_row) / 2;
|
|
|
|
|
memcpy(dest, &uniscr->lines[row][col], nr * sizeof(char32_t));
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Scrollback is active. For now let's simply backtranslate
|
|
|
|
|
* the screen glyphs until the unicode screen buffer does
|
|
|
|
|
* synchronize with console display drivers for a scrollback
|
|
|
|
|
* buffer of its own.
|
|
|
|
|
*/
|
|
|
|
|
u16 *p = (u16 *)pos;
|
|
|
|
|
int mask = vc->vc_hi_font_mask | 0xff;
|
|
|
|
|
char32_t *uni_buf = dest;
|
|
|
|
|
while (nr--) {
|
|
|
|
|
u16 glyph = scr_readw(p++) & mask;
|
|
|
|
|
*uni_buf++ = inverse_translate(vc, glyph, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-06-27 06:56:41 +03:00
|
|
|
}
|
|
|
|
|
|
2018-07-18 04:02:41 +03:00
|
|
|
/* this is for validation and debugging only */
|
|
|
|
|
static void vc_uniscr_debug_check(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
unsigned short *p;
|
|
|
|
|
int x, y, mask;
|
|
|
|
|
|
|
|
|
|
if (!VC_UNI_SCREEN_DEBUG || !uniscr)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Make sure our unicode screen translates into the same glyphs
|
|
|
|
|
* as the actual screen. This is brutal indeed.
|
|
|
|
|
*/
|
|
|
|
|
p = (unsigned short *)vc->vc_origin;
|
|
|
|
|
mask = vc->vc_hi_font_mask | 0xff;
|
|
|
|
|
for (y = 0; y < vc->vc_rows; y++) {
|
|
|
|
|
char32_t *line = uniscr->lines[y];
|
|
|
|
|
for (x = 0; x < vc->vc_cols; x++) {
|
|
|
|
|
u16 glyph = scr_readw(p++) & mask;
|
|
|
|
|
char32_t uc = line[x];
|
|
|
|
|
int tc = conv_uni_to_pc(vc, uc);
|
|
|
|
|
if (tc == -4)
|
|
|
|
|
tc = conv_uni_to_pc(vc, 0xfffd);
|
|
|
|
|
if (tc == -4)
|
|
|
|
|
tc = conv_uni_to_pc(vc, '?');
|
|
|
|
|
if (tc != glyph)
|
|
|
|
|
pr_err_ratelimited(
|
|
|
|
|
"%s: mismatch at %d,%d: glyph=%#x tc=%#x\n",
|
|
|
|
|
__func__, x, y, glyph, tc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
|
2016-10-03 12:18:34 +03:00
|
|
|
static void con_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
|
|
|
|
|
enum con_scroll dir, unsigned int nr)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2016-10-03 12:18:34 +03:00
|
|
|
u16 *clear, *d, *s;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-10-03 12:18:34 +03:00
|
|
|
if (t + nr >= b)
|
2005-04-17 02:20:36 +04:00
|
|
|
nr = b - t - 1;
|
|
|
|
|
if (b > vc->vc_rows || t >= b || nr < 1)
|
|
|
|
|
return;
|
2018-06-27 06:56:40 +03:00
|
|
|
vc_uniscr_scroll(vc, t, b, dir, nr);
|
2016-10-03 12:18:34 +03:00
|
|
|
if (con_is_visible(vc) && vc->vc_sw->con_scroll(vc, t, b, dir, nr))
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
|
2016-10-03 12:18:34 +03:00
|
|
|
s = clear = (u16 *)(vc->vc_origin + vc->vc_size_row * t);
|
|
|
|
|
d = (u16 *)(vc->vc_origin + vc->vc_size_row * (t + nr));
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-10-03 12:18:34 +03:00
|
|
|
if (dir == SM_UP) {
|
|
|
|
|
clear = s + (b - t - nr) * vc->vc_cols;
|
|
|
|
|
swap(s, d);
|
|
|
|
|
}
|
|
|
|
|
scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row);
|
|
|
|
|
scr_memsetw(clear, vc->vc_video_erase_char, vc->vc_size_row * nr);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void do_update_region(struct vc_data *vc, unsigned long start, int count)
|
|
|
|
|
{
|
|
|
|
|
unsigned int xx, yy, offset;
|
|
|
|
|
u16 *p;
|
|
|
|
|
|
|
|
|
|
p = (u16 *) start;
|
|
|
|
|
if (!vc->vc_sw->con_getxy) {
|
|
|
|
|
offset = (start - vc->vc_origin) / 2;
|
|
|
|
|
xx = offset % vc->vc_cols;
|
|
|
|
|
yy = offset / vc->vc_cols;
|
|
|
|
|
} else {
|
|
|
|
|
int nxx, nyy;
|
|
|
|
|
start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy);
|
|
|
|
|
xx = nxx; yy = nyy;
|
|
|
|
|
}
|
|
|
|
|
for(;;) {
|
|
|
|
|
u16 attrib = scr_readw(p) & 0xff00;
|
|
|
|
|
int startx = xx;
|
|
|
|
|
u16 *q = p;
|
|
|
|
|
while (xx < vc->vc_cols && count) {
|
|
|
|
|
if (attrib != (scr_readw(p) & 0xff00)) {
|
|
|
|
|
if (p > q)
|
|
|
|
|
vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
|
|
|
|
|
startx = xx;
|
|
|
|
|
q = p;
|
|
|
|
|
attrib = scr_readw(p) & 0xff00;
|
|
|
|
|
}
|
|
|
|
|
p++;
|
|
|
|
|
xx++;
|
|
|
|
|
count--;
|
|
|
|
|
}
|
|
|
|
|
if (p > q)
|
|
|
|
|
vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
|
|
|
|
|
if (!count)
|
|
|
|
|
break;
|
|
|
|
|
xx = 0;
|
|
|
|
|
yy++;
|
|
|
|
|
if (vc->vc_sw->con_getxy) {
|
|
|
|
|
p = (u16 *)start;
|
|
|
|
|
start = vc->vc_sw->con_getxy(vc, start, NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void update_region(struct vc_data *vc, unsigned long start, int count)
|
|
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
hide_cursor(vc);
|
|
|
|
|
do_update_region(vc, start, count);
|
|
|
|
|
set_cursor(vc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Structure of attributes is hardware-dependent */
|
|
|
|
|
|
2020-06-15 10:48:34 +03:00
|
|
|
static u8 build_attr(struct vc_data *vc, u8 _color,
|
2020-06-15 10:48:35 +03:00
|
|
|
enum vc_intensity _intensity, bool _blink, bool _underline,
|
|
|
|
|
bool _reverse, bool _italic)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
if (vc->vc_sw->con_build_attr)
|
2007-05-08 11:38:04 +04:00
|
|
|
return vc->vc_sw->con_build_attr(vc, _color, _intensity,
|
|
|
|
|
_blink, _underline, _reverse, _italic);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ++roman: I completely changed the attribute format for monochrome
|
|
|
|
|
* mode (!can_do_color). The formerly used MDA (monochrome display
|
|
|
|
|
* adapter) format didn't allow the combination of certain effects.
|
|
|
|
|
* Now the attribute is just a bit vector:
|
|
|
|
|
* Bit 0..1: intensity (0..2)
|
|
|
|
|
* Bit 2 : underline
|
|
|
|
|
* Bit 3 : reverse
|
|
|
|
|
* Bit 7 : blink
|
|
|
|
|
*/
|
|
|
|
|
{
|
vt: fix background color on line feed
A command that causes a line feed while a background color is active,
such as
perl -e 'print "x" x 60, "\e[44m", "x" x 40, "\e[0m\n"'
and
perl -e 'print "x" x 40, "\e[44m\n", "x" x 40, "\e[0m\n"'
causes the line that was started as a result of the line feed to be completely
filled with the currently active background color instead of the default
color.
When scrolling, part of the current screen is memcpy'd/memmove'd to the new
region, and the new line(s) that will appear as a result are cleared using
memset. However, the lines are cleared with vc->vc_video_erase_char, causing
them to be colored with the currently active background color. This is
different from X11 terminal emulators which always paint the new lines with
the default background color (e.g. `xterm -bg black`).
The clear operation (\e[1J and \e[2J) also use vc_video_erase_char, so a new
vc->vc_scrl_erase_char is introduced with contains the erase character used
for scrolling, which is built from vc->vc_def_color instead of vc->vc_color.
Signed-off-by: Jan Engelhardt <jengelh@computergmbh.de>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-29 11:59:46 +04:00
|
|
|
u8 a = _color;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!vc->vc_can_do_color)
|
|
|
|
|
return _intensity |
|
2020-06-15 10:49:00 +03:00
|
|
|
(_italic << 1) |
|
|
|
|
|
(_underline << 2) |
|
|
|
|
|
(_reverse << 3) |
|
|
|
|
|
(_blink << 7);
|
2007-05-08 11:38:04 +04:00
|
|
|
if (_italic)
|
|
|
|
|
a = (a & 0xF0) | vc->vc_itcolor;
|
|
|
|
|
else if (_underline)
|
2005-04-17 02:20:36 +04:00
|
|
|
a = (a & 0xf0) | vc->vc_ulcolor;
|
2020-06-15 10:48:34 +03:00
|
|
|
else if (_intensity == VCI_HALF_BRIGHT)
|
2017-06-03 10:08:25 +03:00
|
|
|
a = (a & 0xf0) | vc->vc_halfcolor;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (_reverse)
|
2020-06-15 10:48:59 +03:00
|
|
|
a = (a & 0x88) | (((a >> 4) | (a << 4)) & 0x77);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (_blink)
|
|
|
|
|
a ^= 0x80;
|
2020-06-15 10:48:34 +03:00
|
|
|
if (_intensity == VCI_BOLD)
|
2005-04-17 02:20:36 +04:00
|
|
|
a ^= 0x08;
|
|
|
|
|
if (vc->vc_hi_font_mask == 0x100)
|
|
|
|
|
a <<= 1;
|
|
|
|
|
return a;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void update_attr(struct vc_data *vc)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_attr = build_attr(vc, vc->state.color, vc->state.intensity,
|
|
|
|
|
vc->state.blink, vc->state.underline,
|
|
|
|
|
vc->state.reverse ^ vc->vc_decscnm, vc->state.italic);
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->vc_video_erase_char = ' ' | (build_attr(vc, vc->state.color,
|
2020-06-15 10:48:35 +03:00
|
|
|
VCI_NORMAL, vc->state.blink, false,
|
|
|
|
|
vc->vc_decscnm, false) << 8);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Note: inverting the screen twice should revert to the original state */
|
2020-08-18 11:56:53 +03:00
|
|
|
void invert_screen(struct vc_data *vc, int offset, int count, bool viewed)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
unsigned short *p;
|
|
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
count /= 2;
|
|
|
|
|
p = screenpos(vc, offset, viewed);
|
2016-06-23 14:34:29 +03:00
|
|
|
if (vc->vc_sw->con_invert_region) {
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_invert_region(vc, p, count);
|
2016-06-23 14:34:29 +03:00
|
|
|
} else {
|
2005-04-17 02:20:36 +04:00
|
|
|
u16 *q = p;
|
|
|
|
|
int cnt = count;
|
|
|
|
|
u16 a;
|
|
|
|
|
|
|
|
|
|
if (!vc->vc_can_do_color) {
|
|
|
|
|
while (cnt--) {
|
|
|
|
|
a = scr_readw(q);
|
|
|
|
|
a ^= 0x0800;
|
|
|
|
|
scr_writew(a, q);
|
|
|
|
|
q++;
|
|
|
|
|
}
|
|
|
|
|
} else if (vc->vc_hi_font_mask == 0x100) {
|
|
|
|
|
while (cnt--) {
|
|
|
|
|
a = scr_readw(q);
|
2020-06-15 10:48:59 +03:00
|
|
|
a = (a & 0x11ff) |
|
|
|
|
|
((a & 0xe000) >> 4) |
|
|
|
|
|
((a & 0x0e00) << 4);
|
2005-04-17 02:20:36 +04:00
|
|
|
scr_writew(a, q);
|
|
|
|
|
q++;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
while (cnt--) {
|
|
|
|
|
a = scr_readw(q);
|
2020-06-15 10:48:59 +03:00
|
|
|
a = (a & 0x88ff) |
|
|
|
|
|
((a & 0x7000) >> 4) |
|
|
|
|
|
((a & 0x0700) << 4);
|
2005-04-17 02:20:36 +04:00
|
|
|
scr_writew(a, q);
|
|
|
|
|
q++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-06-23 14:34:29 +03:00
|
|
|
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
do_update_region(vc, (unsigned long) p, count);
|
2015-01-24 01:07:21 +03:00
|
|
|
notify_update(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* used by selection: complement pointer position */
|
|
|
|
|
void complement_pos(struct vc_data *vc, int offset)
|
|
|
|
|
{
|
2005-09-07 02:17:52 +04:00
|
|
|
static int old_offset = -1;
|
2005-04-17 02:20:36 +04:00
|
|
|
static unsigned short old;
|
|
|
|
|
static unsigned short oldx, oldy;
|
|
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
2005-09-07 02:17:52 +04:00
|
|
|
if (old_offset != -1 && old_offset >= 0 &&
|
|
|
|
|
old_offset < vc->vc_screenbuf_size) {
|
2020-08-18 11:56:53 +03:00
|
|
|
scr_writew(old, screenpos(vc, old_offset, true));
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_putc(vc, old, oldy, oldx);
|
2015-01-24 01:07:21 +03:00
|
|
|
notify_update(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2005-09-07 02:17:52 +04:00
|
|
|
|
|
|
|
|
old_offset = offset;
|
|
|
|
|
|
|
|
|
|
if (offset != -1 && offset >= 0 &&
|
|
|
|
|
offset < vc->vc_screenbuf_size) {
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned short new;
|
2005-09-07 02:17:52 +04:00
|
|
|
unsigned short *p;
|
2020-08-18 11:56:53 +03:00
|
|
|
p = screenpos(vc, offset, true);
|
2005-04-17 02:20:36 +04:00
|
|
|
old = scr_readw(p);
|
|
|
|
|
new = old ^ vc->vc_complement_mask;
|
|
|
|
|
scr_writew(new, p);
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
oldx = (offset >> 1) % vc->vc_cols;
|
|
|
|
|
oldy = (offset >> 1) / vc->vc_cols;
|
|
|
|
|
vc->vc_sw->con_putc(vc, new, oldy, oldx);
|
|
|
|
|
}
|
2015-01-24 01:07:21 +03:00
|
|
|
notify_update(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void insert_char(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
2012-09-06 21:24:13 +04:00
|
|
|
unsigned short *p = (unsigned short *) vc->vc_pos;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
vc_uniscr_insert(vc, nr);
|
2020-06-15 10:48:33 +03:00
|
|
|
scr_memmovew(p + nr, p, (vc->vc_cols - vc->state.x - nr) * 2);
|
2012-09-06 21:24:13 +04:00
|
|
|
scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2012-09-06 21:24:13 +04:00
|
|
|
do_update_region(vc, (unsigned long) p,
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_cols - vc->state.x);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void delete_char(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
2012-09-06 21:24:13 +04:00
|
|
|
unsigned short *p = (unsigned short *) vc->vc_pos;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
vc_uniscr_delete(vc, nr);
|
2020-06-15 10:48:33 +03:00
|
|
|
scr_memcpyw(p, p + nr, (vc->vc_cols - vc->state.x - nr) * 2);
|
|
|
|
|
scr_memsetw(p + vc->vc_cols - vc->state.x - nr, vc->vc_video_erase_char,
|
2012-09-06 21:24:13 +04:00
|
|
|
nr * 2);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2012-09-06 21:24:13 +04:00
|
|
|
do_update_region(vc, (unsigned long) p,
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_cols - vc->state.x);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2015-11-01 21:48:18 +03:00
|
|
|
static int softcursor_original = -1;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
static void add_softcursor(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
int i = scr_readw((u16 *) vc->vc_pos);
|
|
|
|
|
u32 type = vc->vc_cursor_type;
|
|
|
|
|
|
2020-06-15 10:48:58 +03:00
|
|
|
if (!(type & CUR_SW))
|
2020-06-15 10:48:56 +03:00
|
|
|
return;
|
|
|
|
|
if (softcursor_original != -1)
|
|
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
softcursor_original = i;
|
2020-06-15 10:48:58 +03:00
|
|
|
i |= CUR_SET(type);
|
|
|
|
|
i ^= CUR_CHANGE(type);
|
|
|
|
|
if ((type & CUR_ALWAYS_BG) &&
|
|
|
|
|
(softcursor_original & CUR_BG) == (i & CUR_BG))
|
|
|
|
|
i ^= CUR_BG;
|
|
|
|
|
if ((type & CUR_INVERT_FG_BG) && (i & CUR_FG) == ((i & CUR_BG) >> 4))
|
|
|
|
|
i ^= CUR_FG;
|
2020-06-15 10:48:56 +03:00
|
|
|
scr_writew(i, (u16 *)vc->vc_pos);
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_sw->con_putc(vc, i, vc->state.y, vc->state.x);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void hide_softcursor(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
if (softcursor_original != -1) {
|
|
|
|
|
scr_writew(softcursor_original, (u16 *)vc->vc_pos);
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_putc(vc, softcursor_original,
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.y, vc->state.x);
|
2005-04-17 02:20:36 +04:00
|
|
|
softcursor_original = -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void hide_cursor(struct vc_data *vc)
|
|
|
|
|
{
|
2020-02-19 10:39:43 +03:00
|
|
|
if (vc_is_sel(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
clear_selection();
|
2020-02-19 10:39:43 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_cursor(vc, CM_ERASE);
|
|
|
|
|
hide_softcursor(vc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_cursor(struct vc_data *vc)
|
|
|
|
|
{
|
2016-06-23 14:34:35 +03:00
|
|
|
if (!con_is_fg(vc) || console_blanked || vc->vc_mode == KD_GRAPHICS)
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
if (vc->vc_deccm) {
|
2020-02-19 10:39:43 +03:00
|
|
|
if (vc_is_sel(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
clear_selection();
|
|
|
|
|
add_softcursor(vc);
|
2020-06-15 10:48:58 +03:00
|
|
|
if (CUR_SIZE(vc->vc_cursor_type) != CUR_NONE)
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_cursor(vc, CM_DRAW);
|
|
|
|
|
} else
|
|
|
|
|
hide_cursor(vc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_origin(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
2016-06-23 14:34:35 +03:00
|
|
|
if (!con_is_visible(vc) ||
|
2005-04-17 02:20:36 +04:00
|
|
|
!vc->vc_sw->con_set_origin ||
|
|
|
|
|
!vc->vc_sw->con_set_origin(vc))
|
|
|
|
|
vc->vc_origin = (unsigned long)vc->vc_screenbuf;
|
|
|
|
|
vc->vc_visible_origin = vc->vc_origin;
|
|
|
|
|
vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size;
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->state.y +
|
|
|
|
|
2 * vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2015-10-27 20:46:47 +03:00
|
|
|
static void save_screen(struct vc_data *vc)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (vc->vc_sw->con_save_screen)
|
|
|
|
|
vc->vc_sw->con_save_screen(vc);
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-13 23:07:56 +03:00
|
|
|
static void flush_scrollback(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
2019-02-12 03:36:41 +03:00
|
|
|
set_origin(vc);
|
2020-01-28 20:50:33 +03:00
|
|
|
if (vc->vc_sw->con_flush_scrollback) {
|
2017-01-13 23:07:56 +03:00
|
|
|
vc->vc_sw->con_flush_scrollback(vc);
|
2020-01-28 20:50:33 +03:00
|
|
|
} else if (con_is_visible(vc)) {
|
|
|
|
|
/*
|
|
|
|
|
* When no con_flush_scrollback method is provided then the
|
|
|
|
|
* legacy way for flushing the scrollback buffer is to use
|
|
|
|
|
* a side effect of the con_switch method. We do it only on
|
|
|
|
|
* the foreground console as background consoles have no
|
|
|
|
|
* scrollback buffers in that case and we obviously don't
|
|
|
|
|
* want to switch to them.
|
|
|
|
|
*/
|
|
|
|
|
hide_cursor(vc);
|
2019-02-12 03:36:41 +03:00
|
|
|
vc->vc_sw->con_switch(vc);
|
2020-01-28 20:50:33 +03:00
|
|
|
set_cursor(vc);
|
|
|
|
|
}
|
2017-01-13 23:07:56 +03:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* Redrawing of screen
|
|
|
|
|
*/
|
|
|
|
|
|
2013-01-24 08:14:19 +04:00
|
|
|
void clear_buffer_attributes(struct vc_data *vc)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
unsigned short *p = (unsigned short *)vc->vc_origin;
|
|
|
|
|
int count = vc->vc_screenbuf_size / 2;
|
|
|
|
|
int mask = vc->vc_hi_font_mask | 0xff;
|
|
|
|
|
|
|
|
|
|
for (; count > 0; count--, p++) {
|
|
|
|
|
scr_writew((scr_readw(p)&mask) | (vc->vc_video_erase_char & ~mask), p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void redraw_screen(struct vc_data *vc, int is_switch)
|
|
|
|
|
{
|
|
|
|
|
int redraw = 0;
|
|
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (!vc) {
|
|
|
|
|
/* strange ... */
|
|
|
|
|
/* printk("redraw_screen: tty %d not allocated ??\n", new_console+1); */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (is_switch) {
|
|
|
|
|
struct vc_data *old_vc = vc_cons[fg_console].d;
|
|
|
|
|
if (old_vc == vc)
|
|
|
|
|
return;
|
2016-06-23 14:34:35 +03:00
|
|
|
if (!con_is_visible(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
redraw = 1;
|
|
|
|
|
*vc->vc_display_fg = vc;
|
|
|
|
|
fg_console = vc->vc_num;
|
|
|
|
|
hide_cursor(old_vc);
|
2016-06-23 14:34:35 +03:00
|
|
|
if (!con_is_visible(old_vc)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
save_screen(old_vc);
|
|
|
|
|
set_origin(old_vc);
|
|
|
|
|
}
|
2010-12-01 20:51:05 +03:00
|
|
|
if (tty0dev)
|
|
|
|
|
sysfs_notify(&tty0dev->kobj, NULL, "active");
|
2005-04-17 02:20:36 +04:00
|
|
|
} else {
|
|
|
|
|
hide_cursor(vc);
|
|
|
|
|
redraw = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (redraw) {
|
|
|
|
|
int update;
|
|
|
|
|
int old_was_color = vc->vc_can_do_color;
|
|
|
|
|
|
|
|
|
|
set_origin(vc);
|
|
|
|
|
update = vc->vc_sw->con_switch(vc);
|
|
|
|
|
set_palette(vc);
|
|
|
|
|
/*
|
|
|
|
|
* If console changed from mono<->color, the best we can do
|
|
|
|
|
* is to clear the buffer attributes. As it currently stands,
|
|
|
|
|
* rebuilding new attributes from the old buffer is not doable
|
|
|
|
|
* without overly complex code.
|
|
|
|
|
*/
|
|
|
|
|
if (old_was_color != vc->vc_can_do_color) {
|
|
|
|
|
update_attr(vc);
|
|
|
|
|
clear_buffer_attributes(vc);
|
|
|
|
|
}
|
2010-06-23 23:56:12 +04:00
|
|
|
|
2018-08-22 11:54:03 +03:00
|
|
|
if (update && vc->vc_mode != KD_GRAPHICS)
|
2005-04-17 02:20:36 +04:00
|
|
|
do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
|
|
|
|
|
}
|
|
|
|
|
set_cursor(vc);
|
|
|
|
|
if (is_switch) {
|
2021-01-05 15:02:28 +03:00
|
|
|
vt_set_leds_compute_shiftstate();
|
2008-03-05 01:28:36 +03:00
|
|
|
notify_update(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocation, freeing and resizing of VTs.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int vc_cons_allocated(unsigned int i)
|
|
|
|
|
{
|
|
|
|
|
return (i < MAX_NR_CONSOLES && vc_cons[i].d);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void visual_init(struct vc_data *vc, int num, int init)
|
|
|
|
|
{
|
|
|
|
|
/* ++Geert: vc->vc_sw->con_init determines console size */
|
|
|
|
|
if (vc->vc_sw)
|
|
|
|
|
module_put(vc->vc_sw->owner);
|
|
|
|
|
vc->vc_sw = conswitchp;
|
|
|
|
|
#ifndef VT_SINGLE_DRIVER
|
|
|
|
|
if (con_driver_map[num])
|
|
|
|
|
vc->vc_sw = con_driver_map[num];
|
|
|
|
|
#endif
|
|
|
|
|
__module_get(vc->vc_sw->owner);
|
|
|
|
|
vc->vc_num = num;
|
|
|
|
|
vc->vc_display_fg = &master_display_fg;
|
2015-06-10 10:21:10 +03:00
|
|
|
if (vc->vc_uni_pagedir_loc)
|
|
|
|
|
con_free_unimap(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
|
2014-05-13 14:09:28 +04:00
|
|
|
vc->vc_uni_pagedir = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_hi_font_mask = 0;
|
|
|
|
|
vc->vc_complement_mask = 0;
|
|
|
|
|
vc->vc_can_do_color = 0;
|
2016-05-17 21:41:04 +03:00
|
|
|
vc->vc_cur_blink_ms = DEFAULT_CURSOR_BLINK_MS;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_init(vc, init);
|
|
|
|
|
if (!vc->vc_complement_mask)
|
|
|
|
|
vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
|
|
|
|
|
vc->vc_s_complement_mask = vc->vc_complement_mask;
|
|
|
|
|
vc->vc_size_row = vc->vc_cols << 1;
|
|
|
|
|
vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-26 17:59:46 +03:00
|
|
|
|
|
|
|
|
static void visual_deinit(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
vc->vc_sw->con_deinit(vc);
|
|
|
|
|
module_put(vc->vc_sw->owner);
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-22 06:43:04 +03:00
|
|
|
static void vc_port_destruct(struct tty_port *port)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = container_of(port, struct vc_data, port);
|
|
|
|
|
|
|
|
|
|
kfree(vc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct tty_port_operations vc_port_ops = {
|
|
|
|
|
.destruct = vc_port_destruct,
|
|
|
|
|
};
|
|
|
|
|
|
2020-07-12 14:10:12 +03:00
|
|
|
/*
|
|
|
|
|
* Change # of rows and columns (0 means unchanged/the size of fg_console)
|
|
|
|
|
* [this is to be used together with some user program
|
|
|
|
|
* like resize that changes the hardware videomode]
|
|
|
|
|
*/
|
|
|
|
|
#define VC_MAXCOL (32767)
|
|
|
|
|
#define VC_MAXROW (32767)
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
int vc_allocate(unsigned int currcons) /* return 0 on success */
|
|
|
|
|
{
|
2016-03-31 11:08:15 +03:00
|
|
|
struct vt_notifier_param param;
|
|
|
|
|
struct vc_data *vc;
|
2020-07-12 14:10:12 +03:00
|
|
|
int err;
|
2016-03-31 11:08:15 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (currcons >= MAX_NR_CONSOLES)
|
|
|
|
|
return -ENXIO;
|
2016-03-31 11:08:15 +03:00
|
|
|
|
|
|
|
|
if (vc_cons[currcons].d)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* due to the granularity of kmalloc, we waste some memory here */
|
|
|
|
|
/* the alloc is done in two steps, to optimize the common situation
|
|
|
|
|
of a 25x80 console (structsize=216, screenbuf_size=4000) */
|
|
|
|
|
/* although the numbers above are not valid since long ago, the
|
|
|
|
|
point is still up-to-date and the comment still has its value
|
|
|
|
|
even if only as a historical artifact. --mj, July 1998 */
|
|
|
|
|
param.vc = vc = kzalloc(sizeof(struct vc_data), GFP_KERNEL);
|
|
|
|
|
if (!vc)
|
2005-04-17 02:20:36 +04:00
|
|
|
return -ENOMEM;
|
2016-03-31 11:08:15 +03:00
|
|
|
|
|
|
|
|
vc_cons[currcons].d = vc;
|
|
|
|
|
tty_port_init(&vc->port);
|
2020-03-22 06:43:04 +03:00
|
|
|
vc->port.ops = &vc_port_ops;
|
2016-03-31 11:08:15 +03:00
|
|
|
INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK);
|
|
|
|
|
|
|
|
|
|
visual_init(vc, currcons, 1);
|
|
|
|
|
|
|
|
|
|
if (!*vc->vc_uni_pagedir_loc)
|
2005-04-17 02:20:36 +04:00
|
|
|
con_set_default_unimap(vc);
|
2009-11-13 23:14:11 +03:00
|
|
|
|
2020-07-12 14:10:12 +03:00
|
|
|
err = -EINVAL;
|
|
|
|
|
if (vc->vc_cols > VC_MAXCOL || vc->vc_rows > VC_MAXROW ||
|
|
|
|
|
vc->vc_screenbuf_size > KMALLOC_MAX_SIZE || !vc->vc_screenbuf_size)
|
|
|
|
|
goto err_free;
|
|
|
|
|
err = -ENOMEM;
|
2018-06-14 13:23:09 +03:00
|
|
|
vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_KERNEL);
|
2016-03-31 11:08:15 +03:00
|
|
|
if (!vc->vc_screenbuf)
|
|
|
|
|
goto err_free;
|
|
|
|
|
|
|
|
|
|
/* If no drivers have overridden us and the user didn't pass a
|
|
|
|
|
boot option, default to displaying the cursor */
|
|
|
|
|
if (global_cursor_default == -1)
|
|
|
|
|
global_cursor_default = 1;
|
|
|
|
|
|
|
|
|
|
vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
|
|
|
|
|
vcs_make_sysfs(currcons);
|
|
|
|
|
atomic_notifier_call_chain(&vt_notifier_list, VT_ALLOCATE, ¶m);
|
2009-11-13 23:14:11 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
2016-03-31 11:08:15 +03:00
|
|
|
err_free:
|
2019-04-26 17:59:46 +03:00
|
|
|
visual_deinit(vc);
|
2016-03-31 11:08:15 +03:00
|
|
|
kfree(vc);
|
|
|
|
|
vc_cons[currcons].d = NULL;
|
2020-07-12 14:10:12 +03:00
|
|
|
return err;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
vt/vgacon: Check if screen resize request comes from userspace
Various console drivers are able to resize the screen via the con_resize()
hook. This hook is also visible in userspace via the TIOCWINSZ, VT_RESIZE and
VT_RESIZEX ioctl's. One particular utility, SVGATextMode, expects that
con_resize() of the VGA console will always return success even if the
resulting screen is not compatible with the hardware. However, this
particular behavior of the VGA console, as reported in Kernel Bugzilla Bug
7513, can cause undefined behavior if the user starts with a console size
larger than 80x25.
To work around this problem, add an extra parameter to con_resize(). This
parameter is ignored by drivers except for vgacon. If this parameter is
non-zero, then the resize request came from a VT_RESIZE or VT_RESIZEX ioctl
and vgacon will always return success. If this parameter is zero, vgacon will
return -EINVAL if the requested size is not compatible with the hardware. The
latter is the more correct behavior.
With this change, SVGATextMode should still work correctly while in-kernel and
stty resize calls can expect correct behavior from vgacon.
Signed-off-by: Antonino Daplas <adaplas@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 12:29:35 +04:00
|
|
|
static inline int resize_screen(struct vc_data *vc, int width, int height,
|
|
|
|
|
int user)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
/* Resizes the resolution of the display adapater */
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
tty: vt: always invoke vc->vc_sw->con_resize callback
syzbot is reporting OOB write at vga16fb_imageblit() [1], for
resize_screen() from ioctl(VT_RESIZE) returns 0 without checking whether
requested rows/columns fit the amount of memory reserved for the graphical
screen if current mode is KD_GRAPHICS.
----------
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/kd.h>
#include <linux/vt.h>
int main(int argc, char *argv[])
{
const int fd = open("/dev/char/4:1", O_RDWR);
struct vt_sizes vt = { 0x4100, 2 };
ioctl(fd, KDSETMODE, KD_GRAPHICS);
ioctl(fd, VT_RESIZE, &vt);
ioctl(fd, KDSETMODE, KD_TEXT);
return 0;
}
----------
Allow framebuffer drivers to return -EINVAL, by moving vc->vc_mode !=
KD_GRAPHICS check from resize_screen() to fbcon_resize().
Link: https://syzkaller.appspot.com/bug?extid=1f29e126cf461c4de3b3 [1]
Reported-by: syzbot <syzbot+1f29e126cf461c4de3b3@syzkaller.appspotmail.com>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Tested-by: syzbot <syzbot+1f29e126cf461c4de3b3@syzkaller.appspotmail.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-05-15 06:00:37 +03:00
|
|
|
if (vc->vc_sw->con_resize)
|
vt/vgacon: Check if screen resize request comes from userspace
Various console drivers are able to resize the screen via the con_resize()
hook. This hook is also visible in userspace via the TIOCWINSZ, VT_RESIZE and
VT_RESIZEX ioctl's. One particular utility, SVGATextMode, expects that
con_resize() of the VGA console will always return success even if the
resulting screen is not compatible with the hardware. However, this
particular behavior of the VGA console, as reported in Kernel Bugzilla Bug
7513, can cause undefined behavior if the user starts with a console size
larger than 80x25.
To work around this problem, add an extra parameter to con_resize(). This
parameter is ignored by drivers except for vgacon. If this parameter is
non-zero, then the resize request came from a VT_RESIZE or VT_RESIZEX ioctl
and vgacon will always return success. If this parameter is zero, vgacon will
return -EINVAL if the requested size is not compatible with the hardware. The
latter is the more correct behavior.
With this change, SVGATextMode should still work correctly while in-kernel and
stty resize calls can expect correct behavior from vgacon.
Signed-off-by: Antonino Daplas <adaplas@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 12:29:35 +04:00
|
|
|
err = vc->vc_sw->con_resize(vc, width, height, user);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-15 13:39:38 +04:00
|
|
|
/**
|
|
|
|
|
* vc_do_resize - resizing method for the tty
|
|
|
|
|
* @tty: tty being resized
|
|
|
|
|
* @vc: virtual console private data
|
|
|
|
|
* @cols: columns
|
|
|
|
|
* @lines: lines
|
|
|
|
|
*
|
|
|
|
|
* Resize a virtual console, clipping according to the actual constraints.
|
|
|
|
|
* If the caller passes a tty structure then update the termios winsize
|
tree-wide: Assorted spelling fixes
In particular, several occurances of funny versions of 'success',
'unknown', 'therefore', 'acknowledge', 'argument', 'achieve', 'address',
'beginning', 'desirable', 'separate' and 'necessary' are fixed.
Signed-off-by: Daniel Mack <daniel@caiaq.de>
Cc: Joe Perches <joe@perches.com>
Cc: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-02-03 03:01:28 +03:00
|
|
|
* information and perform any necessary signal handling.
|
2008-08-15 13:39:38 +04:00
|
|
|
*
|
2013-06-15 17:14:23 +04:00
|
|
|
* Caller must hold the console semaphore. Takes the termios rwsem and
|
2021-05-05 12:19:06 +03:00
|
|
|
* ctrl.lock of the tty IFF a tty is passed.
|
2008-08-15 13:39:38 +04:00
|
|
|
*/
|
|
|
|
|
|
2009-01-02 16:43:17 +03:00
|
|
|
static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc,
|
|
|
|
|
unsigned int cols, unsigned int lines)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0;
|
2010-08-10 04:21:27 +04:00
|
|
|
unsigned long end;
|
2018-06-27 06:56:40 +03:00
|
|
|
unsigned int old_rows, old_row_size, first_copied_row;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int new_cols, new_rows, new_row_size, new_screen_size;
|
2010-08-10 04:21:27 +04:00
|
|
|
unsigned int user;
|
2020-07-29 17:57:01 +03:00
|
|
|
unsigned short *oldscreen, *newscreen;
|
2018-06-27 06:56:40 +03:00
|
|
|
struct uni_screen *new_uniscr = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (!vc)
|
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
vt/vgacon: Check if screen resize request comes from userspace
Various console drivers are able to resize the screen via the con_resize()
hook. This hook is also visible in userspace via the TIOCWINSZ, VT_RESIZE and
VT_RESIZEX ioctl's. One particular utility, SVGATextMode, expects that
con_resize() of the VGA console will always return success even if the
resulting screen is not compatible with the hardware. However, this
particular behavior of the VGA console, as reported in Kernel Bugzilla Bug
7513, can cause undefined behavior if the user starts with a console size
larger than 80x25.
To work around this problem, add an extra parameter to con_resize(). This
parameter is ignored by drivers except for vgacon. If this parameter is
non-zero, then the resize request came from a VT_RESIZE or VT_RESIZEX ioctl
and vgacon will always return success. If this parameter is zero, vgacon will
return -EINVAL if the requested size is not compatible with the hardware. The
latter is the more correct behavior.
With this change, SVGATextMode should still work correctly while in-kernel and
stty resize calls can expect correct behavior from vgacon.
Signed-off-by: Antonino Daplas <adaplas@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 12:29:35 +04:00
|
|
|
user = vc->vc_resize_user;
|
|
|
|
|
vc->vc_resize_user = 0;
|
|
|
|
|
|
2020-07-12 14:10:12 +03:00
|
|
|
if (cols > VC_MAXCOL || lines > VC_MAXROW)
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
new_cols = (cols ? cols : vc->vc_cols);
|
|
|
|
|
new_rows = (lines ? lines : vc->vc_rows);
|
|
|
|
|
new_row_size = new_cols << 1;
|
|
|
|
|
new_screen_size = new_row_size * new_rows;
|
|
|
|
|
|
|
|
|
|
if (new_cols == vc->vc_cols && new_rows == vc->vc_rows)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2020-07-12 14:10:12 +03:00
|
|
|
if (new_screen_size > KMALLOC_MAX_SIZE || !new_screen_size)
|
2016-10-14 16:18:28 +03:00
|
|
|
return -EINVAL;
|
2018-06-14 13:23:09 +03:00
|
|
|
newscreen = kzalloc(new_screen_size, GFP_USER);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!newscreen)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
if (get_vc_uniscr(vc)) {
|
|
|
|
|
new_uniscr = vc_uniscr_alloc(new_cols, new_rows);
|
|
|
|
|
if (!new_uniscr) {
|
|
|
|
|
kfree(newscreen);
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-19 10:39:43 +03:00
|
|
|
if (vc_is_sel(vc))
|
2016-10-13 20:12:43 +03:00
|
|
|
clear_selection();
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
old_rows = vc->vc_rows;
|
|
|
|
|
old_row_size = vc->vc_size_row;
|
|
|
|
|
|
vt/vgacon: Check if screen resize request comes from userspace
Various console drivers are able to resize the screen via the con_resize()
hook. This hook is also visible in userspace via the TIOCWINSZ, VT_RESIZE and
VT_RESIZEX ioctl's. One particular utility, SVGATextMode, expects that
con_resize() of the VGA console will always return success even if the
resulting screen is not compatible with the hardware. However, this
particular behavior of the VGA console, as reported in Kernel Bugzilla Bug
7513, can cause undefined behavior if the user starts with a console size
larger than 80x25.
To work around this problem, add an extra parameter to con_resize(). This
parameter is ignored by drivers except for vgacon. If this parameter is
non-zero, then the resize request came from a VT_RESIZE or VT_RESIZEX ioctl
and vgacon will always return success. If this parameter is zero, vgacon will
return -EINVAL if the requested size is not compatible with the hardware. The
latter is the more correct behavior.
With this change, SVGATextMode should still work correctly while in-kernel and
stty resize calls can expect correct behavior from vgacon.
Signed-off-by: Antonino Daplas <adaplas@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 12:29:35 +04:00
|
|
|
err = resize_screen(vc, new_cols, new_rows, user);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (err) {
|
|
|
|
|
kfree(newscreen);
|
2020-05-02 18:01:07 +03:00
|
|
|
vc_uniscr_free(new_uniscr);
|
2005-04-17 02:20:36 +04:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vc->vc_rows = new_rows;
|
|
|
|
|
vc->vc_cols = new_cols;
|
|
|
|
|
vc->vc_size_row = new_row_size;
|
|
|
|
|
vc->vc_screenbuf_size = new_screen_size;
|
|
|
|
|
|
|
|
|
|
rlth = min(old_row_size, new_row_size);
|
|
|
|
|
rrem = new_row_size - rlth;
|
|
|
|
|
old_origin = vc->vc_origin;
|
|
|
|
|
new_origin = (long) newscreen;
|
|
|
|
|
new_scr_end = new_origin + new_screen_size;
|
2005-09-10 00:04:39 +04:00
|
|
|
|
2020-06-15 10:48:33 +03:00
|
|
|
if (vc->state.y > new_rows) {
|
|
|
|
|
if (old_rows - vc->state.y < new_rows) {
|
2005-09-10 00:04:39 +04:00
|
|
|
/*
|
|
|
|
|
* Cursor near the bottom, copy contents from the
|
|
|
|
|
* bottom of buffer
|
|
|
|
|
*/
|
2018-06-27 06:56:40 +03:00
|
|
|
first_copied_row = (old_rows - new_rows);
|
2005-09-10 00:04:39 +04:00
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Cursor is in no man's land, copy 1/2 screenful
|
|
|
|
|
* from the top and bottom of cursor position
|
|
|
|
|
*/
|
2020-06-15 10:48:33 +03:00
|
|
|
first_copied_row = (vc->state.y - new_rows/2);
|
2005-09-10 00:04:39 +04:00
|
|
|
}
|
2018-06-27 06:56:40 +03:00
|
|
|
old_origin += first_copied_row * old_row_size;
|
|
|
|
|
} else
|
|
|
|
|
first_copied_row = 0;
|
2010-08-22 19:37:24 +04:00
|
|
|
end = old_origin + old_row_size * min(old_rows, new_rows);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-06-27 06:56:40 +03:00
|
|
|
vc_uniscr_copy_area(new_uniscr, new_cols, new_rows,
|
|
|
|
|
get_vc_uniscr(vc), rlth/2, first_copied_row,
|
|
|
|
|
min(old_rows, new_rows));
|
|
|
|
|
vc_uniscr_set(vc, new_uniscr);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
update_attr(vc);
|
|
|
|
|
|
2005-09-10 00:04:39 +04:00
|
|
|
while (old_origin < end) {
|
|
|
|
|
scr_memcpyw((unsigned short *) new_origin,
|
|
|
|
|
(unsigned short *) old_origin, rlth);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (rrem)
|
2005-09-10 00:04:39 +04:00
|
|
|
scr_memsetw((void *)(new_origin + rlth),
|
|
|
|
|
vc->vc_video_erase_char, rrem);
|
2005-04-17 02:20:36 +04:00
|
|
|
old_origin += old_row_size;
|
|
|
|
|
new_origin += new_row_size;
|
|
|
|
|
}
|
|
|
|
|
if (new_scr_end > new_origin)
|
2005-09-10 00:04:39 +04:00
|
|
|
scr_memsetw((void *)new_origin, vc->vc_video_erase_char,
|
|
|
|
|
new_scr_end - new_origin);
|
2020-07-29 17:57:01 +03:00
|
|
|
oldscreen = vc->vc_screenbuf;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_screenbuf = newscreen;
|
|
|
|
|
vc->vc_screenbuf_size = new_screen_size;
|
|
|
|
|
set_origin(vc);
|
2020-07-29 17:57:01 +03:00
|
|
|
kfree(oldscreen);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/* do part of a reset_terminal() */
|
|
|
|
|
vc->vc_top = 0;
|
|
|
|
|
vc->vc_bottom = vc->vc_rows;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->state.x, vc->state.y);
|
2005-04-17 02:20:36 +04:00
|
|
|
save_cur(vc);
|
|
|
|
|
|
2008-08-15 13:39:38 +04:00
|
|
|
if (tty) {
|
|
|
|
|
/* Rewrite the requested winsize data with the actual
|
|
|
|
|
resulting sizes */
|
|
|
|
|
struct winsize ws;
|
2005-04-17 02:20:36 +04:00
|
|
|
memset(&ws, 0, sizeof(ws));
|
|
|
|
|
ws.ws_row = vc->vc_rows;
|
|
|
|
|
ws.ws_col = vc->vc_cols;
|
|
|
|
|
ws.ws_ypixel = vc->vc_scan_lines;
|
2009-01-02 16:43:17 +03:00
|
|
|
tty_do_resize(tty, &ws);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_is_visible(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
update_screen(vc);
|
2009-09-20 00:13:24 +04:00
|
|
|
vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num);
|
2019-01-09 06:55:01 +03:00
|
|
|
notify_update(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-15 13:39:38 +04:00
|
|
|
/**
|
|
|
|
|
* vc_resize - resize a VT
|
|
|
|
|
* @vc: virtual console
|
|
|
|
|
* @cols: columns
|
|
|
|
|
* @rows: rows
|
|
|
|
|
*
|
|
|
|
|
* Resize a virtual console as seen from the console end of things. We
|
|
|
|
|
* use the common vc_do_resize methods to update the structures. The
|
|
|
|
|
* caller must hold the console sem to protect console internals and
|
2010-06-02 00:52:56 +04:00
|
|
|
* vc->port.tty
|
2008-08-15 13:39:38 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int rows)
|
|
|
|
|
{
|
2010-06-02 00:52:56 +04:00
|
|
|
return vc_do_resize(vc->port.tty, vc, cols, rows);
|
2008-08-15 13:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* vt_resize - resize a VT
|
|
|
|
|
* @tty: tty to resize
|
|
|
|
|
* @ws: winsize attributes
|
|
|
|
|
*
|
|
|
|
|
* Resize a virtual terminal. This is called by the tty layer as we
|
|
|
|
|
* register our own handler for resizing. The mutual helper does all
|
|
|
|
|
* the actual work.
|
|
|
|
|
*
|
|
|
|
|
* Takes the console sem and the called methods then take the tty
|
2021-05-05 12:19:06 +03:00
|
|
|
* termios_rwsem and the tty ctrl.lock in that order.
|
2008-08-15 13:39:38 +04:00
|
|
|
*/
|
2009-01-08 05:09:15 +03:00
|
|
|
static int vt_resize(struct tty_struct *tty, struct winsize *ws)
|
2006-09-29 13:00:03 +04:00
|
|
|
{
|
2008-08-15 13:39:38 +04:00
|
|
|
struct vc_data *vc = tty->driver_data;
|
|
|
|
|
int ret;
|
2006-09-29 13:00:03 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2009-01-02 16:43:17 +03:00
|
|
|
ret = vc_do_resize(tty, vc, ws->ws_col, ws->ws_row);
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2008-08-15 13:39:38 +04:00
|
|
|
return ret;
|
2006-09-29 13:00:03 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
tty/vt: Fix vc_deallocate() lock order
Now that the tty port owns the flip buffers and i/o is allowed
from the driver even when no tty is attached, the destruction
of the tty port (and the flip buffers) must ensure that no
outstanding work is pending.
Unfortunately, this creates a lock order problem with the
console_lock (see attached lockdep report [1] below).
For single console deallocation, drop the console_lock prior
to port destruction. When multiple console deallocation,
defer port destruction until the consoles have been
deallocated.
tty_port_destroy() is not required if the port has not
been used; remove from vc_allocate() failure path.
[1] lockdep report from Dave Jones <davej@redhat.com>
======================================================
[ INFO: possible circular locking dependency detected ]
3.9.0+ #16 Not tainted
-------------------------------------------------------
(agetty)/26163 is trying to acquire lock:
blocked: ((&buf->work)){+.+...}, instance: ffff88011c8b0020, at: [<ffffffff81062065>] flush_work+0x5/0x2e0
but task is already holding lock:
blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (console_lock){+.+.+.}:
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810416c7>] console_lock+0x77/0x80
[<ffffffff813c3dcd>] con_flush_chars+0x2d/0x50
[<ffffffff813b32b2>] n_tty_receive_buf+0x122/0x14d0
[<ffffffff813b7709>] flush_to_ldisc+0x119/0x170
[<ffffffff81064381>] process_one_work+0x211/0x700
[<ffffffff8106498b>] worker_thread+0x11b/0x3a0
[<ffffffff8106ce5d>] kthread+0xed/0x100
[<ffffffff81601cac>] ret_from_fork+0x7c/0xb0
-> #0 ((&buf->work)){+.+...}:
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
other info that might help us debug this:
[ 6760.076175] Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(console_lock);
lock((&buf->work));
lock(console_lock);
lock((&buf->work));
*** DEADLOCK ***
1 lock on stack by (agetty)/26163:
#0: blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
stack backtrace:
Pid: 26163, comm: (agetty) Not tainted 3.9.0+ #16
Call Trace:
[<ffffffff815edb14>] print_circular_bug+0x200/0x20e
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a200>] ? native_sched_clock+0x20/0x80
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff8113c8a3>] ? __free_pages_ok.part.57+0x93/0xc0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff810652f2>] ? __cancel_work_timer+0x82/0x130
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff810aec41>] ? lock_release_holdtime.part.30+0xa1/0x170
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff812b00f6>] ? inode_has_perm.isra.46.constprop.61+0x56/0x80
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff812b04db>] ? selinux_file_ioctl+0x5b/0x110
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
Cc: Dave Jones <davej@redhat.com>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-05-17 20:41:03 +04:00
|
|
|
struct vc_data *vc_deallocate(unsigned int currcons)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
tty/vt: Fix vc_deallocate() lock order
Now that the tty port owns the flip buffers and i/o is allowed
from the driver even when no tty is attached, the destruction
of the tty port (and the flip buffers) must ensure that no
outstanding work is pending.
Unfortunately, this creates a lock order problem with the
console_lock (see attached lockdep report [1] below).
For single console deallocation, drop the console_lock prior
to port destruction. When multiple console deallocation,
defer port destruction until the consoles have been
deallocated.
tty_port_destroy() is not required if the port has not
been used; remove from vc_allocate() failure path.
[1] lockdep report from Dave Jones <davej@redhat.com>
======================================================
[ INFO: possible circular locking dependency detected ]
3.9.0+ #16 Not tainted
-------------------------------------------------------
(agetty)/26163 is trying to acquire lock:
blocked: ((&buf->work)){+.+...}, instance: ffff88011c8b0020, at: [<ffffffff81062065>] flush_work+0x5/0x2e0
but task is already holding lock:
blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (console_lock){+.+.+.}:
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810416c7>] console_lock+0x77/0x80
[<ffffffff813c3dcd>] con_flush_chars+0x2d/0x50
[<ffffffff813b32b2>] n_tty_receive_buf+0x122/0x14d0
[<ffffffff813b7709>] flush_to_ldisc+0x119/0x170
[<ffffffff81064381>] process_one_work+0x211/0x700
[<ffffffff8106498b>] worker_thread+0x11b/0x3a0
[<ffffffff8106ce5d>] kthread+0xed/0x100
[<ffffffff81601cac>] ret_from_fork+0x7c/0xb0
-> #0 ((&buf->work)){+.+...}:
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
other info that might help us debug this:
[ 6760.076175] Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(console_lock);
lock((&buf->work));
lock(console_lock);
lock((&buf->work));
*** DEADLOCK ***
1 lock on stack by (agetty)/26163:
#0: blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
stack backtrace:
Pid: 26163, comm: (agetty) Not tainted 3.9.0+ #16
Call Trace:
[<ffffffff815edb14>] print_circular_bug+0x200/0x20e
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a200>] ? native_sched_clock+0x20/0x80
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff8113c8a3>] ? __free_pages_ok.part.57+0x93/0xc0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff810652f2>] ? __cancel_work_timer+0x82/0x130
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff810aec41>] ? lock_release_holdtime.part.30+0xa1/0x170
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff812b00f6>] ? inode_has_perm.isra.46.constprop.61+0x56/0x80
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff812b04db>] ? selinux_file_ioctl+0x5b/0x110
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
Cc: Dave Jones <davej@redhat.com>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-05-17 20:41:03 +04:00
|
|
|
struct vc_data *vc = NULL;
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (vc_cons_allocated(currcons)) {
|
tty/vt: Fix vc_deallocate() lock order
Now that the tty port owns the flip buffers and i/o is allowed
from the driver even when no tty is attached, the destruction
of the tty port (and the flip buffers) must ensure that no
outstanding work is pending.
Unfortunately, this creates a lock order problem with the
console_lock (see attached lockdep report [1] below).
For single console deallocation, drop the console_lock prior
to port destruction. When multiple console deallocation,
defer port destruction until the consoles have been
deallocated.
tty_port_destroy() is not required if the port has not
been used; remove from vc_allocate() failure path.
[1] lockdep report from Dave Jones <davej@redhat.com>
======================================================
[ INFO: possible circular locking dependency detected ]
3.9.0+ #16 Not tainted
-------------------------------------------------------
(agetty)/26163 is trying to acquire lock:
blocked: ((&buf->work)){+.+...}, instance: ffff88011c8b0020, at: [<ffffffff81062065>] flush_work+0x5/0x2e0
but task is already holding lock:
blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (console_lock){+.+.+.}:
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810416c7>] console_lock+0x77/0x80
[<ffffffff813c3dcd>] con_flush_chars+0x2d/0x50
[<ffffffff813b32b2>] n_tty_receive_buf+0x122/0x14d0
[<ffffffff813b7709>] flush_to_ldisc+0x119/0x170
[<ffffffff81064381>] process_one_work+0x211/0x700
[<ffffffff8106498b>] worker_thread+0x11b/0x3a0
[<ffffffff8106ce5d>] kthread+0xed/0x100
[<ffffffff81601cac>] ret_from_fork+0x7c/0xb0
-> #0 ((&buf->work)){+.+...}:
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
other info that might help us debug this:
[ 6760.076175] Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(console_lock);
lock((&buf->work));
lock(console_lock);
lock((&buf->work));
*** DEADLOCK ***
1 lock on stack by (agetty)/26163:
#0: blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
stack backtrace:
Pid: 26163, comm: (agetty) Not tainted 3.9.0+ #16
Call Trace:
[<ffffffff815edb14>] print_circular_bug+0x200/0x20e
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a200>] ? native_sched_clock+0x20/0x80
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff8113c8a3>] ? __free_pages_ok.part.57+0x93/0xc0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff810652f2>] ? __cancel_work_timer+0x82/0x130
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff810aec41>] ? lock_release_holdtime.part.30+0xa1/0x170
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff812b00f6>] ? inode_has_perm.isra.46.constprop.61+0x56/0x80
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff812b04db>] ? selinux_file_ioctl+0x5b/0x110
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
Cc: Dave Jones <davej@redhat.com>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-05-17 20:41:03 +04:00
|
|
|
struct vt_notifier_param param;
|
2009-03-09 16:18:52 +03:00
|
|
|
|
tty/vt: Fix vc_deallocate() lock order
Now that the tty port owns the flip buffers and i/o is allowed
from the driver even when no tty is attached, the destruction
of the tty port (and the flip buffers) must ensure that no
outstanding work is pending.
Unfortunately, this creates a lock order problem with the
console_lock (see attached lockdep report [1] below).
For single console deallocation, drop the console_lock prior
to port destruction. When multiple console deallocation,
defer port destruction until the consoles have been
deallocated.
tty_port_destroy() is not required if the port has not
been used; remove from vc_allocate() failure path.
[1] lockdep report from Dave Jones <davej@redhat.com>
======================================================
[ INFO: possible circular locking dependency detected ]
3.9.0+ #16 Not tainted
-------------------------------------------------------
(agetty)/26163 is trying to acquire lock:
blocked: ((&buf->work)){+.+...}, instance: ffff88011c8b0020, at: [<ffffffff81062065>] flush_work+0x5/0x2e0
but task is already holding lock:
blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (console_lock){+.+.+.}:
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810416c7>] console_lock+0x77/0x80
[<ffffffff813c3dcd>] con_flush_chars+0x2d/0x50
[<ffffffff813b32b2>] n_tty_receive_buf+0x122/0x14d0
[<ffffffff813b7709>] flush_to_ldisc+0x119/0x170
[<ffffffff81064381>] process_one_work+0x211/0x700
[<ffffffff8106498b>] worker_thread+0x11b/0x3a0
[<ffffffff8106ce5d>] kthread+0xed/0x100
[<ffffffff81601cac>] ret_from_fork+0x7c/0xb0
-> #0 ((&buf->work)){+.+...}:
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
other info that might help us debug this:
[ 6760.076175] Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(console_lock);
lock((&buf->work));
lock(console_lock);
lock((&buf->work));
*** DEADLOCK ***
1 lock on stack by (agetty)/26163:
#0: blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
stack backtrace:
Pid: 26163, comm: (agetty) Not tainted 3.9.0+ #16
Call Trace:
[<ffffffff815edb14>] print_circular_bug+0x200/0x20e
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a200>] ? native_sched_clock+0x20/0x80
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff8113c8a3>] ? __free_pages_ok.part.57+0x93/0xc0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff810652f2>] ? __cancel_work_timer+0x82/0x130
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff810aec41>] ? lock_release_holdtime.part.30+0xa1/0x170
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff812b00f6>] ? inode_has_perm.isra.46.constprop.61+0x56/0x80
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff812b04db>] ? selinux_file_ioctl+0x5b/0x110
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
Cc: Dave Jones <davej@redhat.com>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-05-17 20:41:03 +04:00
|
|
|
param.vc = vc = vc_cons[currcons].d;
|
2007-10-19 10:39:17 +04:00
|
|
|
atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, ¶m);
|
2009-03-09 16:18:52 +03:00
|
|
|
vcs_remove_sysfs(currcons);
|
2019-04-26 17:59:46 +03:00
|
|
|
visual_deinit(vc);
|
2021-03-28 00:44:43 +03:00
|
|
|
con_free_unimap(vc);
|
2006-10-02 13:17:14 +04:00
|
|
|
put_pid(vc->vt_pid);
|
2018-06-27 06:56:40 +03:00
|
|
|
vc_uniscr_set(vc, NULL);
|
2009-07-16 19:06:09 +04:00
|
|
|
kfree(vc->vc_screenbuf);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc_cons[currcons].d = NULL;
|
|
|
|
|
}
|
tty/vt: Fix vc_deallocate() lock order
Now that the tty port owns the flip buffers and i/o is allowed
from the driver even when no tty is attached, the destruction
of the tty port (and the flip buffers) must ensure that no
outstanding work is pending.
Unfortunately, this creates a lock order problem with the
console_lock (see attached lockdep report [1] below).
For single console deallocation, drop the console_lock prior
to port destruction. When multiple console deallocation,
defer port destruction until the consoles have been
deallocated.
tty_port_destroy() is not required if the port has not
been used; remove from vc_allocate() failure path.
[1] lockdep report from Dave Jones <davej@redhat.com>
======================================================
[ INFO: possible circular locking dependency detected ]
3.9.0+ #16 Not tainted
-------------------------------------------------------
(agetty)/26163 is trying to acquire lock:
blocked: ((&buf->work)){+.+...}, instance: ffff88011c8b0020, at: [<ffffffff81062065>] flush_work+0x5/0x2e0
but task is already holding lock:
blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (console_lock){+.+.+.}:
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810416c7>] console_lock+0x77/0x80
[<ffffffff813c3dcd>] con_flush_chars+0x2d/0x50
[<ffffffff813b32b2>] n_tty_receive_buf+0x122/0x14d0
[<ffffffff813b7709>] flush_to_ldisc+0x119/0x170
[<ffffffff81064381>] process_one_work+0x211/0x700
[<ffffffff8106498b>] worker_thread+0x11b/0x3a0
[<ffffffff8106ce5d>] kthread+0xed/0x100
[<ffffffff81601cac>] ret_from_fork+0x7c/0xb0
-> #0 ((&buf->work)){+.+...}:
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
other info that might help us debug this:
[ 6760.076175] Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(console_lock);
lock((&buf->work));
lock(console_lock);
lock((&buf->work));
*** DEADLOCK ***
1 lock on stack by (agetty)/26163:
#0: blocked: (console_lock){+.+.+.}, instance: ffffffff81c2fde0, at: [<ffffffff813bc201>] vt_ioctl+0xb61/0x1230
stack backtrace:
Pid: 26163, comm: (agetty) Not tainted 3.9.0+ #16
Call Trace:
[<ffffffff815edb14>] print_circular_bug+0x200/0x20e
[<ffffffff810b349a>] __lock_acquire+0x193a/0x1c00
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a269>] ? sched_clock+0x9/0x10
[<ffffffff8100a200>] ? native_sched_clock+0x20/0x80
[<ffffffff810b3f74>] lock_acquire+0xa4/0x210
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810620ae>] flush_work+0x4e/0x2e0
[<ffffffff81062065>] ? flush_work+0x5/0x2e0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff8113c8a3>] ? __free_pages_ok.part.57+0x93/0xc0
[<ffffffff810b15db>] ? mark_held_locks+0xbb/0x140
[<ffffffff810652f2>] ? __cancel_work_timer+0x82/0x130
[<ffffffff81065305>] __cancel_work_timer+0x95/0x130
[<ffffffff810653b0>] cancel_work_sync+0x10/0x20
[<ffffffff813b8212>] tty_port_destroy+0x12/0x20
[<ffffffff813c65e8>] vc_deallocate+0xf8/0x110
[<ffffffff813bc20c>] vt_ioctl+0xb6c/0x1230
[<ffffffff810aec41>] ? lock_release_holdtime.part.30+0xa1/0x170
[<ffffffff813b01a5>] tty_ioctl+0x285/0xd50
[<ffffffff812b00f6>] ? inode_has_perm.isra.46.constprop.61+0x56/0x80
[<ffffffff811ba825>] do_vfs_ioctl+0x305/0x530
[<ffffffff812b04db>] ? selinux_file_ioctl+0x5b/0x110
[<ffffffff811baad1>] sys_ioctl+0x81/0xa0
[<ffffffff81601d59>] system_call_fastpath+0x16/0x1b
Cc: Dave Jones <davej@redhat.com>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-05-17 20:41:03 +04:00
|
|
|
return vc;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* VT102 emulator
|
|
|
|
|
*/
|
|
|
|
|
|
2018-12-15 17:34:20 +03:00
|
|
|
enum { EPecma = 0, EPdec, EPeq, EPgt, EPlt};
|
|
|
|
|
|
2012-02-28 18:49:23 +04:00
|
|
|
#define set_kbd(vc, x) vt_set_kbd_mode_bit((vc)->vc_num, (x))
|
|
|
|
|
#define clr_kbd(vc, x) vt_clr_kbd_mode_bit((vc)->vc_num, (x))
|
|
|
|
|
#define is_kbd(vc, x) vt_get_kbd_mode_bit((vc)->vc_num, (x))
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
#define decarm VC_REPEAT
|
|
|
|
|
#define decckm VC_CKMODE
|
|
|
|
|
#define kbdapplic VC_APPLIC
|
|
|
|
|
#define lnm VC_CRLF
|
|
|
|
|
|
2016-03-31 11:08:16 +03:00
|
|
|
const unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
|
2005-04-17 02:20:36 +04:00
|
|
|
8,12,10,14, 9,13,11,15 };
|
|
|
|
|
|
|
|
|
|
/* the default colour table, for VGA+ colour systems */
|
2016-03-31 11:08:17 +03:00
|
|
|
unsigned char default_red[] = {
|
|
|
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
|
|
|
0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff
|
|
|
|
|
};
|
|
|
|
|
module_param_array(default_red, byte, NULL, S_IRUGO | S_IWUSR);
|
|
|
|
|
|
|
|
|
|
unsigned char default_grn[] = {
|
|
|
|
|
0x00, 0x00, 0xaa, 0x55, 0x00, 0x00, 0xaa, 0xaa,
|
|
|
|
|
0x55, 0x55, 0xff, 0xff, 0x55, 0x55, 0xff, 0xff
|
|
|
|
|
};
|
|
|
|
|
module_param_array(default_grn, byte, NULL, S_IRUGO | S_IWUSR);
|
|
|
|
|
|
|
|
|
|
unsigned char default_blu[] = {
|
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xaa,
|
|
|
|
|
0x55, 0x55, 0x55, 0x55, 0xff, 0xff, 0xff, 0xff
|
|
|
|
|
};
|
|
|
|
|
module_param_array(default_blu, byte, NULL, S_IRUGO | S_IWUSR);
|
2007-05-08 11:38:03 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* gotoxy() must verify all boundaries, because the arguments
|
|
|
|
|
* might also be negative. If the given position is out of
|
|
|
|
|
* bounds, the cursor is placed at the nearest margin.
|
|
|
|
|
*/
|
|
|
|
|
static void gotoxy(struct vc_data *vc, int new_x, int new_y)
|
|
|
|
|
{
|
|
|
|
|
int min_y, max_y;
|
|
|
|
|
|
|
|
|
|
if (new_x < 0)
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.x = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
else {
|
|
|
|
|
if (new_x >= vc->vc_cols)
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.x = vc->vc_cols - 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
else
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.x = new_x;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (vc->vc_decom) {
|
|
|
|
|
min_y = vc->vc_top;
|
|
|
|
|
max_y = vc->vc_bottom;
|
|
|
|
|
} else {
|
|
|
|
|
min_y = 0;
|
|
|
|
|
max_y = vc->vc_rows;
|
|
|
|
|
}
|
|
|
|
|
if (new_y < min_y)
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.y = min_y;
|
2005-04-17 02:20:36 +04:00
|
|
|
else if (new_y >= max_y)
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.y = max_y - 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
else
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.y = new_y;
|
|
|
|
|
vc->vc_pos = vc->vc_origin + vc->state.y * vc->vc_size_row +
|
|
|
|
|
(vc->state.x << 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* for absolute user moves, when decom is set */
|
|
|
|
|
static void gotoxay(struct vc_data *vc, int new_x, int new_y)
|
|
|
|
|
{
|
|
|
|
|
gotoxy(vc, new_x, vc->vc_decom ? (vc->vc_top + new_y) : new_y);
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-23 14:34:23 +03:00
|
|
|
void scrollback(struct vc_data *vc)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2016-06-23 14:34:23 +03:00
|
|
|
scrolldelta(-(vc->vc_rows / 2));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void scrollfront(struct vc_data *vc, int lines)
|
|
|
|
|
{
|
|
|
|
|
if (!lines)
|
|
|
|
|
lines = vc->vc_rows / 2;
|
|
|
|
|
scrolldelta(lines);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void lf(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
/* don't scroll if above bottom of scrolling region, or
|
|
|
|
|
* if below scrolling region
|
|
|
|
|
*/
|
2020-06-15 10:48:33 +03:00
|
|
|
if (vc->state.y + 1 == vc->vc_bottom)
|
2016-10-03 12:18:34 +03:00
|
|
|
con_scroll(vc, vc->vc_top, vc->vc_bottom, SM_UP, 1);
|
2020-06-15 10:48:33 +03:00
|
|
|
else if (vc->state.y < vc->vc_rows - 1) {
|
|
|
|
|
vc->state.y++;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_pos += vc->vc_size_row;
|
|
|
|
|
}
|
|
|
|
|
vc->vc_need_wrap = 0;
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_write(vc, '\n');
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void ri(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
/* don't scroll if below top of scrolling region, or
|
|
|
|
|
* if above scrolling region
|
|
|
|
|
*/
|
2020-06-15 10:48:33 +03:00
|
|
|
if (vc->state.y == vc->vc_top)
|
2016-10-03 12:18:34 +03:00
|
|
|
con_scroll(vc, vc->vc_top, vc->vc_bottom, SM_DOWN, 1);
|
2020-06-15 10:48:33 +03:00
|
|
|
else if (vc->state.y > 0) {
|
|
|
|
|
vc->state.y--;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_pos -= vc->vc_size_row;
|
|
|
|
|
}
|
|
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void cr(struct vc_data *vc)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_pos -= vc->state.x << 1;
|
|
|
|
|
vc->vc_need_wrap = vc->state.x = 0;
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_write(vc, '\r');
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bs(struct vc_data *vc)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
if (vc->state.x) {
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_pos -= 2;
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.x--;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_write(vc, '\b');
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void del(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
/* ignored */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void csi_J(struct vc_data *vc, int vpar)
|
|
|
|
|
{
|
|
|
|
|
unsigned int count;
|
|
|
|
|
unsigned short * start;
|
|
|
|
|
|
|
|
|
|
switch (vpar) {
|
|
|
|
|
case 0: /* erase from cursor to end of display */
|
2020-06-15 10:48:33 +03:00
|
|
|
vc_uniscr_clear_line(vc, vc->state.x,
|
|
|
|
|
vc->vc_cols - vc->state.x);
|
|
|
|
|
vc_uniscr_clear_lines(vc, vc->state.y + 1,
|
|
|
|
|
vc->vc_rows - vc->state.y - 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
count = (vc->vc_scr_end - vc->vc_pos) >> 1;
|
|
|
|
|
start = (unsigned short *)vc->vc_pos;
|
|
|
|
|
break;
|
|
|
|
|
case 1: /* erase from start to cursor */
|
2020-06-15 10:48:33 +03:00
|
|
|
vc_uniscr_clear_line(vc, 0, vc->state.x + 1);
|
|
|
|
|
vc_uniscr_clear_lines(vc, 0, vc->state.y);
|
2005-04-17 02:20:36 +04:00
|
|
|
count = ((vc->vc_pos - vc->vc_origin) >> 1) + 1;
|
|
|
|
|
start = (unsigned short *)vc->vc_origin;
|
|
|
|
|
break;
|
2019-02-12 03:36:41 +03:00
|
|
|
case 3: /* include scrollback */
|
|
|
|
|
flush_scrollback(vc);
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2005-04-17 02:20:36 +04:00
|
|
|
case 2: /* erase whole display */
|
2018-06-27 06:56:40 +03:00
|
|
|
vc_uniscr_clear_lines(vc, 0, vc->vc_rows);
|
2005-04-17 02:20:36 +04:00
|
|
|
count = vc->vc_cols * vc->vc_rows;
|
|
|
|
|
start = (unsigned short *)vc->vc_origin;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
|
2019-04-05 03:53:28 +03:00
|
|
|
if (con_should_update(vc))
|
|
|
|
|
do_update_region(vc, (unsigned long) start, count);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void csi_K(struct vc_data *vc, int vpar)
|
|
|
|
|
{
|
|
|
|
|
unsigned int count;
|
2018-06-27 06:56:40 +03:00
|
|
|
unsigned short *start = (unsigned short *)vc->vc_pos;
|
|
|
|
|
int offset;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
switch (vpar) {
|
|
|
|
|
case 0: /* erase from cursor to end of line */
|
2018-06-27 06:56:40 +03:00
|
|
|
offset = 0;
|
2020-06-15 10:48:33 +03:00
|
|
|
count = vc->vc_cols - vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case 1: /* erase from start of line to cursor */
|
2020-06-15 10:48:33 +03:00
|
|
|
offset = -vc->state.x;
|
|
|
|
|
count = vc->state.x + 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case 2: /* erase whole line */
|
2020-06-15 10:48:33 +03:00
|
|
|
offset = -vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
count = vc->vc_cols;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
}
|
2020-06-15 10:48:33 +03:00
|
|
|
vc_uniscr_clear_line(vc, vc->state.x + offset, count);
|
2018-06-27 06:56:40 +03:00
|
|
|
scr_memsetw(start + offset, vc->vc_video_erase_char, 2 * count);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2018-10-23 18:28:28 +03:00
|
|
|
do_update_region(vc, (unsigned long)(start + offset), count);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:55 +03:00
|
|
|
/* erase the following vpar positions */
|
|
|
|
|
static void csi_X(struct vc_data *vc, unsigned int vpar)
|
2005-04-17 02:20:36 +04:00
|
|
|
{ /* not vt100? */
|
2020-06-15 10:48:55 +03:00
|
|
|
unsigned int count;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (!vpar)
|
|
|
|
|
vpar++;
|
2020-06-15 10:48:55 +03:00
|
|
|
|
|
|
|
|
count = min(vpar, vc->vc_cols - vc->state.x);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-06-15 10:48:33 +03:00
|
|
|
vc_uniscr_clear_line(vc, vc->state.x, count);
|
2005-04-17 02:20:36 +04:00
|
|
|
scr_memsetw((unsigned short *)vc->vc_pos, vc->vc_video_erase_char, 2 * count);
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_should_update(vc))
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_sw->con_clear(vc, vc->state.y, vc->state.x, 1, count);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void default_attr(struct vc_data *vc)
|
|
|
|
|
{
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_NORMAL;
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.italic = false;
|
|
|
|
|
vc->state.underline = false;
|
|
|
|
|
vc->state.reverse = false;
|
|
|
|
|
vc->state.blink = false;
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = vc->vc_def_color;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2014-05-23 03:33:08 +04:00
|
|
|
struct rgb { u8 r; u8 g; u8 b; };
|
|
|
|
|
|
2016-06-23 14:34:32 +03:00
|
|
|
static void rgb_from_256(int i, struct rgb *c)
|
2014-05-23 03:33:08 +04:00
|
|
|
{
|
|
|
|
|
if (i < 8) { /* Standard colours. */
|
2016-06-23 14:34:32 +03:00
|
|
|
c->r = i&1 ? 0xaa : 0x00;
|
|
|
|
|
c->g = i&2 ? 0xaa : 0x00;
|
|
|
|
|
c->b = i&4 ? 0xaa : 0x00;
|
2014-05-23 03:33:08 +04:00
|
|
|
} else if (i < 16) {
|
2016-06-23 14:34:32 +03:00
|
|
|
c->r = i&1 ? 0xff : 0x55;
|
|
|
|
|
c->g = i&2 ? 0xff : 0x55;
|
|
|
|
|
c->b = i&4 ? 0xff : 0x55;
|
2014-05-23 03:33:08 +04:00
|
|
|
} else if (i < 232) { /* 6x6x6 colour cube. */
|
2016-06-23 14:34:32 +03:00
|
|
|
c->r = (i - 16) / 36 * 85 / 2;
|
|
|
|
|
c->g = (i - 16) / 6 % 6 * 85 / 2;
|
|
|
|
|
c->b = (i - 16) % 6 * 85 / 2;
|
2014-05-23 03:33:08 +04:00
|
|
|
} else /* Grayscale ramp. */
|
2016-06-23 14:34:32 +03:00
|
|
|
c->r = c->g = c->b = i * 10 - 2312;
|
2014-05-23 03:33:08 +04:00
|
|
|
}
|
|
|
|
|
|
2016-06-23 14:34:32 +03:00
|
|
|
static void rgb_foreground(struct vc_data *vc, const struct rgb *c)
|
2014-05-23 03:33:08 +04:00
|
|
|
{
|
2016-06-23 14:34:33 +03:00
|
|
|
u8 hue = 0, max = max3(c->r, c->g, c->b);
|
|
|
|
|
|
|
|
|
|
if (c->r > max / 2)
|
|
|
|
|
hue |= 4;
|
|
|
|
|
if (c->g > max / 2)
|
|
|
|
|
hue |= 2;
|
|
|
|
|
if (c->b > max / 2)
|
|
|
|
|
hue |= 1;
|
|
|
|
|
|
|
|
|
|
if (hue == 7 && max <= 0x55) {
|
|
|
|
|
hue = 0;
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_BOLD;
|
2016-06-23 14:34:33 +03:00
|
|
|
} else if (max > 0xaa)
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_BOLD;
|
2014-05-23 03:33:08 +04:00
|
|
|
else
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_NORMAL;
|
2016-06-23 14:34:33 +03:00
|
|
|
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = (vc->state.color & 0xf0) | hue;
|
2014-05-23 03:33:08 +04:00
|
|
|
}
|
|
|
|
|
|
2016-06-23 14:34:32 +03:00
|
|
|
static void rgb_background(struct vc_data *vc, const struct rgb *c)
|
2014-05-23 03:33:08 +04:00
|
|
|
{
|
|
|
|
|
/* For backgrounds, err on the dark side. */
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = (vc->state.color & 0x0f)
|
2016-06-23 14:34:32 +03:00
|
|
|
| (c->r&0x80) >> 1 | (c->g&0x80) >> 2 | (c->b&0x80) >> 3;
|
2014-05-23 03:33:08 +04:00
|
|
|
}
|
|
|
|
|
|
2016-06-23 14:34:31 +03:00
|
|
|
/*
|
|
|
|
|
* ITU T.416 Higher colour modes. They break the usual properties of SGR codes
|
2018-12-15 17:34:23 +03:00
|
|
|
* and thus need to be detected and ignored by hand. That standard also
|
|
|
|
|
* wants : rather than ; as separators but sequences containing : are currently
|
|
|
|
|
* completely ignored by the parser.
|
2016-06-23 14:34:31 +03:00
|
|
|
*
|
|
|
|
|
* Subcommands 3 (CMY) and 4 (CMYK) are so insane there's no point in
|
|
|
|
|
* supporting them.
|
|
|
|
|
*/
|
|
|
|
|
static int vc_t416_color(struct vc_data *vc, int i,
|
2016-06-23 14:34:32 +03:00
|
|
|
void(*set_color)(struct vc_data *vc, const struct rgb *c))
|
2016-06-23 14:34:31 +03:00
|
|
|
{
|
2016-06-23 14:34:32 +03:00
|
|
|
struct rgb c;
|
|
|
|
|
|
2016-06-23 14:34:31 +03:00
|
|
|
i++;
|
|
|
|
|
if (i > vc->vc_npar)
|
|
|
|
|
return i;
|
|
|
|
|
|
2016-09-15 17:47:10 +03:00
|
|
|
if (vc->vc_par[i] == 5 && i + 1 <= vc->vc_npar) {
|
2016-09-15 17:47:11 +03:00
|
|
|
/* 256 colours */
|
2016-06-23 14:34:31 +03:00
|
|
|
i++;
|
2016-06-23 14:34:32 +03:00
|
|
|
rgb_from_256(vc->vc_par[i], &c);
|
2016-09-15 17:47:09 +03:00
|
|
|
} else if (vc->vc_par[i] == 2 && i + 3 <= vc->vc_npar) {
|
2016-09-15 17:47:11 +03:00
|
|
|
/* 24 bit */
|
2016-06-23 14:34:32 +03:00
|
|
|
c.r = vc->vc_par[i + 1];
|
|
|
|
|
c.g = vc->vc_par[i + 2];
|
|
|
|
|
c.b = vc->vc_par[i + 3];
|
2016-06-23 14:34:31 +03:00
|
|
|
i += 3;
|
2016-06-23 14:34:32 +03:00
|
|
|
} else
|
|
|
|
|
return i;
|
|
|
|
|
|
|
|
|
|
set_color(vc, &c);
|
2016-06-23 14:34:31 +03:00
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void csi_m(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i <= vc->vc_npar; i++)
|
|
|
|
|
switch (vc->vc_par[i]) {
|
2016-06-23 14:34:34 +03:00
|
|
|
case 0: /* all attributes off */
|
|
|
|
|
default_attr(vc);
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_BOLD;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 2:
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_HALF_BRIGHT;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 3:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.italic = true;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
2018-01-30 01:08:21 +03:00
|
|
|
case 21:
|
|
|
|
|
/*
|
|
|
|
|
* No console drivers support double underline, so
|
|
|
|
|
* convert it to a single underline.
|
|
|
|
|
*/
|
2016-06-23 14:34:34 +03:00
|
|
|
case 4:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.underline = true;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 5:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.blink = true;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 7:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.reverse = true;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 10: /* ANSI X3.64-1979 (SCO-ish?)
|
|
|
|
|
* Select primary font, don't display control chars if
|
|
|
|
|
* defined, don't set bit 8 on output.
|
|
|
|
|
*/
|
2020-06-15 10:48:37 +03:00
|
|
|
vc->vc_translate = set_translate(vc->state.Gx_charset[vc->state.charset], vc);
|
2016-06-23 14:34:34 +03:00
|
|
|
vc->vc_disp_ctrl = 0;
|
|
|
|
|
vc->vc_toggle_meta = 0;
|
|
|
|
|
break;
|
|
|
|
|
case 11: /* ANSI X3.64-1979 (SCO-ish?)
|
|
|
|
|
* Select first alternate font, lets chars < 32 be
|
|
|
|
|
* displayed as ROM chars.
|
|
|
|
|
*/
|
|
|
|
|
vc->vc_translate = set_translate(IBMPC_MAP, vc);
|
|
|
|
|
vc->vc_disp_ctrl = 1;
|
|
|
|
|
vc->vc_toggle_meta = 0;
|
|
|
|
|
break;
|
|
|
|
|
case 12: /* ANSI X3.64-1979 (SCO-ish?)
|
|
|
|
|
* Select second alternate font, toggle high bit
|
|
|
|
|
* before displaying as ROM char.
|
|
|
|
|
*/
|
|
|
|
|
vc->vc_translate = set_translate(IBMPC_MAP, vc);
|
|
|
|
|
vc->vc_disp_ctrl = 1;
|
|
|
|
|
vc->vc_toggle_meta = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 22:
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_NORMAL;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 23:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.italic = false;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 24:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.underline = false;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 25:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.blink = false;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 27:
|
2020-06-15 10:48:35 +03:00
|
|
|
vc->state.reverse = false;
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 38:
|
|
|
|
|
i = vc_t416_color(vc, i, rgb_foreground);
|
|
|
|
|
break;
|
|
|
|
|
case 48:
|
|
|
|
|
i = vc_t416_color(vc, i, rgb_background);
|
|
|
|
|
break;
|
|
|
|
|
case 39:
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = (vc->vc_def_color & 0x0f) |
|
|
|
|
|
(vc->state.color & 0xf0);
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
case 49:
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = (vc->vc_def_color & 0xf0) |
|
|
|
|
|
(vc->state.color & 0x0f);
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
|
|
|
|
default:
|
2016-09-15 17:47:13 +03:00
|
|
|
if (vc->vc_par[i] >= 90 && vc->vc_par[i] <= 107) {
|
|
|
|
|
if (vc->vc_par[i] < 100)
|
2020-06-15 10:48:34 +03:00
|
|
|
vc->state.intensity = VCI_BOLD;
|
2016-09-15 17:47:12 +03:00
|
|
|
vc->vc_par[i] -= 60;
|
|
|
|
|
}
|
2016-06-23 14:34:34 +03:00
|
|
|
if (vc->vc_par[i] >= 30 && vc->vc_par[i] <= 37)
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = color_table[vc->vc_par[i] - 30]
|
|
|
|
|
| (vc->state.color & 0xf0);
|
2016-06-23 14:34:34 +03:00
|
|
|
else if (vc->vc_par[i] >= 40 && vc->vc_par[i] <= 47)
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.color = (color_table[vc->vc_par[i] - 40] << 4)
|
|
|
|
|
| (vc->state.color & 0x0f);
|
2016-06-23 14:34:34 +03:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
update_attr(vc);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:40 +03:00
|
|
|
static void respond_string(const char *p, size_t len, struct tty_port *port)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2020-06-15 10:48:40 +03:00
|
|
|
tty_insert_flip_string(port, p, len);
|
2013-01-03 18:53:07 +04:00
|
|
|
tty_schedule_flip(port);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void cursor_report(struct vc_data *vc, struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
char buf[40];
|
2020-06-15 10:48:40 +03:00
|
|
|
int len;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-06-15 10:48:40 +03:00
|
|
|
len = sprintf(buf, "\033[%d;%dR", vc->state.y +
|
|
|
|
|
(vc->vc_decom ? vc->vc_top + 1 : 1),
|
|
|
|
|
vc->state.x + 1);
|
|
|
|
|
respond_string(buf, len, tty->port);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void status_report(struct tty_struct *tty)
|
|
|
|
|
{
|
2020-06-15 10:48:40 +03:00
|
|
|
static const char teminal_ok[] = "\033[0n";
|
|
|
|
|
|
|
|
|
|
respond_string(teminal_ok, strlen(teminal_ok), tty->port);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2013-01-03 18:53:07 +04:00
|
|
|
static inline void respond_ID(struct tty_struct *tty)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2020-06-15 10:48:41 +03:00
|
|
|
/* terminal answer to an ESC-Z or csi0c query. */
|
|
|
|
|
static const char vt102_id[] = "\033[?6c";
|
|
|
|
|
|
|
|
|
|
respond_string(vt102_id, strlen(vt102_id), tty->port);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry)
|
|
|
|
|
{
|
|
|
|
|
char buf[8];
|
2020-06-15 10:48:40 +03:00
|
|
|
int len;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-06-15 10:48:40 +03:00
|
|
|
len = sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt),
|
|
|
|
|
(char)('!' + mrx), (char)('!' + mry));
|
|
|
|
|
respond_string(buf, len, tty->port);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2019-04-17 15:21:13 +03:00
|
|
|
/* invoked via ioctl(TIOCLINUX) and through set_selection_user */
|
2005-04-17 02:20:36 +04:00
|
|
|
int mouse_reporting(void)
|
|
|
|
|
{
|
|
|
|
|
return vc_cons[fg_console].d->vc_report_mouse;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void set_mode(struct vc_data *vc, int on_off)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i <= vc->vc_npar; i++)
|
2018-12-15 17:34:20 +03:00
|
|
|
if (vc->vc_priv == EPdec) {
|
2005-04-17 02:20:36 +04:00
|
|
|
switch(vc->vc_par[i]) { /* DEC private modes set/reset */
|
|
|
|
|
case 1: /* Cursor keys send ^[Ox/^[[x */
|
|
|
|
|
if (on_off)
|
|
|
|
|
set_kbd(vc, decckm);
|
|
|
|
|
else
|
|
|
|
|
clr_kbd(vc, decckm);
|
|
|
|
|
break;
|
|
|
|
|
case 3: /* 80/132 mode switch unimplemented */
|
|
|
|
|
#if 0
|
|
|
|
|
vc_resize(deccolm ? 132 : 80, vc->vc_rows);
|
|
|
|
|
/* this alone does not suffice; some user mode
|
|
|
|
|
utility has to change the hardware regs */
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
case 5: /* Inverted screen on/off */
|
|
|
|
|
if (vc->vc_decscnm != on_off) {
|
|
|
|
|
vc->vc_decscnm = on_off;
|
2020-08-18 11:56:53 +03:00
|
|
|
invert_screen(vc, 0,
|
|
|
|
|
vc->vc_screenbuf_size,
|
|
|
|
|
false);
|
2005-04-17 02:20:36 +04:00
|
|
|
update_attr(vc);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 6: /* Origin relative/absolute */
|
|
|
|
|
vc->vc_decom = on_off;
|
|
|
|
|
gotoxay(vc, 0, 0);
|
|
|
|
|
break;
|
|
|
|
|
case 7: /* Autowrap on/off */
|
|
|
|
|
vc->vc_decawm = on_off;
|
|
|
|
|
break;
|
|
|
|
|
case 8: /* Autorepeat on/off */
|
|
|
|
|
if (on_off)
|
|
|
|
|
set_kbd(vc, decarm);
|
|
|
|
|
else
|
|
|
|
|
clr_kbd(vc, decarm);
|
|
|
|
|
break;
|
|
|
|
|
case 9:
|
|
|
|
|
vc->vc_report_mouse = on_off ? 1 : 0;
|
|
|
|
|
break;
|
|
|
|
|
case 25: /* Cursor on/off */
|
|
|
|
|
vc->vc_deccm = on_off;
|
|
|
|
|
break;
|
|
|
|
|
case 1000:
|
|
|
|
|
vc->vc_report_mouse = on_off ? 2 : 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
switch(vc->vc_par[i]) { /* ANSI modes set/reset */
|
|
|
|
|
case 3: /* Monitor (display ctrls) */
|
|
|
|
|
vc->vc_disp_ctrl = on_off;
|
|
|
|
|
break;
|
|
|
|
|
case 4: /* Insert Mode on/off */
|
|
|
|
|
vc->vc_decim = on_off;
|
|
|
|
|
break;
|
|
|
|
|
case 20: /* Lf, Enter == CrLf/Lf */
|
|
|
|
|
if (on_off)
|
|
|
|
|
set_kbd(vc, lnm);
|
|
|
|
|
else
|
|
|
|
|
clr_kbd(vc, lnm);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void setterm_command(struct vc_data *vc)
|
|
|
|
|
{
|
2020-03-16 09:59:11 +03:00
|
|
|
switch (vc->vc_par[0]) {
|
|
|
|
|
case 1: /* set color for underline mode */
|
|
|
|
|
if (vc->vc_can_do_color && vc->vc_par[1] < 16) {
|
|
|
|
|
vc->vc_ulcolor = color_table[vc->vc_par[1]];
|
2020-06-15 10:48:33 +03:00
|
|
|
if (vc->state.underline)
|
2020-03-16 09:59:11 +03:00
|
|
|
update_attr(vc);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 2: /* set color for half intensity mode */
|
|
|
|
|
if (vc->vc_can_do_color && vc->vc_par[1] < 16) {
|
|
|
|
|
vc->vc_halfcolor = color_table[vc->vc_par[1]];
|
2020-06-15 10:48:34 +03:00
|
|
|
if (vc->state.intensity == VCI_HALF_BRIGHT)
|
2020-03-16 09:59:11 +03:00
|
|
|
update_attr(vc);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 8: /* store colors as defaults */
|
|
|
|
|
vc->vc_def_color = vc->vc_attr;
|
|
|
|
|
if (vc->vc_hi_font_mask == 0x100)
|
|
|
|
|
vc->vc_def_color >>= 1;
|
|
|
|
|
default_attr(vc);
|
|
|
|
|
update_attr(vc);
|
|
|
|
|
break;
|
|
|
|
|
case 9: /* set blanking interval */
|
|
|
|
|
blankinterval = min(vc->vc_par[1], 60U) * 60;
|
|
|
|
|
poke_blanked_console();
|
|
|
|
|
break;
|
|
|
|
|
case 10: /* set bell frequency in Hz */
|
|
|
|
|
if (vc->vc_npar >= 1)
|
|
|
|
|
vc->vc_bell_pitch = vc->vc_par[1];
|
|
|
|
|
else
|
|
|
|
|
vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
|
|
|
|
|
break;
|
|
|
|
|
case 11: /* set bell duration in msec */
|
|
|
|
|
if (vc->vc_npar >= 1)
|
|
|
|
|
vc->vc_bell_duration = (vc->vc_par[1] < 2000) ?
|
|
|
|
|
msecs_to_jiffies(vc->vc_par[1]) : 0;
|
|
|
|
|
else
|
|
|
|
|
vc->vc_bell_duration = DEFAULT_BELL_DURATION;
|
|
|
|
|
break;
|
|
|
|
|
case 12: /* bring specified console to the front */
|
|
|
|
|
if (vc->vc_par[1] >= 1 && vc_cons_allocated(vc->vc_par[1] - 1))
|
|
|
|
|
set_console(vc->vc_par[1] - 1);
|
|
|
|
|
break;
|
|
|
|
|
case 13: /* unblank the screen */
|
|
|
|
|
poke_blanked_console();
|
|
|
|
|
break;
|
|
|
|
|
case 14: /* set vesa powerdown interval */
|
|
|
|
|
vesa_off_interval = min(vc->vc_par[1], 60U) * 60 * HZ;
|
|
|
|
|
break;
|
|
|
|
|
case 15: /* activate the previous console */
|
|
|
|
|
set_console(last_console);
|
|
|
|
|
break;
|
|
|
|
|
case 16: /* set cursor blink duration in msec */
|
|
|
|
|
if (vc->vc_npar >= 1 && vc->vc_par[1] >= 50 &&
|
|
|
|
|
vc->vc_par[1] <= USHRT_MAX)
|
|
|
|
|
vc->vc_cur_blink_ms = vc->vc_par[1];
|
|
|
|
|
else
|
|
|
|
|
vc->vc_cur_blink_ms = DEFAULT_CURSOR_BLINK_MS;
|
|
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void csi_at(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
if (nr > vc->vc_cols - vc->state.x)
|
|
|
|
|
nr = vc->vc_cols - vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
else if (!nr)
|
|
|
|
|
nr = 1;
|
|
|
|
|
insert_char(vc, nr);
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void csi_L(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
if (nr > vc->vc_rows - vc->state.y)
|
|
|
|
|
nr = vc->vc_rows - vc->state.y;
|
2005-04-17 02:20:36 +04:00
|
|
|
else if (!nr)
|
|
|
|
|
nr = 1;
|
2020-06-15 10:48:33 +03:00
|
|
|
con_scroll(vc, vc->state.y, vc->vc_bottom, SM_DOWN, nr);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void csi_P(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
if (nr > vc->vc_cols - vc->state.x)
|
|
|
|
|
nr = vc->vc_cols - vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
else if (!nr)
|
|
|
|
|
nr = 1;
|
|
|
|
|
delete_char(vc, nr);
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void csi_M(struct vc_data *vc, unsigned int nr)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
if (nr > vc->vc_rows - vc->state.y)
|
|
|
|
|
nr = vc->vc_rows - vc->state.y;
|
2005-04-17 02:20:36 +04:00
|
|
|
else if (!nr)
|
|
|
|
|
nr=1;
|
2020-06-15 10:48:33 +03:00
|
|
|
con_scroll(vc, vc->state.y, vc->vc_bottom, SM_UP, nr);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held (except via vc_init->reset_terminal */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void save_cur(struct vc_data *vc)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
memcpy(&vc->saved_state, &vc->state, sizeof(vc->state));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void restore_cur(struct vc_data *vc)
|
|
|
|
|
{
|
2020-06-15 10:48:33 +03:00
|
|
|
memcpy(&vc->state, &vc->saved_state, sizeof(vc->state));
|
|
|
|
|
|
|
|
|
|
gotoxy(vc, vc->state.x, vc->state.y);
|
2020-06-15 10:48:37 +03:00
|
|
|
vc->vc_translate = set_translate(vc->state.Gx_charset[vc->state.charset],
|
|
|
|
|
vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
update_attr(vc);
|
|
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-19 04:40:16 +04:00
|
|
|
enum { ESnormal, ESesc, ESsquare, ESgetpars, ESfunckey,
|
2018-12-15 17:34:22 +03:00
|
|
|
EShash, ESsetG0, ESsetG1, ESpercent, EScsiignore, ESnonstd,
|
2014-02-19 04:38:04 +04:00
|
|
|
ESpalette, ESosc };
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held (except via vc_init()) */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void reset_terminal(struct vc_data *vc, int do_clear)
|
|
|
|
|
{
|
2020-06-15 10:48:38 +03:00
|
|
|
unsigned int i;
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_top = 0;
|
|
|
|
|
vc->vc_bottom = vc->vc_rows;
|
|
|
|
|
vc->vc_state = ESnormal;
|
2018-12-15 17:34:20 +03:00
|
|
|
vc->vc_priv = EPecma;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_translate = set_translate(LAT1_MAP, vc);
|
2020-06-15 10:48:37 +03:00
|
|
|
vc->state.Gx_charset[0] = LAT1_MAP;
|
|
|
|
|
vc->state.Gx_charset[1] = GRAF_MAP;
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.charset = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 0;
|
|
|
|
|
vc->vc_report_mouse = 0;
|
2007-05-08 11:38:09 +04:00
|
|
|
vc->vc_utf = default_utf8;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_utf_count = 0;
|
|
|
|
|
|
|
|
|
|
vc->vc_disp_ctrl = 0;
|
|
|
|
|
vc->vc_toggle_meta = 0;
|
|
|
|
|
|
|
|
|
|
vc->vc_decscnm = 0;
|
|
|
|
|
vc->vc_decom = 0;
|
|
|
|
|
vc->vc_decawm = 1;
|
2009-11-13 23:14:11 +03:00
|
|
|
vc->vc_deccm = global_cursor_default;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_decim = 0;
|
|
|
|
|
|
2012-02-28 18:49:23 +04:00
|
|
|
vt_reset_keyboard(vc->vc_num);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-12-16 03:45:39 +03:00
|
|
|
vc->vc_cursor_type = cur_default;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_complement_mask = vc->vc_s_complement_mask;
|
|
|
|
|
|
|
|
|
|
default_attr(vc);
|
|
|
|
|
update_attr(vc);
|
|
|
|
|
|
2020-06-15 10:48:38 +03:00
|
|
|
bitmap_zero(vc->vc_tab_stop, VC_TABSTOPS_COUNT);
|
|
|
|
|
for (i = 0; i < VC_TABSTOPS_COUNT; i += 8)
|
|
|
|
|
set_bit(i, vc->vc_tab_stop);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
|
|
|
|
|
vc->vc_bell_duration = DEFAULT_BELL_DURATION;
|
2015-03-26 16:54:39 +03:00
|
|
|
vc->vc_cur_blink_ms = DEFAULT_CURSOR_BLINK_MS;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
gotoxy(vc, 0, 0);
|
|
|
|
|
save_cur(vc);
|
|
|
|
|
if (do_clear)
|
|
|
|
|
csi_J(vc, 2);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:36 +03:00
|
|
|
static void vc_setGx(struct vc_data *vc, unsigned int which, int c)
|
|
|
|
|
{
|
2020-06-15 10:48:37 +03:00
|
|
|
unsigned char *charset = &vc->state.Gx_charset[which];
|
2020-06-15 10:48:36 +03:00
|
|
|
|
|
|
|
|
switch (c) {
|
|
|
|
|
case '0':
|
|
|
|
|
*charset = GRAF_MAP;
|
|
|
|
|
break;
|
|
|
|
|
case 'B':
|
|
|
|
|
*charset = LAT1_MAP;
|
|
|
|
|
break;
|
|
|
|
|
case 'U':
|
|
|
|
|
*charset = IBMPC_MAP;
|
|
|
|
|
break;
|
|
|
|
|
case 'K':
|
|
|
|
|
*charset = USER_MAP;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (vc->state.charset == which)
|
|
|
|
|
vc->vc_translate = set_translate(*charset, vc);
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* console_lock is held */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Control characters can be used in the _middle_
|
|
|
|
|
* of an escape sequence.
|
|
|
|
|
*/
|
2014-02-19 04:38:04 +04:00
|
|
|
if (vc->vc_state == ESosc && c>=8 && c<=13) /* ... except for OSC */
|
|
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
switch (c) {
|
|
|
|
|
case 0:
|
|
|
|
|
return;
|
|
|
|
|
case 7:
|
2014-02-19 04:38:04 +04:00
|
|
|
if (vc->vc_state == ESosc)
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
else if (vc->vc_bell_duration)
|
2005-04-17 02:20:36 +04:00
|
|
|
kd_mksound(vc->vc_bell_pitch, vc->vc_bell_duration);
|
|
|
|
|
return;
|
|
|
|
|
case 8:
|
|
|
|
|
bs(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 9:
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_pos -= (vc->state.x << 1);
|
2020-06-15 10:48:38 +03:00
|
|
|
|
|
|
|
|
vc->state.x = find_next_bit(vc->vc_tab_stop,
|
|
|
|
|
min(vc->vc_cols - 1, VC_TABSTOPS_COUNT),
|
|
|
|
|
vc->state.x + 1);
|
|
|
|
|
if (vc->state.x >= VC_TABSTOPS_COUNT)
|
|
|
|
|
vc->state.x = vc->vc_cols - 1;
|
|
|
|
|
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_pos += (vc->state.x << 1);
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_write(vc, '\t');
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 10: case 11: case 12:
|
|
|
|
|
lf(vc);
|
|
|
|
|
if (!is_kbd(vc, lnm))
|
|
|
|
|
return;
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2005-04-17 02:20:36 +04:00
|
|
|
case 13:
|
|
|
|
|
cr(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 14:
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.charset = 1;
|
2020-06-15 10:48:37 +03:00
|
|
|
vc->vc_translate = set_translate(vc->state.Gx_charset[1], vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_disp_ctrl = 1;
|
|
|
|
|
return;
|
|
|
|
|
case 15:
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.charset = 0;
|
2020-06-15 10:48:37 +03:00
|
|
|
vc->vc_translate = set_translate(vc->state.Gx_charset[0], vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_disp_ctrl = 0;
|
|
|
|
|
return;
|
|
|
|
|
case 24: case 26:
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
|
|
|
|
case 27:
|
|
|
|
|
vc->vc_state = ESesc;
|
|
|
|
|
return;
|
|
|
|
|
case 127:
|
|
|
|
|
del(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 128+27:
|
|
|
|
|
vc->vc_state = ESsquare;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
switch(vc->vc_state) {
|
|
|
|
|
case ESesc:
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
switch (c) {
|
|
|
|
|
case '[':
|
|
|
|
|
vc->vc_state = ESsquare;
|
|
|
|
|
return;
|
|
|
|
|
case ']':
|
|
|
|
|
vc->vc_state = ESnonstd;
|
|
|
|
|
return;
|
|
|
|
|
case '%':
|
|
|
|
|
vc->vc_state = ESpercent;
|
|
|
|
|
return;
|
|
|
|
|
case 'E':
|
|
|
|
|
cr(vc);
|
|
|
|
|
lf(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 'M':
|
|
|
|
|
ri(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 'D':
|
|
|
|
|
lf(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 'H':
|
2020-06-15 10:48:38 +03:00
|
|
|
if (vc->state.x < VC_TABSTOPS_COUNT)
|
|
|
|
|
set_bit(vc->state.x, vc->vc_tab_stop);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'Z':
|
|
|
|
|
respond_ID(tty);
|
|
|
|
|
return;
|
|
|
|
|
case '7':
|
|
|
|
|
save_cur(vc);
|
|
|
|
|
return;
|
|
|
|
|
case '8':
|
|
|
|
|
restore_cur(vc);
|
|
|
|
|
return;
|
|
|
|
|
case '(':
|
|
|
|
|
vc->vc_state = ESsetG0;
|
|
|
|
|
return;
|
|
|
|
|
case ')':
|
|
|
|
|
vc->vc_state = ESsetG1;
|
|
|
|
|
return;
|
|
|
|
|
case '#':
|
|
|
|
|
vc->vc_state = EShash;
|
|
|
|
|
return;
|
|
|
|
|
case 'c':
|
|
|
|
|
reset_terminal(vc, 1);
|
|
|
|
|
return;
|
|
|
|
|
case '>': /* Numeric keypad */
|
|
|
|
|
clr_kbd(vc, kbdapplic);
|
|
|
|
|
return;
|
|
|
|
|
case '=': /* Appl. keypad */
|
|
|
|
|
set_kbd(vc, kbdapplic);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
case ESnonstd:
|
|
|
|
|
if (c=='P') { /* palette escape sequence */
|
|
|
|
|
for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
|
|
|
|
|
vc->vc_par[vc->vc_npar] = 0;
|
|
|
|
|
vc->vc_npar = 0;
|
|
|
|
|
vc->vc_state = ESpalette;
|
|
|
|
|
return;
|
|
|
|
|
} else if (c=='R') { /* reset palette */
|
|
|
|
|
reset_palette(vc);
|
|
|
|
|
vc->vc_state = ESnormal;
|
2014-02-19 04:38:04 +04:00
|
|
|
} else if (c>='0' && c<='9')
|
|
|
|
|
vc->vc_state = ESosc;
|
|
|
|
|
else
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
|
|
|
|
case ESpalette:
|
2010-06-15 18:24:16 +04:00
|
|
|
if (isxdigit(c)) {
|
|
|
|
|
vc->vc_par[vc->vc_npar++] = hex_to_bin(c);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (vc->vc_npar == 7) {
|
|
|
|
|
int i = vc->vc_par[0] * 3, j = 1;
|
|
|
|
|
vc->vc_palette[i] = 16 * vc->vc_par[j++];
|
|
|
|
|
vc->vc_palette[i++] += vc->vc_par[j++];
|
|
|
|
|
vc->vc_palette[i] = 16 * vc->vc_par[j++];
|
|
|
|
|
vc->vc_palette[i++] += vc->vc_par[j++];
|
|
|
|
|
vc->vc_palette[i] = 16 * vc->vc_par[j++];
|
|
|
|
|
vc->vc_palette[i] += vc->vc_par[j];
|
|
|
|
|
set_palette(vc);
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
|
|
|
|
case ESsquare:
|
|
|
|
|
for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
|
|
|
|
|
vc->vc_par[vc->vc_npar] = 0;
|
|
|
|
|
vc->vc_npar = 0;
|
|
|
|
|
vc->vc_state = ESgetpars;
|
|
|
|
|
if (c == '[') { /* Function key */
|
|
|
|
|
vc->vc_state=ESfunckey;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2018-12-15 17:34:21 +03:00
|
|
|
switch (c) {
|
|
|
|
|
case '?':
|
|
|
|
|
vc->vc_priv = EPdec;
|
|
|
|
|
return;
|
|
|
|
|
case '>':
|
|
|
|
|
vc->vc_priv = EPgt;
|
|
|
|
|
return;
|
|
|
|
|
case '=':
|
|
|
|
|
vc->vc_priv = EPeq;
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
2018-12-15 17:34:21 +03:00
|
|
|
case '<':
|
|
|
|
|
vc->vc_priv = EPlt;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
vc->vc_priv = EPecma;
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2005-04-17 02:20:36 +04:00
|
|
|
case ESgetpars:
|
|
|
|
|
if (c == ';' && vc->vc_npar < NPAR - 1) {
|
|
|
|
|
vc->vc_npar++;
|
|
|
|
|
return;
|
|
|
|
|
} else if (c>='0' && c<='9') {
|
|
|
|
|
vc->vc_par[vc->vc_npar] *= 10;
|
|
|
|
|
vc->vc_par[vc->vc_npar] += c - '0';
|
|
|
|
|
return;
|
2014-02-19 04:40:16 +04:00
|
|
|
}
|
2018-12-15 17:34:23 +03:00
|
|
|
if (c >= 0x20 && c <= 0x3f) { /* 0x2x, 0x3a and 0x3c - 0x3f */
|
2018-12-15 17:34:22 +03:00
|
|
|
vc->vc_state = EScsiignore;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
switch(c) {
|
|
|
|
|
case 'h':
|
2018-12-15 17:34:21 +03:00
|
|
|
if (vc->vc_priv <= EPdec)
|
|
|
|
|
set_mode(vc, 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'l':
|
2018-12-15 17:34:21 +03:00
|
|
|
if (vc->vc_priv <= EPdec)
|
|
|
|
|
set_mode(vc, 0);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'c':
|
2018-12-15 17:34:20 +03:00
|
|
|
if (vc->vc_priv == EPdec) {
|
2005-04-17 02:20:36 +04:00
|
|
|
if (vc->vc_par[0])
|
2020-06-15 10:48:58 +03:00
|
|
|
vc->vc_cursor_type =
|
|
|
|
|
CUR_MAKE(vc->vc_par[0],
|
|
|
|
|
vc->vc_par[1],
|
|
|
|
|
vc->vc_par[2]);
|
2005-04-17 02:20:36 +04:00
|
|
|
else
|
2009-12-16 03:45:39 +03:00
|
|
|
vc->vc_cursor_type = cur_default;
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'm':
|
2018-12-15 17:34:20 +03:00
|
|
|
if (vc->vc_priv == EPdec) {
|
2005-04-17 02:20:36 +04:00
|
|
|
clear_selection();
|
|
|
|
|
if (vc->vc_par[0])
|
|
|
|
|
vc->vc_complement_mask = vc->vc_par[0] << 8 | vc->vc_par[1];
|
|
|
|
|
else
|
|
|
|
|
vc->vc_complement_mask = vc->vc_s_complement_mask;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'n':
|
2018-12-15 17:34:20 +03:00
|
|
|
if (vc->vc_priv == EPecma) {
|
2005-04-17 02:20:36 +04:00
|
|
|
if (vc->vc_par[0] == 5)
|
|
|
|
|
status_report(tty);
|
|
|
|
|
else if (vc->vc_par[0] == 6)
|
|
|
|
|
cursor_report(vc, tty);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
2018-12-15 17:34:20 +03:00
|
|
|
if (vc->vc_priv != EPecma) {
|
|
|
|
|
vc->vc_priv = EPecma;
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
switch(c) {
|
|
|
|
|
case 'G': case '`':
|
|
|
|
|
if (vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]--;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->vc_par[0], vc->state.y);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'A':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->state.x, vc->state.y - vc->vc_par[0]);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'B': case 'e':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->state.x, vc->state.y + vc->vc_par[0]);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'C': case 'a':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->state.x + vc->vc_par[0], vc->state.y);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'D':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->state.x - vc->vc_par[0], vc->state.y);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'E':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, 0, vc->state.y + vc->vc_par[0]);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'F':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, 0, vc->state.y - vc->vc_par[0]);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'd':
|
|
|
|
|
if (vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]--;
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxay(vc, vc->state.x ,vc->vc_par[0]);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'H': case 'f':
|
|
|
|
|
if (vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]--;
|
|
|
|
|
if (vc->vc_par[1])
|
|
|
|
|
vc->vc_par[1]--;
|
|
|
|
|
gotoxay(vc, vc->vc_par[1], vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case 'J':
|
|
|
|
|
csi_J(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case 'K':
|
|
|
|
|
csi_K(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case 'L':
|
|
|
|
|
csi_L(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case 'M':
|
|
|
|
|
csi_M(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case 'P':
|
|
|
|
|
csi_P(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case 'c':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
respond_ID(tty);
|
|
|
|
|
return;
|
|
|
|
|
case 'g':
|
2020-06-15 10:48:38 +03:00
|
|
|
if (!vc->vc_par[0] && vc->state.x < VC_TABSTOPS_COUNT)
|
|
|
|
|
set_bit(vc->state.x, vc->vc_tab_stop);
|
|
|
|
|
else if (vc->vc_par[0] == 3)
|
|
|
|
|
bitmap_zero(vc->vc_tab_stop, VC_TABSTOPS_COUNT);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
case 'm':
|
|
|
|
|
csi_m(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 'q': /* DECLL - but only 3 leds */
|
|
|
|
|
/* map 0,1,2,3 to 0,1,2,4 */
|
|
|
|
|
if (vc->vc_par[0] < 4)
|
2012-02-28 18:49:23 +04:00
|
|
|
vt_set_led_state(vc->vc_num,
|
2005-04-17 02:20:36 +04:00
|
|
|
(vc->vc_par[0] < 3) ? vc->vc_par[0] : 4);
|
|
|
|
|
return;
|
|
|
|
|
case 'r':
|
|
|
|
|
if (!vc->vc_par[0])
|
|
|
|
|
vc->vc_par[0]++;
|
|
|
|
|
if (!vc->vc_par[1])
|
|
|
|
|
vc->vc_par[1] = vc->vc_rows;
|
|
|
|
|
/* Minimum allowed region is 2 lines */
|
|
|
|
|
if (vc->vc_par[0] < vc->vc_par[1] &&
|
|
|
|
|
vc->vc_par[1] <= vc->vc_rows) {
|
|
|
|
|
vc->vc_top = vc->vc_par[0] - 1;
|
|
|
|
|
vc->vc_bottom = vc->vc_par[1];
|
|
|
|
|
gotoxay(vc, 0, 0);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
case 's':
|
|
|
|
|
save_cur(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 'u':
|
|
|
|
|
restore_cur(vc);
|
|
|
|
|
return;
|
|
|
|
|
case 'X':
|
|
|
|
|
csi_X(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case '@':
|
|
|
|
|
csi_at(vc, vc->vc_par[0]);
|
|
|
|
|
return;
|
|
|
|
|
case ']': /* setterm functions */
|
|
|
|
|
setterm_command(vc);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
return;
|
2018-12-15 17:34:22 +03:00
|
|
|
case EScsiignore:
|
|
|
|
|
if (c >= 20 && c <= 0x3f)
|
|
|
|
|
return;
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
case ESpercent:
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
switch (c) {
|
|
|
|
|
case '@': /* defined in ISO 2022 */
|
|
|
|
|
vc->vc_utf = 0;
|
|
|
|
|
return;
|
|
|
|
|
case 'G': /* prelim official escape code */
|
|
|
|
|
case '8': /* retained for compatibility */
|
|
|
|
|
vc->vc_utf = 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
case ESfunckey:
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
|
|
|
|
case EShash:
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
if (c == '8') {
|
|
|
|
|
/* DEC screen alignment test. kludge :-) */
|
|
|
|
|
vc->vc_video_erase_char =
|
|
|
|
|
(vc->vc_video_erase_char & 0xff00) | 'E';
|
|
|
|
|
csi_J(vc, 2);
|
|
|
|
|
vc->vc_video_erase_char =
|
|
|
|
|
(vc->vc_video_erase_char & 0xff00) | ' ';
|
|
|
|
|
do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
case ESsetG0:
|
2020-06-15 10:48:36 +03:00
|
|
|
vc_setGx(vc, 0, c);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
|
|
|
|
case ESsetG1:
|
2020-06-15 10:48:36 +03:00
|
|
|
vc_setGx(vc, 1, c);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
return;
|
2014-02-19 04:38:04 +04:00
|
|
|
case ESosc:
|
|
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
default:
|
|
|
|
|
vc->vc_state = ESnormal;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
/* is_double_width() is based on the wcwidth() implementation by
|
console UTF-8 fixes (fix)
Recently my console UTF-8 patch went mainline. Here is an additional patch
that fixes two nasty issues and improves a third one, namely:
1. My patch changed the behavior if a glyph is not found in the Unicode
mapping table. Previously for Unicode values less than 256 or 512 the
kernel tried to display the glyph from that position of the glyph table,
which could lead to a different accented letter being displayed. I
removed this fallback possibility and changed it to display the
replacement symbol.
As Behdad pointed out, some fonts (e.g. sun12x22 from the kbd package)
lack Unicode mapping information, hence all you get is lots of question
marks. Though theoretically it's actually a user-space bug (the font
should be fixed), Behdad and I both believe that it'd be good to work
around in the kernel by re-introducing the fallback solution for ASCII
characters only. This sounds a quite reasonable decision, since all fonts
ship the ASCII characters in the first 128 positions. This way users
won't be surprised by lots of question marks just because s/he issued a
not-so-perfectly parameterized setfont command. As this fallback is only
re-introduced for code points below 128, you still won't see an accented
letter replaced by another, but at least you'll always get the English
letters right.
2. My patch introduced "question mark with inverted color attributes" as a
last resort fallback glyph. Though it perfectly works on VGA console, on
framebuffer you may end up with question marks that are highlighed but
shouldn't be, and normal characters that are accidentally highlighed.
This is caused by missing FLUSHes when changing the color attribute.
3. I've updated the table of double-width character based on Markus's
updated version. Only ten new code poings (one interval) is added.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-24 04:16:27 +04:00
|
|
|
* Markus Kuhn -- 2007-05-26 (Unicode 5.0)
|
2020-07-18 16:34:52 +03:00
|
|
|
* Latest version: https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
*/
|
|
|
|
|
struct interval {
|
|
|
|
|
uint32_t first;
|
|
|
|
|
uint32_t last;
|
|
|
|
|
};
|
|
|
|
|
|
2017-09-16 11:03:05 +03:00
|
|
|
static int ucs_cmp(const void *key, const void *elt)
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
{
|
2017-09-16 11:03:05 +03:00
|
|
|
uint32_t ucs = *(uint32_t *)key;
|
|
|
|
|
struct interval e = *(struct interval *) elt;
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
|
2017-09-16 11:03:05 +03:00
|
|
|
if (ucs > e.last)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (ucs < e.first)
|
|
|
|
|
return -1;
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int is_double_width(uint32_t ucs)
|
|
|
|
|
{
|
|
|
|
|
static const struct interval double_width[] = {
|
|
|
|
|
{ 0x1100, 0x115F }, { 0x2329, 0x232A }, { 0x2E80, 0x303E },
|
|
|
|
|
{ 0x3040, 0xA4CF }, { 0xAC00, 0xD7A3 }, { 0xF900, 0xFAFF },
|
console UTF-8 fixes (fix)
Recently my console UTF-8 patch went mainline. Here is an additional patch
that fixes two nasty issues and improves a third one, namely:
1. My patch changed the behavior if a glyph is not found in the Unicode
mapping table. Previously for Unicode values less than 256 or 512 the
kernel tried to display the glyph from that position of the glyph table,
which could lead to a different accented letter being displayed. I
removed this fallback possibility and changed it to display the
replacement symbol.
As Behdad pointed out, some fonts (e.g. sun12x22 from the kbd package)
lack Unicode mapping information, hence all you get is lots of question
marks. Though theoretically it's actually a user-space bug (the font
should be fixed), Behdad and I both believe that it'd be good to work
around in the kernel by re-introducing the fallback solution for ASCII
characters only. This sounds a quite reasonable decision, since all fonts
ship the ASCII characters in the first 128 positions. This way users
won't be surprised by lots of question marks just because s/he issued a
not-so-perfectly parameterized setfont command. As this fallback is only
re-introduced for code points below 128, you still won't see an accented
letter replaced by another, but at least you'll always get the English
letters right.
2. My patch introduced "question mark with inverted color attributes" as a
last resort fallback glyph. Though it perfectly works on VGA console, on
framebuffer you may end up with question marks that are highlighed but
shouldn't be, and normal characters that are accidentally highlighed.
This is caused by missing FLUSHes when changing the color attribute.
3. I've updated the table of double-width character based on Markus's
updated version. Only ten new code poings (one interval) is added.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-24 04:16:27 +04:00
|
|
|
{ 0xFE10, 0xFE19 }, { 0xFE30, 0xFE6F }, { 0xFF00, 0xFF60 },
|
|
|
|
|
{ 0xFFE0, 0xFFE6 }, { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD }
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
};
|
2017-09-16 11:03:05 +03:00
|
|
|
if (ucs < double_width[0].first ||
|
|
|
|
|
ucs > double_width[ARRAY_SIZE(double_width) - 1].last)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return bsearch(&ucs, double_width, ARRAY_SIZE(double_width),
|
|
|
|
|
sizeof(struct interval), ucs_cmp) != NULL;
|
console UTF-8 fixes
The UTF-8 part of the vt driver suffers from the following issues which are
addressed in my patch:
1) If there's no glyph found for a particular valid UTF-8 character, we try
to display U+FFFD. However if this one is not found either, here's what
the current kernel does:
- First, if the Unicode value is less than the number of glyphs, use the
glyph directly from that position of the glyph table. While it may be a
good idea in the 8-bit world, it has absolutely no sense with Unicode
in mind. For example, if a Latin-2 font is loaded and an application
prints U+00FB ("u with circumflex", not present in Latin-2) then as a
fallback solution the glyph from the 0xFB position of the Latin-2
fontset (which is an "u with double accent" - a different character) is
displayed.
- Second, if this fallback fails too, a simple ASCII question mark is
printed, which is visually undistinguishable from a real question mark.
I changed the code to skip the first step (except if in non-UTF-8 mode),
and changed the second step to print the question mark with inverse color
attributes, so it is visually clear that it's not a real question mark,
and resembles more to the common glyph of U+FFFD.
2) The UTF-8 decoder is buggy in many ways:
- Lone continuation bytes (section 3.1 of Markus Kuhn's UTF-8 stress
test) are not caught, they are displayed as some "random" (taken
directly form the font table, see above) glyphs instead the replacement
character.
- Incomplete sequences (sections 3.2 and 3.3 of the stress test) emit no
replacement character, but rather cause the subsequent valid character
to be displayed more times(!).
- The decoder is not safe: overlong sequences are not caught currently,
they are displayed as if these were valid representations. This may
even have security impacts.
- The decoder does not handle D800..DFFF and FFFE..FFFF specially, it
just emits these code points and lets it be looked up in the glyph
table. Since these are invalid code points, I replace them by U+FFFD
and hence give no chance for them to be looked up in the glyph table.
(Assuming no font ships glyphs for these code points, this change is
not visible to the users since the glyph shown will be the same.)
With my fixes to the decoder it now behaves exactly as Markus Kuhn's
stress test recommends.
3) It has no concept of double-width (CJK) characters. It's way beyond the
scope of my patch to try to display them, but at least I think it's
important for the cursor to jump two positions when printing such
characters, since this is what applications (such as text editors)
expect. Currently the cursor only jumps one position, and hence
applications suffer from displaying and refreshing problems, and editing
some English letters that are preceded by some CJK characters in the same
line is a nightmare. With my patch an additional space is inserted after
the CJK character has been printed (which usually means a replacement
symbol of course). (If U+FFFD isn't availble and hence an inverse
question mark is displayed in the first cell, I keep the inverted state
for the space in the 2nd column so it's quite easy to see that they are
tied together.)
4) There is a small built-in table of zero-width spaces that are not to be
printed but silently skipped. U+200A is included there, but it's not a
zero-width character, so I remove it from there.
Signed-off-by: Egmont Koblinger <egmont@uhulinux.hu>
Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 11:30:37 +04:00
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:49 +03:00
|
|
|
struct vc_draw_region {
|
|
|
|
|
unsigned long from, to;
|
|
|
|
|
int x;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void con_flush(struct vc_data *vc, struct vc_draw_region *draw)
|
2016-06-23 14:34:30 +03:00
|
|
|
{
|
2020-06-15 10:48:49 +03:00
|
|
|
if (draw->x < 0)
|
2016-06-23 14:34:30 +03:00
|
|
|
return;
|
|
|
|
|
|
2020-06-15 10:48:49 +03:00
|
|
|
vc->vc_sw->con_putcs(vc, (u16 *)draw->from,
|
|
|
|
|
(u16 *)draw->to - (u16 *)draw->from, vc->state.y,
|
|
|
|
|
draw->x);
|
|
|
|
|
draw->x = -1;
|
2016-06-23 14:34:30 +03:00
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:42 +03:00
|
|
|
static inline int vc_translate_ascii(const struct vc_data *vc, int c)
|
|
|
|
|
{
|
|
|
|
|
if (IS_ENABLED(CONFIG_CONSOLE_TRANSLATIONS)) {
|
|
|
|
|
if (vc->vc_toggle_meta)
|
|
|
|
|
c |= 0x80;
|
|
|
|
|
|
|
|
|
|
return vc->vc_translate[c];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return c;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:45 +03:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* vc_sanitize_unicode -- Replace invalid Unicode code points with U+FFFD
|
|
|
|
|
* @c: the received character, or U+FFFD for invalid sequences.
|
|
|
|
|
*/
|
|
|
|
|
static inline int vc_sanitize_unicode(const int c)
|
|
|
|
|
{
|
|
|
|
|
if ((c >= 0xd800 && c <= 0xdfff) || c == 0xfffe || c == 0xffff)
|
|
|
|
|
return 0xfffd;
|
|
|
|
|
|
|
|
|
|
return c;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:44 +03:00
|
|
|
/**
|
|
|
|
|
* vc_translate_unicode -- Combine UTF-8 into Unicode in @vc_utf_char
|
2020-08-18 11:56:53 +03:00
|
|
|
* @vc: virtual console
|
|
|
|
|
* @c: character to translate
|
|
|
|
|
* @rescan: we return true if we need more (continuation) data
|
2020-06-15 10:48:44 +03:00
|
|
|
*
|
|
|
|
|
* @vc_utf_char is the being-constructed unicode character.
|
|
|
|
|
* @vc_utf_count is the number of continuation bytes still expected to arrive.
|
|
|
|
|
* @vc_npar is the number of continuation bytes arrived so far.
|
|
|
|
|
*/
|
|
|
|
|
static int vc_translate_unicode(struct vc_data *vc, int c, bool *rescan)
|
|
|
|
|
{
|
|
|
|
|
static const u32 utf8_length_changes[] = {
|
|
|
|
|
0x0000007f, 0x000007ff, 0x0000ffff,
|
|
|
|
|
0x001fffff, 0x03ffffff, 0x7fffffff
|
|
|
|
|
};
|
|
|
|
|
|
2020-06-15 10:48:45 +03:00
|
|
|
/* Continuation byte received */
|
2020-06-15 10:48:44 +03:00
|
|
|
if ((c & 0xc0) == 0x80) {
|
2020-06-15 10:48:45 +03:00
|
|
|
/* Unexpected continuation byte? */
|
|
|
|
|
if (!vc->vc_utf_count)
|
2020-06-15 10:48:44 +03:00
|
|
|
return 0xfffd;
|
2020-06-15 10:48:45 +03:00
|
|
|
|
|
|
|
|
vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
|
|
|
|
|
vc->vc_npar++;
|
|
|
|
|
if (--vc->vc_utf_count)
|
|
|
|
|
goto need_more_bytes;
|
|
|
|
|
|
|
|
|
|
/* Got a whole character */
|
|
|
|
|
c = vc->vc_utf_char;
|
|
|
|
|
/* Reject overlong sequences */
|
|
|
|
|
if (c <= utf8_length_changes[vc->vc_npar - 1] ||
|
|
|
|
|
c > utf8_length_changes[vc->vc_npar])
|
2020-06-15 10:48:44 +03:00
|
|
|
return 0xfffd;
|
2020-06-15 10:48:45 +03:00
|
|
|
|
|
|
|
|
return vc_sanitize_unicode(c);
|
2020-06-15 10:48:44 +03:00
|
|
|
}
|
2020-06-15 10:48:45 +03:00
|
|
|
|
|
|
|
|
/* Single ASCII byte or first byte of a sequence received */
|
|
|
|
|
if (vc->vc_utf_count) {
|
|
|
|
|
/* Continuation byte expected */
|
|
|
|
|
*rescan = true;
|
|
|
|
|
vc->vc_utf_count = 0;
|
2020-06-15 10:48:44 +03:00
|
|
|
return 0xfffd;
|
2020-06-15 10:48:45 +03:00
|
|
|
}
|
2020-06-15 10:48:44 +03:00
|
|
|
|
2020-06-15 10:48:45 +03:00
|
|
|
/* Nothing to do if an ASCII byte was received */
|
|
|
|
|
if (c <= 0x7f)
|
|
|
|
|
return c;
|
|
|
|
|
|
|
|
|
|
/* First byte of a multibyte sequence received */
|
|
|
|
|
vc->vc_npar = 0;
|
|
|
|
|
if ((c & 0xe0) == 0xc0) {
|
|
|
|
|
vc->vc_utf_count = 1;
|
|
|
|
|
vc->vc_utf_char = (c & 0x1f);
|
|
|
|
|
} else if ((c & 0xf0) == 0xe0) {
|
|
|
|
|
vc->vc_utf_count = 2;
|
|
|
|
|
vc->vc_utf_char = (c & 0x0f);
|
|
|
|
|
} else if ((c & 0xf8) == 0xf0) {
|
|
|
|
|
vc->vc_utf_count = 3;
|
|
|
|
|
vc->vc_utf_char = (c & 0x07);
|
|
|
|
|
} else if ((c & 0xfc) == 0xf8) {
|
|
|
|
|
vc->vc_utf_count = 4;
|
|
|
|
|
vc->vc_utf_char = (c & 0x03);
|
|
|
|
|
} else if ((c & 0xfe) == 0xfc) {
|
|
|
|
|
vc->vc_utf_count = 5;
|
|
|
|
|
vc->vc_utf_char = (c & 0x01);
|
|
|
|
|
} else {
|
|
|
|
|
/* 254 and 255 are invalid */
|
|
|
|
|
return 0xfffd;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
need_more_bytes:
|
|
|
|
|
return -1;
|
2020-06-15 10:48:44 +03:00
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:48 +03:00
|
|
|
static int vc_translate(struct vc_data *vc, int *c, bool *rescan)
|
|
|
|
|
{
|
|
|
|
|
/* Do no translation at all in control states */
|
|
|
|
|
if (vc->vc_state != ESnormal)
|
|
|
|
|
return *c;
|
|
|
|
|
|
|
|
|
|
if (vc->vc_utf && !vc->vc_disp_ctrl)
|
|
|
|
|
return *c = vc_translate_unicode(vc, *c, rescan);
|
|
|
|
|
|
|
|
|
|
/* no utf or alternate charset mode */
|
|
|
|
|
return vc_translate_ascii(vc, *c);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:46 +03:00
|
|
|
static inline unsigned char vc_invert_attr(const struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
if (!vc->vc_can_do_color)
|
|
|
|
|
return vc->vc_attr ^ 0x08;
|
|
|
|
|
|
|
|
|
|
if (vc->vc_hi_font_mask == 0x100)
|
|
|
|
|
return (vc->vc_attr & 0x11) |
|
|
|
|
|
((vc->vc_attr & 0xe0) >> 4) |
|
|
|
|
|
((vc->vc_attr & 0x0e) << 4);
|
|
|
|
|
|
|
|
|
|
return (vc->vc_attr & 0x88) |
|
|
|
|
|
((vc->vc_attr & 0x70) >> 4) |
|
|
|
|
|
((vc->vc_attr & 0x07) << 4);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:50 +03:00
|
|
|
static bool vc_is_control(struct vc_data *vc, int tc, int c)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* A bitmap for codes <32. A bit of 1 indicates that the code
|
|
|
|
|
* corresponding to that bit number invokes some special action (such
|
|
|
|
|
* as cursor movement) and should not be displayed as a glyph unless
|
|
|
|
|
* the disp_ctrl mode is explicitly enabled.
|
|
|
|
|
*/
|
|
|
|
|
static const u32 CTRL_ACTION = 0x0d00ff81;
|
|
|
|
|
/* Cannot be overridden by disp_ctrl */
|
|
|
|
|
static const u32 CTRL_ALWAYS = 0x0800f501;
|
|
|
|
|
|
|
|
|
|
if (vc->vc_state != ESnormal)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
if (!tc)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If the original code was a control character we only allow a glyph
|
|
|
|
|
* to be displayed if the code is not normally used (such as for cursor
|
|
|
|
|
* movement) or if the disp_ctrl mode has been explicitly enabled.
|
|
|
|
|
* Certain characters (as given by the CTRL_ALWAYS bitmap) are always
|
|
|
|
|
* displayed as control characters, as the console would be pretty
|
|
|
|
|
* useless without them; to display an arbitrary font position use the
|
|
|
|
|
* direct-to-font zone in UTF-8 mode.
|
|
|
|
|
*/
|
|
|
|
|
if (c < 32) {
|
|
|
|
|
if (vc->vc_disp_ctrl)
|
|
|
|
|
return CTRL_ALWAYS & BIT(c);
|
|
|
|
|
else
|
|
|
|
|
return vc->vc_utf || (CTRL_ACTION & BIT(c));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (c == 127 && !vc->vc_disp_ctrl)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
if (c == 128 + 27)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-15 10:48:51 +03:00
|
|
|
static int vc_con_write_normal(struct vc_data *vc, int tc, int c,
|
|
|
|
|
struct vc_draw_region *draw)
|
|
|
|
|
{
|
|
|
|
|
int next_c;
|
2020-06-15 10:48:53 +03:00
|
|
|
unsigned char vc_attr = vc->vc_attr;
|
2020-06-15 10:48:51 +03:00
|
|
|
u16 himask = vc->vc_hi_font_mask, charmask = himask ? 0x1ff : 0xff;
|
|
|
|
|
u8 width = 1;
|
|
|
|
|
bool inverse = false;
|
|
|
|
|
|
|
|
|
|
if (vc->vc_utf && !vc->vc_disp_ctrl) {
|
|
|
|
|
if (is_double_width(c))
|
|
|
|
|
width = 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now try to find out how to display it */
|
|
|
|
|
tc = conv_uni_to_pc(vc, tc);
|
|
|
|
|
if (tc & ~charmask) {
|
|
|
|
|
if (tc == -1 || tc == -2)
|
|
|
|
|
return -1; /* nothing to display */
|
|
|
|
|
|
|
|
|
|
/* Glyph not found */
|
2020-06-15 10:48:52 +03:00
|
|
|
if ((!vc->vc_utf || vc->vc_disp_ctrl || c < 128) &&
|
2020-06-15 10:48:51 +03:00
|
|
|
!(c & ~charmask)) {
|
|
|
|
|
/*
|
|
|
|
|
* In legacy mode use the glyph we get by a 1:1
|
|
|
|
|
* mapping.
|
|
|
|
|
* This would make absolutely no sense with Unicode in
|
|
|
|
|
* mind, but do this for ASCII characters since a font
|
|
|
|
|
* may lack Unicode mapping info and we don't want to
|
|
|
|
|
* end up with having question marks only.
|
|
|
|
|
*/
|
|
|
|
|
tc = c;
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Display U+FFFD. If it's not found, display an inverse
|
|
|
|
|
* question mark.
|
|
|
|
|
*/
|
|
|
|
|
tc = conv_uni_to_pc(vc, 0xfffd);
|
|
|
|
|
if (tc < 0) {
|
|
|
|
|
inverse = true;
|
|
|
|
|
tc = conv_uni_to_pc(vc, '?');
|
|
|
|
|
if (tc < 0)
|
|
|
|
|
tc = '?';
|
2020-06-15 10:48:53 +03:00
|
|
|
|
|
|
|
|
vc_attr = vc_invert_attr(vc);
|
|
|
|
|
con_flush(vc, draw);
|
2020-06-15 10:48:51 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
next_c = c;
|
|
|
|
|
while (1) {
|
|
|
|
|
if (vc->vc_need_wrap || vc->vc_decim)
|
|
|
|
|
con_flush(vc, draw);
|
|
|
|
|
if (vc->vc_need_wrap) {
|
|
|
|
|
cr(vc);
|
|
|
|
|
lf(vc);
|
|
|
|
|
}
|
|
|
|
|
if (vc->vc_decim)
|
|
|
|
|
insert_char(vc, 1);
|
|
|
|
|
vc_uniscr_putc(vc, next_c);
|
2020-06-15 10:48:54 +03:00
|
|
|
|
|
|
|
|
if (himask)
|
|
|
|
|
tc = ((tc & 0x100) ? himask : 0) |
|
|
|
|
|
(tc & 0xff);
|
|
|
|
|
tc |= (vc_attr << 8) & ~himask;
|
|
|
|
|
|
|
|
|
|
scr_writew(tc, (u16 *)vc->vc_pos);
|
|
|
|
|
|
2020-06-15 10:48:51 +03:00
|
|
|
if (con_should_update(vc) && draw->x < 0) {
|
|
|
|
|
draw->x = vc->state.x;
|
|
|
|
|
draw->from = vc->vc_pos;
|
|
|
|
|
}
|
|
|
|
|
if (vc->state.x == vc->vc_cols - 1) {
|
|
|
|
|
vc->vc_need_wrap = vc->vc_decawm;
|
|
|
|
|
draw->to = vc->vc_pos + 2;
|
|
|
|
|
} else {
|
|
|
|
|
vc->state.x++;
|
|
|
|
|
draw->to = (vc->vc_pos += 2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!--width)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* A space is printed in the second column */
|
|
|
|
|
tc = conv_uni_to_pc(vc, ' ');
|
|
|
|
|
if (tc < 0)
|
|
|
|
|
tc = ' ';
|
|
|
|
|
next_c = ' ';
|
|
|
|
|
}
|
|
|
|
|
notify_write(vc, c);
|
|
|
|
|
|
|
|
|
|
if (inverse)
|
|
|
|
|
con_flush(vc, draw);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
/* acquires console_lock */
|
2005-04-17 02:20:36 +04:00
|
|
|
static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int count)
|
|
|
|
|
{
|
2020-06-15 10:48:49 +03:00
|
|
|
struct vc_draw_region draw = {
|
|
|
|
|
.x = -1,
|
|
|
|
|
};
|
2020-06-15 10:48:51 +03:00
|
|
|
int c, tc, n = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int currcons;
|
|
|
|
|
struct vc_data *vc;
|
2008-04-28 13:14:25 +04:00
|
|
|
struct vt_notifier_param param;
|
2020-06-15 10:48:43 +03:00
|
|
|
bool rescan;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (in_interrupt())
|
|
|
|
|
return count;
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
vc = tty->driver_data;
|
|
|
|
|
if (vc == NULL) {
|
2017-10-02 18:48:55 +03:00
|
|
|
pr_err("vt: argh, driver_data is NULL !\n");
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
currcons = vc->vc_num;
|
|
|
|
|
if (!vc_cons_allocated(currcons)) {
|
2011-02-06 20:31:53 +03:00
|
|
|
/* could this happen? */
|
|
|
|
|
pr_warn_once("con_write: tty %d not allocated\n", currcons+1);
|
|
|
|
|
console_unlock();
|
|
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* undraw cursor first */
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_is_fg(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
hide_cursor(vc);
|
|
|
|
|
|
2008-04-28 13:14:25 +04:00
|
|
|
param.vc = vc;
|
|
|
|
|
|
2021-05-05 12:19:05 +03:00
|
|
|
while (!tty->flow.stopped && count) {
|
2005-04-17 02:20:36 +04:00
|
|
|
int orig = *buf;
|
|
|
|
|
buf++;
|
|
|
|
|
n++;
|
|
|
|
|
count--;
|
2020-06-15 10:48:47 +03:00
|
|
|
rescan_last_byte:
|
|
|
|
|
c = orig;
|
2020-06-15 10:48:43 +03:00
|
|
|
rescan = false;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-06-15 10:48:48 +03:00
|
|
|
tc = vc_translate(vc, &c, &rescan);
|
|
|
|
|
if (tc == -1)
|
|
|
|
|
continue;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-04-28 13:14:25 +04:00
|
|
|
param.c = tc;
|
|
|
|
|
if (atomic_notifier_call_chain(&vt_notifier_list, VT_PREWRITE,
|
|
|
|
|
¶m) == NOTIFY_STOP)
|
|
|
|
|
continue;
|
|
|
|
|
|
2020-06-15 10:48:51 +03:00
|
|
|
if (vc_is_control(vc, tc, c)) {
|
|
|
|
|
con_flush(vc, &draw);
|
|
|
|
|
do_con_trol(tty, vc, orig);
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
|
|
|
|
}
|
2020-06-15 10:48:51 +03:00
|
|
|
|
|
|
|
|
if (vc_con_write_normal(vc, tc, c, &draw) < 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (rescan)
|
|
|
|
|
goto rescan_last_byte;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2020-06-15 10:48:49 +03:00
|
|
|
con_flush(vc, &draw);
|
2018-07-18 04:02:41 +03:00
|
|
|
vc_uniscr_debug_check(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
console_conditional_schedule();
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_update(vc);
|
2019-01-09 06:55:00 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
return n;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is the console switching callback.
|
|
|
|
|
*
|
|
|
|
|
* Doing console switching in a process context allows
|
|
|
|
|
* us to do the switches asynchronously (needed when we want
|
|
|
|
|
* to switch due to a keyboard interrupt). Synchronization
|
|
|
|
|
* with other console code and prevention of re-entrancy is
|
2011-01-26 02:07:35 +03:00
|
|
|
* ensured with console_lock.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2006-11-22 17:55:48 +03:00
|
|
|
static void console_callback(struct work_struct *ignored)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (want_console >= 0) {
|
|
|
|
|
if (want_console != fg_console &&
|
|
|
|
|
vc_cons_allocated(want_console)) {
|
|
|
|
|
hide_cursor(vc_cons[fg_console].d);
|
|
|
|
|
change_console(vc_cons[want_console].d);
|
|
|
|
|
/* we only changed when the console had already
|
|
|
|
|
been allocated - a new console is not created
|
|
|
|
|
in an interrupt routine */
|
|
|
|
|
}
|
|
|
|
|
want_console = -1;
|
|
|
|
|
}
|
|
|
|
|
if (do_poke_blanked_console) { /* do not unblank for a LED change */
|
|
|
|
|
do_poke_blanked_console = 0;
|
|
|
|
|
poke_blanked_console();
|
|
|
|
|
}
|
|
|
|
|
if (scrollback_delta) {
|
|
|
|
|
struct vc_data *vc = vc_cons[fg_console].d;
|
|
|
|
|
clear_selection();
|
2016-06-23 14:34:26 +03:00
|
|
|
if (vc->vc_mode == KD_TEXT && vc->vc_sw->con_scrolldelta)
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_scrolldelta(vc, scrollback_delta);
|
|
|
|
|
scrollback_delta = 0;
|
|
|
|
|
}
|
|
|
|
|
if (blank_timer_expired) {
|
|
|
|
|
do_blank_screen(0);
|
|
|
|
|
blank_timer_expired = 0;
|
|
|
|
|
}
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_update(vc_cons[fg_console].d);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2007-03-17 00:38:24 +03:00
|
|
|
int set_console(int nr)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2007-03-17 00:38:24 +03:00
|
|
|
struct vc_data *vc = vc_cons[fg_console].d;
|
|
|
|
|
|
|
|
|
|
if (!vc_cons_allocated(nr) || vt_dont_switch ||
|
|
|
|
|
(vc->vt_mode.mode == VT_AUTO && vc->vc_mode == KD_GRAPHICS)) {
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Console switch will fail in console_callback() or
|
|
|
|
|
* change_console() so there is no point scheduling
|
|
|
|
|
* the callback
|
|
|
|
|
*
|
|
|
|
|
* Existing set_console() users don't check the return
|
|
|
|
|
* value so this shouldn't break anything
|
|
|
|
|
*/
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
want_console = nr;
|
|
|
|
|
schedule_console_callback();
|
2007-03-17 00:38:24 +03:00
|
|
|
|
|
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct tty_driver *console_driver;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_VT_CONSOLE
|
|
|
|
|
|
2009-12-15 05:00:43 +03:00
|
|
|
/**
|
|
|
|
|
* vt_kmsg_redirect() - Sets/gets the kernel message console
|
|
|
|
|
* @new: The new virtual terminal number or -1 if the console should stay
|
|
|
|
|
* unchanged
|
|
|
|
|
*
|
|
|
|
|
* By default, the kernel messages are always printed on the current virtual
|
|
|
|
|
* console. However, the user may modify that default with the
|
|
|
|
|
* TIOCL_SETKMSGREDIRECT ioctl call.
|
|
|
|
|
*
|
|
|
|
|
* This function sets the kernel message console to be @new. It returns the old
|
|
|
|
|
* virtual console number. The virtual terminal number 0 (both as parameter and
|
|
|
|
|
* return value) means no redirection (i.e. always printed on the currently
|
|
|
|
|
* active console).
|
|
|
|
|
*
|
|
|
|
|
* The parameter -1 means that only the current console is returned, but the
|
|
|
|
|
* value is not modified. You may use the macro vt_get_kmsg_redirect() in that
|
|
|
|
|
* case to make the code more understandable.
|
|
|
|
|
*
|
|
|
|
|
* When the kernel is compiled without CONFIG_VT_CONSOLE, this function ignores
|
|
|
|
|
* the parameter and always returns 0.
|
|
|
|
|
*/
|
|
|
|
|
int vt_kmsg_redirect(int new)
|
|
|
|
|
{
|
|
|
|
|
static int kmsg_con;
|
|
|
|
|
|
|
|
|
|
if (new != -1)
|
|
|
|
|
return xchg(&kmsg_con, new);
|
|
|
|
|
else
|
|
|
|
|
return kmsg_con;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* Console on virtual terminal
|
|
|
|
|
*
|
|
|
|
|
* The console must be locked when we get here.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void vt_console_print(struct console *co, const char *b, unsigned count)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = vc_cons[fg_console].d;
|
|
|
|
|
unsigned char c;
|
2008-02-06 12:37:04 +03:00
|
|
|
static DEFINE_SPINLOCK(printing_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
const ushort *start;
|
2019-01-09 06:54:59 +03:00
|
|
|
ushort start_x, cnt;
|
2009-12-15 05:00:43 +03:00
|
|
|
int kmsg_console;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/* console busy or not yet initialized */
|
2008-02-06 12:37:04 +03:00
|
|
|
if (!printable)
|
|
|
|
|
return;
|
|
|
|
|
if (!spin_trylock(&printing_lock))
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
|
2009-12-15 05:00:43 +03:00
|
|
|
kmsg_console = vt_get_kmsg_redirect();
|
|
|
|
|
if (kmsg_console && vc_cons_allocated(kmsg_console - 1))
|
|
|
|
|
vc = vc_cons[kmsg_console - 1].d;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (!vc_cons_allocated(fg_console)) {
|
|
|
|
|
/* impossible */
|
|
|
|
|
/* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */
|
|
|
|
|
goto quit;
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-22 11:54:03 +03:00
|
|
|
if (vc->vc_mode != KD_TEXT)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto quit;
|
|
|
|
|
|
|
|
|
|
/* undraw cursor first */
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_is_fg(vc))
|
2005-04-17 02:20:36 +04:00
|
|
|
hide_cursor(vc);
|
|
|
|
|
|
|
|
|
|
start = (ushort *)vc->vc_pos;
|
2020-06-15 10:48:33 +03:00
|
|
|
start_x = vc->state.x;
|
2019-01-09 06:54:59 +03:00
|
|
|
cnt = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
while (count--) {
|
|
|
|
|
c = *b++;
|
|
|
|
|
if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) {
|
2019-01-09 06:54:59 +03:00
|
|
|
if (cnt && con_is_visible(vc))
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_sw->con_putcs(vc, start, cnt, vc->state.y, start_x);
|
2019-01-09 06:54:59 +03:00
|
|
|
cnt = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (c == 8) { /* backspace */
|
|
|
|
|
bs(vc);
|
|
|
|
|
start = (ushort *)vc->vc_pos;
|
2020-06-15 10:48:33 +03:00
|
|
|
start_x = vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (c != 13)
|
|
|
|
|
lf(vc);
|
|
|
|
|
cr(vc);
|
|
|
|
|
start = (ushort *)vc->vc_pos;
|
2020-06-15 10:48:33 +03:00
|
|
|
start_x = vc->state.x;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (c == 10 || c == 13)
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2019-01-09 06:54:59 +03:00
|
|
|
vc_uniscr_putc(vc, c);
|
2005-04-17 02:20:36 +04:00
|
|
|
scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos);
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_write(vc, c);
|
2005-04-17 02:20:36 +04:00
|
|
|
cnt++;
|
2020-06-15 10:48:33 +03:00
|
|
|
if (vc->state.x == vc->vc_cols - 1) {
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_need_wrap = 1;
|
2019-01-09 06:54:59 +03:00
|
|
|
} else {
|
|
|
|
|
vc->vc_pos += 2;
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->state.x++;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
}
|
2019-01-09 06:54:59 +03:00
|
|
|
if (cnt && con_is_visible(vc))
|
2020-06-15 10:48:33 +03:00
|
|
|
vc->vc_sw->con_putcs(vc, start, cnt, vc->state.y, start_x);
|
2005-04-17 02:20:36 +04:00
|
|
|
set_cursor(vc);
|
2007-10-19 10:39:17 +04:00
|
|
|
notify_update(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
quit:
|
2008-02-06 12:37:04 +03:00
|
|
|
spin_unlock(&printing_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct tty_driver *vt_console_device(struct console *c, int *index)
|
|
|
|
|
{
|
|
|
|
|
*index = c->index ? c->index-1 : fg_console;
|
|
|
|
|
return console_driver;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct console vt_console_driver = {
|
|
|
|
|
.name = "tty",
|
|
|
|
|
.write = vt_console_print,
|
|
|
|
|
.device = vt_console_device,
|
|
|
|
|
.unblank = unblank_screen,
|
|
|
|
|
.flags = CON_PRINTBUFFER,
|
|
|
|
|
.index = -1,
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Handling of Linux-specific VC ioctls
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
2011-01-26 02:07:35 +03:00
|
|
|
* Generally a bit racy with respect to console_lock();.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
|
* There are some functions which don't need it.
|
|
|
|
|
*
|
|
|
|
|
* There are some functions which can sleep for arbitrary periods
|
|
|
|
|
* (paste_selection) but we don't need the lock there anyway.
|
|
|
|
|
*
|
2019-04-17 15:21:13 +03:00
|
|
|
* set_selection_user has locking, and definitely needs it
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int tioclinux(struct tty_struct *tty, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
char type, data;
|
|
|
|
|
char __user *p = (char __user *)arg;
|
|
|
|
|
int lines;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (current->signal->tty != tty && !capable(CAP_SYS_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
if (get_user(type, p))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
ret = 0;
|
2008-04-30 11:53:29 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
switch (type)
|
|
|
|
|
{
|
|
|
|
|
case TIOCL_SETSEL:
|
2019-04-17 15:21:13 +03:00
|
|
|
ret = set_selection_user((struct tiocl_selection
|
|
|
|
|
__user *)(p+1), tty);
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case TIOCL_PASTESEL:
|
|
|
|
|
ret = paste_selection(tty);
|
|
|
|
|
break;
|
|
|
|
|
case TIOCL_UNBLANKSCREEN:
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
unblank_screen();
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case TIOCL_SELLOADLUT:
|
2012-03-02 19:00:02 +04:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
ret = sel_loadlut(p);
|
2012-03-02 19:00:02 +04:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case TIOCL_GETSHIFTSTATE:
|
2008-04-30 11:53:29 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* Make it possible to react to Shift+Mousebutton.
|
|
|
|
|
* Note that 'shift_state' is an undocumented
|
|
|
|
|
* kernel-internal variable; programs not closely
|
|
|
|
|
* related to the kernel should not use this.
|
|
|
|
|
*/
|
2012-02-28 18:49:23 +04:00
|
|
|
data = vt_get_shift_state();
|
2017-06-03 10:35:06 +03:00
|
|
|
ret = put_user(data, p);
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case TIOCL_GETMOUSEREPORTING:
|
2012-03-02 18:59:37 +04:00
|
|
|
console_lock(); /* May be overkill */
|
2005-04-17 02:20:36 +04:00
|
|
|
data = mouse_reporting();
|
2012-03-02 18:59:37 +04:00
|
|
|
console_unlock();
|
2017-06-03 10:35:06 +03:00
|
|
|
ret = put_user(data, p);
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case TIOCL_SETVESABLANK:
|
2012-03-02 18:59:37 +04:00
|
|
|
console_lock();
|
2006-12-07 07:38:38 +03:00
|
|
|
ret = set_vesa_blanking(p);
|
2012-03-02 18:59:37 +04:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
2006-03-31 14:30:58 +04:00
|
|
|
case TIOCL_GETKMSGREDIRECT:
|
2009-12-15 05:00:43 +03:00
|
|
|
data = vt_get_kmsg_redirect();
|
2017-06-03 10:35:06 +03:00
|
|
|
ret = put_user(data, p);
|
2006-03-31 14:30:58 +04:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
case TIOCL_SETKMSGREDIRECT:
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
|
|
|
ret = -EPERM;
|
|
|
|
|
} else {
|
|
|
|
|
if (get_user(data, p+1))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
else
|
2009-12-15 05:00:43 +03:00
|
|
|
vt_kmsg_redirect(data);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case TIOCL_GETFGCONSOLE:
|
2012-03-02 18:59:37 +04:00
|
|
|
/* No locking needed as this is a transiently
|
|
|
|
|
correct return anyway if the caller hasn't
|
|
|
|
|
disabled switching */
|
2005-04-17 02:20:36 +04:00
|
|
|
ret = fg_console;
|
|
|
|
|
break;
|
|
|
|
|
case TIOCL_SCROLLCONSOLE:
|
|
|
|
|
if (get_user(lines, (s32 __user *)(p+4))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
} else {
|
2012-03-02 18:59:37 +04:00
|
|
|
/* Need the console lock here. Note that lots
|
|
|
|
|
of other calls need fixing before the lock
|
|
|
|
|
is actually useful ! */
|
|
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
scrollfront(vc_cons[fg_console].d, lines);
|
2012-03-02 18:59:37 +04:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
ret = 0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
ignore_poke = 1;
|
|
|
|
|
do_blank_screen(0);
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
|
case TIOCL_BLANKEDSCREEN:
|
|
|
|
|
ret = console_blanked;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* /dev/ttyN handling
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int con_write(struct tty_struct *tty, const unsigned char *buf, int count)
|
|
|
|
|
{
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
retval = do_con_write(tty, buf, count);
|
|
|
|
|
con_flush_chars(tty);
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-30 11:54:08 +04:00
|
|
|
static int con_put_char(struct tty_struct *tty, unsigned char ch)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2008-04-30 11:54:08 +04:00
|
|
|
return do_con_write(tty, &ch, 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2021-05-05 12:19:15 +03:00
|
|
|
static unsigned int con_write_room(struct tty_struct *tty)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2021-05-05 12:19:05 +03:00
|
|
|
if (tty->flow.stopped)
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
2009-01-02 16:40:53 +03:00
|
|
|
return 32768; /* No limit, really; we're not buffering */
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* con_throttle and con_unthrottle are only used for
|
|
|
|
|
* paste_selection(), which has to stuff in a large number of
|
|
|
|
|
* characters...
|
|
|
|
|
*/
|
|
|
|
|
static void con_throttle(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void con_unthrottle(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = tty->driver_data;
|
|
|
|
|
|
|
|
|
|
wake_up_interruptible(&vc->paste_wait);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Turn the Scroll-Lock LED on when the tty is stopped
|
|
|
|
|
*/
|
|
|
|
|
static void con_stop(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
int console_num;
|
|
|
|
|
if (!tty)
|
|
|
|
|
return;
|
|
|
|
|
console_num = tty->index;
|
|
|
|
|
if (!vc_cons_allocated(console_num))
|
|
|
|
|
return;
|
2012-02-28 18:49:23 +04:00
|
|
|
vt_kbd_con_stop(console_num);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Turn the Scroll-Lock LED off when the console is started
|
|
|
|
|
*/
|
|
|
|
|
static void con_start(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
int console_num;
|
|
|
|
|
if (!tty)
|
|
|
|
|
return;
|
|
|
|
|
console_num = tty->index;
|
|
|
|
|
if (!vc_cons_allocated(console_num))
|
|
|
|
|
return;
|
2012-02-28 18:49:23 +04:00
|
|
|
vt_kbd_con_start(console_num);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void con_flush_chars(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc;
|
|
|
|
|
|
|
|
|
|
if (in_interrupt()) /* from flush_to_ldisc */
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* if we race with con_close(), vt may be null */
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
vc = tty->driver_data;
|
|
|
|
|
if (vc)
|
|
|
|
|
set_cursor(vc);
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate the console screen memory.
|
|
|
|
|
*/
|
2012-06-04 15:35:33 +04:00
|
|
|
static int con_install(struct tty_driver *driver, struct tty_struct *tty)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
unsigned int currcons = tty->index;
|
2012-06-04 15:35:33 +04:00
|
|
|
struct vc_data *vc;
|
|
|
|
|
int ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2012-06-04 15:35:33 +04:00
|
|
|
ret = vc_allocate(currcons);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto unlock;
|
2008-10-13 13:41:30 +04:00
|
|
|
|
2012-06-04 15:35:33 +04:00
|
|
|
vc = vc_cons[currcons].d;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-06-04 15:35:33 +04:00
|
|
|
/* Still being freed */
|
|
|
|
|
if (vc->port.tty) {
|
|
|
|
|
ret = -ERESTARTSYS;
|
|
|
|
|
goto unlock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = tty_port_install(&vc->port, driver, tty);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
|
|
tty->driver_data = vc;
|
|
|
|
|
vc->port.tty = tty;
|
2020-03-22 06:43:04 +03:00
|
|
|
tty_port_get(&vc->port);
|
2012-06-04 15:35:33 +04:00
|
|
|
|
|
|
|
|
if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
|
|
|
|
|
tty->winsize.ws_row = vc_cons[currcons].d->vc_rows;
|
|
|
|
|
tty->winsize.ws_col = vc_cons[currcons].d->vc_cols;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2012-06-04 15:35:33 +04:00
|
|
|
if (vc->vc_utf)
|
2012-07-14 18:31:47 +04:00
|
|
|
tty->termios.c_iflag |= IUTF8;
|
2012-06-04 15:35:33 +04:00
|
|
|
else
|
2012-07-14 18:31:47 +04:00
|
|
|
tty->termios.c_iflag &= ~IUTF8;
|
2012-06-04 15:35:33 +04:00
|
|
|
unlock:
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-04 15:35:33 +04:00
|
|
|
static int con_open(struct tty_struct *tty, struct file *filp)
|
|
|
|
|
{
|
|
|
|
|
/* everything done in install */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static void con_close(struct tty_struct *tty, struct file *filp)
|
|
|
|
|
{
|
2008-10-13 13:41:30 +04:00
|
|
|
/* Nothing to do - we defer to shutdown */
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-10-13 13:41:30 +04:00
|
|
|
static void con_shutdown(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = tty->driver_data;
|
|
|
|
|
BUG_ON(vc == NULL);
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2010-06-02 00:52:56 +04:00
|
|
|
vc->port.tty = NULL;
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2020-03-22 06:43:04 +03:00
|
|
|
static void con_cleanup(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = tty->driver_data;
|
|
|
|
|
|
|
|
|
|
tty_port_put(&vc->port);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-04 15:09:50 +04:00
|
|
|
static int default_color = 7; /* white */
|
2007-05-08 11:38:04 +04:00
|
|
|
static int default_italic_color = 2; // green (ASCII)
|
|
|
|
|
static int default_underline_color = 3; // cyan (ASCII)
|
2013-08-04 15:09:50 +04:00
|
|
|
module_param_named(color, default_color, int, S_IRUGO | S_IWUSR);
|
2007-05-08 11:38:04 +04:00
|
|
|
module_param_named(italic, default_italic_color, int, S_IRUGO | S_IWUSR);
|
|
|
|
|
module_param_named(underline, default_underline_color, int, S_IRUGO | S_IWUSR);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static void vc_init(struct vc_data *vc, unsigned int rows,
|
|
|
|
|
unsigned int cols, int do_clear)
|
|
|
|
|
{
|
|
|
|
|
int j, k ;
|
|
|
|
|
|
|
|
|
|
vc->vc_cols = cols;
|
|
|
|
|
vc->vc_rows = rows;
|
|
|
|
|
vc->vc_size_row = cols << 1;
|
|
|
|
|
vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
|
|
|
|
|
|
|
|
|
|
set_origin(vc);
|
|
|
|
|
vc->vc_pos = vc->vc_origin;
|
|
|
|
|
reset_vc(vc);
|
|
|
|
|
for (j=k=0; j<16; j++) {
|
|
|
|
|
vc->vc_palette[k++] = default_red[j] ;
|
|
|
|
|
vc->vc_palette[k++] = default_grn[j] ;
|
|
|
|
|
vc->vc_palette[k++] = default_blu[j] ;
|
|
|
|
|
}
|
2013-08-04 15:09:50 +04:00
|
|
|
vc->vc_def_color = default_color;
|
2007-05-08 11:38:04 +04:00
|
|
|
vc->vc_ulcolor = default_underline_color;
|
|
|
|
|
vc->vc_itcolor = default_italic_color;
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_halfcolor = 0x08; /* grey */
|
|
|
|
|
init_waitqueue_head(&vc->paste_wait);
|
|
|
|
|
reset_terminal(vc, do_clear);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This routine initializes console interrupts, and does nothing
|
|
|
|
|
* else. If you want the screen to clear, call tty_write with
|
|
|
|
|
* the appropriate escape-sequence.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int __init con_init(void)
|
|
|
|
|
{
|
|
|
|
|
const char *display_desc = NULL;
|
|
|
|
|
struct vc_data *vc;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
unsigned int currcons = 0, i;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-12-19 00:44:44 +03:00
|
|
|
if (!conswitchp)
|
|
|
|
|
conswitchp = &dummy_con;
|
|
|
|
|
display_desc = conswitchp->con_startup();
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!display_desc) {
|
|
|
|
|
fg_console = 0;
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
struct con_driver *con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
|
|
|
|
if (con_driver->con == NULL) {
|
|
|
|
|
con_driver->con = conswitchp;
|
|
|
|
|
con_driver->desc = display_desc;
|
|
|
|
|
con_driver->flag = CON_DRIVER_FLAG_INIT;
|
|
|
|
|
con_driver->first = 0;
|
|
|
|
|
con_driver->last = MAX_NR_CONSOLES - 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NR_CONSOLES; i++)
|
|
|
|
|
con_driver_map[i] = conswitchp;
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
if (blankinterval) {
|
|
|
|
|
blank_state = blank_normal_wait;
|
2009-06-17 02:33:52 +04:00
|
|
|
mod_timer(&console_timer, jiffies + (blankinterval * HZ));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
|
2009-06-11 00:53:37 +04:00
|
|
|
vc_cons[currcons].d = vc = kzalloc(sizeof(struct vc_data), GFP_NOWAIT);
|
2007-02-14 00:38:58 +03:00
|
|
|
INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK);
|
2010-06-02 00:52:55 +04:00
|
|
|
tty_port_init(&vc->port);
|
2005-04-17 02:20:36 +04:00
|
|
|
visual_init(vc, currcons, 1);
|
2020-07-12 14:10:12 +03:00
|
|
|
/* Assuming vc->vc_{cols,rows,screenbuf_size} are sane here. */
|
2009-06-11 00:53:37 +04:00
|
|
|
vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_NOWAIT);
|
2005-04-17 02:20:36 +04:00
|
|
|
vc_init(vc, vc->vc_rows, vc->vc_cols,
|
|
|
|
|
currcons || !vc->vc_sw->con_save_screen);
|
|
|
|
|
}
|
|
|
|
|
currcons = fg_console = 0;
|
|
|
|
|
master_display_fg = vc = vc_cons[currcons].d;
|
|
|
|
|
set_origin(vc);
|
|
|
|
|
save_screen(vc);
|
2020-06-15 10:48:33 +03:00
|
|
|
gotoxy(vc, vc->state.x, vc->state.y);
|
2005-04-17 02:20:36 +04:00
|
|
|
csi_J(vc, 0);
|
|
|
|
|
update_screen(vc);
|
2012-04-03 05:18:23 +04:00
|
|
|
pr_info("Console: %s %s %dx%d\n",
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_can_do_color ? "colour" : "mono",
|
|
|
|
|
display_desc, vc->vc_cols, vc->vc_rows);
|
|
|
|
|
printable = 1;
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_VT_CONSOLE
|
|
|
|
|
register_console(&vt_console_driver);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
console_initcall(con_init);
|
|
|
|
|
|
2006-10-02 13:17:18 +04:00
|
|
|
static const struct tty_operations con_ops = {
|
2012-06-04 15:35:33 +04:00
|
|
|
.install = con_install,
|
2005-04-17 02:20:36 +04:00
|
|
|
.open = con_open,
|
|
|
|
|
.close = con_close,
|
|
|
|
|
.write = con_write,
|
|
|
|
|
.write_room = con_write_room,
|
|
|
|
|
.put_char = con_put_char,
|
|
|
|
|
.flush_chars = con_flush_chars,
|
|
|
|
|
.ioctl = vt_ioctl,
|
2009-08-06 17:09:28 +04:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
|
.compat_ioctl = vt_compat_ioctl,
|
|
|
|
|
#endif
|
2005-04-17 02:20:36 +04:00
|
|
|
.stop = con_stop,
|
|
|
|
|
.start = con_start,
|
|
|
|
|
.throttle = con_throttle,
|
|
|
|
|
.unthrottle = con_unthrottle,
|
2008-08-15 13:39:38 +04:00
|
|
|
.resize = vt_resize,
|
2020-03-22 06:43:04 +03:00
|
|
|
.shutdown = con_shutdown,
|
|
|
|
|
.cleanup = con_cleanup,
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
2008-10-13 13:41:42 +04:00
|
|
|
static struct cdev vc0_cdev;
|
|
|
|
|
|
2010-12-01 20:51:05 +03:00
|
|
|
static ssize_t show_tty_active(struct device *dev,
|
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
|
|
|
|
return sprintf(buf, "tty%d\n", fg_console + 1);
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(active, S_IRUGO, show_tty_active, NULL);
|
|
|
|
|
|
2015-02-05 13:07:42 +03:00
|
|
|
static struct attribute *vt_dev_attrs[] = {
|
|
|
|
|
&dev_attr_active.attr,
|
|
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
ATTRIBUTE_GROUPS(vt_dev);
|
|
|
|
|
|
2008-10-13 13:41:42 +04:00
|
|
|
int __init vty_init(const struct file_operations *console_fops)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2008-10-13 13:41:42 +04:00
|
|
|
cdev_init(&vc0_cdev, console_fops);
|
|
|
|
|
if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
|
|
|
|
|
register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
|
|
|
|
|
panic("Couldn't register /dev/tty0 driver\n");
|
2015-02-05 13:07:42 +03:00
|
|
|
tty0dev = device_create_with_groups(tty_class, NULL,
|
|
|
|
|
MKDEV(TTY_MAJOR, 0), NULL,
|
|
|
|
|
vt_dev_groups, "tty0");
|
2010-12-01 20:51:05 +03:00
|
|
|
if (IS_ERR(tty0dev))
|
|
|
|
|
tty0dev = NULL;
|
2008-10-13 13:41:42 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
vcs_init();
|
|
|
|
|
|
|
|
|
|
console_driver = alloc_tty_driver(MAX_NR_CONSOLES);
|
|
|
|
|
if (!console_driver)
|
|
|
|
|
panic("Couldn't allocate console driver\n");
|
2012-03-05 17:51:52 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
console_driver->name = "tty";
|
|
|
|
|
console_driver->name_base = 1;
|
|
|
|
|
console_driver->major = TTY_MAJOR;
|
|
|
|
|
console_driver->minor_start = 1;
|
|
|
|
|
console_driver->type = TTY_DRIVER_TYPE_CONSOLE;
|
|
|
|
|
console_driver->init_termios = tty_std_termios;
|
2008-05-07 07:42:37 +04:00
|
|
|
if (default_utf8)
|
|
|
|
|
console_driver->init_termios.c_iflag |= IUTF8;
|
2005-04-17 02:20:36 +04:00
|
|
|
console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
|
|
|
|
|
tty_set_operations(console_driver, &con_ops);
|
|
|
|
|
if (tty_register_driver(console_driver))
|
|
|
|
|
panic("Couldn't register console driver\n");
|
|
|
|
|
kbd_init();
|
|
|
|
|
console_map_init();
|
|
|
|
|
#ifdef CONFIG_MDA_CONSOLE
|
|
|
|
|
mda_console_init();
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifndef VT_SINGLE_DRIVER
|
2006-06-26 11:27:12 +04:00
|
|
|
|
|
|
|
|
static struct class *vtconsole_class;
|
|
|
|
|
|
2013-01-25 04:28:15 +04:00
|
|
|
static int do_bind_con_driver(const struct consw *csw, int first, int last,
|
2007-07-17 15:05:34 +04:00
|
|
|
int deflt)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
struct module *owner = csw->owner;
|
|
|
|
|
const char *desc = NULL;
|
|
|
|
|
struct con_driver *con_driver;
|
|
|
|
|
int i, j = -1, k = -1, retval = -ENODEV;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (!try_module_get(owner))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
2013-01-25 04:28:15 +04:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
2006-06-26 11:27:03 +04:00
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
/* check if driver is registered */
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
|
|
|
|
if (con_driver->con == csw) {
|
|
|
|
|
desc = con_driver->desc;
|
|
|
|
|
retval = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (retval)
|
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
if (!(con_driver->flag & CON_DRIVER_FLAG_INIT)) {
|
|
|
|
|
csw->con_startup();
|
|
|
|
|
con_driver->flag |= CON_DRIVER_FLAG_INIT;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2006-06-26 11:27:03 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
if (deflt) {
|
|
|
|
|
if (conswitchp)
|
|
|
|
|
module_put(conswitchp->owner);
|
2006-06-26 11:27:03 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
__module_get(owner);
|
|
|
|
|
conswitchp = csw;
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
first = max(first, con_driver->first);
|
|
|
|
|
last = min(last, con_driver->last);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
for (i = first; i <= last; i++) {
|
|
|
|
|
int old_was_color;
|
|
|
|
|
struct vc_data *vc = vc_cons[i].d;
|
|
|
|
|
|
|
|
|
|
if (con_driver_map[i])
|
|
|
|
|
module_put(con_driver_map[i]->owner);
|
|
|
|
|
__module_get(owner);
|
|
|
|
|
con_driver_map[i] = csw;
|
|
|
|
|
|
|
|
|
|
if (!vc || !vc->vc_sw)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
j = i;
|
2006-06-26 11:27:03 +04:00
|
|
|
|
2016-06-23 14:34:35 +03:00
|
|
|
if (con_is_visible(vc)) {
|
2006-06-26 11:26:41 +04:00
|
|
|
k = i;
|
2005-04-17 02:20:36 +04:00
|
|
|
save_screen(vc);
|
2006-06-26 11:26:41 +04:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
old_was_color = vc->vc_can_do_color;
|
|
|
|
|
vc->vc_sw->con_deinit(vc);
|
2010-08-22 19:37:24 +04:00
|
|
|
vc->vc_origin = (unsigned long)vc->vc_screenbuf;
|
2005-04-17 02:20:36 +04:00
|
|
|
visual_init(vc, i, 0);
|
2006-06-26 11:27:03 +04:00
|
|
|
set_origin(vc);
|
2005-04-17 02:20:36 +04:00
|
|
|
update_attr(vc);
|
|
|
|
|
|
|
|
|
|
/* If the console changed between mono <-> color, then
|
|
|
|
|
* the attributes in the screenbuf will be wrong. The
|
|
|
|
|
* following resets all attributes to something sane.
|
|
|
|
|
*/
|
|
|
|
|
if (old_was_color != vc->vc_can_do_color)
|
|
|
|
|
clear_buffer_attributes(vc);
|
|
|
|
|
}
|
2006-06-26 11:26:41 +04:00
|
|
|
|
2011-02-06 20:31:53 +03:00
|
|
|
pr_info("Console: switching ");
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!deflt)
|
2017-10-02 18:48:55 +03:00
|
|
|
pr_cont("consoles %d-%d ", first + 1, last + 1);
|
2006-06-26 11:26:41 +04:00
|
|
|
if (j >= 0) {
|
|
|
|
|
struct vc_data *vc = vc_cons[j].d;
|
|
|
|
|
|
2017-10-02 18:48:55 +03:00
|
|
|
pr_cont("to %s %s %dx%d\n",
|
|
|
|
|
vc->vc_can_do_color ? "colour" : "mono",
|
|
|
|
|
desc, vc->vc_cols, vc->vc_rows);
|
2006-06-26 11:26:41 +04:00
|
|
|
|
|
|
|
|
if (k >= 0) {
|
|
|
|
|
vc = vc_cons[k].d;
|
|
|
|
|
update_screen(vc);
|
|
|
|
|
}
|
2017-10-02 18:48:55 +03:00
|
|
|
} else {
|
|
|
|
|
pr_cont("to %s\n", desc);
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
retval = 0;
|
|
|
|
|
err:
|
2005-04-17 02:20:36 +04:00
|
|
|
module_put(owner);
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
return retval;
|
|
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-01-25 04:28:15 +04:00
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
#ifdef CONFIG_VT_HW_CONSOLE_BINDING
|
2013-01-25 04:28:18 +04:00
|
|
|
int do_unbind_con_driver(const struct consw *csw, int first, int last, int deflt)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
struct module *owner = csw->owner;
|
|
|
|
|
const struct consw *defcsw = NULL;
|
|
|
|
|
struct con_driver *con_driver = NULL, *con_back = NULL;
|
|
|
|
|
int i, retval = -ENODEV;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
if (!try_module_get(owner))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
2013-01-25 04:28:18 +04:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
/* check if driver is registered and if it is unbindable */
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
|
|
|
|
if (con_driver->con == csw &&
|
2006-06-26 11:27:12 +04:00
|
|
|
con_driver->flag & CON_DRIVER_FLAG_MODULE) {
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
retval = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-25 04:28:18 +04:00
|
|
|
if (retval)
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
goto err;
|
|
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
retval = -ENODEV;
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
/* check if backup driver exists */
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
con_back = ®istered_con_driver[i];
|
|
|
|
|
|
2014-06-05 18:24:47 +04:00
|
|
|
if (con_back->con && con_back->con != csw) {
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
defcsw = con_back->con;
|
|
|
|
|
retval = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-25 04:28:18 +04:00
|
|
|
if (retval)
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
goto err;
|
|
|
|
|
|
2013-01-25 04:28:18 +04:00
|
|
|
if (!con_is_bound(csw))
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
first = max(first, con_driver->first);
|
|
|
|
|
last = min(last, con_driver->last);
|
|
|
|
|
|
|
|
|
|
for (i = first; i <= last; i++) {
|
2005-04-17 02:20:36 +04:00
|
|
|
if (con_driver_map[i] == csw) {
|
|
|
|
|
module_put(csw->owner);
|
|
|
|
|
con_driver_map[i] = NULL;
|
|
|
|
|
}
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!con_is_bound(defcsw)) {
|
2006-06-26 11:27:12 +04:00
|
|
|
const struct consw *defconsw = conswitchp;
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
defcsw->con_startup();
|
|
|
|
|
con_back->flag |= CON_DRIVER_FLAG_INIT;
|
2006-06-26 11:27:12 +04:00
|
|
|
/*
|
|
|
|
|
* vgacon may change the default driver to point
|
|
|
|
|
* to dummycon, we restore it here...
|
|
|
|
|
*/
|
|
|
|
|
conswitchp = defconsw;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!con_is_bound(csw))
|
|
|
|
|
con_driver->flag &= ~CON_DRIVER_FLAG_INIT;
|
|
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
/* ignore return value, binding should not fail */
|
2013-01-25 04:28:15 +04:00
|
|
|
do_bind_con_driver(defcsw, first, last, deflt);
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
err:
|
|
|
|
|
module_put(owner);
|
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
|
|
}
|
2013-01-25 04:28:18 +04:00
|
|
|
EXPORT_SYMBOL_GPL(do_unbind_con_driver);
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
static int vt_bind(struct con_driver *con)
|
|
|
|
|
{
|
|
|
|
|
const struct consw *defcsw = NULL, *csw = NULL;
|
|
|
|
|
int i, more = 1, first = -1, last = -1, deflt = 0;
|
|
|
|
|
|
2015-04-13 12:16:21 +03:00
|
|
|
if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE))
|
2006-06-26 11:27:12 +04:00
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
csw = con->con;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
struct con_driver *con = ®istered_con_driver[i];
|
|
|
|
|
|
|
|
|
|
if (con->con && !(con->flag & CON_DRIVER_FLAG_MODULE)) {
|
|
|
|
|
defcsw = con->con;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!defcsw)
|
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
while (more) {
|
|
|
|
|
more = 0;
|
|
|
|
|
|
|
|
|
|
for (i = con->first; i <= con->last; i++) {
|
|
|
|
|
if (con_driver_map[i] == defcsw) {
|
|
|
|
|
if (first == -1)
|
|
|
|
|
first = i;
|
|
|
|
|
last = i;
|
|
|
|
|
more = 1;
|
|
|
|
|
} else if (first != -1)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (first == 0 && last == MAX_NR_CONSOLES -1)
|
|
|
|
|
deflt = 1;
|
|
|
|
|
|
2014-12-16 01:16:00 +03:00
|
|
|
if (first != -1)
|
2013-05-08 22:14:21 +04:00
|
|
|
do_bind_con_driver(csw, first, last, deflt);
|
2006-06-26 11:27:12 +04:00
|
|
|
|
|
|
|
|
first = -1;
|
|
|
|
|
last = -1;
|
|
|
|
|
deflt = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int vt_unbind(struct con_driver *con)
|
|
|
|
|
{
|
|
|
|
|
const struct consw *csw = NULL;
|
|
|
|
|
int i, more = 1, first = -1, last = -1, deflt = 0;
|
2014-06-05 18:33:24 +04:00
|
|
|
int ret;
|
2006-06-26 11:27:12 +04:00
|
|
|
|
2015-04-13 12:16:21 +03:00
|
|
|
if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE))
|
2006-06-26 11:27:12 +04:00
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
csw = con->con;
|
|
|
|
|
|
|
|
|
|
while (more) {
|
|
|
|
|
more = 0;
|
|
|
|
|
|
|
|
|
|
for (i = con->first; i <= con->last; i++) {
|
|
|
|
|
if (con_driver_map[i] == csw) {
|
|
|
|
|
if (first == -1)
|
|
|
|
|
first = i;
|
|
|
|
|
last = i;
|
|
|
|
|
more = 1;
|
|
|
|
|
} else if (first != -1)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (first == 0 && last == MAX_NR_CONSOLES -1)
|
|
|
|
|
deflt = 1;
|
|
|
|
|
|
2013-05-08 22:14:07 +04:00
|
|
|
if (first != -1) {
|
2014-06-05 18:33:24 +04:00
|
|
|
ret = do_unbind_con_driver(csw, first, last, deflt);
|
|
|
|
|
if (ret != 0)
|
|
|
|
|
return ret;
|
2013-05-08 22:14:07 +04:00
|
|
|
}
|
2006-06-26 11:27:12 +04:00
|
|
|
|
|
|
|
|
first = -1;
|
|
|
|
|
last = -1;
|
|
|
|
|
deflt = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2006-06-26 11:27:12 +04:00
|
|
|
#else
|
|
|
|
|
static inline int vt_bind(struct con_driver *con)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
static inline int vt_unbind(struct con_driver *con)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_VT_HW_CONSOLE_BINDING */
|
2006-06-26 11:27:12 +04:00
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
static ssize_t store_bind(struct device *dev, struct device_attribute *attr,
|
2006-06-26 11:27:12 +04:00
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
2006-08-08 09:19:37 +04:00
|
|
|
struct con_driver *con = dev_get_drvdata(dev);
|
2006-06-26 11:27:12 +04:00
|
|
|
int bind = simple_strtoul(buf, NULL, 0);
|
|
|
|
|
|
2014-12-16 01:16:00 +03:00
|
|
|
console_lock();
|
|
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
if (bind)
|
|
|
|
|
vt_bind(con);
|
|
|
|
|
else
|
|
|
|
|
vt_unbind(con);
|
|
|
|
|
|
2014-12-16 01:16:00 +03:00
|
|
|
console_unlock();
|
|
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
static ssize_t show_bind(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2006-06-26 11:27:12 +04:00
|
|
|
{
|
2006-08-08 09:19:37 +04:00
|
|
|
struct con_driver *con = dev_get_drvdata(dev);
|
2019-07-18 11:09:03 +03:00
|
|
|
int bind;
|
|
|
|
|
|
|
|
|
|
console_lock();
|
|
|
|
|
bind = con_is_bound(con->con);
|
|
|
|
|
console_unlock();
|
2006-06-26 11:27:12 +04:00
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%i\n", bind);
|
|
|
|
|
}
|
|
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
static ssize_t show_name(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2006-06-26 11:27:12 +04:00
|
|
|
{
|
2006-08-08 09:19:37 +04:00
|
|
|
struct con_driver *con = dev_get_drvdata(dev);
|
2006-06-26 11:27:12 +04:00
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s %s\n",
|
|
|
|
|
(con->flag & CON_DRIVER_FLAG_MODULE) ? "(M)" : "(S)",
|
|
|
|
|
con->desc);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-05 13:07:42 +03:00
|
|
|
static DEVICE_ATTR(bind, S_IRUGO|S_IWUSR, show_bind, store_bind);
|
|
|
|
|
static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
|
|
|
|
|
|
|
|
|
|
static struct attribute *con_dev_attrs[] = {
|
|
|
|
|
&dev_attr_bind.attr,
|
|
|
|
|
&dev_attr_name.attr,
|
|
|
|
|
NULL
|
2006-06-26 11:27:12 +04:00
|
|
|
};
|
|
|
|
|
|
2015-02-05 13:07:42 +03:00
|
|
|
ATTRIBUTE_GROUPS(con_dev);
|
|
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
static int vtconsole_init_device(struct con_driver *con)
|
2006-06-26 11:27:12 +04:00
|
|
|
{
|
2006-10-03 12:14:49 +04:00
|
|
|
con->flag |= CON_DRIVER_FLAG_ATTR;
|
2015-02-05 13:07:42 +03:00
|
|
|
return 0;
|
2006-06-26 11:27:12 +04:00
|
|
|
}
|
|
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
static void vtconsole_deinit_device(struct con_driver *con)
|
2006-06-26 11:27:12 +04:00
|
|
|
{
|
2015-02-05 13:07:42 +03:00
|
|
|
con->flag &= ~CON_DRIVER_FLAG_ATTR;
|
2006-06-26 11:27:12 +04:00
|
|
|
}
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
/**
|
|
|
|
|
* con_is_bound - checks if driver is bound to the console
|
|
|
|
|
* @csw: console driver
|
|
|
|
|
*
|
|
|
|
|
* RETURNS: zero if unbound, nonzero if bound
|
|
|
|
|
*
|
|
|
|
|
* Drivers can call this and if zero, they should release
|
|
|
|
|
* all resources allocated on con_startup()
|
|
|
|
|
*/
|
|
|
|
|
int con_is_bound(const struct consw *csw)
|
|
|
|
|
{
|
|
|
|
|
int i, bound = 0;
|
|
|
|
|
|
2019-05-28 12:02:35 +03:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
for (i = 0; i < MAX_NR_CONSOLES; i++) {
|
|
|
|
|
if (con_driver_map[i] == csw) {
|
|
|
|
|
bound = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return bound;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(con_is_bound);
|
|
|
|
|
|
2019-05-28 12:02:35 +03:00
|
|
|
/**
|
|
|
|
|
* con_is_visible - checks whether the current console is visible
|
|
|
|
|
* @vc: virtual console
|
|
|
|
|
*
|
|
|
|
|
* RETURNS: zero if not visible, nonzero if visible
|
|
|
|
|
*/
|
|
|
|
|
bool con_is_visible(const struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
return *vc->vc_display_fg == vc;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(con_is_visible);
|
|
|
|
|
|
2010-08-05 18:22:30 +04:00
|
|
|
/**
|
|
|
|
|
* con_debug_enter - prepare the console for the kernel debugger
|
2020-08-18 11:56:53 +03:00
|
|
|
* @vc: virtual console
|
2010-08-05 18:22:30 +04:00
|
|
|
*
|
|
|
|
|
* Called when the console is taken over by the kernel debugger, this
|
|
|
|
|
* function needs to save the current console state, then put the console
|
|
|
|
|
* into a state suitable for the kernel debugger.
|
|
|
|
|
*
|
|
|
|
|
* RETURNS:
|
|
|
|
|
* Zero on success, nonzero if a failure occurred when trying to prepare
|
|
|
|
|
* the console for the debugger.
|
|
|
|
|
*/
|
|
|
|
|
int con_debug_enter(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
saved_fg_console = fg_console;
|
|
|
|
|
saved_last_console = last_console;
|
|
|
|
|
saved_want_console = want_console;
|
|
|
|
|
saved_vc_mode = vc->vc_mode;
|
2010-08-17 00:58:31 +04:00
|
|
|
saved_console_blanked = console_blanked;
|
2010-08-05 18:22:30 +04:00
|
|
|
vc->vc_mode = KD_TEXT;
|
|
|
|
|
console_blanked = 0;
|
|
|
|
|
if (vc->vc_sw->con_debug_enter)
|
|
|
|
|
ret = vc->vc_sw->con_debug_enter(vc);
|
2010-08-05 18:22:30 +04:00
|
|
|
#ifdef CONFIG_KGDB_KDB
|
|
|
|
|
/* Set the initial LINES variable if it is not already set */
|
|
|
|
|
if (vc->vc_rows < 999) {
|
|
|
|
|
int linecount;
|
|
|
|
|
char lns[4];
|
|
|
|
|
const char *setargs[3] = {
|
|
|
|
|
"set",
|
|
|
|
|
"LINES",
|
|
|
|
|
lns,
|
|
|
|
|
};
|
|
|
|
|
if (kdbgetintenv(setargs[0], &linecount)) {
|
|
|
|
|
snprintf(lns, 4, "%i", vc->vc_rows);
|
|
|
|
|
kdb_set(2, setargs);
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-08-27 07:37:03 +04:00
|
|
|
if (vc->vc_cols < 999) {
|
|
|
|
|
int colcount;
|
|
|
|
|
char cols[4];
|
|
|
|
|
const char *setargs[3] = {
|
|
|
|
|
"set",
|
|
|
|
|
"COLUMNS",
|
|
|
|
|
cols,
|
|
|
|
|
};
|
|
|
|
|
if (kdbgetintenv(setargs[0], &colcount)) {
|
|
|
|
|
snprintf(cols, 4, "%i", vc->vc_cols);
|
|
|
|
|
kdb_set(2, setargs);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-08-05 18:22:30 +04:00
|
|
|
#endif /* CONFIG_KGDB_KDB */
|
2010-08-05 18:22:30 +04:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(con_debug_enter);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* con_debug_leave - restore console state
|
|
|
|
|
*
|
|
|
|
|
* Restore the console state to what it was before the kernel debugger
|
|
|
|
|
* was invoked.
|
|
|
|
|
*
|
|
|
|
|
* RETURNS:
|
|
|
|
|
* Zero on success, nonzero if a failure occurred when trying to restore
|
|
|
|
|
* the console.
|
|
|
|
|
*/
|
|
|
|
|
int con_debug_leave(void)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
fg_console = saved_fg_console;
|
|
|
|
|
last_console = saved_last_console;
|
|
|
|
|
want_console = saved_want_console;
|
2010-08-17 00:58:31 +04:00
|
|
|
console_blanked = saved_console_blanked;
|
2010-08-05 18:22:30 +04:00
|
|
|
vc_cons[fg_console].d->vc_mode = saved_vc_mode;
|
|
|
|
|
|
|
|
|
|
vc = vc_cons[fg_console].d;
|
|
|
|
|
if (vc->vc_sw->con_debug_leave)
|
|
|
|
|
ret = vc->vc_sw->con_debug_leave(vc);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(con_debug_leave);
|
|
|
|
|
|
2013-01-25 04:28:15 +04:00
|
|
|
static int do_register_con_driver(const struct consw *csw, int first, int last)
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
{
|
|
|
|
|
struct module *owner = csw->owner;
|
|
|
|
|
struct con_driver *con_driver;
|
|
|
|
|
const char *desc;
|
2016-05-03 18:05:55 +03:00
|
|
|
int i, retval;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
2013-01-25 04:28:15 +04:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
if (!try_module_get(owner))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
|
|
|
|
/* already registered */
|
2016-05-03 18:05:55 +03:00
|
|
|
if (con_driver->con == csw) {
|
2011-01-07 02:57:41 +03:00
|
|
|
retval = -EBUSY;
|
2016-05-03 18:05:55 +03:00
|
|
|
goto err;
|
|
|
|
|
}
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
desc = csw->con_startup();
|
2016-05-03 18:05:54 +03:00
|
|
|
if (!desc) {
|
|
|
|
|
retval = -ENODEV;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
goto err;
|
2016-05-03 18:05:54 +03:00
|
|
|
}
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
retval = -EINVAL;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
2015-04-01 21:06:16 +03:00
|
|
|
if (con_driver->con == NULL &&
|
|
|
|
|
!(con_driver->flag & CON_DRIVER_FLAG_ZOMBIE)) {
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
con_driver->con = csw;
|
|
|
|
|
con_driver->desc = desc;
|
2006-06-26 11:27:12 +04:00
|
|
|
con_driver->node = i;
|
|
|
|
|
con_driver->flag = CON_DRIVER_FLAG_MODULE |
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
CON_DRIVER_FLAG_INIT;
|
|
|
|
|
con_driver->first = first;
|
|
|
|
|
con_driver->last = last;
|
|
|
|
|
retval = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
if (retval)
|
|
|
|
|
goto err;
|
|
|
|
|
|
2015-02-05 13:07:42 +03:00
|
|
|
con_driver->dev =
|
|
|
|
|
device_create_with_groups(vtconsole_class, NULL,
|
|
|
|
|
MKDEV(0, con_driver->node),
|
|
|
|
|
con_driver, con_dev_groups,
|
|
|
|
|
"vtcon%i", con_driver->node);
|
2006-08-08 09:19:37 +04:00
|
|
|
if (IS_ERR(con_driver->dev)) {
|
2017-10-02 18:48:55 +03:00
|
|
|
pr_warn("Unable to create device for %s; errno = %ld\n",
|
|
|
|
|
con_driver->desc, PTR_ERR(con_driver->dev));
|
2006-08-08 09:19:37 +04:00
|
|
|
con_driver->dev = NULL;
|
2006-06-26 11:27:12 +04:00
|
|
|
} else {
|
2006-08-08 09:19:37 +04:00
|
|
|
vtconsole_init_device(con_driver);
|
2006-06-26 11:27:12 +04:00
|
|
|
}
|
2006-10-03 12:14:49 +04:00
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
err:
|
|
|
|
|
module_put(owner);
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
2013-01-25 04:28:15 +04:00
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
/**
|
2013-05-08 22:14:44 +04:00
|
|
|
* do_unregister_con_driver - unregister console driver from console layer
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
* @csw: console driver
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: All drivers that registers to the console layer must
|
|
|
|
|
* call this function upon exit, or if the console driver is in a state
|
|
|
|
|
* where it won't be able to handle console services, such as the
|
|
|
|
|
* framebuffer console without loaded framebuffer drivers.
|
|
|
|
|
*
|
|
|
|
|
* The driver must unbind first prior to unregistration.
|
|
|
|
|
*/
|
2013-01-25 04:28:18 +04:00
|
|
|
int do_unregister_con_driver(const struct consw *csw)
|
|
|
|
|
{
|
2014-06-05 18:29:56 +04:00
|
|
|
int i;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
/* cannot unregister a bound driver */
|
|
|
|
|
if (con_is_bound(csw))
|
2014-06-05 18:29:56 +04:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
|
|
if (csw == conswitchp)
|
|
|
|
|
return -EINVAL;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
struct con_driver *con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
2014-12-16 01:15:59 +03:00
|
|
|
if (con_driver->con == csw) {
|
2015-04-01 21:06:16 +03:00
|
|
|
/*
|
|
|
|
|
* Defer the removal of the sysfs entries since that
|
|
|
|
|
* will acquire the kernfs s_active lock and we can't
|
|
|
|
|
* acquire this lock while holding the console lock:
|
|
|
|
|
* the unbind sysfs entry imposes already the opposite
|
|
|
|
|
* order. Reset con already here to prevent any later
|
|
|
|
|
* lookup to succeed and mark this slot as zombie, so
|
|
|
|
|
* it won't get reused until we complete the removal
|
|
|
|
|
* in the deferred work.
|
|
|
|
|
*/
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
con_driver->con = NULL;
|
2015-04-01 21:06:16 +03:00
|
|
|
con_driver->flag = CON_DRIVER_FLAG_ZOMBIE;
|
|
|
|
|
schedule_work(&con_driver_unregister_work);
|
|
|
|
|
|
2014-06-05 18:29:56 +04:00
|
|
|
return 0;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
|
|
|
|
}
|
2014-06-05 18:29:56 +04:00
|
|
|
|
|
|
|
|
return -ENODEV;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
2013-01-25 04:28:18 +04:00
|
|
|
EXPORT_SYMBOL_GPL(do_unregister_con_driver);
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
2015-04-01 21:06:16 +03:00
|
|
|
static void con_driver_unregister_callback(struct work_struct *ignored)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
console_lock();
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
struct con_driver *con_driver = ®istered_con_driver[i];
|
|
|
|
|
|
|
|
|
|
if (!(con_driver->flag & CON_DRIVER_FLAG_ZOMBIE))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
console_unlock();
|
|
|
|
|
|
|
|
|
|
vtconsole_deinit_device(con_driver);
|
|
|
|
|
device_destroy(vtconsole_class, MKDEV(0, con_driver->node));
|
|
|
|
|
|
|
|
|
|
console_lock();
|
|
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(con_driver->con))
|
|
|
|
|
con_driver->con = NULL;
|
|
|
|
|
con_driver->desc = NULL;
|
|
|
|
|
con_driver->dev = NULL;
|
|
|
|
|
con_driver->node = 0;
|
|
|
|
|
WARN_ON_ONCE(con_driver->flag != CON_DRIVER_FLAG_ZOMBIE);
|
|
|
|
|
con_driver->flag = 0;
|
|
|
|
|
con_driver->first = 0;
|
|
|
|
|
con_driver->last = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
console_unlock();
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
/*
|
|
|
|
|
* If we support more console drivers, this function is used
|
|
|
|
|
* when a driver wants to take over some existing consoles
|
|
|
|
|
* and become default driver for newly opened ones.
|
|
|
|
|
*
|
2020-01-09 15:59:21 +03:00
|
|
|
* do_take_over_console is basically a register followed by bind
|
2013-01-25 04:28:15 +04:00
|
|
|
*/
|
|
|
|
|
int do_take_over_console(const struct consw *csw, int first, int last, int deflt)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = do_register_con_driver(csw, first, last);
|
|
|
|
|
/*
|
|
|
|
|
* If we get an busy error we still want to bind the console driver
|
|
|
|
|
* and return success, as we may have unbound the console driver
|
|
|
|
|
* but not unregistered it.
|
|
|
|
|
*/
|
|
|
|
|
if (err == -EBUSY)
|
|
|
|
|
err = 0;
|
|
|
|
|
if (!err)
|
|
|
|
|
do_bind_con_driver(csw, first, last, deflt);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(do_take_over_console);
|
|
|
|
|
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* give_up_console is a wrapper to unregister_con_driver. It will only
|
|
|
|
|
* work if driver is fully unbound.
|
|
|
|
|
*/
|
|
|
|
|
void give_up_console(const struct consw *csw)
|
|
|
|
|
{
|
2013-05-08 22:14:39 +04:00
|
|
|
console_lock();
|
|
|
|
|
do_unregister_con_driver(csw);
|
|
|
|
|
console_unlock();
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
|
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
static int __init vtconsole_class_init(void)
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
{
|
2006-06-26 11:27:12 +04:00
|
|
|
int i;
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
vtconsole_class = class_create(THIS_MODULE, "vtconsole");
|
|
|
|
|
if (IS_ERR(vtconsole_class)) {
|
2017-10-02 18:48:55 +03:00
|
|
|
pr_warn("Unable to create vt console class; errno = %ld\n",
|
|
|
|
|
PTR_ERR(vtconsole_class));
|
2006-06-26 11:27:12 +04:00
|
|
|
vtconsole_class = NULL;
|
|
|
|
|
}
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
2006-06-26 11:27:12 +04:00
|
|
|
/* Add system drivers to sysfs */
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
|
|
|
|
|
struct con_driver *con = ®istered_con_driver[i];
|
|
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
if (con->con && !con->dev) {
|
2015-02-05 13:07:42 +03:00
|
|
|
con->dev =
|
|
|
|
|
device_create_with_groups(vtconsole_class, NULL,
|
|
|
|
|
MKDEV(0, con->node),
|
|
|
|
|
con, con_dev_groups,
|
|
|
|
|
"vtcon%i", con->node);
|
2006-06-26 11:27:12 +04:00
|
|
|
|
2006-08-08 09:19:37 +04:00
|
|
|
if (IS_ERR(con->dev)) {
|
2017-10-02 18:48:55 +03:00
|
|
|
pr_warn("Unable to create device for %s; errno = %ld\n",
|
|
|
|
|
con->desc, PTR_ERR(con->dev));
|
2006-08-08 09:19:37 +04:00
|
|
|
con->dev = NULL;
|
2006-06-26 11:27:12 +04:00
|
|
|
} else {
|
2006-08-08 09:19:37 +04:00
|
|
|
vtconsole_init_device(con);
|
2006-06-26 11:27:12 +04:00
|
|
|
}
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2006-06-26 11:27:12 +04:00
|
|
|
postcore_initcall(vtconsole_class_init);
|
[PATCH] VT binding: Add binding/unbinding support for the VT console
The framebuffer console is now able to dynamically bind and unbind from the VT
console layer. Due to the way the VT console layer works, the drivers
themselves decide when to bind or unbind. However, it was decided that
binding must be controlled, not by the drivers themselves, but by the VT
console layer. With this, dynamic binding is possible for all VT console
drivers, not just fbcon.
Thus, the VT console layer will impose the following to all VT console
drivers:
- all registered VT console drivers will be entered in a private list
- drivers can register themselves to the VT console layer, but they cannot
decide when to bind or unbind. (Exception: To maintain backwards
compatibility, take_over_console() will automatically bind the driver after
registration.)
- drivers can remove themselves from the list by unregistering from the VT
console layer. A prerequisite for unregistration is that the driver must not
be bound.
The following functions are new in the vt.c:
register_con_driver() - public function, this function adds the VT console
driver to an internal list maintained by the VT console
bind_con_driver() - private function, it binds the driver to the console
take_over_console() is changed to call register_con_driver() followed by a
bind_con_driver(). This is the only time drivers can decide when to bind to
the VT layer. This is to maintain backwards compatibility.
unbind_con_driver() - private function, it unbinds the driver from its
console. The vacated consoles will be taken over by the default boot console
driver.
unregister_con_driver() - public function, removes the driver from the
internal list maintained by the VT console. It will only succeed if the
driver is currently unbound.
con_is_bound() checks if the driver is currently bound or not
give_up_console() is just a wrapper to unregister_con_driver().
There are also 3 additional functions meant to be called only by the tty layer
for sysfs control:
vt_bind() - calls bind_con_driver()
vt_unbind() - calls unbind_con_driver()
vt_show_drivers() - shows the list of registered drivers
Most VT console drivers will continue to work as is, but might have problems
when unbinding or binding which should be fixable with minimal changes.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-26 11:27:08 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Screen blanking
|
|
|
|
|
*/
|
|
|
|
|
|
2006-12-07 07:38:38 +03:00
|
|
|
static int set_vesa_blanking(char __user *p)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-12-07 07:38:38 +03:00
|
|
|
unsigned int mode;
|
|
|
|
|
|
|
|
|
|
if (get_user(mode, p + 1))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
vesa_blank_mode = (mode < 4) ? mode : 0;
|
|
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void do_blank_screen(int entering_gfx)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = vc_cons[fg_console].d;
|
|
|
|
|
int i;
|
|
|
|
|
|
2019-05-28 12:02:34 +03:00
|
|
|
might_sleep();
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
if (console_blanked) {
|
|
|
|
|
if (blank_state == blank_vesa_wait) {
|
|
|
|
|
blank_state = blank_off;
|
2006-01-10 07:53:49 +03:00
|
|
|
vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* entering graphics mode? */
|
|
|
|
|
if (entering_gfx) {
|
|
|
|
|
hide_cursor(vc);
|
|
|
|
|
save_screen(vc);
|
|
|
|
|
vc->vc_sw->con_blank(vc, -1, 1);
|
|
|
|
|
console_blanked = fg_console + 1;
|
2007-07-17 15:05:49 +04:00
|
|
|
blank_state = blank_off;
|
2005-04-17 02:20:36 +04:00
|
|
|
set_origin(vc);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2007-07-17 15:05:49 +04:00
|
|
|
blank_state = blank_off;
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* don't blank graphics */
|
|
|
|
|
if (vc->vc_mode != KD_TEXT) {
|
|
|
|
|
console_blanked = fg_console + 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hide_cursor(vc);
|
|
|
|
|
del_timer_sync(&console_timer);
|
|
|
|
|
blank_timer_expired = 0;
|
|
|
|
|
|
|
|
|
|
save_screen(vc);
|
|
|
|
|
/* In case we need to reset origin, blanking hook returns 1 */
|
2006-01-10 07:53:49 +03:00
|
|
|
i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0);
|
2005-04-17 02:20:36 +04:00
|
|
|
console_blanked = fg_console + 1;
|
|
|
|
|
if (i)
|
|
|
|
|
set_origin(vc);
|
|
|
|
|
|
|
|
|
|
if (console_blank_hook && console_blank_hook(1))
|
|
|
|
|
return;
|
|
|
|
|
|
2006-01-10 07:53:49 +03:00
|
|
|
if (vesa_off_interval && vesa_blank_mode) {
|
2005-07-15 14:56:25 +04:00
|
|
|
blank_state = blank_vesa_wait;
|
2005-04-17 02:20:36 +04:00
|
|
|
mod_timer(&console_timer, jiffies + vesa_off_interval);
|
|
|
|
|
}
|
2009-09-20 00:13:24 +04:00
|
|
|
vt_event_post(VT_EVENT_BLANK, vc->vc_num, vc->vc_num);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(do_blank_screen);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Called by timer as well as from vt_console_driver
|
|
|
|
|
*/
|
|
|
|
|
void do_unblank_screen(int leaving_gfx)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc;
|
|
|
|
|
|
|
|
|
|
/* This should now always be called from a "sane" (read: can schedule)
|
|
|
|
|
* context for the sake of the low level drivers, except in the special
|
|
|
|
|
* case of oops_in_progress
|
|
|
|
|
*/
|
|
|
|
|
if (!oops_in_progress)
|
|
|
|
|
might_sleep();
|
|
|
|
|
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
ignore_poke = 0;
|
|
|
|
|
if (!console_blanked)
|
|
|
|
|
return;
|
|
|
|
|
if (!vc_cons_allocated(fg_console)) {
|
|
|
|
|
/* impossible */
|
2014-11-10 09:46:35 +03:00
|
|
|
pr_warn("unblank_screen: tty %d not allocated ??\n",
|
|
|
|
|
fg_console + 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
vc = vc_cons[fg_console].d;
|
2018-08-22 11:54:03 +03:00
|
|
|
if (vc->vc_mode != KD_TEXT)
|
2005-04-17 02:20:36 +04:00
|
|
|
return; /* but leave console_blanked != 0 */
|
|
|
|
|
|
|
|
|
|
if (blankinterval) {
|
2009-06-17 02:33:52 +04:00
|
|
|
mod_timer(&console_timer, jiffies + (blankinterval * HZ));
|
2005-04-17 02:20:36 +04:00
|
|
|
blank_state = blank_normal_wait;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
console_blanked = 0;
|
2018-08-22 11:54:03 +03:00
|
|
|
if (vc->vc_sw->con_blank(vc, 0, leaving_gfx))
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Low-level driver cannot restore -> do it ourselves */
|
|
|
|
|
update_screen(vc);
|
|
|
|
|
if (console_blank_hook)
|
|
|
|
|
console_blank_hook(0);
|
|
|
|
|
set_palette(vc);
|
|
|
|
|
set_cursor(vc);
|
2009-09-20 00:13:24 +04:00
|
|
|
vt_event_post(VT_EVENT_UNBLANK, vc->vc_num, vc->vc_num);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(do_unblank_screen);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is called by the outside world to cause a forced unblank, mostly for
|
|
|
|
|
* oopses. Currently, I just call do_unblank_screen(0), but we could eventually
|
|
|
|
|
* call it with 1 as an argument and so force a mode restore... that may kill
|
|
|
|
|
* X or at least garbage the screen but would also make the Oops visible...
|
|
|
|
|
*/
|
|
|
|
|
void unblank_screen(void)
|
|
|
|
|
{
|
|
|
|
|
do_unblank_screen(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2006-03-23 14:00:31 +03:00
|
|
|
* We defer the timer blanking to work queue so it can take the console mutex
|
2005-04-17 02:20:36 +04:00
|
|
|
* (console operations can still happen at irq time, but only from printk which
|
2006-03-23 14:00:31 +03:00
|
|
|
* has the console mutex. Not perfect yet, but better than no locking
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2017-08-28 21:28:21 +03:00
|
|
|
static void blank_screen_t(struct timer_list *unused)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
blank_timer_expired = 1;
|
|
|
|
|
schedule_work(&console_work);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void poke_blanked_console(void)
|
|
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
|
|
|
|
/* Add this so we quickly catch whoever might call us in a non
|
|
|
|
|
* safe context. Nowadays, unblank_screen() isn't to be called in
|
|
|
|
|
* atomic contexts and is allowed to schedule (with the special case
|
|
|
|
|
* of oops_in_progress, but that isn't of any concern for this
|
|
|
|
|
* function. --BenH.
|
|
|
|
|
*/
|
|
|
|
|
might_sleep();
|
|
|
|
|
|
|
|
|
|
/* This isn't perfectly race free, but a race here would be mostly harmless,
|
2021-03-14 09:27:16 +03:00
|
|
|
* at worst, we'll do a spurious blank and it's unlikely
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
del_timer(&console_timer);
|
|
|
|
|
blank_timer_expired = 0;
|
|
|
|
|
|
|
|
|
|
if (ignore_poke || !vc_cons[fg_console].d || vc_cons[fg_console].d->vc_mode == KD_GRAPHICS)
|
|
|
|
|
return;
|
|
|
|
|
if (console_blanked)
|
|
|
|
|
unblank_screen();
|
|
|
|
|
else if (blankinterval) {
|
2009-06-17 02:33:52 +04:00
|
|
|
mod_timer(&console_timer, jiffies + (blankinterval * HZ));
|
2005-04-17 02:20:36 +04:00
|
|
|
blank_state = blank_normal_wait;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Palettes
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void set_palette(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
WARN_CONSOLE_UNLOCKED();
|
|
|
|
|
|
2016-06-23 14:34:27 +03:00
|
|
|
if (vc->vc_mode != KD_GRAPHICS && vc->vc_sw->con_set_palette)
|
2005-04-17 02:20:36 +04:00
|
|
|
vc->vc_sw->con_set_palette(vc, color_table);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Load palette into the DAC registers. arg points to a colour
|
|
|
|
|
* map, 3 bytes per colour, 16 colours, range from 0 to 255.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int con_set_cmap(unsigned char __user *arg)
|
|
|
|
|
{
|
2012-03-21 04:26:45 +04:00
|
|
|
int i, j, k;
|
|
|
|
|
unsigned char colormap[3*16];
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(colormap, arg, sizeof(colormap)))
|
|
|
|
|
return -EFAULT;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2012-03-21 04:26:45 +04:00
|
|
|
for (i = k = 0; i < 16; i++) {
|
|
|
|
|
default_red[i] = colormap[k++];
|
|
|
|
|
default_grn[i] = colormap[k++];
|
|
|
|
|
default_blu[i] = colormap[k++];
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < MAX_NR_CONSOLES; i++) {
|
|
|
|
|
if (!vc_cons_allocated(i))
|
|
|
|
|
continue;
|
|
|
|
|
for (j = k = 0; j < 16; j++) {
|
|
|
|
|
vc_cons[i].d->vc_palette[k++] = default_red[j];
|
|
|
|
|
vc_cons[i].d->vc_palette[k++] = default_grn[j];
|
|
|
|
|
vc_cons[i].d->vc_palette[k++] = default_blu[j];
|
|
|
|
|
}
|
|
|
|
|
set_palette(vc_cons[i].d);
|
|
|
|
|
}
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-03-21 04:26:45 +04:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int con_get_cmap(unsigned char __user *arg)
|
|
|
|
|
{
|
2012-03-21 04:26:45 +04:00
|
|
|
int i, k;
|
|
|
|
|
unsigned char colormap[3*16];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2012-03-21 04:26:45 +04:00
|
|
|
for (i = k = 0; i < 16; i++) {
|
|
|
|
|
colormap[k++] = default_red[i];
|
|
|
|
|
colormap[k++] = default_grn[i];
|
|
|
|
|
colormap[k++] = default_blu[i];
|
|
|
|
|
}
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-03-21 04:26:45 +04:00
|
|
|
if (copy_to_user(arg, colormap, sizeof(colormap)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void reset_palette(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
int j, k;
|
|
|
|
|
for (j=k=0; j<16; j++) {
|
|
|
|
|
vc->vc_palette[k++] = default_red[j];
|
|
|
|
|
vc->vc_palette[k++] = default_grn[j];
|
|
|
|
|
vc->vc_palette[k++] = default_blu[j];
|
|
|
|
|
}
|
|
|
|
|
set_palette(vc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Font switching
|
|
|
|
|
*
|
|
|
|
|
* Currently we only support fonts up to 32 pixels wide, at a maximum height
|
|
|
|
|
* of 32 pixels. Userspace fontdata is stored with 32 bytes (shorts/ints,
|
|
|
|
|
* depending on width) reserved for each character which is kinda wasty, but
|
|
|
|
|
* this is done in order to maintain compatibility with the EGA/VGA fonts. It
|
2011-03-31 05:57:33 +04:00
|
|
|
* is up to the actual low-level console-driver convert data into its favorite
|
2005-04-17 02:20:36 +04:00
|
|
|
* format (maybe we should add a `fontoffset' field to the `display'
|
|
|
|
|
* structure so we won't have to convert the fontdata all the time.
|
|
|
|
|
* /Jes
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define max_font_size 65536
|
|
|
|
|
|
|
|
|
|
static int con_font_get(struct vc_data *vc, struct console_font_op *op)
|
|
|
|
|
{
|
|
|
|
|
struct console_font font;
|
|
|
|
|
int rc = -EINVAL;
|
|
|
|
|
int c;
|
|
|
|
|
|
|
|
|
|
if (op->data) {
|
|
|
|
|
font.data = kmalloc(max_font_size, GFP_KERNEL);
|
|
|
|
|
if (!font.data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
} else
|
|
|
|
|
font.data = NULL;
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2012-03-02 18:59:08 +04:00
|
|
|
if (vc->vc_mode != KD_TEXT)
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
else if (vc->vc_sw->con_font_get)
|
2005-04-17 02:20:36 +04:00
|
|
|
rc = vc->vc_sw->con_font_get(vc, &font);
|
|
|
|
|
else
|
|
|
|
|
rc = -ENOSYS;
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
if (rc)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
c = (font.width+7)/8 * 32 * font.charcount;
|
2008-04-30 11:53:29 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
if (op->data && font.charcount > op->charcount)
|
|
|
|
|
rc = -ENOSPC;
|
2021-01-05 15:02:35 +03:00
|
|
|
if (font.width > op->width || font.height > op->height)
|
|
|
|
|
rc = -ENOSPC;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (rc)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
op->height = font.height;
|
|
|
|
|
op->width = font.width;
|
|
|
|
|
op->charcount = font.charcount;
|
|
|
|
|
|
|
|
|
|
if (op->data && copy_to_user(op->data, font.data, c))
|
|
|
|
|
rc = -EFAULT;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(font.data);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int con_font_set(struct vc_data *vc, struct console_font_op *op)
|
|
|
|
|
{
|
|
|
|
|
struct console_font font;
|
|
|
|
|
int rc = -EINVAL;
|
|
|
|
|
int size;
|
|
|
|
|
|
|
|
|
|
if (vc->vc_mode != KD_TEXT)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (!op->data)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (op->charcount > 512)
|
|
|
|
|
return -EINVAL;
|
2021-01-05 15:02:35 +03:00
|
|
|
if (op->width <= 0 || op->width > 32 || !op->height || op->height > 32)
|
2017-10-04 17:38:37 +03:00
|
|
|
return -EINVAL;
|
|
|
|
|
size = (op->width+7)/8 * 32 * op->charcount;
|
|
|
|
|
if (size > max_font_size)
|
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
|
|
font.data = memdup_user(op->data, size);
|
|
|
|
|
if (IS_ERR(font.data))
|
|
|
|
|
return PTR_ERR(font.data);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
font.charcount = op->charcount;
|
|
|
|
|
font.width = op->width;
|
2017-10-04 17:38:37 +03:00
|
|
|
font.height = op->height;
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2012-03-02 18:59:08 +04:00
|
|
|
if (vc->vc_mode != KD_TEXT)
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
else if (vc->vc_sw->con_font_set)
|
2005-04-17 02:20:36 +04:00
|
|
|
rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
|
|
|
|
|
else
|
|
|
|
|
rc = -ENOSYS;
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
kfree(font.data);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int con_font_default(struct vc_data *vc, struct console_font_op *op)
|
|
|
|
|
{
|
|
|
|
|
struct console_font font = {.width = op->width, .height = op->height};
|
|
|
|
|
char name[MAX_FONT_NAME];
|
|
|
|
|
char *s = name;
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!op->data)
|
|
|
|
|
s = NULL;
|
|
|
|
|
else if (strncpy_from_user(name, op->data, MAX_FONT_NAME - 1) < 0)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
else
|
|
|
|
|
name[MAX_FONT_NAME - 1] = 0;
|
|
|
|
|
|
2011-01-26 02:07:35 +03:00
|
|
|
console_lock();
|
2012-03-02 18:59:08 +04:00
|
|
|
if (vc->vc_mode != KD_TEXT) {
|
|
|
|
|
console_unlock();
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
if (vc->vc_sw->con_font_default)
|
|
|
|
|
rc = vc->vc_sw->con_font_default(vc, &font, s);
|
|
|
|
|
else
|
|
|
|
|
rc = -ENOSYS;
|
2011-01-26 02:07:35 +03:00
|
|
|
console_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!rc) {
|
|
|
|
|
op->width = font.width;
|
|
|
|
|
op->height = font.height;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int con_font_op(struct vc_data *vc, struct console_font_op *op)
|
|
|
|
|
{
|
|
|
|
|
switch (op->op) {
|
|
|
|
|
case KD_FONT_OP_SET:
|
|
|
|
|
return con_font_set(vc, op);
|
|
|
|
|
case KD_FONT_OP_GET:
|
|
|
|
|
return con_font_get(vc, op);
|
|
|
|
|
case KD_FONT_OP_SET_DEFAULT:
|
|
|
|
|
return con_font_default(vc, op);
|
|
|
|
|
case KD_FONT_OP_COPY:
|
vt: Disable KD_FONT_OP_COPY
It's buggy:
On Fri, Nov 06, 2020 at 10:30:08PM +0800, Minh Yuan wrote:
> We recently discovered a slab-out-of-bounds read in fbcon in the latest
> kernel ( v5.10-rc2 for now ). The root cause of this vulnerability is that
> "fbcon_do_set_font" did not handle "vc->vc_font.data" and
> "vc->vc_font.height" correctly, and the patch
> <https://lkml.org/lkml/2020/9/27/223> for VT_RESIZEX can't handle this
> issue.
>
> Specifically, we use KD_FONT_OP_SET to set a small font.data for tty6, and
> use KD_FONT_OP_SET again to set a large font.height for tty1. After that,
> we use KD_FONT_OP_COPY to assign tty6's vc_font.data to tty1's vc_font.data
> in "fbcon_do_set_font", while tty1 retains the original larger
> height. Obviously, this will cause an out-of-bounds read, because we can
> access a smaller vc_font.data with a larger vc_font.height.
Further there was only one user ever.
- Android's loadfont, busybox and console-tools only ever use OP_GET
and OP_SET
- fbset documentation only mentions the kernel cmdline font: option,
not anything else.
- systemd used OP_COPY before release 232 published in Nov 2016
Now unfortunately the crucial report seems to have gone down with
gmane, and the commit message doesn't say much. But the pull request
hints at OP_COPY being broken
https://github.com/systemd/systemd/pull/3651
So in other words, this never worked, and the only project which
foolishly every tried to use it, realized that rather quickly too.
Instead of trying to fix security issues here on dead code by adding
missing checks, fix the entire thing by removing the functionality.
Note that systemd code using the OP_COPY function ignored the return
value, so it doesn't matter what we're doing here really - just in
case a lone server somewhere happens to be extremely unlucky and
running an affected old version of systemd. The relevant code from
font_copy_to_all_vcs() in systemd was:
/* copy font from active VT, where the font was uploaded to */
cfo.op = KD_FONT_OP_COPY;
cfo.height = vcs.v_active-1; /* tty1 == index 0 */
(void) ioctl(vcfd, KDFONTOP, &cfo);
Note this just disables the ioctl, garbage collecting the now unused
callbacks is left for -next.
v2: Tetsuo found the old mail, which allowed me to find it on another
archive. Add the link too.
Acked-by: Peilin Ye <yepeilin.cs@gmail.com>
Reported-by: Minh Yuan <yuanmingbuaa@gmail.com>
References: https://lists.freedesktop.org/archives/systemd-devel/2016-June/036935.html
References: https://github.com/systemd/systemd/pull/3651
Cc: Greg KH <greg@kroah.com>
Cc: Peilin Ye <yepeilin.cs@gmail.com>
Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: https://lore.kernel.org/r/20201108153806.3140315-1-daniel.vetter@ffwll.ch
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-11-08 18:38:06 +03:00
|
|
|
/* was buggy and never really used */
|
|
|
|
|
return -EINVAL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Interface exported to selection and vcs.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* used by selection */
|
2020-08-18 11:56:51 +03:00
|
|
|
u16 screen_glyph(const struct vc_data *vc, int offset)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2020-08-18 11:56:53 +03:00
|
|
|
u16 w = scr_readw(screenpos(vc, offset, true));
|
2005-04-17 02:20:36 +04:00
|
|
|
u16 c = w & 0xff;
|
|
|
|
|
|
|
|
|
|
if (w & vc->vc_hi_font_mask)
|
|
|
|
|
c |= 0x100;
|
|
|
|
|
return c;
|
|
|
|
|
}
|
2008-04-30 11:54:51 +04:00
|
|
|
EXPORT_SYMBOL_GPL(screen_glyph);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-08-18 11:56:51 +03:00
|
|
|
u32 screen_glyph_unicode(const struct vc_data *vc, int n)
|
2018-07-18 05:10:44 +03:00
|
|
|
{
|
|
|
|
|
struct uni_screen *uniscr = get_vc_uniscr(vc);
|
|
|
|
|
|
|
|
|
|
if (uniscr)
|
|
|
|
|
return uniscr->lines[n / vc->vc_cols][n % vc->vc_cols];
|
|
|
|
|
return inverse_translate(vc, screen_glyph(vc, n * 2), 1);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(screen_glyph_unicode);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* used by vcs - note the word offset */
|
2020-08-18 11:56:53 +03:00
|
|
|
unsigned short *screen_pos(const struct vc_data *vc, int w_offset, bool viewed)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
return screenpos(vc, 2 * w_offset, viewed);
|
|
|
|
|
}
|
2016-01-25 03:32:08 +03:00
|
|
|
EXPORT_SYMBOL_GPL(screen_pos);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-08-18 11:56:52 +03:00
|
|
|
void getconsxy(const struct vc_data *vc, unsigned char xy[static 2])
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-01-09 06:55:02 +03:00
|
|
|
/* clamp values if they don't fit */
|
2020-08-18 11:56:52 +03:00
|
|
|
xy[0] = min(vc->state.x, 0xFFu);
|
|
|
|
|
xy[1] = min(vc->state.y, 0xFFu);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
2020-08-18 11:56:52 +03:00
|
|
|
void putconsxy(struct vc_data *vc, unsigned char xy[static const 2])
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-02-01 14:06:52 +03:00
|
|
|
hide_cursor(vc);
|
2020-08-18 11:56:52 +03:00
|
|
|
gotoxy(vc, xy[0], xy[1]);
|
2005-04-17 02:20:36 +04:00
|
|
|
set_cursor(vc);
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-18 11:56:51 +03:00
|
|
|
u16 vcs_scr_readw(const struct vc_data *vc, const u16 *org)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
|
if ((unsigned long)org == vc->vc_pos && softcursor_original != -1)
|
|
|
|
|
return softcursor_original;
|
|
|
|
|
return scr_readw(org);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org)
|
|
|
|
|
{
|
|
|
|
|
scr_writew(val, org);
|
|
|
|
|
if ((unsigned long)org == vc->vc_pos) {
|
|
|
|
|
softcursor_original = -1;
|
|
|
|
|
add_softcursor(vc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-01 08:10:44 +04:00
|
|
|
void vcs_scr_updated(struct vc_data *vc)
|
|
|
|
|
{
|
|
|
|
|
notify_update(vc);
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-03 12:18:35 +03:00
|
|
|
void vc_scrolldelta_helper(struct vc_data *c, int lines,
|
|
|
|
|
unsigned int rolled_over, void *base, unsigned int size)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ubase = (unsigned long)base;
|
2016-10-03 12:18:36 +03:00
|
|
|
ptrdiff_t scr_end = (void *)c->vc_scr_end - base;
|
|
|
|
|
ptrdiff_t vorigin = (void *)c->vc_visible_origin - base;
|
|
|
|
|
ptrdiff_t origin = (void *)c->vc_origin - base;
|
2016-10-03 12:18:35 +03:00
|
|
|
int margin = c->vc_size_row * 4;
|
2016-10-03 12:18:37 +03:00
|
|
|
int from, wrap, from_off, avail;
|
2016-10-03 12:18:35 +03:00
|
|
|
|
|
|
|
|
/* Turn scrollback off */
|
|
|
|
|
if (!lines) {
|
|
|
|
|
c->vc_visible_origin = c->vc_origin;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Do we have already enough to allow jumping from 0 to the end? */
|
2016-10-03 12:18:36 +03:00
|
|
|
if (rolled_over > scr_end + margin) {
|
2016-10-03 12:18:37 +03:00
|
|
|
from = scr_end;
|
|
|
|
|
wrap = rolled_over + c->vc_size_row;
|
2016-10-03 12:18:35 +03:00
|
|
|
} else {
|
2016-10-03 12:18:37 +03:00
|
|
|
from = 0;
|
|
|
|
|
wrap = size;
|
2016-10-03 12:18:35 +03:00
|
|
|
}
|
|
|
|
|
|
2016-10-03 12:18:37 +03:00
|
|
|
from_off = (vorigin - from + wrap) % wrap + lines * c->vc_size_row;
|
|
|
|
|
avail = (origin - from + wrap) % wrap;
|
2016-10-03 12:18:35 +03:00
|
|
|
|
|
|
|
|
/* Only a little piece would be left? Show all incl. the piece! */
|
2016-10-03 12:18:37 +03:00
|
|
|
if (avail < 2 * margin)
|
2016-10-03 12:18:35 +03:00
|
|
|
margin = 0;
|
2016-10-03 12:18:37 +03:00
|
|
|
if (from_off < margin)
|
|
|
|
|
from_off = 0;
|
|
|
|
|
if (from_off > avail - margin)
|
|
|
|
|
from_off = avail;
|
2016-10-03 12:18:35 +03:00
|
|
|
|
2016-10-03 12:18:37 +03:00
|
|
|
c->vc_visible_origin = ubase + (from + from_off) % wrap;
|
2016-10-03 12:18:35 +03:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(vc_scrolldelta_helper);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* Visible symbols for modules
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(color_table);
|
|
|
|
|
EXPORT_SYMBOL(default_red);
|
|
|
|
|
EXPORT_SYMBOL(default_grn);
|
|
|
|
|
EXPORT_SYMBOL(default_blu);
|
|
|
|
|
EXPORT_SYMBOL(update_region);
|
|
|
|
|
EXPORT_SYMBOL(redraw_screen);
|
|
|
|
|
EXPORT_SYMBOL(vc_resize);
|
|
|
|
|
EXPORT_SYMBOL(fg_console);
|
|
|
|
|
EXPORT_SYMBOL(console_blank_hook);
|
|
|
|
|
EXPORT_SYMBOL(console_blanked);
|
|
|
|
|
EXPORT_SYMBOL(vc_cons);
|
2009-11-13 23:14:11 +03:00
|
|
|
EXPORT_SYMBOL(global_cursor_default);
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifndef VT_SINGLE_DRIVER
|
|
|
|
|
EXPORT_SYMBOL(give_up_console);
|
|
|
|
|
#endif
|
