1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (c) 2010 Werner Fink, Jiri Slaby
  4 */
  5
  6#include <linux/console.h>
  7#include <linux/kernel.h>
  8#include <linux/proc_fs.h>
  9#include <linux/seq_file.h>
 10#include <linux/tty_driver.h>
 11
 12/*
 13 * This is handler for /proc/consoles
 14 */
 15static int show_console_dev(struct seq_file *m, void *v)
 16{
 17	static const struct {
 18		short flag;
 19		char name;
 20	} con_flags[] = {
 21		{ CON_ENABLED,		'E' },
 22		{ CON_CONSDEV,		'C' },
 23		{ CON_BOOT,		'B' },
 24		{ CON_NBCON,		'N' },
 25		{ CON_PRINTBUFFER,	'p' },
 26		{ CON_BRL,		'b' },
 27		{ CON_ANYTIME,		'a' },
 28	};
 29	char flags[ARRAY_SIZE(con_flags) + 1];
 30	struct console *con = v;
 31	unsigned int a;
 32	dev_t dev = 0;
 33
 34	if (con->device) {
 35		const struct tty_driver *driver;
 36		int index;
 37
 38		/*
 39		 * Take console_lock to serialize device() callback with
 40		 * other console operations. For example, fg_console is
 41		 * modified under console_lock when switching vt.
 42		 */
 43		console_lock();
 44		driver = con->device(con, &index);
 45		console_unlock();
 46
 47		if (driver) {
 48			dev = MKDEV(driver->major, driver->minor_start);
 49			dev += index;
 50		}
 51	}
 52
 53	for (a = 0; a < ARRAY_SIZE(con_flags); a++)
 54		flags[a] = (con->flags & con_flags[a].flag) ?
 55			con_flags[a].name : ' ';
 56	flags[a] = 0;
 57
 58	seq_setwidth(m, 21 - 1);
 59	seq_printf(m, "%s%d", con->name, con->index);
 60	seq_pad(m, ' ');
 61	seq_printf(m, "%c%c%c (%s)", con->read ? 'R' : '-',
 62		   ((con->flags & CON_NBCON) || con->write) ? 'W' : '-',
 63		   con->unblank ? 'U' : '-', flags);
 64	if (dev)
 65		seq_printf(m, " %4d:%d", MAJOR(dev), MINOR(dev));
 66
 67	seq_putc(m, '\n');
 68	return 0;
 69}
 70
 71static void *c_start(struct seq_file *m, loff_t *pos)
 72	__acquires(&console_mutex)
 73{
 74	struct console *con;
 75	loff_t off = 0;
 76
 77	/*
 78	 * Hold the console_list_lock to guarantee safe traversal of the
 79	 * console list. SRCU cannot be used because there is no
 80	 * place to store the SRCU cookie.
 81	 */
 82	console_list_lock();
 83	for_each_console(con)
 84		if (off++ == *pos)
 85			break;
 86
 87	return con;
 88}
 89
 90static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 91{
 92	struct console *con = v;
 93
 94	++*pos;
 95	return hlist_entry_safe(con->node.next, struct console, node);
 96}
 97
 98static void c_stop(struct seq_file *m, void *v)
 99	__releases(&console_mutex)
100{
101	console_list_unlock();
102}
103
104static const struct seq_operations consoles_op = {
105	.start	= c_start,
106	.next	= c_next,
107	.stop	= c_stop,
108	.show	= show_console_dev
109};
110
111static int __init proc_consoles_init(void)
112{
113	proc_create_seq("consoles", 0, NULL, &consoles_op);
114	return 0;
115}
116fs_initcall(proc_consoles_init);

 1// SPDX-License-Identifier: GPL-2.0-only
 2/*
 3 * Copyright (c) 2010 Werner Fink, Jiri Slaby
 4 */
 5
 6#include <linux/console.h>
 7#include <linux/kernel.h>
 8#include <linux/proc_fs.h>
 9#include <linux/seq_file.h>
10#include <linux/tty_driver.h>
11
12/*
13 * This is handler for /proc/consoles
14 */
15static int show_console_dev(struct seq_file *m, void *v)
16{
17	static const struct {
18		short flag;
19		char name;
20	} con_flags[] = {
21		{ CON_ENABLED,		'E' },
22		{ CON_CONSDEV,		'C' },
23		{ CON_BOOT,		'B' },
 
24		{ CON_PRINTBUFFER,	'p' },
25		{ CON_BRL,		'b' },
26		{ CON_ANYTIME,		'a' },
27	};
28	char flags[ARRAY_SIZE(con_flags) + 1];
29	struct console *con = v;
30	unsigned int a;
31	dev_t dev = 0;
32
33	if (con->device) {
34		const struct tty_driver *driver;
35		int index;
 
 
 
 
 
 
 
36		driver = con->device(con, &index);
 
 
37		if (driver) {
38			dev = MKDEV(driver->major, driver->minor_start);
39			dev += index;
40		}
41	}
42
43	for (a = 0; a < ARRAY_SIZE(con_flags); a++)
44		flags[a] = (con->flags & con_flags[a].flag) ?
45			con_flags[a].name : ' ';
46	flags[a] = 0;
47
48	seq_setwidth(m, 21 - 1);
49	seq_printf(m, "%s%d", con->name, con->index);
50	seq_pad(m, ' ');
51	seq_printf(m, "%c%c%c (%s)", con->read ? 'R' : '-',
52			con->write ? 'W' : '-', con->unblank ? 'U' : '-',
53			flags);
54	if (dev)
55		seq_printf(m, " %4d:%d", MAJOR(dev), MINOR(dev));
56
57	seq_putc(m, '\n');
58	return 0;
59}
60
61static void *c_start(struct seq_file *m, loff_t *pos)
 
62{
63	struct console *con;
64	loff_t off = 0;
65
66	console_lock();
 
 
 
 
 
67	for_each_console(con)
68		if (off++ == *pos)
69			break;
70
71	return con;
72}
73
74static void *c_next(struct seq_file *m, void *v, loff_t *pos)
75{
76	struct console *con = v;
 
77	++*pos;
78	return con->next;
79}
80
81static void c_stop(struct seq_file *m, void *v)
 
82{
83	console_unlock();
84}
85
86static const struct seq_operations consoles_op = {
87	.start	= c_start,
88	.next	= c_next,
89	.stop	= c_stop,
90	.show	= show_console_dev
91};
92
93static int __init proc_consoles_init(void)
94{
95	proc_create_seq("consoles", 0, NULL, &consoles_op);
96	return 0;
97}
98fs_initcall(proc_consoles_init);