Consoles can have vastly different latencies and throughputs. For
example, writing a message to the serial console can take on the order
of tens of milliseconds to get the UART to successfully write a message.
While this might be fine for a single, one-off message, this can cause
significant application-level stalls in situations where the kernel
writes large amounts of information to the console.
This means that while you might want to send at least INFO level
messages to (for example) netconsole, which is relatively fast, you may
only want to send at least WARN level messages to the serial console.
Such an implementation would permit debugging using the serial console
in cases that netconsole doesn't receive messages during particularly
bad system issues, while still keeping the noise low enough to avoid
inducing latency in userspace applications. This patch adds such an
interface, extending the existing console loglevel controls to allow
each console to have its own loglevel.
One can't just disable the serial console, because one may actually need
it in situations where the machine is in a bad enough state that nothing
is received on netconsole. One also can't just bump the loglevel at
runtime after the issue, because usually the machine is already so
wedged by this point that it isn't responsive to such requests.
In terms of technical implementation, this patch embeds a device pointer
in the console struct, and registers each console using it so we can
expose attributes in sysfs. We currently expose the following
attributes:
% ls -l /sys/class/console/ttyS/
total 0
lrwxrwxrwx 1 root root 0 Jul 20 17:37 subsystem -> ../../../../class/console/
-r--r--r-- 1 root root 4096 Jul 20 17:38 effective_loglevel
-r--r--r-- 1 root root 4096 Jul 20 17:38 effective_loglevel_source
-r--r--r-- 1 root root 4096 Jul 20 17:38 enabled
-rw-r--r-- 1 root root 4096 Jul 20 17:38 loglevel
-rw-r--r-- 1 root root 4096 Jul 20 17:37 uevent
The lifecycle of this classdev looks like this on registration:
register_console(con)/printk_late_init()
console_register_device(con)
device_initialize(con->classdev) # refcount++
device_add(con->classdev) # refcount++
At stable state, the refcount is two.
Console unregistration looks like this:
[con->classdev refcount drops to 0]
console_classdev_release(con->classdev)
kfree(con->classdev)
unregister_console(con)
device_unregister(con->classdev)
device_del(con->classdev) # refcount--
device_remove_class_symlinks()
kernfs_remove_by_name_ns()
kernfs_drain()
kernfs_drain_open_files() # wait for close()
put_device(con->classdev) # refcount--
We also deprecate the kernel.printk sysctl as it doesn't know about
per-console loglevels, and is generally pretty confusing.
For information on the precedence and application of the new controls,
see Documentation/ABI/testing/sysfs-class-console and
Documentation/admin-guide/per-console-loglevel.rst.
Signed-off-by: Chris Down <[email protected]>
---
Documentation/ABI/testing/sysfs-class-console | 43 +++
.../admin-guide/kernel-parameters.txt | 28 +-
.../admin-guide/per-console-loglevel.rst | 92 ++++++
Documentation/admin-guide/serial-console.rst | 17 +-
Documentation/core-api/printk-basics.rst | 35 +--
Documentation/networking/netconsole.rst | 17 ++
MAINTAINERS | 3 +
include/linux/console.h | 24 ++
kernel/printk/console_cmdline.h | 2 +
kernel/printk/printk.c | 285 +++++++++++++++++-
kernel/printk/sysctl.c | 64 +++-
11 files changed, 574 insertions(+), 36 deletions(-)
create mode 100644 Documentation/ABI/testing/sysfs-class-console
create mode 100644 Documentation/admin-guide/per-console-loglevel.rst
diff --git a/Documentation/ABI/testing/sysfs-class-console b/Documentation/ABI/testing/sysfs-class-console
new file mode 100644
index 000000000000..4abbde9b57e0
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-class-console
@@ -0,0 +1,43 @@
+What: /sys/class/console/
+Date: May 2022
+Contact: Chris Down <[email protected]>
+Description: Interface for viewing and setting per-console attributes, like
+ the per-console loglevel. For a high-level document describing
+ the motivations for this interface and related non-sysfs
+ controls, see
+ Documentation/admin-guide/per-console-loglevel.rst.
+
+What: /sys/class/console/<C>/effective_loglevel
+Date: May 2022
+Contact: Chris Down <[email protected]>
+Description: Read only. The currently effective loglevel for this console.
+ All messages emitted with a loglevel below the effective value
+ will be emitted to the console.
+
+What: /sys/class/console/<C>/effective_loglevel_source
+Date: May 2022
+Contact: Chris Down <[email protected]>
+Description: Read only. The currently effective loglevel source for this
+ console -- for example, whether it was set globally, or whether
+ it was set locally for this console. Possible values are:
+
+ local: The loglevel comes from the per-console loglevel.
+ global: The loglevel comes from the global loglevel.
+ ignore_loglevel: Both the per-console loglevel and global
+ loglevels are ignored as ignore_loglevel is
+ present on the kernel command line.
+
+What: /sys/class/console/<C>/enabled
+Date: May 2022
+Contact: Chris Down <[email protected]>
+Description: Read only. "1" if the console is enabled, "0" otherwise.
+
+What: /sys/class/console/<C>/loglevel
+Date: May 2022
+Contact: Chris Down <[email protected]>
+Description: Read write. The current per-console loglevel, which will take
+ effect if not overridden by other non-sysfs controls (see
+ Documentation/admin-guide/per-console-loglevel.rst). Bounds are
+ 0 (LOGLEVEL_EMERG) to 8 (LOGLEVEL_DEBUG + 1) inclusive. Also
+ takes the special value "unset" to indicate that no per-console
+ loglevel is set, and we should defer to the global controls.
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 2522b11e593f..a8ef6d0b7c1d 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -702,13 +702,18 @@
ttyS<n>[,options]
ttyUSB0[,options]
Use the specified serial port. The options are of
- the form "bbbbpnf", where "bbbb" is the baud rate,
- "p" is parity ("n", "o", or "e"), "n" is number of
- bits, and "f" is flow control ("r" for RTS or
- omit it). Default is "9600n8".
+ the form "bbbbpnf,extra", where "bbbb" is the baud
+ rate, "p" is parity ("n", "o", or "e"), "n" is
+ number of bits, and "f" is flow control ("r" for RTS
+ or omit it). Default is "9600n8".
- See Documentation/admin-guide/serial-console.rst for more
- information. See
+ At present the only extra option is "loglevel" to
+ set the per-console loglevel. For example:
+
+ console=ttyS0,9600n8,loglevel:3
+
+ See Documentation/admin-guide/serial-console.rst for
+ more information. See
Documentation/networking/netconsole.rst for an
alternative.
@@ -2806,10 +2811,13 @@
logibm.irq= [HW,MOUSE] Logitech Bus Mouse Driver
Format: <irq>
- loglevel= All Kernel Messages with a loglevel smaller than the
- console loglevel will be printed to the console. It can
- also be changed with klogd or other programs. The
- loglevels are defined as follows:
+ loglevel= Sets the global loglevel. All messages with a loglevel
+ smaller than the console loglevel will be printed to
+ the console. Note that this can be overridden
+ per-console, see
+ Documentation/admin-guide/per-console-loglevel.rst.
+
+ The loglevels are defined as follows:
0 (KERN_EMERG) system is unusable
1 (KERN_ALERT) action must be taken immediately
diff --git a/Documentation/admin-guide/per-console-loglevel.rst b/Documentation/admin-guide/per-console-loglevel.rst
new file mode 100644
index 000000000000..11ffdc53c8e8
--- /dev/null
+++ b/Documentation/admin-guide/per-console-loglevel.rst
@@ -0,0 +1,92 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+.. _per_console_loglevel:
+
+Per-console loglevel support
+============================
+
+Motivation
+----------
+
+Consoles can have vastly different latencies and throughputs. For example,
+writing a message to the serial console can take on the order of tens of
+milliseconds to get the UART to successfully write a message. While this might
+be fine for a single, one-off message, this can cause significant
+application-level stalls in situations where the kernel writes large amounts of
+information to the console.
+
+This means that while you might want to send at least INFO level messages to
+(for example) netconsole, which is relatively fast, you may only want to send
+at least WARN level messages to the serial console. This permits debugging
+using the serial console in cases that netconsole doesn't receive messages
+during particularly bad system issues, while still keeping the noise low enough
+to avoid inducing latency in userspace applications.
+
+Tunables
+--------
+
+In order to allow tuning this, the following controls exist:
+
+Global
+~~~~~~
+
+The global loglevel is set by the ``kernel.console_loglevel`` sysctl, which can
+also be set as ``loglevel=`` on the kernel command line.
+
+The printk module also takes two parameters which modify this behaviour
+further:
+
+* ``ignore_loglevel`` on the kernel command line or set in printk parameters:
+ Emit all messages. All other controls are ignored if this is present.
+* ``ignore_per_console_loglevel`` on the kernel command line or set in printk
+ parameters: Ignore all per-console loglevels and use the global loglevel.
+
+The default value for ``kernel.console_loglevel`` comes from
+``CONFIG_CONSOLE_LOGLEVEL_DEFAULT``, or ``CONFIG_CONSOLE_LOGLEVEL_QUIET`` if
+``quiet`` is passed on the kernel command line.
+
+Console attributes
+~~~~~~~~~~~~~~~~~~
+
+Registered consoles are exposed at ``/sys/class/console``. For example, if you
+are using ``ttyS0``, the console backing it can be viewed at
+``/sys/class/console/ttyS/``. The following files are available:
+
+* ``effective_loglevel`` (r): The effective loglevel after considering all
+ loglevel authorities. For example, if the console-specific loglevel is 3, but
+ the global minimum console loglevel[*]_ is 5, then the value will be 5.
+* ``effective_loglevel_source`` (r): The loglevel authority which resulted in
+ the effective loglevel being set. The following values can be present:
+
+ * ``local``: The console-specific loglevel is in effect.
+ * ``global``: The global loglevel (``kernel.console_loglevel``) is in
+ effect. Set a console-specific loglevel to override it.
+ * ``ignore_loglevel``: ``ignore_loglevel`` was specified on the kernel
+ command line or at ``/sys/module/printk/parameters/ignore_loglevel``.
+ Disable it to use level controls.
+ * ``ignore_per_console_loglevel``: ``ignore_per_console_loglevel`` was
+ specified on the kernel command line or at
+ ``/sys/module/printk/parameters/ignore_per_console_loglevel``. Disable it
+ to use per-console level controls.
+
+* ``enabled`` (r): Whether the console is enabled.
+* ``loglevel`` (rw): The local, console-specific loglevel for this console.
+ This will be in effect if no other global control overrides it. Look at
+ ``effective_loglevel`` and ``effective_loglevel_source`` to verify that.
+
+.. [*] The existence of a minimum console loglevel is generally considered to
+ be a confusing and rarely used interface, and as such is not exposed through
+ the modern printk sysctl APIs that obsoleted ``kernel.printk``. Use the
+ legacy ``kernel.printk`` sysctl to control it if you have a rare use case
+ that requires changing it. The default value is ``CONSOLE_LOGLEVEL_MIN``.
+
+Deprecated
+~~~~~~~~~~
+
+* ``kernel.printk`` sysctl: this takes four values, setting
+ ``kernel.console_loglevel``, ``kernel.default_message_loglevel``, the minimum
+ console loglevel, and a fourth unused value. The interface is generally
+ considered to quite confusing, doesn't perform checks on the values given,
+ and is unaware of per-console loglevel semantics.
+
+Chris Down <[email protected]>, 17-May-2022
diff --git a/Documentation/admin-guide/serial-console.rst b/Documentation/admin-guide/serial-console.rst
index 58b32832e50a..794c1a51497b 100644
--- a/Documentation/admin-guide/serial-console.rst
+++ b/Documentation/admin-guide/serial-console.rst
@@ -32,15 +32,25 @@ The format of this option is::
and F is flow control ('r' for RTS). Default is
9600n8. The maximum baudrate is 115200.
+ One can also specify the per-console loglevel for this
+ console by providing a loglevel parameter, for example
+ "loglevel:4" to set this console's loglevel to 4. The
+ value provided can be from 0 (LOGLEVEL_EMERG) to 8
+ (LOGLEVEL_DEBUG + 1), and messages below that will be
+ emitted onto the console as they become available.
+
You can specify multiple console= options on the kernel command line.
Output will appear on all of them. The last device will be used when
you open ``/dev/console``. So, for example::
- console=ttyS1,9600 console=tty0
+ console=ttyS1,9600,loglevel:5 console=tty0
defines that opening ``/dev/console`` will get you the current foreground
-virtual console, and kernel messages will appear on both the VGA
-console and the 2nd serial port (ttyS1 or COM2) at 9600 baud.
+virtual console, and kernel messages will appear on both the VGA console and
+the 2nd serial port (ttyS1 or COM2) at 9600 baud. The optional loglevel "5"
+indicates that this console will emit messages more serious than
+LOGLEVEL_NOTICE (that is, LOGLEVEL_WARNING and below, since more serious
+messages have lower ordering).
Note that you can only define one console per device type (serial, video).
@@ -113,3 +123,4 @@ Replace the sample values as needed.
the integration of these patches into m68k, ppc and alpha.
Miquel van Smoorenburg <[email protected]>, 11-Jun-2000
+Chris Down <[email protected]>, 17-May-2022
diff --git a/Documentation/core-api/printk-basics.rst b/Documentation/core-api/printk-basics.rst
index 2dde24ca7d9f..44a4e62558b8 100644
--- a/Documentation/core-api/printk-basics.rst
+++ b/Documentation/core-api/printk-basics.rst
@@ -54,32 +54,33 @@ string, the log level is not a separate argument). The available log levels are:
The log level specifies the importance of a message. The kernel decides whether
to show the message immediately (printing it to the current console) depending
-on its log level and the current *console_loglevel* (a kernel variable). If the
-message priority is higher (lower log level value) than the *console_loglevel*
-the message will be printed to the console.
+on its log level and the current global *console_loglevel* or local per-console
+loglevel (kernel variables). If the message priority is higher (lower log level
+value) than the effective loglevel the message will be printed to the console.
If the log level is omitted, the message is printed with ``KERN_DEFAULT``
level.
-You can check the current *console_loglevel* with::
+You can check the current console's loglevel -- for example if you want to
+check the loglevel for serial consoles:
- $ cat /proc/sys/kernel/printk
- 4 4 1 7
+ $ cat /sys/class/console/ttyS/effective_loglevel
+ 6
+ $ cat /sys/class/console/ttyS/effective_loglevel_source
+ local
-The result shows the *current*, *default*, *minimum* and *boot-time-default* log
-levels.
+To change the default loglevel for all consoles, simply write the desired level
+to ``/proc/sys/kernel/console_loglevel``. For example::
-To change the current console_loglevel simply write the desired level to
-``/proc/sys/kernel/printk``. For example, to print all messages to the console::
+ # echo 5 > /proc/sys/kernel/console_loglevel
- # echo 8 > /proc/sys/kernel/printk
+This sets the console_loglevel to print KERN_WARNING (4) or more severe
+messages to console. Consoles with a per-console loglevel set will ignore it
+unless ``ignore_per_console_loglevel`` is set on the kernel command line or at
+``/sys/module/printk/parameters/ignore_per_console_loglevel``.
-Another way, using ``dmesg``::
-
- # dmesg -n 5
-
-sets the console_loglevel to print KERN_WARNING (4) or more severe messages to
-console. See ``dmesg(1)`` for more information.
+For more information on per-console loglevels, see
+Documentation/admin-guide/per-console-loglevel.rst.
As an alternative to printk() you can use the ``pr_*()`` aliases for
logging. This family of macros embed the log level in the macro names. For
diff --git a/Documentation/networking/netconsole.rst b/Documentation/networking/netconsole.rst
index 1f5c4a04027c..fd566840b429 100644
--- a/Documentation/networking/netconsole.rst
+++ b/Documentation/networking/netconsole.rst
@@ -67,6 +67,23 @@ Built-in netconsole starts immediately after the TCP stack is
initialized and attempts to bring up the supplied dev at the supplied
address.
+You can also set a loglevel at boot time on the kernel command line::
+
+ console=netcon0,loglevel:2
+
+This can also be changed at runtime::
+
+ $ ls -l /sys/class/console/netcon/
+ total 0
+ lrwxrwxrwx 1 root root 0 May 18 13:28 subsystem -> ../../../../class/console/
+ -r--r--r-- 1 root root 4096 May 18 13:28 effective_loglevel
+ -r--r--r-- 1 root root 4096 May 18 13:28 effective_loglevel_source
+ -r--r--r-- 1 root root 4096 May 18 13:28 enabled
+ -rw-r--r-- 1 root root 4096 May 18 13:28 loglevel
+ -rw-r--r-- 1 root root 4096 May 18 13:28 uevent
+
+See Documentation/admin-guide/per-console-loglevel.rst for more information.
+
The remote host has several options to receive the kernel messages,
for example:
diff --git a/MAINTAINERS b/MAINTAINERS
index 6cc825857722..e51e25ec3cdf 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -16044,6 +16044,9 @@ R: Steven Rostedt <[email protected]>
R: John Ogness <[email protected]>
S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/printk/linux.git
+F: Documentation/ABI/testing/sysfs-class-console
+F: Documentation/admin-guide/per-console-loglevel.rst
+F: Documentation/core-api/printk-basics.rst
F: include/linux/printk.h
F: kernel/printk/
diff --git a/include/linux/console.h b/include/linux/console.h
index 8c1686e2c233..4ed9bde63139 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -15,6 +15,7 @@
#define _LINUX_CONSOLE_H_ 1
#include <linux/atomic.h>
+#include <linux/device.h>
#include <linux/types.h>
struct vc_data;
@@ -137,6 +138,22 @@ static inline int con_debug_leave(void)
#define CON_BRL (32) /* Used for a braille device */
#define CON_EXTENDED (64) /* Use the extended output format a la /dev/kmsg */
+/*
+ * The loglevel for a console can be set in many places:
+ *
+ * 1. It can be forced to emit everything (ignore_loglevel);
+ * 2. It can be set globally (sysctls kernel.printk (deprecated),
+ * kernel.console_loglevel, magic sysrq, loglevel= on kernel command line);
+ * 3. It can be locally set for this specific console (console=...,loglevel:N on
+ * kernel command line, /sys/class/console/.../loglevel);
+ * 4. It can be set by a compile-time default
+ * (CONFIG_CONSOLE_LOGLEVEL_{DEFAULT,QUIET})
+ *
+ * If case 3 happens, even if another global value in effect, CON_LOGLEVEL will
+ * be set.
+ */
+#define CON_LOGLEVEL (128) /* Level set locally for this console */
+
struct console {
char name[16];
void (*write)(struct console *, const char *, unsigned);
@@ -155,8 +172,15 @@ struct console {
unsigned long dropped;
void *data;
struct console *next;
+ int level;
+ struct device *classdev;
};
+static inline struct console *classdev_to_console(struct device *dev)
+{
+ return dev_get_drvdata(dev);
+}
+
/*
* for_each_console() allows you to iterate on each console
*/
diff --git a/kernel/printk/console_cmdline.h b/kernel/printk/console_cmdline.h
index 3ca74ad391d6..40f1a1ff0965 100644
--- a/kernel/printk/console_cmdline.h
+++ b/kernel/printk/console_cmdline.h
@@ -6,6 +6,8 @@ struct console_cmdline
{
char name[16]; /* Name of the driver */
int index; /* Minor dev. to use */
+ int level; /* Log level to use */
+ short flags; /* Initial flags */
bool user_specified; /* Specified by command line vs. platform */
char *options; /* Options for the driver */
#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 6094f773ad4a..6f5e29b60875 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -44,6 +44,7 @@
#include <linux/irq_work.h>
#include <linux/ctype.h>
#include <linux/uio.h>
+#include <linux/device.h>
#include <linux/sched/clock.h>
#include <linux/sched/debug.h>
#include <linux/sched/task_stack.h>
@@ -385,6 +386,20 @@ static struct latched_seq clear_seq = {
.val[1] = 0,
};
+static struct class *console_class;
+
+enum loglevel_source {
+ LLS_GLOBAL,
+ LLS_LOCAL,
+ LLS_IGNORE_LOGLEVEL,
+};
+
+static const char *const loglevel_source_names[] = {
+ [LLS_GLOBAL] = "global",
+ [LLS_LOCAL] = "local",
+ [LLS_IGNORE_LOGLEVEL] = "ignore_loglevel",
+};
+
#ifdef CONFIG_PRINTK_CALLER
#define PREFIX_MAX 48
#else
@@ -1202,9 +1217,72 @@ module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(ignore_loglevel,
"ignore loglevel setting (prints all kernel messages to the console)");
-static bool suppress_message_printing(int level)
+static bool __read_mostly ignore_per_console_loglevel;
+
+static int __init ignore_per_console_loglevel_setup(char *str)
+{
+ ignore_per_console_loglevel = true;
+ return 0;
+}
+
+early_param("ignore_per_console_loglevel", ignore_per_console_loglevel_setup);
+module_param(ignore_per_console_loglevel, bool, 0644);
+MODULE_PARM_DESC(ignore_per_console_loglevel,
+ "ignore per-console loglevel setting (only respect global console loglevel)");
+
+/*
+ * Hierarchy of loglevel authority:
+ *
+ * 1. con->level. The locally set, console-specific loglevel. Optional, only
+ * valid if the CON_LOGLEVEL flag is set.
+ * 2. console_loglevel. The default global console loglevel, always present.
+ *
+ * The behaviour can be further changed by the following printk module
+ * parameters:
+ *
+ * 1. ignore_loglevel. Can be set at boot or at runtime with
+ * /sys/module/printk/parameters/ignore_loglevel. Overrides absolutely
+ * everything since it's used to debug.
+ * 2. ignore_per_console_loglevel. Existing per-console loglevel values are left
+ * intact, but are ignored in favour of console_loglevel as long as this is
+ * true.
+ *
+ * Callers typically only need the level _or_ the source, but they're both
+ * emitted from this function so that the effective loglevel logic can be
+ * kept in one place.
+ */
+static int console_effective_loglevel(const struct console *con,
+ enum loglevel_source *source)
+{
+ enum loglevel_source lsource;
+ int level;
+
+ if (ignore_loglevel) {
+ lsource = LLS_IGNORE_LOGLEVEL;
+ level = CONSOLE_LOGLEVEL_MOTORMOUTH;
+ goto out;
+ }
+
+ if (!ignore_per_console_loglevel &&
+ (con && (con->flags & CON_LOGLEVEL))) {
+ lsource = LLS_LOCAL;
+ level = con->level;
+ goto out;
+ }
+
+ lsource = LLS_GLOBAL;
+ level = console_loglevel;
+
+out:
+ *source = lsource;
+ return level;
+}
+
+static bool suppress_message_printing(int level, struct console *con)
{
- return (level >= console_loglevel && !ignore_loglevel);
+ enum loglevel_source source;
+
+ return level >= console_effective_loglevel(con, &source);
}
#ifdef CONFIG_BOOT_PRINTK_DELAY
@@ -1236,7 +1314,7 @@ static void boot_delay_msec(int level)
unsigned long timeout;
if ((boot_delay == 0 || system_state >= SYSTEM_RUNNING)
- || suppress_message_printing(level)) {
+ || suppress_message_printing(level, NULL)) {
return;
}
@@ -1656,6 +1734,33 @@ static void syslog_clear(void)
mutex_unlock(&syslog_lock);
}
+/*
+ * Using the global klogctl/syslog API is unlikely to do what you want if you
+ * also have console specific loglevels. Warn about it.
+ */
+static void warn_on_local_loglevel(void)
+{
+ static bool warned;
+ struct console *con;
+
+ if (warned)
+ return;
+
+ if (ignore_per_console_loglevel)
+ return;
+
+ console_lock();
+ for_each_console(con) {
+ if (con->flags & CON_LOGLEVEL) {
+ warned = true;
+ pr_warn("%s (%d) used syslog(SYSLOG_ACTION_CONSOLE_*) with per-console loglevels set. Consoles with per-console loglevels will ignore the updated value.\n",
+ current->comm, current->pid);
+ break;
+ }
+ }
+ console_unlock();
+}
+
int do_syslog(int type, char __user *buf, int len, int source)
{
struct printk_info info;
@@ -1701,12 +1806,14 @@ int do_syslog(int type, char __user *buf, int len, int source)
break;
/* Disable logging to console */
case SYSLOG_ACTION_CONSOLE_OFF:
+ warn_on_local_loglevel();
if (saved_console_loglevel == LOGLEVEL_DEFAULT)
saved_console_loglevel = console_loglevel;
console_loglevel = minimum_console_loglevel;
break;
/* Enable logging to console */
case SYSLOG_ACTION_CONSOLE_ON:
+ warn_on_local_loglevel();
if (saved_console_loglevel != LOGLEVEL_DEFAULT) {
console_loglevel = saved_console_loglevel;
saved_console_loglevel = LOGLEVEL_DEFAULT;
@@ -1714,6 +1821,7 @@ int do_syslog(int type, char __user *buf, int len, int source)
break;
/* Set level of messages printed to console */
case SYSLOG_ACTION_CONSOLE_LEVEL:
+ warn_on_local_loglevel();
if (len < 1 || len > 8)
return -EINVAL;
if (len < minimum_console_loglevel)
@@ -2329,7 +2437,10 @@ static void call_console_driver(struct console *con, const char *text, size_t le
char *dropped_text)
{
}
-static bool suppress_message_printing(int level) { return false; }
+static bool suppress_message_printing(int level, struct console *con)
+{
+ return false;
+}
static bool __pr_flush(struct console *con, int timeout_ms, bool reset_on_progress) { return true; }
#endif /* CONFIG_PRINTK */
@@ -2381,6 +2492,14 @@ static void parse_console_cmdline_options(struct console_cmdline *c,
if (value)
*(value++) = '\0';
+ if (strcmp(key, "loglevel") == 0 && value &&
+ isdigit(value[0]) && strlen(value) == 1) {
+ c->level = clamp(value[0] - '0', LOGLEVEL_EMERG,
+ LOGLEVEL_DEBUG + 1);
+ c->flags |= CON_LOGLEVEL;
+ continue;
+ }
+
if (!seen_serial_opts && isdigit(key[0]) && !value) {
seen_serial_opts = true;
c->options = key;
@@ -2724,7 +2843,7 @@ static bool console_emit_next_record(struct console *con, char *text, char *ext_
}
/* Skip record that has level above the console loglevel. */
- if (suppress_message_printing(r.info->level)) {
+ if (suppress_message_printing(r.info->level, con)) {
con->seq++;
goto skip;
}
@@ -3030,6 +3149,145 @@ static int __init keep_bootcon_setup(char *str)
early_param("keep_bootcon", keep_bootcon_setup);
+#ifdef CONFIG_PRINTK
+static ssize_t loglevel_show(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct console *con = classdev_to_console(dev);
+
+ if (con->flags & CON_LOGLEVEL)
+ return sysfs_emit(buf, "%d\n", con->level);
+ else
+ return sysfs_emit(buf, "unset\n");
+}
+
+static ssize_t loglevel_store(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct console *con = classdev_to_console(dev);
+ ssize_t ret;
+ int tmp;
+
+ if (!strcmp(buf, "unset") || !strcmp(buf, "unset\n")) {
+ con->flags &= ~CON_LOGLEVEL;
+ return size;
+ }
+
+ ret = kstrtoint(buf, 10, &tmp);
+ if (ret < 0)
+ return ret;
+
+ if (tmp < LOGLEVEL_EMERG || tmp > LOGLEVEL_DEBUG + 1)
+ return -ERANGE;
+
+ if (tmp < minimum_console_loglevel)
+ return -EINVAL;
+
+ con->level = tmp;
+ con->flags |= CON_LOGLEVEL;
+
+ return size;
+}
+
+static DEVICE_ATTR_RW(loglevel);
+
+static ssize_t effective_loglevel_source_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct console *con = classdev_to_console(dev);
+ enum loglevel_source source;
+
+ console_effective_loglevel(con, &source);
+ return sysfs_emit(buf, "%s\n", loglevel_source_names[source]);
+}
+
+static DEVICE_ATTR_RO(effective_loglevel_source);
+
+static ssize_t effective_loglevel_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct console *con = classdev_to_console(dev);
+ enum loglevel_source source;
+
+ return sysfs_emit(buf, "%d\n",
+ console_effective_loglevel(con, &source));
+}
+
+static DEVICE_ATTR_RO(effective_loglevel);
+
+static ssize_t enabled_show(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct console *con = classdev_to_console(dev);
+
+ return sysfs_emit(buf, "%d\n", !!(con->flags & CON_ENABLED));
+}
+
+static DEVICE_ATTR_RO(enabled);
+
+static struct attribute *console_sysfs_attrs[] = {
+ &dev_attr_loglevel.attr,
+ &dev_attr_effective_loglevel_source.attr,
+ &dev_attr_effective_loglevel.attr,
+ &dev_attr_enabled.attr,
+ NULL,
+};
+
+ATTRIBUTE_GROUPS(console_sysfs);
+
+static void console_classdev_release(struct device *dev)
+{
+ kfree(dev);
+}
+
+static void console_register_device(struct console *new)
+{
+ /*
+ * We might be called from register_console() before the class is
+ * registered. If that happens, we'll take care of it in
+ * printk_late_init.
+ */
+ if (IS_ERR_OR_NULL(console_class))
+ return;
+
+ new->classdev = kzalloc(sizeof(struct device), GFP_KERNEL);
+ if (!new->classdev)
+ return;
+
+ device_initialize(new->classdev);
+ dev_set_name(new->classdev, "%s", new->name);
+ dev_set_drvdata(new->classdev, new);
+ new->classdev->release = console_classdev_release;
+ new->classdev->class = console_class;
+ if (device_add(new->classdev))
+ put_device(new->classdev);
+}
+
+static void console_setup_class(void)
+{
+ struct console *con;
+
+ /*
+ * printk exists for the lifetime of the kernel, it cannot be unloaded,
+ * so we should never end up back in here.
+ */
+ if (WARN_ON(console_class))
+ return;
+
+ console_class = class_create(THIS_MODULE, "console");
+ if (!IS_ERR(console_class))
+ console_class->dev_groups = console_sysfs_groups;
+
+ for_each_console(con)
+ console_register_device(con);
+}
+#else /* CONFIG_PRINTK */
+static void console_register_device(struct console *new) {}
+static void console_setup_class(void) {}
+#endif
+
/*
* This is called by register_console() to try to match
* the newly registered console with any of the ones selected
@@ -3062,6 +3320,11 @@ static int try_enable_preferred_console(struct console *newcon,
if (newcon->index < 0)
newcon->index = c->index;
+ if (c->flags & CON_LOGLEVEL)
+ newcon->level = c->level;
+ newcon->flags |= c->flags;
+ newcon->classdev = NULL;
+
if (_braille_register_console(newcon, c))
return 0;
@@ -3223,6 +3486,7 @@ void register_console(struct console *newcon)
/* Begin with next message. */
newcon->seq = prb_next_seq(prb);
}
+ console_register_device(newcon);
console_unlock();
console_sysfs_notify();
@@ -3289,6 +3553,10 @@ int unregister_console(struct console *console)
console_drivers->flags |= CON_CONSDEV;
console->flags &= ~CON_ENABLED;
+
+ if (console->classdev)
+ device_unregister(console->classdev);
+
console_unlock();
console_sysfs_notify();
@@ -3348,6 +3616,10 @@ void __init console_init(void)
* To mitigate this problem somewhat, only unregister consoles whose memory
* intersects with the init section. Note that all other boot consoles will
* get unregistered when the real preferred console is registered.
+ *
+ * Early consoles will also have been registered before we had the
+ * infrastructure to put them into /sys/class/console, so make sure they get
+ * set up now that we're ready.
*/
static int __init printk_late_init(void)
{
@@ -3381,6 +3653,9 @@ static int __init printk_late_init(void)
console_cpu_notify, NULL);
WARN_ON(ret < 0);
printk_sysctl_init();
+
+ console_setup_class();
+
return 0;
}
late_initcall(printk_late_init);
diff --git a/kernel/printk/sysctl.c b/kernel/printk/sysctl.c
index c228343eeb97..97689d728d3e 100644
--- a/kernel/printk/sysctl.c
+++ b/kernel/printk/sysctl.c
@@ -7,10 +7,14 @@
#include <linux/printk.h>
#include <linux/capability.h>
#include <linux/ratelimit.h>
+#include <linux/console.h>
#include "internal.h"
static const int ten_thousand = 10000;
+static int min_loglevel = LOGLEVEL_EMERG;
+static int max_loglevel = LOGLEVEL_DEBUG + 1;
+
static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos)
{
@@ -20,13 +24,55 @@ static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
}
+static int printk_sysctl_deprecated(struct ctl_table *table, int write,
+ void __user *buffer, size_t *lenp,
+ loff_t *ppos)
+{
+ int res = proc_dointvec(table, write, buffer, lenp, ppos);
+
+ if (write)
+ pr_warn_once(
+ "printk: The kernel.printk sysctl is deprecated. Consider using kernel.console_loglevel or kernel.default_message_loglevel instead.\n"
+ );
+
+ return res;
+}
+
+static int printk_console_loglevel(struct ctl_table *table, int write,
+ void __user *buffer, size_t *lenp,
+ loff_t *ppos)
+{
+
+ struct ctl_table ltable = *table;
+ int ret, value;
+
+ if (!write)
+ return proc_dointvec(table, write, buffer, lenp, ppos);
+
+ ltable.data = &value;
+
+ ret = proc_dointvec(<able, write, buffer, lenp, ppos);
+ if (ret)
+ return ret;
+
+ if (value < min_loglevel || value > max_loglevel)
+ return -ERANGE;
+
+ if (value < minimum_console_loglevel)
+ return -EINVAL;
+
+ console_loglevel = value;
+
+ return 0;
+}
+
static struct ctl_table printk_sysctls[] = {
{
.procname = "printk",
.data = &console_loglevel,
.maxlen = 4*sizeof(int),
.mode = 0644,
- .proc_handler = proc_dointvec,
+ .proc_handler = printk_sysctl_deprecated,
},
{
.procname = "printk_ratelimit",
@@ -76,6 +122,22 @@ static struct ctl_table printk_sysctls[] = {
.extra1 = SYSCTL_ZERO,
.extra2 = SYSCTL_TWO,
},
+ {
+ .procname = "console_loglevel",
+ .data = &console_loglevel,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = printk_console_loglevel,
+ },
+ {
+ .procname = "default_message_loglevel",
+ .data = &default_message_loglevel,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &min_loglevel,
+ .extra2 = &max_loglevel,
+ },
{}
};
--
2.37.1
Hi Chris,
I love your patch! Perhaps something to improve:
[auto build test WARNING on 9d882352bac8f2ff3753d691e2dc65fcaf738729]
url: https://github.com/intel-lab-lkp/linux/commits/Chris-Down/printk-console-Per-console-loglevels/20220721-015315
base: 9d882352bac8f2ff3753d691e2dc65fcaf738729
reproduce: make htmldocs
If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <[email protected]>
All warnings (new ones prefixed by >>):
>> Documentation/ABI/testing/sysfs-class-console:18: WARNING: Unexpected indentation.
>> Documentation/admin-guide/per-console-loglevel.rst: WARNING: document isn't included in any toctree
vim +18 Documentation/ABI/testing/sysfs-class-console
> 18 Date: May 2022
19 Contact: Chris Down <[email protected]>
20 Description: Read only. The currently effective loglevel source for this
21 console -- for example, whether it was set globally, or whether
22 it was set locally for this console. Possible values are:
23
24 local: The loglevel comes from the per-console loglevel.
25 global: The loglevel comes from the global loglevel.
26 ignore_loglevel: Both the per-console loglevel and global
27 loglevels are ignored as ignore_loglevel is
28 present on the kernel command line.
29
--
0-DAY CI Kernel Test Service
https://01.org/lkp
Hi Chris,
I love your patch! Perhaps something to improve:
[auto build test WARNING on 9d882352bac8f2ff3753d691e2dc65fcaf738729]
url: https://github.com/intel-lab-lkp/linux/commits/Chris-Down/printk-console-Per-console-loglevels/20220721-015315
base: 9d882352bac8f2ff3753d691e2dc65fcaf738729
config: riscv-randconfig-s053-20220718 (https://download.01.org/0day-ci/archive/20220722/[email protected]/config)
compiler: riscv64-linux-gcc (GCC) 12.1.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# apt-get install sparse
# sparse version: v0.6.4-39-gce1a6720-dirty
# https://github.com/intel-lab-lkp/linux/commit/fac1dc8424bd6e1ae37f6e180f96ed7e4f44e2fc
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Chris-Down/printk-console-Per-console-loglevels/20220721-015315
git checkout fac1dc8424bd6e1ae37f6e180f96ed7e4f44e2fc
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' O=build_dir ARCH=riscv SHELL=/bin/bash kernel/printk/
If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <[email protected]>
sparse warnings: (new ones prefixed by >>)
>> kernel/printk/sysctl.c:31:47: sparse: sparse: incorrect type in argument 3 (different address spaces) @@ expected void * @@ got void [noderef] __user *buffer @@
kernel/printk/sysctl.c:31:47: sparse: expected void *
kernel/printk/sysctl.c:31:47: sparse: got void [noderef] __user *buffer
kernel/printk/sysctl.c:50:52: sparse: sparse: incorrect type in argument 3 (different address spaces) @@ expected void * @@ got void [noderef] __user *buffer @@
kernel/printk/sysctl.c:50:52: sparse: expected void *
kernel/printk/sysctl.c:50:52: sparse: got void [noderef] __user *buffer
kernel/printk/sysctl.c:54:45: sparse: sparse: incorrect type in argument 3 (different address spaces) @@ expected void * @@ got void [noderef] __user *buffer @@
kernel/printk/sysctl.c:54:45: sparse: expected void *
kernel/printk/sysctl.c:54:45: sparse: got void [noderef] __user *buffer
>> kernel/printk/sysctl.c:75:35: sparse: sparse: incorrect type in initializer (incompatible argument 3 (different address spaces)) @@ expected int ( [usertype] *proc_handler )( ... ) @@ got int ( * )( ... ) @@
kernel/printk/sysctl.c:75:35: sparse: expected int ( [usertype] *proc_handler )( ... )
kernel/printk/sysctl.c:75:35: sparse: got int ( * )( ... )
kernel/printk/sysctl.c:130:35: sparse: sparse: incorrect type in initializer (incompatible argument 3 (different address spaces)) @@ expected int ( [usertype] *proc_handler )( ... ) @@ got int ( * )( ... ) @@
kernel/printk/sysctl.c:130:35: sparse: expected int ( [usertype] *proc_handler )( ... )
kernel/printk/sysctl.c:130:35: sparse: got int ( * )( ... )
vim +31 kernel/printk/sysctl.c
26
27 static int printk_sysctl_deprecated(struct ctl_table *table, int write,
28 void __user *buffer, size_t *lenp,
29 loff_t *ppos)
30 {
> 31 int res = proc_dointvec(table, write, buffer, lenp, ppos);
32
33 if (write)
34 pr_warn_once(
35 "printk: The kernel.printk sysctl is deprecated. Consider using kernel.console_loglevel or kernel.default_message_loglevel instead.\n"
36 );
37
38 return res;
39 }
40
41 static int printk_console_loglevel(struct ctl_table *table, int write,
42 void __user *buffer, size_t *lenp,
43 loff_t *ppos)
44 {
45
46 struct ctl_table ltable = *table;
47 int ret, value;
48
49 if (!write)
50 return proc_dointvec(table, write, buffer, lenp, ppos);
51
52 ltable.data = &value;
53
54 ret = proc_dointvec(<able, write, buffer, lenp, ppos);
55 if (ret)
56 return ret;
57
58 if (value < min_loglevel || value > max_loglevel)
59 return -ERANGE;
60
61 if (value < minimum_console_loglevel)
62 return -EINVAL;
63
64 console_loglevel = value;
65
66 return 0;
67 }
68
69 static struct ctl_table printk_sysctls[] = {
70 {
71 .procname = "printk",
72 .data = &console_loglevel,
73 .maxlen = 4*sizeof(int),
74 .mode = 0644,
> 75 .proc_handler = printk_sysctl_deprecated,
76 },
77 {
78 .procname = "printk_ratelimit",
79 .data = &printk_ratelimit_state.interval,
80 .maxlen = sizeof(int),
81 .mode = 0644,
82 .proc_handler = proc_dointvec_jiffies,
83 },
84 {
85 .procname = "printk_ratelimit_burst",
86 .data = &printk_ratelimit_state.burst,
87 .maxlen = sizeof(int),
88 .mode = 0644,
89 .proc_handler = proc_dointvec,
90 },
91 {
92 .procname = "printk_delay",
93 .data = &printk_delay_msec,
94 .maxlen = sizeof(int),
95 .mode = 0644,
96 .proc_handler = proc_dointvec_minmax,
97 .extra1 = SYSCTL_ZERO,
98 .extra2 = (void *)&ten_thousand,
99 },
100 {
101 .procname = "printk_devkmsg",
102 .data = devkmsg_log_str,
103 .maxlen = DEVKMSG_STR_MAX_SIZE,
104 .mode = 0644,
105 .proc_handler = devkmsg_sysctl_set_loglvl,
106 },
107 {
108 .procname = "dmesg_restrict",
109 .data = &dmesg_restrict,
110 .maxlen = sizeof(int),
111 .mode = 0644,
112 .proc_handler = proc_dointvec_minmax_sysadmin,
113 .extra1 = SYSCTL_ZERO,
114 .extra2 = SYSCTL_ONE,
115 },
116 {
117 .procname = "kptr_restrict",
118 .data = &kptr_restrict,
119 .maxlen = sizeof(int),
120 .mode = 0644,
121 .proc_handler = proc_dointvec_minmax_sysadmin,
122 .extra1 = SYSCTL_ZERO,
123 .extra2 = SYSCTL_TWO,
124 },
125 {
126 .procname = "console_loglevel",
127 .data = &console_loglevel,
128 .maxlen = sizeof(int),
129 .mode = 0644,
130 .proc_handler = printk_console_loglevel,
131 },
132 {
133 .procname = "default_message_loglevel",
134 .data = &default_message_loglevel,
135 .maxlen = sizeof(int),
136 .mode = 0644,
137 .proc_handler = proc_dointvec_minmax,
138 .extra1 = &min_loglevel,
139 .extra2 = &max_loglevel,
140 },
141 {}
142 };
143
--
0-DAY CI Kernel Test Service
https://01.org/lkp
kernel test robot writes:
>sparse warnings: (new ones prefixed by >>)
>>> kernel/printk/sysctl.c:31:47: sparse: sparse: incorrect type in argument 3 (different address spaces) @@ expected void * @@ got void [noderef] __user *buffer @@
> kernel/printk/sysctl.c:31:47: sparse: expected void *
> kernel/printk/sysctl.c:31:47: sparse: got void [noderef] __user *buffer
Ah, since commit 32927393dc1c ("sysctl: pass kernel pointers to
->proc_handler") we copy to kernelspace before passing to the callback, so it's
not a userspace pointer. That's certainly an improvement.
Will fix for v4.
On Wed 2022-07-20 18:48:16, Chris Down wrote:
> In terms of technical implementation, this patch embeds a device pointer
> in the console struct, and registers each console using it so we can
> expose attributes in sysfs.
>
> For information on the precedence and application of the new controls,
> see Documentation/ABI/testing/sysfs-class-console and
> Documentation/admin-guide/per-console-loglevel.rst.
The overall logic looks good to me. I finally have good feeling that
the behavior is "easy" to understand.
The detailed documentation is very nice!
See below for comments about various implementation details.
> --- a/include/linux/console.h
> +++ b/include/linux/console.h
> @@ -137,6 +138,22 @@ static inline int con_debug_leave(void)
> #define CON_BRL (32) /* Used for a braille device */
> #define CON_EXTENDED (64) /* Use the extended output format a la /dev/kmsg */
>
> +/*
> + * The loglevel for a console can be set in many places:
> + *
> + * 1. It can be forced to emit everything (ignore_loglevel);
> + * 2. It can be set globally (sysctls kernel.printk (deprecated),
> + * kernel.console_loglevel, magic sysrq, loglevel= on kernel command line);
> + * 3. It can be locally set for this specific console (console=...,loglevel:N on
> + * kernel command line, /sys/class/console/.../loglevel);
> + * 4. It can be set by a compile-time default
> + * (CONFIG_CONSOLE_LOGLEVEL_{DEFAULT,QUIET})
> + *
> + * If case 3 happens, even if another global value in effect, CON_LOGLEVEL will
> + * be set.
The last sentence is not clear to me.
Well, I suggest to keep it simple and remove this comment
completely. The meaning of the flag is simple. It is set when
the local (per-console) loglevel is set.
The precedence of the various loglevel setting is explained above
console_effective_loglevel() where it belongs.
> + */
> +#define CON_LOGLEVEL (128) /* Level set locally for this console */
I would write:
#define CON_LOGLEVEL (128) /* Local (per-console) loglevel is set. */
Alternatively we could avoid the flag completely. The per-console
loglevel is set when con->level > 0. A valid value must never
be below CONSOLE_MIN_LOGLEVEL which is 1. And it is perfectly fine
to say that 0 or -1 is not a valid loglevel. The same effect could
be achieved by disabling the console completely.
I do not have strong opinion. The flag has obvious meaning and might
make the code better readable. On the other hand, it adds an extra
code and complexity.
I slightly prefer to do it without the flag.
Anyway, if we add the new flag, we should also show it in
/proc/consoles, see fs/proc/consoles.c.
> +
> struct console {
> char name[16];
> void (*write)(struct console *, const char *, unsigned);
> @@ -155,8 +172,15 @@ struct console {
> unsigned long dropped;
> void *data;
> struct console *next;
> + int level;
> + struct device *classdev;
> };
>
> +static inline struct console *classdev_to_console(struct device *dev)
> +{
> + return dev_get_drvdata(dev);
> +}
Please, open code this in the _show()/_store() callbacks. dev_get_drvdata()
seems to be the standard way how it is done. Hiding it into a custom
function just adds an extra step when reading the code.
> +
> /*
> * for_each_console() allows you to iterate on each console
> */
> diff --git a/kernel/printk/console_cmdline.h b/kernel/printk/console_cmdline.h
> index 3ca74ad391d6..40f1a1ff0965 100644
> --- a/kernel/printk/console_cmdline.h
> +++ b/kernel/printk/console_cmdline.h
> @@ -6,6 +6,8 @@ struct console_cmdline
> {
> char name[16]; /* Name of the driver */
> int index; /* Minor dev. to use */
> + int level; /* Log level to use */
> + short flags; /* Initial flags */
> bool user_specified; /* Specified by command line vs. platform */
> char *options; /* Options for the driver */
> #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
> diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
> index 6094f773ad4a..6f5e29b60875 100644
> --- a/kernel/printk/printk.c
> +++ b/kernel/printk/printk.c
> @@ -1202,9 +1217,72 @@ module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
> MODULE_PARM_DESC(ignore_loglevel,
> "ignore loglevel setting (prints all kernel messages to the console)");
>
> -static bool suppress_message_printing(int level)
> +static bool __read_mostly ignore_per_console_loglevel;
> +
> +static int __init ignore_per_console_loglevel_setup(char *str)
> +{
> + ignore_per_console_loglevel = true;
> + return 0;
> +}
> +
> +early_param("ignore_per_console_loglevel", ignore_per_console_loglevel_setup);
> +module_param(ignore_per_console_loglevel, bool, 0644);
> +MODULE_PARM_DESC(ignore_per_console_loglevel,
> + "ignore per-console loglevel setting (only respect global console loglevel)");
> +
> +/*
> + * Hierarchy of loglevel authority:
> + *
> + * 1. con->level. The locally set, console-specific loglevel. Optional, only
> + * valid if the CON_LOGLEVEL flag is set.
> + * 2. console_loglevel. The default global console loglevel, always present.
> + *
> + * The behaviour can be further changed by the following printk module
> + * parameters:
> + *
> + * 1. ignore_loglevel. Can be set at boot or at runtime with
> + * /sys/module/printk/parameters/ignore_loglevel. Overrides absolutely
> + * everything since it's used to debug.
> + * 2. ignore_per_console_loglevel. Existing per-console loglevel values are left
> + * intact, but are ignored in favour of console_loglevel as long as this is
> + * true.
> + *
> + * Callers typically only need the level _or_ the source, but they're both
> + * emitted from this function so that the effective loglevel logic can be
> + * kept in one place.
> + */
> +static int console_effective_loglevel(const struct console *con,
> + enum loglevel_source *source)
> +{
> + enum loglevel_source lsource;
> + int level;
> +
> + if (ignore_loglevel) {
> + lsource = LLS_IGNORE_LOGLEVEL;
> + level = CONSOLE_LOGLEVEL_MOTORMOUTH;
> + goto out;
> + }
> +
> + if (!ignore_per_console_loglevel &&
> + (con && (con->flags & CON_LOGLEVEL))) {
> + lsource = LLS_LOCAL;
> + level = con->level;
> + goto out;
> + }
> +
> + lsource = LLS_GLOBAL;
> + level = console_loglevel;
> +
> +out:
> + *source = lsource;
> + return level;
> +}
It might be a matter of taste. But I would probably do it the
following way (note that these would not be used in
boot_delay_msec()):
static int console_effective_loglevel(const struct console *con)
{
enum loglevel_source source;
int level;
if (WARN_ON_ONCE(!con))
return;
source = console_effective_loglevel_source(con);
switch (source) {
case LLS_IGNORE_LOGLEVEL:
level = CONSOLE_LOGLEVEL_MOTORMOUTH;
break;
case LSS_LOCAL:
level = con->level;
break;
case LSS_GLOBAL:
level = console_loglevel;
break;
default:
pr_warn("Unhandled console loglevel source: %d, source);
level = default_console_loglevel;
break;
}
return level;
}
static const char *console_effective_loglevel_source_str(const struct *con)
{
enum loglevel_source source;
const char *str;
if (WARN_ON_ONCE(!con))
return;
source = console_effective_loglevel_source(con);
switch (source) {
case LLS_IGNORE_LOGLEVEL:
str = "ignore_loglevel";
break;
case LSS_LOCAL:
str = "local"
break;
case LSS_GLOBAL:
str = "global";
break;
default:
pr_warn("Unhandled console loglevel source: %d, source);
str = "unknown";
break;
}
return str;
}
static enum loglevel_source
console_effective_loglevel_source(const struct console *con)
{
if (WARN_ON_ONCE(!con))
return;
if (ignore_loglevel)
return LLS_IGNORE_LOGLEVEL;
if (con->flags & CON_LOGLEVEL && !ignore_per_console_loglevel))
return LLS_LOCAL;
return LLS_GLOBAL;
}
It looks like a bit cleaner and better separated (layered) logic.
There is no need to define "enum loglevel_source" variable when
the caller is interested only into the loglevel value.
The advantage of console_effective_loglevel_source_str() is that it
always returns a valid string. It prevents a potential out-of-bound
access to loglevel_source_names[].
> +
> +static bool suppress_message_printing(int level, struct console *con)
> {
> - return (level >= console_loglevel && !ignore_loglevel);
> + enum loglevel_source source;
> +
> + return level >= console_effective_loglevel(con, &source);
> }
>
> #ifdef CONFIG_BOOT_PRINTK_DELAY
> @@ -1236,7 +1314,7 @@ static void boot_delay_msec(int level)
> unsigned long timeout;
>
> if ((boot_delay == 0 || system_state >= SYSTEM_RUNNING)
> - || suppress_message_printing(level)) {
> + || suppress_message_printing(level, NULL)) {
This does not take into account per-console loglevels.
And we could not check them in vprintk_emit() because
we could not take console_lock() there.
AFAIK, the purpose of this call is to allow reading the messages
on consoles when they do not support scrolling.
A solution would be to call boot_delay_msec() in
console_flush_all(). It would need adding parameter
into console_emit_next_record() that pass information
whether it emitted or suppressed the message.
Something like:
/*
[...]
* @emitted will be set to "true" when the message was really emitted to the
* console. It means that it was not suppressed because of console loglevel.
[...]
*/
static bool console_emit_next_record(struct console *con, char *text, char *ext_text,
char *dropped_text, bool *emitted, bool *handover)
> return;
> }
>
> @@ -1701,12 +1806,14 @@ int do_syslog(int type, char __user *buf, int len, int source)
> break;
> /* Disable logging to console */
> case SYSLOG_ACTION_CONSOLE_OFF:
> + warn_on_local_loglevel();
> if (saved_console_loglevel == LOGLEVEL_DEFAULT)
> saved_console_loglevel = console_loglevel;
> console_loglevel = minimum_console_loglevel;
> break;
We actually could disable logging on all consoles by setting
ignore_per_console_loglevel. Something like:
case SYSLOG_ACTION_CONSOLE_OFF:
if (saved_console_loglevel == LOGLEVEL_DEFAULT) {
saved_console_loglevel = console_loglevel;
saved_ignore_per_console_loglevel = ignore_per_console_loglevel;
}
console_loglevel = minimum_console_loglevel;
ignore_per_console_loglevel = true;
break;
> /* Enable logging to console */
> case SYSLOG_ACTION_CONSOLE_ON:
> + warn_on_local_loglevel();
> if (saved_console_loglevel != LOGLEVEL_DEFAULT) {
> console_loglevel = saved_console_loglevel;
> saved_console_loglevel = LOGLEVEL_DEFAULT;
and here:
case SYSLOG_ACTION_CONSOLE_ON:
if (saved_console_loglevel != LOGLEVEL_DEFAULT) {
console_loglevel = saved_console_loglevel;
ignore_per_console_loglevel = saved_ignore_per_console_loglevel;
saved_console_loglevel = LOGLEVEL_DEFAULT;
}
> @@ -1714,6 +1821,7 @@ int do_syslog(int type, char __user *buf, int len, int source)
> break;
> /* Set level of messages printed to console */
> case SYSLOG_ACTION_CONSOLE_LEVEL:
> + warn_on_local_loglevel();
I would keep it simple:
if (!ignore_per_console_loglevel)
pr_warn_once("SYSLOG_ACTION_CONSOLE_LEVEL is ignored by consoles with explicitely set per-console loglevel, see Documentation/admin-guide/per-console-loglevel\n");
People should know that this API has limits. The check of
ignore_per_console_loglevel allows to prevent the warning
when the users are not interested into the per-console
loglevels feature.
I think about opening discussion about obsoleting the syslog
syscall. It has many drawbacks. Everything is stored in global
variables. As a result, it supports only one reader and one
writer.
> if (len < 1 || len > 8)
> return -EINVAL;
> if (len < minimum_console_loglevel)
> @@ -3030,6 +3149,145 @@ static int __init keep_bootcon_setup(char *str)
>
> early_param("keep_bootcon", keep_bootcon_setup);
>
> +#ifdef CONFIG_PRINTK
> +static ssize_t loglevel_show(struct device *dev, struct device_attribute *attr,
> + char *buf)
> +{
> + struct console *con = classdev_to_console(dev);
> +
> + if (con->flags & CON_LOGLEVEL)
> + return sysfs_emit(buf, "%d\n", con->level);
> + else
> + return sysfs_emit(buf, "unset\n");
I can't find any other sysfs interface using this style (number or
"unset"). Or any other interface combining number or a string values.
I feel a bit uneasy to introduce a completely new semantic. Instead I
prefer using either -1 or 0 when the per-console is not set. It might
be slightly less obvious but it is a standard way so it might be
easier for users in the end.
Both 0 and -1 values are usable as explained above. I personally
prefer -1 because the meaning is more obvious. I would even
use it instead of CON_LOGLEVEL flag.
> +}
> +
> +static ssize_t loglevel_store(struct device *dev, struct device_attribute *attr,
> + const char *buf, size_t size)
> +{
> + struct console *con = classdev_to_console(dev);
> + ssize_t ret;
> + int tmp;
> +
> + if (!strcmp(buf, "unset") || !strcmp(buf, "unset\n")) {
> + con->flags &= ~CON_LOGLEVEL;
> + return size;
> + }
> +
> + ret = kstrtoint(buf, 10, &tmp);
> + if (ret < 0)
> + return ret;
> +
> + if (tmp < LOGLEVEL_EMERG || tmp > LOGLEVEL_DEBUG + 1)
> + return -ERANGE;
> +
> + if (tmp < minimum_console_loglevel)
> + return -EINVAL;
This looks superfluous. Please, use minimum_console_loglevel
instead of LOGLEVEL_EMERG in the above range check.
Also, we should make a helper function for this. The same range check
is useful also for the global console_loglevel.
> +
> + con->level = tmp;
> + con->flags |= CON_LOGLEVEL;
> +
> + return size;
> +}
> +
> +static DEVICE_ATTR_RW(loglevel);
> +
[...]
> +static struct attribute *console_sysfs_attrs[] = {
> + &dev_attr_loglevel.attr,
> + &dev_attr_effective_loglevel_source.attr,
> + &dev_attr_effective_loglevel.attr,
> + &dev_attr_enabled.attr,
> + NULL,
> +};
> +
> +ATTRIBUTE_GROUPS(console_sysfs);
> +
> +static void console_classdev_release(struct device *dev)
> +{
> + kfree(dev);
> +}
> +
> +static void console_register_device(struct console *new)
Please use "con" instead of "new" like it is done in the other
API manipulating struct console. It helps when reading the code.
> +{
> + /*
> + * We might be called from register_console() before the class is
> + * registered. If that happens, we'll take care of it in
> + * printk_late_init.
> + */
> + if (IS_ERR_OR_NULL(console_class))
> + return;
> +
We should check whether new->classdev is NULL to prevent double
initialization. It should not happen but better be on the safe side.
> + new->classdev = kzalloc(sizeof(struct device), GFP_KERNEL);
> + if (!new->classdev)
> + return;
> +
> + device_initialize(new->classdev);
> + dev_set_name(new->classdev, "%s", new->name);
This should be:
dev_set_name(new->classdev, "%s%d", con->name, con->index);
It should match console names defined on the command line
and shown by /proc/consoles. See how the name is printed in
fs/proc/consoles.c.
> + dev_set_drvdata(new->classdev, new);
> + new->classdev->release = console_classdev_release;
> + new->classdev->class = console_class;
> + if (device_add(new->classdev))
> + put_device(new->classdev);
> +}
> +
> +static void console_setup_class(void)
> +{
> + struct console *con;
> +
> + /*
> + * printk exists for the lifetime of the kernel, it cannot be unloaded,
> + * so we should never end up back in here.
> + */
> + if (WARN_ON(console_class))
> + return;
> +
> + console_class = class_create(THIS_MODULE, "console");
> + if (!IS_ERR(console_class))
> + console_class->dev_groups = console_sysfs_groups;
> +
> + for_each_console(con)
> + console_register_device(con);
This should be done under console_lock so that the list of registered
console could not get manipulated.
> +}
> +#else /* CONFIG_PRINTK */
> +static void console_register_device(struct console *new) {}
> +static void console_setup_class(void) {}
> +#endif
> +
> /*
> * This is called by register_console() to try to match
> * the newly registered console with any of the ones selected
> --- a/kernel/printk/sysctl.c
> +++ b/kernel/printk/sysctl.c
> @@ -7,10 +7,14 @@
> #include <linux/printk.h>
> #include <linux/capability.h>
> #include <linux/ratelimit.h>
> +#include <linux/console.h>
> #include "internal.h"
>
> static const int ten_thousand = 10000;
>
> +static int min_loglevel = LOGLEVEL_EMERG;
We should use minimum_console_loglevel instead.
> +static int max_loglevel = LOGLEVEL_DEBUG + 1;
Please, define maximum_console_loglevel in kernel/printk/printk.c
after the console_printk[4] array.
This will allow to create a function for the range check that might
be used for both sysfs and proc interface.
Also I would set the maximal value to CONSOLE_LOGLEVEL_MOTORMOUTH.
> +
> static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
> void *buffer, size_t *lenp, loff_t *ppos)
> {
> @@ -76,6 +122,22 @@ static struct ctl_table printk_sysctls[] = {
> .extra1 = SYSCTL_ZERO,
> .extra2 = SYSCTL_TWO,
> },
> + {
> + .procname = "console_loglevel",
> + .data = &console_loglevel,
> + .maxlen = sizeof(int),
> + .mode = 0644,
> + .proc_handler = printk_console_loglevel,
> + },
> + {
> + .procname = "default_message_loglevel",
> + .data = &default_message_loglevel,
> + .maxlen = sizeof(int),
> + .mode = 0644,
> + .proc_handler = proc_dointvec_minmax,
> + .extra1 = &min_loglevel,
> + .extra2 = &max_loglevel,
> + },
Is there any chance to add this into /sys/class/console instead?
I mean:
/sys/class/console/loglevel
/sys/class/console/default_message_loglevel
It would be nice to have the things are on the same place.
Especially it would be nice to have the global loglevel there.
Best Regards,
Petr
Hi Petr,
Thanks a lot for getting back! :-)
Any comments not explicitly addressed are acked.
Petr Mladek writes:
>On Wed 2022-07-20 18:48:16, Chris Down wrote:
>> In terms of technical implementation, this patch embeds a device pointer
>> in the console struct, and registers each console using it so we can
>> expose attributes in sysfs.
>>
>> For information on the precedence and application of the new controls,
>> see Documentation/ABI/testing/sysfs-class-console and
>> Documentation/admin-guide/per-console-loglevel.rst.
>
>The overall logic looks good to me. I finally have good feeling that
>the behavior is "easy" to understand.
That's great! Thank you for all your help improving it.
>> + */
>> +#define CON_LOGLEVEL (128) /* Level set locally for this console */
>
>I would write:
>
>#define CON_LOGLEVEL (128) /* Local (per-console) loglevel is set. */
>
>Alternatively we could avoid the flag completely. The per-console
>loglevel is set when con->level > 0. A valid value must never
>be below CONSOLE_MIN_LOGLEVEL which is 1. And it is perfectly fine
>to say that 0 or -1 is not a valid loglevel. The same effect could
>be achieved by disabling the console completely.
>
>I do not have strong opinion. The flag has obvious meaning and might
>make the code better readable. On the other hand, it adds an extra
>code and complexity.
>
>I slightly prefer to do it without the flag.
>
>Anyway, if we add the new flag, we should also show it in
>/proc/consoles, see fs/proc/consoles.c.
Hmm, it's true it can be done without the flag, I mostly preferred to do it
this way out of a concern for code readability.
That said, with the changes suggested below to just show -1 instead of "unset",
maybe the best solution is just to set -1.
I will think about it some more before v4 and probably just have -1 mean unset.
Thanks!
>> +static int console_effective_loglevel(const struct console *con,
>> + enum loglevel_source *source)
>> +{
>> + enum loglevel_source lsource;
>> + int level;
>> +
>> + if (ignore_loglevel) {
>> + lsource = LLS_IGNORE_LOGLEVEL;
>> + level = CONSOLE_LOGLEVEL_MOTORMOUTH;
>> + goto out;
>> + }
>> +
>> + if (!ignore_per_console_loglevel &&
>> + (con && (con->flags & CON_LOGLEVEL))) {
>> + lsource = LLS_LOCAL;
>> + level = con->level;
>> + goto out;
>> + }
>> +
>> + lsource = LLS_GLOBAL;
>> + level = console_loglevel;
>> +
>> +out:
>> + *source = lsource;
>> + return level;
>> +}
>
>It might be a matter of taste. But I would probably do it the
>following way (note that these would not be used in
>boot_delay_msec()):
>
>static int console_effective_loglevel(const struct console *con)
>{
> enum loglevel_source source;
> int level;
>
> if (WARN_ON_ONCE(!con))
> return;
>
> source = console_effective_loglevel_source(con);
>
> switch (source) {
> case LLS_IGNORE_LOGLEVEL:
> level = CONSOLE_LOGLEVEL_MOTORMOUTH;
> break;
> case LSS_LOCAL:
> level = con->level;
> break;
> case LSS_GLOBAL:
> level = console_loglevel;
> break;
> default:
> pr_warn("Unhandled console loglevel source: %d, source);
> level = default_console_loglevel;
> break;
> }
>
> return level;
>}
>
>static const char *console_effective_loglevel_source_str(const struct *con)
>{
> enum loglevel_source source;
> const char *str;
>
> if (WARN_ON_ONCE(!con))
> return;
>
> source = console_effective_loglevel_source(con);
>
> switch (source) {
> case LLS_IGNORE_LOGLEVEL:
> str = "ignore_loglevel";
> break;
> case LSS_LOCAL:
> str = "local"
> break;
> case LSS_GLOBAL:
> str = "global";
> break;
> default:
> pr_warn("Unhandled console loglevel source: %d, source);
> str = "unknown";
> break;
> }
>
> return str;
>}
>
>static enum loglevel_source
>console_effective_loglevel_source(const struct console *con)
>{
> if (WARN_ON_ONCE(!con))
> return;
>
> if (ignore_loglevel)
> return LLS_IGNORE_LOGLEVEL;
>
> if (con->flags & CON_LOGLEVEL && !ignore_per_console_loglevel))
> return LLS_LOCAL;
>
> return LLS_GLOBAL;
>}
>
>It looks like a bit cleaner and better separated (layered) logic.
>
>There is no need to define "enum loglevel_source" variable when
>the caller is interested only into the loglevel value.
>
>The advantage of console_effective_loglevel_source_str() is that it
>always returns a valid string. It prevents a potential out-of-bound
>access to loglevel_source_names[].
No strong opinions, so I'll do this for v4. Thanks!
>>
>> @@ -1701,12 +1806,14 @@ int do_syslog(int type, char __user *buf, int len, int source)
>> break;
>> /* Disable logging to console */
>> case SYSLOG_ACTION_CONSOLE_OFF:
>> + warn_on_local_loglevel();
>> if (saved_console_loglevel == LOGLEVEL_DEFAULT)
>> saved_console_loglevel = console_loglevel;
>> console_loglevel = minimum_console_loglevel;
>> break;
>
>We actually could disable logging on all consoles by setting
>ignore_per_console_loglevel. Something like:
>
> case SYSLOG_ACTION_CONSOLE_OFF:
> if (saved_console_loglevel == LOGLEVEL_DEFAULT) {
> saved_console_loglevel = console_loglevel;
> saved_ignore_per_console_loglevel = ignore_per_console_loglevel;
> }
> console_loglevel = minimum_console_loglevel;
> ignore_per_console_loglevel = true;
> break;
Oh, that's very true. Thanks!
>> + warn_on_local_loglevel();
>
>I would keep it simple:
>
> if (!ignore_per_console_loglevel)
> pr_warn_once("SYSLOG_ACTION_CONSOLE_LEVEL is ignored by consoles with explicitely set per-console loglevel, see Documentation/admin-guide/per-console-loglevel\n");
My concern with this is that this will then warn on basically any first
syslog() use, even for people who don't care about the per-console loglevel
semantics. They will now get the warning, since by default
ignore_per_console_loglevel isn't true -- however no per-console loglevel is
set either, so it's not really relevant.
That's why I implemented it as warn_on_local_loglevel() checking for
CON_LOGLEVEL, because otherwise it seems noisy for those that are not using the
feature.
Maybe you have thoughts on that? :-)
>> +static ssize_t loglevel_store(struct device *dev, struct device_attribute *attr,
>> + const char *buf, size_t size)
>> +{
>> + struct console *con = classdev_to_console(dev);
>> + ssize_t ret;
>> + int tmp;
>> +
>> + if (!strcmp(buf, "unset") || !strcmp(buf, "unset\n")) {
>> + con->flags &= ~CON_LOGLEVEL;
>> + return size;
>> + }
>> +
>> + ret = kstrtoint(buf, 10, &tmp);
>> + if (ret < 0)
>> + return ret;
>> +
>> + if (tmp < LOGLEVEL_EMERG || tmp > LOGLEVEL_DEBUG + 1)
>> + return -ERANGE;
>> +
>> + if (tmp < minimum_console_loglevel)
>> + return -EINVAL;
>
>This looks superfluous. Please, use minimum_console_loglevel
>instead of LOGLEVEL_EMERG in the above range check.
That's fair. In which case we probably end up with one error for all cases: do
you prefer we should return -EINVAL or -ERANGE?
>> +
>> static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
>> void *buffer, size_t *lenp, loff_t *ppos)
>> {
>> @@ -76,6 +122,22 @@ static struct ctl_table printk_sysctls[] = {
>> .extra1 = SYSCTL_ZERO,
>> .extra2 = SYSCTL_TWO,
>> },
>> + {
>> + .procname = "console_loglevel",
>> + .data = &console_loglevel,
>> + .maxlen = sizeof(int),
>> + .mode = 0644,
>> + .proc_handler = printk_console_loglevel,
>> + },
>> + {
>> + .procname = "default_message_loglevel",
>> + .data = &default_message_loglevel,
>> + .maxlen = sizeof(int),
>> + .mode = 0644,
>> + .proc_handler = proc_dointvec_minmax,
>> + .extra1 = &min_loglevel,
>> + .extra2 = &max_loglevel,
>> + },
>
>Is there any chance to add this into /sys/class/console instead?
>I mean:
>
> /sys/class/console/loglevel
> /sys/class/console/default_message_loglevel
>
>It would be nice to have the things are on the same place.
>Especially it would be nice to have the global loglevel there.
I think this one is a little complicated: on the one hand, yes, it does seem
more ergonomic to keep everything together in /sys/class/console. On the other
hand, this means that users can no longer use the sysctl infrastructure, which
makes things more unwieldy than with kernel.printk.
Not really a problem with sysfs as much as a problem with userspace ergonomics:
sysctls have a really easy way to set them at boot, but sysfs stuff, not so.
You can hack it with systemd-tmpfiles, a boot unit, or similar, but the
infrastructure is a lot less specialised and requires more work. I am worried
that people may complain that that's unhelpful, especially since we're
deprecating kernel.printk.
Maybe I shouldn't worry about that so much? I'm curious to hear your further
thoughts.
Thanks a lot for the detailed feedback!
Chris
On Mon 2022-09-05 15:07:44, Chris Down wrote:
> Hi Petr,
>
> Thanks a lot for getting back! :-)
>
> Any comments not explicitly addressed are acked.
>
> Petr Mladek writes:
> > On Wed 2022-07-20 18:48:16, Chris Down wrote:
> > > In terms of technical implementation, this patch embeds a device pointer
> > > in the console struct, and registers each console using it so we can
> > > expose attributes in sysfs.
> > >
> > > For information on the precedence and application of the new controls,
> > > see Documentation/ABI/testing/sysfs-class-console and
> > > Documentation/admin-guide/per-console-loglevel.rst.
> > > @@ -1701,12 +1806,14 @@ int do_syslog(int type, char __user *buf, int len, int source)
> > > break;
> > > /* Disable logging to console */
> > > case SYSLOG_ACTION_CONSOLE_OFF:
> > > + warn_on_local_loglevel();
> > > if (saved_console_loglevel == LOGLEVEL_DEFAULT)
> > > saved_console_loglevel = console_loglevel;
> > > console_loglevel = minimum_console_loglevel;
> > > break;
> >
> > We actually could disable logging on all consoles by setting
> > ignore_per_console_loglevel. Something like:
> >
> > case SYSLOG_ACTION_CONSOLE_OFF:
> > if (saved_console_loglevel == LOGLEVEL_DEFAULT) {
> > saved_console_loglevel = console_loglevel;
> > saved_ignore_per_console_loglevel = ignore_per_console_loglevel;
> > }
> > console_loglevel = minimum_console_loglevel;
> > ignore_per_console_loglevel = true;
> > break;
>
> Oh, that's very true. Thanks!
>
> > > + warn_on_local_loglevel();
> >
> > I would keep it simple:
> >
> > if (!ignore_per_console_loglevel)
> > pr_warn_once("SYSLOG_ACTION_CONSOLE_LEVEL is ignored by consoles with explicitely set per-console loglevel, see Documentation/admin-guide/per-console-loglevel\n");
>
> My concern with this is that this will then warn on basically any first
> syslog() use, even for people who don't care about the per-console loglevel
> semantics. They will now get the warning, since by default
> ignore_per_console_loglevel isn't true -- however no per-console loglevel is
> set either, so it's not really relevant.
>
> That's why I implemented it as warn_on_local_loglevel() checking for
> CON_LOGLEVEL, because otherwise it seems noisy for those that are not using
> the feature.
IMHO, the question is if any commonly used tool is using syslog
SYSLOG_ACTION_CONSOLE_ON/OFF these days.
It is supported by dmesg but I am not sure if anyone is really
using it. And I am not sure if anyone uses this during boot, suspend,
or so.
I think that I really should open the discussion whether to obsolete syslog
syscall in general. I am sure that it won't me possible to remove
it anytime soon, maybe it would need to stay forever. Anyway, it has
many problems because they modify global variables. And even reading
does not work well when there are more readers.
I am going to send it. Well, I would need to some time to think
about it.
In the meantime, you could either do it the conservative way or
always show it for these operations. It would be simple to fix
when anyone complains.
> > > +static ssize_t loglevel_store(struct device *dev, struct device_attribute *attr,
> > > + const char *buf, size_t size)
> > > +{
> > > + struct console *con = classdev_to_console(dev);
> > > + ssize_t ret;
> > > + int tmp;
> > > +
> > > + if (!strcmp(buf, "unset") || !strcmp(buf, "unset\n")) {
> > > + con->flags &= ~CON_LOGLEVEL;
> > > + return size;
> > > + }
> > > +
> > > + ret = kstrtoint(buf, 10, &tmp);
> > > + if (ret < 0)
> > > + return ret;
> > > +
> > > + if (tmp < LOGLEVEL_EMERG || tmp > LOGLEVEL_DEBUG + 1)
> > > + return -ERANGE;
> > > +
> > > + if (tmp < minimum_console_loglevel)
> > > + return -EINVAL;
> >
> > This looks superfluous. Please, use minimum_console_loglevel
> > instead of LOGLEVEL_EMERG in the above range check.
>
> That's fair. In which case we probably end up with one error for all cases:
> do you prefer we should return -EINVAL or -ERANGE?
I prefer -ERANGE.
> > > +
> > > static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
> > > void *buffer, size_t *lenp, loff_t *ppos)
> > > {
> > > @@ -76,6 +122,22 @@ static struct ctl_table printk_sysctls[] = {
> > > .extra1 = SYSCTL_ZERO,
> > > .extra2 = SYSCTL_TWO,
> > > },
> > > + {
> > > + .procname = "console_loglevel",
> > > + .data = &console_loglevel,
> > > + .maxlen = sizeof(int),
> > > + .mode = 0644,
> > > + .proc_handler = printk_console_loglevel,
> > > + },
> > > + {
> > > + .procname = "default_message_loglevel",
> > > + .data = &default_message_loglevel,
> > > + .maxlen = sizeof(int),
> > > + .mode = 0644,
> > > + .proc_handler = proc_dointvec_minmax,
> > > + .extra1 = &min_loglevel,
> > > + .extra2 = &max_loglevel,
> > > + },
> >
> > Is there any chance to add this into /sys/class/console instead?
> > I mean:
> >
> > /sys/class/console/loglevel
> > /sys/class/console/default_message_loglevel
> >
> > It would be nice to have the things are on the same place.
> > Especially it would be nice to have the global loglevel there.
>
> I think this one is a little complicated: on the one hand, yes, it does seem
> more ergonomic to keep everything together in /sys/class/console. On the
> other hand, this means that users can no longer use the sysctl
> infrastructure, which makes things more unwieldy than with kernel.printk.
>
> Not really a problem with sysfs as much as a problem with userspace
> ergonomics: sysctls have a really easy way to set them at boot, but sysfs
> stuff, not so. You can hack it with systemd-tmpfiles, a boot unit, or
> similar, but the infrastructure is a lot less specialised and requires more
> work. I am worried that people may complain that that's unhelpful,
> especially since we're deprecating kernel.printk.
Good point. Let's keep the global values in /proc so that they might
be modified by sysctl.
Best Regards,
Petr