1 // SPDX-License-Identifier: GPL-2.0
3 * Provide access to virtual console memory.
4 * /dev/vcs: the screen as it is being viewed right now (possibly scrolled)
5 * /dev/vcsN: the screen of /dev/ttyN (1 <= N <= 63)
8 * /dev/vcsaN: idem, but including attributes, and prefixed with
9 * the 4 bytes lines,columns,x,y (as screendump used to give).
10 * Attribute/character pair is in native endianity.
13 * /dev/vcsuN: similar to /dev/vcsaN but using 4-byte unicode values
14 * instead of 1-byte screen glyph values.
17 * /dev/vcsuaN: same idea as /dev/vcsaN for unicode (not yet implemented).
19 * This replaces screendump and part of selection, so that the system
20 * administrator can control access using file system permissions.
22 * aeb@cwi.nl - efter Friedas begravelse - 950211
24 * machek@k332.feld.cvut.cz - modified not to send characters to wrong console
25 * - fixed some fatal off-by-one bugs (0-- no longer == -1 -> looping and looping and looping...)
26 * - making it shorter - scr_readw are macros which expand in PRETTY long code
29 #include <linux/kernel.h>
30 #include <linux/major.h>
31 #include <linux/errno.h>
32 #include <linux/export.h>
33 #include <linux/tty.h>
34 #include <linux/interrupt.h>
36 #include <linux/init.h>
37 #include <linux/vt_kern.h>
38 #include <linux/selection.h>
39 #include <linux/kbd_kern.h>
40 #include <linux/console.h>
41 #include <linux/device.h>
42 #include <linux/sched.h>
44 #include <linux/poll.h>
45 #include <linux/signal.h>
46 #include <linux/slab.h>
47 #include <linux/notifier.h>
49 #include <linux/uaccess.h>
50 #include <asm/byteorder.h>
51 #include <asm/unaligned.h>
53 #define HEADER_SIZE 4u
54 #define CON_BUF_SIZE (CONFIG_BASE_SMALL ? 256 : PAGE_SIZE)
59 * 0 ... 63 glyph mode without attributes
60 * 64 ... 127 unicode mode without attributes
61 * 128 ... 191 glyph mode with attributes
62 * 192 ... 255 unused (reserved for unicode with attributes)
64 * This relies on MAX_NR_CONSOLES being <= 63, meaning 63 actual consoles
65 * with minors 0, 64, 128 and 192 being proxies for the foreground console.
67 #if MAX_NR_CONSOLES > 63
68 #warning "/dev/vcs* devices may not accommodate more than 63 consoles"
71 #define console(inode) (iminor(inode) & 63)
72 #define use_unicode(inode) (iminor(inode) & 64)
73 #define use_attributes(inode) (iminor(inode) & 128)
76 struct vcs_poll_data
{
77 struct notifier_block notifier
;
78 unsigned int cons_num
;
80 wait_queue_head_t waitq
;
81 struct fasync_struct
*fasync
;
85 vcs_notifier(struct notifier_block
*nb
, unsigned long code
, void *_param
)
87 struct vt_notifier_param
*param
= _param
;
88 struct vc_data
*vc
= param
->vc
;
89 struct vcs_poll_data
*poll
=
90 container_of(nb
, struct vcs_poll_data
, notifier
);
91 int currcons
= poll
->cons_num
;
106 currcons
= fg_console
;
109 if (currcons
!= vc
->vc_num
)
113 wake_up_interruptible(&poll
->waitq
);
114 kill_fasync(&poll
->fasync
, SIGIO
, fa_band
);
119 vcs_poll_data_free(struct vcs_poll_data
*poll
)
121 unregister_vt_notifier(&poll
->notifier
);
125 static struct vcs_poll_data
*
126 vcs_poll_data_get(struct file
*file
)
128 struct vcs_poll_data
*poll
= file
->private_data
, *kill
= NULL
;
133 poll
= kzalloc(sizeof(*poll
), GFP_KERNEL
);
136 poll
->cons_num
= console(file_inode(file
));
137 init_waitqueue_head(&poll
->waitq
);
138 poll
->notifier
.notifier_call
= vcs_notifier
;
140 * In order not to lose any update event, we must pretend one might
141 * have occurred before we have a chance to register our notifier.
142 * This is also how user space has come to detect which kernels
143 * support POLLPRI on /dev/vcs* devices i.e. using poll() with
144 * POLLPRI and a zero timeout.
146 poll
->event
= VT_UPDATE
;
148 if (register_vt_notifier(&poll
->notifier
) != 0) {
154 * This code may be called either through ->poll() or ->fasync().
155 * If we have two threads using the same file descriptor, they could
156 * both enter this function, both notice that the structure hasn't
157 * been allocated yet and go ahead allocating it in parallel, but
158 * only one of them must survive and be shared otherwise we'd leak
159 * memory with a dangling notifier callback.
161 spin_lock(&file
->f_lock
);
162 if (!file
->private_data
) {
163 file
->private_data
= poll
;
165 /* someone else raced ahead of us */
167 poll
= file
->private_data
;
169 spin_unlock(&file
->f_lock
);
171 vcs_poll_data_free(kill
);
177 * vcs_vc -- return VC for @inode
178 * @inode: inode for which to return a VC
179 * @viewed: returns whether this console is currently foreground (viewed)
181 * Must be called with console_lock.
183 static struct vc_data
*vcs_vc(struct inode
*inode
, bool *viewed
)
185 unsigned int currcons
= console(inode
);
187 WARN_CONSOLE_UNLOCKED();
190 currcons
= fg_console
;
198 return vc_cons
[currcons
].d
;
202 * vcs_size -- return size for a VC in @vc
204 * @attr: does it use attributes?
205 * @unicode: is it unicode?
207 * Must be called with console_lock.
209 static int vcs_size(const struct vc_data
*vc
, bool attr
, bool unicode
)
213 WARN_CONSOLE_UNLOCKED();
215 size
= vc
->vc_rows
* vc
->vc_cols
;
221 size
= 2 * size
+ HEADER_SIZE
;
228 static loff_t
vcs_lseek(struct file
*file
, loff_t offset
, int orig
)
230 struct inode
*inode
= file_inode(file
);
235 vc
= vcs_vc(inode
, NULL
);
241 size
= vcs_size(vc
, use_attributes(inode
), use_unicode(inode
));
245 return fixed_size_llseek(file
, offset
, orig
, size
);
248 static int vcs_read_buf_uni(struct vc_data
*vc
, char *con_buf
,
249 unsigned int pos
, unsigned int count
, bool viewed
)
251 unsigned int nr
, row
, col
, maxcol
= vc
->vc_cols
;
254 ret
= vc_uniscr_check(vc
);
265 vc_uniscr_copy_line(vc
, con_buf
, viewed
, row
, col
, nr
);
276 static void vcs_read_buf_noattr(const struct vc_data
*vc
, char *con_buf
,
277 unsigned int pos
, unsigned int count
, bool viewed
)
280 unsigned int col
, maxcol
= vc
->vc_cols
;
282 org
= screen_pos(vc
, pos
, viewed
);
286 while (count
-- > 0) {
287 *con_buf
++ = (vcs_scr_readw(vc
, org
++) & 0xff);
288 if (++col
== maxcol
) {
289 org
= screen_pos(vc
, pos
, viewed
);
296 static unsigned int vcs_read_buf(const struct vc_data
*vc
, char *con_buf
,
297 unsigned int pos
, unsigned int count
, bool viewed
,
300 u16
*org
, *con_buf16
;
301 unsigned int col
, maxcol
= vc
->vc_cols
;
302 unsigned int filled
= count
;
304 if (pos
< HEADER_SIZE
) {
305 /* clamp header values if they don't fit */
306 con_buf
[0] = min(vc
->vc_rows
, 0xFFu
);
307 con_buf
[1] = min(vc
->vc_cols
, 0xFFu
);
308 getconsxy(vc
, con_buf
+ 2);
312 if (count
> CON_BUF_SIZE
) {
313 count
= CON_BUF_SIZE
;
314 filled
= count
- pos
;
317 /* Advance state pointers and move on. */
318 count
-= min(HEADER_SIZE
, count
);
320 con_buf
+= HEADER_SIZE
;
321 /* If count >= 0, then pos is even... */
322 } else if (pos
& 1) {
324 * Skip first byte for output if start address is odd. Update
325 * region sizes up/down depending on free space in buffer.
328 if (count
< CON_BUF_SIZE
)
341 org
= screen_pos(vc
, pos
, viewed
);
345 * Buffer has even length, so we can always copy character + attribute.
346 * We do not copy last byte to userspace if count is odd.
348 count
= (count
+ 1) / 2;
349 con_buf16
= (u16
*)con_buf
;
352 *con_buf16
++ = vcs_scr_readw(vc
, org
++);
354 if (++col
== maxcol
) {
355 org
= screen_pos(vc
, pos
, viewed
);
365 vcs_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
367 struct inode
*inode
= file_inode(file
);
369 struct vcs_poll_data
*poll
;
374 bool viewed
, attr
, uni_mode
;
376 con_buf
= (char *) __get_free_page(GFP_KERNEL
);
382 /* Select the proper current console and verify
383 * sanity of the situation under the console lock.
387 uni_mode
= use_unicode(inode
);
388 attr
= use_attributes(inode
);
390 vc
= vcs_vc(inode
, &viewed
);
397 /* we enforce 32-bit alignment for pos and count in unicode mode */
398 if (uni_mode
&& (pos
| count
) & 3)
401 poll
= file
->private_data
;
407 unsigned int this_round
, skip
= 0;
410 /* Check whether we are above size each round,
411 * as copy_to_user at the end of this loop
414 size
= vcs_size(vc
, attr
, uni_mode
);
423 if (count
> size
- pos
)
427 if (this_round
> CON_BUF_SIZE
)
428 this_round
= CON_BUF_SIZE
;
430 /* Perform the whole read into the local con_buf.
431 * Then we can drop the console spinlock and safely
432 * attempt to move it to userspace.
436 ret
= vcs_read_buf_uni(vc
, con_buf
, pos
, this_round
,
441 vcs_read_buf_noattr(vc
, con_buf
, pos
, this_round
,
444 this_round
= vcs_read_buf(vc
, con_buf
, pos
, this_round
,
448 /* Finally, release the console semaphore while we push
449 * all the data to userspace from our temporary buffer.
451 * AKPM: Even though it's a semaphore, we should drop it because
452 * the pagefault handling code may want to call printk().
456 ret
= copy_to_user(buf
, con_buf
+ skip
, this_round
);
460 read
+= this_round
- ret
;
474 free_page((unsigned long) con_buf
);
478 static u16
*vcs_write_buf_noattr(struct vc_data
*vc
, const char *con_buf
,
479 unsigned int pos
, unsigned int count
, bool viewed
, u16
**org0
)
482 unsigned int col
, maxcol
= vc
->vc_cols
;
484 *org0
= org
= screen_pos(vc
, pos
, viewed
);
489 unsigned char c
= *con_buf
++;
493 (vcs_scr_readw(vc
, org
) & 0xff00) | c
, org
);
495 if (++col
== maxcol
) {
496 org
= screen_pos(vc
, pos
, viewed
);
506 * Compilers (gcc 10) are unable to optimize the swap in cpu_to_le16. So do it
509 static inline u16
vc_compile_le16(u8 hi
, u8 lo
)
512 return (lo
<< 8u) | hi
;
514 return (hi
<< 8u) | lo
;
518 static u16
*vcs_write_buf(struct vc_data
*vc
, const char *con_buf
,
519 unsigned int pos
, unsigned int count
, bool viewed
, u16
**org0
)
522 unsigned int col
, maxcol
= vc
->vc_cols
;
526 if (pos
< HEADER_SIZE
) {
527 char header
[HEADER_SIZE
];
529 getconsxy(vc
, header
+ 2);
530 while (pos
< HEADER_SIZE
&& count
> 0) {
532 header
[pos
++] = *con_buf
++;
535 putconsxy(vc
, header
+ 2);
542 col
= (pos
/2) % maxcol
;
544 *org0
= org
= screen_pos(vc
, pos
/2, viewed
);
546 /* odd pos -- the first single character */
550 vcs_scr_writew(vc
, vc_compile_le16(c
, vcs_scr_readw(vc
, org
)),
554 if (++col
== maxcol
) {
555 org
= screen_pos(vc
, pos
/2, viewed
);
563 /* even pos -- handle attr+character pairs */
567 w
= get_unaligned(((unsigned short *)con_buf
));
568 vcs_scr_writew(vc
, w
, org
++);
571 if (++col
== maxcol
) {
572 org
= screen_pos(vc
, pos
, viewed
);
581 /* odd pos -- the remaining character */
583 vcs_scr_writew(vc
, vc_compile_le16(vcs_scr_readw(vc
, org
) >> 8, c
),
590 vcs_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
592 struct inode
*inode
= file_inode(file
);
596 unsigned int written
;
602 if (use_unicode(inode
))
605 con_buf
= (char *) __get_free_page(GFP_KERNEL
);
611 /* Select the proper current console and verify
612 * sanity of the situation under the console lock.
616 attr
= use_attributes(inode
);
618 vc
= vcs_vc(inode
, &viewed
);
622 size
= vcs_size(vc
, attr
, false);
628 if (pos
< 0 || pos
> size
)
630 if (count
> size
- pos
)
634 unsigned int this_round
= count
;
636 if (this_round
> CON_BUF_SIZE
)
637 this_round
= CON_BUF_SIZE
;
639 /* Temporarily drop the console lock so that we can read
640 * in the write data from userspace safely.
643 ret
= copy_from_user(con_buf
, buf
, this_round
);
649 /* Abort loop if no data were copied. Otherwise
659 /* The vcs_size might have changed while we slept to grab
660 * the user buffer, so recheck.
661 * Return data written up to now on failure.
663 size
= vcs_size(vc
, attr
, false);
672 if (this_round
> size
- pos
)
673 this_round
= size
- pos
;
675 /* OK, now actually push the write to the console
676 * under the lock using the local kernel buffer.
680 org
= vcs_write_buf(vc
, con_buf
, pos
, this_round
,
683 org
= vcs_write_buf_noattr(vc
, con_buf
, pos
, this_round
,
687 written
+= this_round
;
691 update_region(vc
, (unsigned long)(org0
), org
- org0
);
700 free_page((unsigned long) con_buf
);
705 vcs_poll(struct file
*file
, poll_table
*wait
)
707 struct vcs_poll_data
*poll
= vcs_poll_data_get(file
);
708 __poll_t ret
= DEFAULT_POLLMASK
|EPOLLERR
;
711 poll_wait(file
, &poll
->waitq
, wait
);
712 switch (poll
->event
) {
714 ret
= DEFAULT_POLLMASK
|EPOLLPRI
;
717 ret
= DEFAULT_POLLMASK
|EPOLLHUP
|EPOLLERR
;
720 ret
= DEFAULT_POLLMASK
;
728 vcs_fasync(int fd
, struct file
*file
, int on
)
730 struct vcs_poll_data
*poll
= file
->private_data
;
733 /* don't allocate anything if all we want is disable fasync */
736 poll
= vcs_poll_data_get(file
);
741 return fasync_helper(fd
, file
, on
, &poll
->fasync
);
745 vcs_open(struct inode
*inode
, struct file
*filp
)
747 unsigned int currcons
= console(inode
);
748 bool attr
= use_attributes(inode
);
749 bool uni_mode
= use_unicode(inode
);
752 /* we currently don't support attributes in unicode mode */
753 if (attr
&& uni_mode
)
757 if(currcons
&& !vc_cons_allocated(currcons
-1))
763 static int vcs_release(struct inode
*inode
, struct file
*file
)
765 struct vcs_poll_data
*poll
= file
->private_data
;
768 vcs_poll_data_free(poll
);
772 static const struct file_operations vcs_fops
= {
777 .fasync
= vcs_fasync
,
779 .release
= vcs_release
,
782 static struct class *vc_class
;
784 void vcs_make_sysfs(int index
)
786 device_create(vc_class
, NULL
, MKDEV(VCS_MAJOR
, index
+ 1), NULL
,
788 device_create(vc_class
, NULL
, MKDEV(VCS_MAJOR
, index
+ 65), NULL
,
789 "vcsu%u", index
+ 1);
790 device_create(vc_class
, NULL
, MKDEV(VCS_MAJOR
, index
+ 129), NULL
,
791 "vcsa%u", index
+ 1);
794 void vcs_remove_sysfs(int index
)
796 device_destroy(vc_class
, MKDEV(VCS_MAJOR
, index
+ 1));
797 device_destroy(vc_class
, MKDEV(VCS_MAJOR
, index
+ 65));
798 device_destroy(vc_class
, MKDEV(VCS_MAJOR
, index
+ 129));
801 int __init
vcs_init(void)
805 if (register_chrdev(VCS_MAJOR
, "vcs", &vcs_fops
))
806 panic("unable to get major %d for vcs device", VCS_MAJOR
);
807 vc_class
= class_create(THIS_MODULE
, "vc");
809 device_create(vc_class
, NULL
, MKDEV(VCS_MAJOR
, 0), NULL
, "vcs");
810 device_create(vc_class
, NULL
, MKDEV(VCS_MAJOR
, 64), NULL
, "vcsu");
811 device_create(vc_class
, NULL
, MKDEV(VCS_MAJOR
, 128), NULL
, "vcsa");
812 for (i
= 0; i
< MIN_NR_CONSOLES
; i
++)