xref: /linux/drivers/tty/vt/consolemap.c (revision 0af298e62e5cff4ebf9bec47b8711177a7e2f115)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * consolemap.c
4  *
5  * Mapping from internal code (such as Latin-1 or Unicode or IBM PC code)
6  * to font positions.
7  *
8  * aeb, 950210
9  *
10  * Support for multiple unimaps by Jakub Jelinek <jj@ultra.linux.cz>, July 1998
11  *
12  * Fix bug in inverse translation. Stanislav Voronyi <stas@cnti.uanet.kharkov.ua>, Dec 1998
13  *
14  * In order to prevent the following circular lock dependency:
15  *   &mm->mmap_lock --> cpu_hotplug.lock --> console_lock --> &mm->mmap_lock
16  *
17  * We cannot allow page fault to happen while holding the console_lock.
18  * Therefore, all the userspace copy operations have to be done outside
19  * the console_lock critical sections.
20  *
21  * As all the affected functions are all called directly from vt_ioctl(), we
22  * can allocate some small buffers directly on stack without worrying about
23  * stack overflow.
24  */
25 
26 #include <linux/bitfield.h>
27 #include <linux/bits.h>
28 #include <linux/module.h>
29 #include <linux/kd.h>
30 #include <linux/errno.h>
31 #include <linux/mm.h>
32 #include <linux/slab.h>
33 #include <linux/init.h>
34 #include <linux/tty.h>
35 #include <linux/uaccess.h>
36 #include <linux/console.h>
37 #include <linux/consolemap.h>
38 #include <linux/vt_kern.h>
39 #include <linux/string.h>
40 
41 static unsigned short translations[][E_TABSZ] = {
42   /* 8-bit Latin-1 mapped to Unicode -- trivial mapping */
43   [LAT1_MAP] = {
44     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
45     0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
46     0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
47     0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
48     0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
49     0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
50     0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
51     0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
52     0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
53     0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
54     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
55     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
56     0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
57     0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
58     0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
59     0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
60     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
61     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
62     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
63     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
64     0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
65     0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
66     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
67     0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
68     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
69     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
70     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
71     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
72     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
73     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
74     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
75     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
76   },
77   /* VT100 graphics mapped to Unicode */
78   [GRAF_MAP] = {
79     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
80     0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
81     0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
82     0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
83     0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
84     0x0028, 0x0029, 0x002a, 0x2192, 0x2190, 0x2191, 0x2193, 0x002f,
85     0x2588, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
86     0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
87     0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
88     0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
89     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
90     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x00a0,
91     0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
92     0x2591, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
93     0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
94     0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x007f,
95     0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
96     0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
97     0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
98     0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
99     0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
100     0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
101     0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
102     0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
103     0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
104     0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
105     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
106     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
107     0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
108     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
109     0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
110     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
111   },
112   /* IBM Codepage 437 mapped to Unicode */
113   [IBMPC_MAP] = {
114     0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022,
115     0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c,
116     0x25b6, 0x25c0, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8,
117     0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc,
118     0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
119     0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
120     0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
121     0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
122     0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
123     0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
124     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
125     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
126     0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
127     0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
128     0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
129     0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302,
130     0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7,
131     0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
132     0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
133     0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192,
134     0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba,
135     0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
136     0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
137     0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
138     0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
139     0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
140     0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
141     0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
142     0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4,
143     0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229,
144     0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
145     0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0
146   },
147   /* User mapping -- default to codes for direct font mapping */
148   [USER_MAP] = {
149     0xf000, 0xf001, 0xf002, 0xf003, 0xf004, 0xf005, 0xf006, 0xf007,
150     0xf008, 0xf009, 0xf00a, 0xf00b, 0xf00c, 0xf00d, 0xf00e, 0xf00f,
151     0xf010, 0xf011, 0xf012, 0xf013, 0xf014, 0xf015, 0xf016, 0xf017,
152     0xf018, 0xf019, 0xf01a, 0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f,
153     0xf020, 0xf021, 0xf022, 0xf023, 0xf024, 0xf025, 0xf026, 0xf027,
154     0xf028, 0xf029, 0xf02a, 0xf02b, 0xf02c, 0xf02d, 0xf02e, 0xf02f,
155     0xf030, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, 0xf037,
156     0xf038, 0xf039, 0xf03a, 0xf03b, 0xf03c, 0xf03d, 0xf03e, 0xf03f,
157     0xf040, 0xf041, 0xf042, 0xf043, 0xf044, 0xf045, 0xf046, 0xf047,
158     0xf048, 0xf049, 0xf04a, 0xf04b, 0xf04c, 0xf04d, 0xf04e, 0xf04f,
159     0xf050, 0xf051, 0xf052, 0xf053, 0xf054, 0xf055, 0xf056, 0xf057,
160     0xf058, 0xf059, 0xf05a, 0xf05b, 0xf05c, 0xf05d, 0xf05e, 0xf05f,
161     0xf060, 0xf061, 0xf062, 0xf063, 0xf064, 0xf065, 0xf066, 0xf067,
162     0xf068, 0xf069, 0xf06a, 0xf06b, 0xf06c, 0xf06d, 0xf06e, 0xf06f,
163     0xf070, 0xf071, 0xf072, 0xf073, 0xf074, 0xf075, 0xf076, 0xf077,
164     0xf078, 0xf079, 0xf07a, 0xf07b, 0xf07c, 0xf07d, 0xf07e, 0xf07f,
165     0xf080, 0xf081, 0xf082, 0xf083, 0xf084, 0xf085, 0xf086, 0xf087,
166     0xf088, 0xf089, 0xf08a, 0xf08b, 0xf08c, 0xf08d, 0xf08e, 0xf08f,
167     0xf090, 0xf091, 0xf092, 0xf093, 0xf094, 0xf095, 0xf096, 0xf097,
168     0xf098, 0xf099, 0xf09a, 0xf09b, 0xf09c, 0xf09d, 0xf09e, 0xf09f,
169     0xf0a0, 0xf0a1, 0xf0a2, 0xf0a3, 0xf0a4, 0xf0a5, 0xf0a6, 0xf0a7,
170     0xf0a8, 0xf0a9, 0xf0aa, 0xf0ab, 0xf0ac, 0xf0ad, 0xf0ae, 0xf0af,
171     0xf0b0, 0xf0b1, 0xf0b2, 0xf0b3, 0xf0b4, 0xf0b5, 0xf0b6, 0xf0b7,
172     0xf0b8, 0xf0b9, 0xf0ba, 0xf0bb, 0xf0bc, 0xf0bd, 0xf0be, 0xf0bf,
173     0xf0c0, 0xf0c1, 0xf0c2, 0xf0c3, 0xf0c4, 0xf0c5, 0xf0c6, 0xf0c7,
174     0xf0c8, 0xf0c9, 0xf0ca, 0xf0cb, 0xf0cc, 0xf0cd, 0xf0ce, 0xf0cf,
175     0xf0d0, 0xf0d1, 0xf0d2, 0xf0d3, 0xf0d4, 0xf0d5, 0xf0d6, 0xf0d7,
176     0xf0d8, 0xf0d9, 0xf0da, 0xf0db, 0xf0dc, 0xf0dd, 0xf0de, 0xf0df,
177     0xf0e0, 0xf0e1, 0xf0e2, 0xf0e3, 0xf0e4, 0xf0e5, 0xf0e6, 0xf0e7,
178     0xf0e8, 0xf0e9, 0xf0ea, 0xf0eb, 0xf0ec, 0xf0ed, 0xf0ee, 0xf0ef,
179     0xf0f0, 0xf0f1, 0xf0f2, 0xf0f3, 0xf0f4, 0xf0f5, 0xf0f6, 0xf0f7,
180     0xf0f8, 0xf0f9, 0xf0fa, 0xf0fb, 0xf0fc, 0xf0fd, 0xf0fe, 0xf0ff
181   }
182 };
183 
184 /* The standard kernel character-to-font mappings are not invertible
185    -- this is just a best effort. */
186 
187 #define MAX_GLYPH 512		/* Max possible glyph value */
188 
189 static enum translation_map inv_translate[MAX_NR_CONSOLES];
190 
191 #define UNI_DIRS	32U
192 #define UNI_DIR_ROWS	32U
193 #define UNI_ROW_GLYPHS	64U
194 
195 #define UNI_DIR_BITS		GENMASK(15, 11)
196 #define UNI_ROW_BITS		GENMASK(10,  6)
197 #define UNI_GLYPH_BITS		GENMASK( 5,  0)
198 
199 #define UNI_DIR(uni)		FIELD_GET(UNI_DIR_BITS, (uni))
200 #define UNI_ROW(uni)		FIELD_GET(UNI_ROW_BITS, (uni))
201 #define UNI_GLYPH(uni)		FIELD_GET(UNI_GLYPH_BITS, (uni))
202 
203 #define UNI(dir, row, glyph)	(FIELD_PREP(UNI_DIR_BITS, (dir)) | \
204 				 FIELD_PREP(UNI_ROW_BITS, (row)) | \
205 				 FIELD_PREP(UNI_GLYPH_BITS, (glyph)))
206 
207 /**
208  * struct uni_pagedict - unicode directory
209  *
210  * @uni_pgdir: 32*32*64 table with glyphs
211  * @refcount: reference count of this structure
212  * @sum: checksum
213  * @inverse_translations: best-effort inverse mapping
214  * @inverse_trans_unicode: best-effort inverse mapping to unicode
215  */
216 struct uni_pagedict {
217 	u16		**uni_pgdir[UNI_DIRS];
218 	unsigned long	refcount;
219 	unsigned long	sum;
220 	unsigned char	*inverse_translations[LAST_MAP + 1];
221 	u16		*inverse_trans_unicode;
222 };
223 
224 static struct uni_pagedict *dflt;
225 
226 static void set_inverse_transl(struct vc_data *conp, struct uni_pagedict *dict,
227 	       enum translation_map m)
228 {
229 	unsigned short *t = translations[m];
230 	unsigned char *inv;
231 
232 	if (!dict)
233 		return;
234 	inv = dict->inverse_translations[m];
235 
236 	if (!inv) {
237 		inv = dict->inverse_translations[m] = kmalloc(MAX_GLYPH,
238 				GFP_KERNEL);
239 		if (!inv)
240 			return;
241 	}
242 	memset(inv, 0, MAX_GLYPH);
243 
244 	for (unsigned int ch = 0; ch < ARRAY_SIZE(translations[m]); ch++) {
245 		int glyph = conv_uni_to_pc(conp, t[ch]);
246 		if (glyph >= 0 && glyph < MAX_GLYPH && inv[glyph] < 32) {
247 			/* prefer '-' above SHY etc. */
248 			inv[glyph] = ch;
249 		}
250 	}
251 }
252 
253 static void set_inverse_trans_unicode(struct uni_pagedict *dict)
254 {
255 	unsigned int d, r, g;
256 	u16 *inv;
257 
258 	if (!dict)
259 		return;
260 
261 	inv = dict->inverse_trans_unicode;
262 	if (!inv) {
263 		inv = dict->inverse_trans_unicode = kmalloc_objs(*inv,
264 								 MAX_GLYPH);
265 		if (!inv)
266 			return;
267 	}
268 	memset(inv, 0, MAX_GLYPH * sizeof(*inv));
269 
270 	for (d = 0; d < UNI_DIRS; d++) {
271 		u16 **dir = dict->uni_pgdir[d];
272 		if (!dir)
273 			continue;
274 		for (r = 0; r < UNI_DIR_ROWS; r++) {
275 			u16 *row = dir[r];
276 			if (!row)
277 				continue;
278 			for (g = 0; g < UNI_ROW_GLYPHS; g++) {
279 				u16 glyph = row[g];
280 				if (glyph < MAX_GLYPH && inv[glyph] < 32)
281 					inv[glyph] = UNI(d, r, g);
282 			}
283 		}
284 	}
285 }
286 
287 unsigned short *set_translate(enum translation_map m, struct vc_data *vc)
288 {
289 	inv_translate[vc->vc_num] = m;
290 	return translations[m];
291 }
292 
293 /*
294  * Inverse translation is impossible for several reasons:
295  * 1. The font<->character maps are not 1-1.
296  * 2. The text may have been written while a different translation map
297  *    was active.
298  * Still, it is now possible to a certain extent to cut and paste non-ASCII.
299  */
300 u16 inverse_translate(const struct vc_data *conp, u16 glyph, bool use_unicode)
301 {
302 	struct uni_pagedict *p;
303 	enum translation_map m;
304 
305 	if (glyph >= MAX_GLYPH)
306 		return 0;
307 
308 	p = *conp->uni_pagedict_loc;
309 	if (!p)
310 		return glyph;
311 
312 	if (use_unicode) {
313 		if (!p->inverse_trans_unicode)
314 			return glyph;
315 
316 		return p->inverse_trans_unicode[glyph];
317 	}
318 
319 	m = inv_translate[conp->vc_num];
320 	if (!p->inverse_translations[m])
321 		return glyph;
322 
323 	return p->inverse_translations[m][glyph];
324 }
325 EXPORT_SYMBOL_GPL(inverse_translate);
326 
327 static void update_user_maps(void)
328 {
329 	int i;
330 	struct uni_pagedict *p, *q = NULL;
331 
332 	for (i = 0; i < MAX_NR_CONSOLES; i++) {
333 		if (!vc_cons_allocated(i))
334 			continue;
335 		p = *vc_cons[i].d->uni_pagedict_loc;
336 		if (p && p != q) {
337 			set_inverse_transl(vc_cons[i].d, p, USER_MAP);
338 			set_inverse_trans_unicode(p);
339 			q = p;
340 		}
341 	}
342 }
343 
344 /*
345  * Load customizable translation table
346  * arg points to a 256 byte translation table.
347  *
348  * The "old" variants are for translation directly to font (using the
349  * 0xf000-0xf0ff "transparent" Unicodes) whereas the "new" variants set
350  * Unicodes explicitly.
351  */
352 int con_set_trans_old(unsigned char __user * arg)
353 {
354 	unsigned short inbuf[E_TABSZ];
355 	unsigned int i;
356 	unsigned char ch;
357 
358 	for (i = 0; i < ARRAY_SIZE(inbuf); i++) {
359 		if (get_user(ch, &arg[i]))
360 			return -EFAULT;
361 		inbuf[i] = UNI_DIRECT_BASE | ch;
362 	}
363 
364 	guard(console_lock)();
365 	memcpy(translations[USER_MAP], inbuf, sizeof(inbuf));
366 	update_user_maps();
367 
368 	return 0;
369 }
370 
371 int con_get_trans_old(unsigned char __user * arg)
372 {
373 	int i, ch;
374 	unsigned short *p = translations[USER_MAP];
375 	unsigned char outbuf[E_TABSZ];
376 
377 	scoped_guard(console_lock)
378 		for (i = 0; i < ARRAY_SIZE(outbuf); i++) {
379 			ch = conv_uni_to_pc(vc_cons[fg_console].d, p[i]);
380 			outbuf[i] = (ch & ~0xff) ? 0 : ch;
381 		}
382 
383 	return copy_to_user(arg, outbuf, sizeof(outbuf)) ? -EFAULT : 0;
384 }
385 
386 int con_set_trans_new(ushort __user * arg)
387 {
388 	unsigned short inbuf[E_TABSZ];
389 
390 	if (copy_from_user(inbuf, arg, sizeof(inbuf)))
391 		return -EFAULT;
392 
393 	guard(console_lock)();
394 	memcpy(translations[USER_MAP], inbuf, sizeof(inbuf));
395 	update_user_maps();
396 
397 	return 0;
398 }
399 
400 int con_get_trans_new(ushort __user * arg)
401 {
402 	unsigned short outbuf[E_TABSZ];
403 
404 	scoped_guard(console_lock)
405 		memcpy(outbuf, translations[USER_MAP], sizeof(outbuf));
406 
407 	return copy_to_user(arg, outbuf, sizeof(outbuf)) ? -EFAULT : 0;
408 }
409 
410 /*
411  * Unicode -> current font conversion
412  *
413  * A font has at most 512 chars, usually 256.
414  * But one font position may represent several Unicode chars.
415  * A hashtable is somewhat of a pain to deal with, so use a
416  * "paged table" instead.  Simulation has shown the memory cost of
417  * this 3-level paged table scheme to be comparable to a hash table.
418  */
419 
420 extern u8 dfont_unicount[];	/* Defined in console_defmap.c */
421 extern u16 dfont_unitable[];
422 
423 static void con_release_unimap(struct uni_pagedict *dict)
424 {
425 	unsigned int d, r;
426 
427 	if (dict == dflt)
428 		dflt = NULL;
429 
430 	for (d = 0; d < UNI_DIRS; d++) {
431 		u16 **dir = dict->uni_pgdir[d];
432 		if (dir != NULL) {
433 			for (r = 0; r < UNI_DIR_ROWS; r++)
434 				kfree(dir[r]);
435 			kfree(dir);
436 		}
437 		dict->uni_pgdir[d] = NULL;
438 	}
439 
440 	for (r = 0; r < ARRAY_SIZE(dict->inverse_translations); r++) {
441 		kfree(dict->inverse_translations[r]);
442 		dict->inverse_translations[r] = NULL;
443 	}
444 
445 	kfree(dict->inverse_trans_unicode);
446 	dict->inverse_trans_unicode = NULL;
447 }
448 
449 /* Caller must hold the console lock */
450 void con_free_unimap(struct vc_data *vc)
451 {
452 	struct uni_pagedict *p;
453 
454 	p = *vc->uni_pagedict_loc;
455 	if (!p)
456 		return;
457 	*vc->uni_pagedict_loc = NULL;
458 	if (--p->refcount)
459 		return;
460 	con_release_unimap(p);
461 	kfree(p);
462 }
463 
464 static int con_unify_unimap(struct vc_data *conp, struct uni_pagedict *dict1)
465 {
466 	struct uni_pagedict *dict2;
467 	unsigned int cons, d, r;
468 
469 	for (cons = 0; cons < MAX_NR_CONSOLES; cons++) {
470 		if (!vc_cons_allocated(cons))
471 			continue;
472 		dict2 = *vc_cons[cons].d->uni_pagedict_loc;
473 		if (!dict2 || dict2 == dict1 || dict2->sum != dict1->sum)
474 			continue;
475 		for (d = 0; d < UNI_DIRS; d++) {
476 			u16 **dir1 = dict1->uni_pgdir[d];
477 			u16 **dir2 = dict2->uni_pgdir[d];
478 			if (!dir1 && !dir2)
479 				continue;
480 			if (!dir1 || !dir2)
481 				break;
482 			for (r = 0; r < UNI_DIR_ROWS; r++) {
483 				if (!dir1[r] && !dir2[r])
484 					continue;
485 				if (!dir1[r] || !dir2[r])
486 					break;
487 				if (memcmp(dir1[r], dir2[r], UNI_ROW_GLYPHS *
488 							sizeof(*dir1[r])))
489 					break;
490 			}
491 			if (r < UNI_DIR_ROWS)
492 				break;
493 		}
494 		if (d == UNI_DIRS) {
495 			dict2->refcount++;
496 			*conp->uni_pagedict_loc = dict2;
497 			con_release_unimap(dict1);
498 			kfree(dict1);
499 			return 1;
500 		}
501 	}
502 	return 0;
503 }
504 
505 static int
506 con_insert_unipair(struct uni_pagedict *p, u_short unicode, u_short fontpos)
507 {
508 	u16 **dir, *row;
509 	unsigned int n;
510 
511 	n = UNI_DIR(unicode);
512 	dir = p->uni_pgdir[n];
513 	if (!dir) {
514 		dir = p->uni_pgdir[n] = kzalloc_objs(*dir, UNI_DIR_ROWS);
515 		if (!dir)
516 			return -ENOMEM;
517 	}
518 
519 	n = UNI_ROW(unicode);
520 	row = dir[n];
521 	if (!row) {
522 		row = dir[n] = kmalloc_objs(*row, UNI_ROW_GLYPHS);
523 		if (!row)
524 			return -ENOMEM;
525 		/* No glyphs for the characters (yet) */
526 		memset(row, 0xff, UNI_ROW_GLYPHS * sizeof(*row));
527 	}
528 
529 	row[UNI_GLYPH(unicode)] = fontpos;
530 
531 	p->sum += (fontpos << 20U) + unicode;
532 
533 	return 0;
534 }
535 
536 static int con_allocate_new(struct vc_data *vc)
537 {
538 	struct uni_pagedict *new, *old = *vc->uni_pagedict_loc;
539 
540 	new = kzalloc_obj(*new);
541 	if (!new)
542 		return -ENOMEM;
543 
544 	new->refcount = 1;
545 	*vc->uni_pagedict_loc = new;
546 
547 	if (old)
548 		old->refcount--;
549 
550 	return 0;
551 }
552 
553 /* Caller must hold the lock */
554 static int con_do_clear_unimap(struct vc_data *vc)
555 {
556 	struct uni_pagedict *old = *vc->uni_pagedict_loc;
557 
558 	if (!old || old->refcount > 1)
559 		return con_allocate_new(vc);
560 
561 	old->sum = 0;
562 	con_release_unimap(old);
563 
564 	return 0;
565 }
566 
567 int con_clear_unimap(struct vc_data *vc)
568 {
569 	guard(console_lock)();
570 	return con_do_clear_unimap(vc);
571 }
572 
573 static struct uni_pagedict *con_unshare_unimap(struct vc_data *vc,
574 		struct uni_pagedict *old)
575 {
576 	struct uni_pagedict *new;
577 	unsigned int d, r, g;
578 	int ret;
579 	u16 uni = 0;
580 
581 	ret = con_allocate_new(vc);
582 	if (ret)
583 		return ERR_PTR(ret);
584 
585 	new = *vc->uni_pagedict_loc;
586 
587 	/*
588 	 * uni_pgdir is a 32*32*64 table with rows allocated when its first
589 	 * entry is added. The unicode value must still be incremented for
590 	 * empty rows. We are copying entries from "old" to "new".
591 	 */
592 	for (d = 0; d < UNI_DIRS; d++) {
593 		u16 **dir = old->uni_pgdir[d];
594 		if (!dir) {
595 			/* Account for empty table */
596 			uni += UNI_DIR_ROWS * UNI_ROW_GLYPHS;
597 			continue;
598 		}
599 
600 		for (r = 0; r < UNI_DIR_ROWS; r++) {
601 			u16 *row = dir[r];
602 			if (!row) {
603 				/* Account for row of 64 empty entries */
604 				uni += UNI_ROW_GLYPHS;
605 				continue;
606 			}
607 
608 			for (g = 0; g < UNI_ROW_GLYPHS; g++, uni++) {
609 				if (row[g] == 0xffff)
610 					continue;
611 				/*
612 				 * Found one, copy entry for unicode uni with
613 				 * fontpos value row[g].
614 				 */
615 				ret = con_insert_unipair(new, uni, row[g]);
616 				if (ret) {
617 					old->refcount++;
618 					*vc->uni_pagedict_loc = old;
619 					con_release_unimap(new);
620 					kfree(new);
621 					return ERR_PTR(ret);
622 				}
623 			}
624 		}
625 	}
626 
627 	return new;
628 }
629 
630 int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
631 {
632 	struct uni_pagedict *dict;
633 	struct unipair *plist;
634 	int err = 0;
635 
636 	if (!ct)
637 		return 0;
638 
639 	struct unipair *unilist __free(kvfree) = vmemdup_array_user(list, ct, sizeof(*unilist));
640 	if (IS_ERR(unilist))
641 		return PTR_ERR(unilist);
642 
643 	guard(console_lock)();
644 
645 	/* Save original vc_unipagdir_loc in case we allocate a new one */
646 	dict = *vc->uni_pagedict_loc;
647 	if (!dict)
648 		return -EINVAL;
649 
650 	if (dict->refcount > 1) {
651 		dict = con_unshare_unimap(vc, dict);
652 		if (IS_ERR(dict))
653 			return PTR_ERR(dict);
654 	} else if (dict == dflt) {
655 		dflt = NULL;
656 	}
657 
658 	/*
659 	 * Insert user specified unicode pairs into new table.
660 	 */
661 	for (plist = unilist; ct; ct--, plist++) {
662 		int err1 = con_insert_unipair(dict, plist->unicode, plist->fontpos);
663 		if (err1)
664 			err = err1;
665 	}
666 
667 	/*
668 	 * Merge with fontmaps of any other virtual consoles.
669 	 */
670 	if (con_unify_unimap(vc, dict))
671 		return err;
672 
673 	for (enum translation_map m = FIRST_MAP; m <= LAST_MAP; m++)
674 		set_inverse_transl(vc, dict, m);
675 	set_inverse_trans_unicode(dict);
676 
677 	return err;
678 }
679 
680 /**
681  *	con_set_default_unimap	-	set default unicode map
682  *	@vc: the console we are updating
683  *
684  *	Loads the unimap for the hardware font, as defined in uni_hash.tbl.
685  *	The representation used was the most compact I could come up
686  *	with.  This routine is executed at video setup, and when the
687  *	PIO_FONTRESET ioctl is called.
688  *
689  *	The caller must hold the console lock
690  */
691 int con_set_default_unimap(struct vc_data *vc)
692 {
693 	struct uni_pagedict *dict;
694 	unsigned int fontpos, count;
695 	int err = 0, err1;
696 	u16 *dfont;
697 
698 	if (dflt) {
699 		dict = *vc->uni_pagedict_loc;
700 		if (dict == dflt)
701 			return 0;
702 
703 		dflt->refcount++;
704 		*vc->uni_pagedict_loc = dflt;
705 		if (dict && !--dict->refcount) {
706 			con_release_unimap(dict);
707 			kfree(dict);
708 		}
709 		return 0;
710 	}
711 
712 	/* The default font is always 256 characters */
713 
714 	err = con_do_clear_unimap(vc);
715 	if (err)
716 		return err;
717 
718 	dict = *vc->uni_pagedict_loc;
719 	dfont = dfont_unitable;
720 
721 	for (fontpos = 0; fontpos < 256U; fontpos++)
722 		for (count = dfont_unicount[fontpos]; count; count--) {
723 			err1 = con_insert_unipair(dict, *(dfont++), fontpos);
724 			if (err1)
725 				err = err1;
726 		}
727 
728 	if (con_unify_unimap(vc, dict)) {
729 		dflt = *vc->uni_pagedict_loc;
730 		return err;
731 	}
732 
733 	for (enum translation_map m = FIRST_MAP; m <= LAST_MAP; m++)
734 		set_inverse_transl(vc, dict, m);
735 	set_inverse_trans_unicode(dict);
736 	dflt = dict;
737 	return err;
738 }
739 EXPORT_SYMBOL(con_set_default_unimap);
740 
741 /**
742  *	con_copy_unimap		-	copy unimap between two vts
743  *	@dst_vc: target
744  *	@src_vc: source
745  *
746  *	The caller must hold the console lock when invoking this method
747  */
748 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
749 {
750 	struct uni_pagedict *src;
751 
752 	if (!*src_vc->uni_pagedict_loc)
753 		return -EINVAL;
754 	if (*dst_vc->uni_pagedict_loc == *src_vc->uni_pagedict_loc)
755 		return 0;
756 	con_free_unimap(dst_vc);
757 	src = *src_vc->uni_pagedict_loc;
758 	src->refcount++;
759 	*dst_vc->uni_pagedict_loc = src;
760 	return 0;
761 }
762 EXPORT_SYMBOL(con_copy_unimap);
763 
764 /*
765  *	con_get_unimap		-	get the unicode map
766  *
767  *	Read the console unicode data for this console. Called from the ioctl
768  *	handlers.
769  */
770 int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct,
771 		struct unipair __user *list)
772 {
773 	ushort ect;
774 	struct uni_pagedict *dict;
775 	unsigned int d, r, g;
776 
777 	struct unipair *unilist __free(kvfree) = kvmalloc_objs(*unilist, ct);
778 	if (!unilist)
779 		return -ENOMEM;
780 
781 	scoped_guard(console_lock) {
782 		ect = 0;
783 		dict = *vc->uni_pagedict_loc;
784 		if (!dict)
785 			break;
786 
787 		for (d = 0; d < UNI_DIRS; d++) {
788 			u16 **dir = dict->uni_pgdir[d];
789 			if (!dir)
790 				continue;
791 
792 			for (r = 0; r < UNI_DIR_ROWS; r++) {
793 				u16 *row = dir[r];
794 				if (!row)
795 					continue;
796 
797 				for (g = 0; g < UNI_ROW_GLYPHS; g++, row++) {
798 					if (*row >= MAX_GLYPH)
799 						continue;
800 					if (ect < ct) {
801 						unilist[ect].unicode = UNI(d, r, g);
802 						unilist[ect].fontpos = *row;
803 					}
804 					ect++;
805 				}
806 			}
807 		}
808 	}
809 
810 	if (copy_to_user(list, unilist, min(ect, ct) * sizeof(*unilist)))
811 		return -EFAULT;
812 	if (put_user(ect, uct))
813 		return -EFAULT;
814 	if (ect > ct)
815 		return -ENOMEM;
816 
817 	return 0;
818 }
819 
820 /*
821  * Always use USER_MAP. These functions are used by the keyboard,
822  * which shouldn't be affected by G0/G1 switching, etc.
823  * If the user map still contains default values, i.e. the
824  * direct-to-font mapping, then assume user is using Latin1.
825  *
826  * FIXME: at some point we need to decide if we want to lock the table
827  * update element itself via the keyboard_event_lock for consistency with the
828  * keyboard driver as well as the consoles
829  */
830 /* may be called during an interrupt */
831 u32 conv_8bit_to_uni(unsigned char c)
832 {
833 	unsigned short uni = translations[USER_MAP][c];
834 	return uni == (0xf000 | c) ? c : uni;
835 }
836 
837 int conv_uni_to_8bit(u32 uni)
838 {
839 	int c;
840 	for (c = 0; c < ARRAY_SIZE(translations[USER_MAP]); c++)
841 		if (translations[USER_MAP][c] == uni ||
842 		   (translations[USER_MAP][c] == (c | 0xf000) && uni == c))
843 			return c;
844 	return -1;
845 }
846 
847 int conv_uni_to_pc(struct vc_data *conp, long ucs)
848 {
849 	struct uni_pagedict *dict;
850 	u16 **dir, *row, glyph;
851 
852 	/* Only 16-bit codes supported at this time */
853 	if (ucs > 0xffff)
854 		return -4;		/* Not found */
855 	else if (ucs < 0x20)
856 		return -1;		/* Not a printable character */
857 	/*
858 	 * UNI_DIRECT_BASE indicates the start of the region in the User Zone
859 	 * which always has a 1:1 mapping to the currently loaded font.  The
860 	 * UNI_DIRECT_MASK indicates the bit span of the region.
861 	 */
862 	else if ((ucs & ~UNI_DIRECT_MASK) == UNI_DIRECT_BASE)
863 		return ucs & UNI_DIRECT_MASK;
864 
865 	dict = *conp->uni_pagedict_loc;
866 	if (!dict)
867 		return -3;
868 
869 	dir = dict->uni_pgdir[UNI_DIR(ucs)];
870 	if (!dir)
871 		return -4;
872 
873 	row = dir[UNI_ROW(ucs)];
874 	if (!row)
875 		return -4;
876 
877 	glyph = row[UNI_GLYPH(ucs)];
878 	if (glyph >= MAX_GLYPH)
879 		return -4;
880 
881 	return glyph;
882 }
883 
884 /*
885  * This is called at sys_setup time, after memory and the console are
886  * initialized.  It must be possible to call kmalloc(..., GFP_KERNEL)
887  * from this function, hence the call from sys_setup.
888  */
889 void __init
890 console_map_init(void)
891 {
892 	int i;
893 
894 	for (i = 0; i < MAX_NR_CONSOLES; i++)
895 		if (vc_cons_allocated(i) && !*vc_cons[i].d->uni_pagedict_loc)
896 			con_set_default_unimap(vc_cons[i].d);
897 }
898 
899