internal.h

  1/* SPDX-License-Identifier: GPL-2.0-or-later */
  2/*
  3 * internal.h - printk internal definitions
  4 */
  5#include <linux/console.h>
  6#include <linux/types.h>
  7
  8#if defined(CONFIG_PRINTK) && defined(CONFIG_SYSCTL)
  9struct ctl_table;
 10void __init printk_sysctl_init(void);
 11int devkmsg_sysctl_set_loglvl(const struct ctl_table *table, int write,
 12			      void *buffer, size_t *lenp, loff_t *ppos);
 13#else
 14#define printk_sysctl_init() do { } while (0)
 15#endif
 16
 17#define con_printk(lvl, con, fmt, ...)				\
 18	printk(lvl pr_fmt("%s%sconsole [%s%d] " fmt),		\
 19		(con->flags & CON_NBCON) ? "" : "legacy ",	\
 20		(con->flags & CON_BOOT) ? "boot" : "",		\
 21		con->name, con->index, ##__VA_ARGS__)
 22
 23/*
 24 * Identify if legacy printing is forced in a dedicated kthread. If
 25 * true, all printing via console lock occurs within a dedicated
 26 * legacy printer thread. The only exception is on panic, after the
 27 * nbcon consoles have had their chance to print the panic messages
 28 * first.
 29 */
 30#ifdef CONFIG_PREEMPT_RT
 31# define force_legacy_kthread()	(true)
 32#else
 33# define force_legacy_kthread()	(false)
 34#endif
 35
 36#ifdef CONFIG_PRINTK
 37
 38#ifdef CONFIG_PRINTK_CALLER
 39#define PRINTK_PREFIX_MAX	48
 40#else
 41#define PRINTK_PREFIX_MAX	32
 42#endif
 43
 44/*
 45 * the maximum size of a formatted record (i.e. with prefix added
 46 * per line and dropped messages or in extended message format)
 47 */
 48#define PRINTK_MESSAGE_MAX	2048
 49
 50/* the maximum size allowed to be reserved for a record */
 51#define PRINTKRB_RECORD_MAX	1024
 52
 53/* Flags for a single printk record. */
 54enum printk_info_flags {
 55	/* always show on console, ignore console_loglevel */
 56	LOG_FORCE_CON	= 1,
 57	LOG_NEWLINE	= 2,	/* text ended with a newline */
 58	LOG_CONT	= 8,	/* text is a fragment of a continuation line */
 59};
 60
 61struct printk_ringbuffer;
 62struct dev_printk_info;
 63
 64extern struct printk_ringbuffer *prb;
 65extern bool printk_kthreads_running;
 66extern bool printk_kthreads_ready;
 67extern bool debug_non_panic_cpus;
 68
 69__printf(4, 0)
 70int vprintk_store(int facility, int level,
 71		  const struct dev_printk_info *dev_info,
 72		  const char *fmt, va_list args);
 73
 74__printf(1, 0) int vprintk_default(const char *fmt, va_list args);
 75
 76void __printk_safe_enter(void);
 77void __printk_safe_exit(void);
 78
 79bool printk_percpu_data_ready(void);
 80
 81#define printk_safe_enter_irqsave(flags)	\
 82	do {					\
 83		local_irq_save(flags);		\
 84		__printk_safe_enter();		\
 85	} while (0)
 86
 87#define printk_safe_exit_irqrestore(flags)	\
 88	do {					\
 89		__printk_safe_exit();		\
 90		local_irq_restore(flags);	\
 91	} while (0)
 92
 93void defer_console_output(void);
 94bool is_printk_legacy_deferred(void);
 95bool is_printk_force_console(void);
 96
 97u16 printk_parse_prefix(const char *text, int *level,
 98			enum printk_info_flags *flags);
 99void console_lock_spinning_enable(void);
100int console_lock_spinning_disable_and_check(int cookie);
101
102u64 nbcon_seq_read(struct console *con);
103void nbcon_seq_force(struct console *con, u64 seq);
104bool nbcon_alloc(struct console *con);
105void nbcon_free(struct console *con);
106enum nbcon_prio nbcon_get_default_prio(void);
107void nbcon_atomic_flush_pending(void);
108bool nbcon_legacy_emit_next_record(struct console *con, bool *handover,
109				   int cookie, bool use_atomic);
110bool nbcon_kthread_create(struct console *con);
111void nbcon_kthread_stop(struct console *con);
112void nbcon_kthreads_wake(void);
113
114/**
115 * nbcon_kthread_wake - Wake up a console printing thread
116 * @con:	Console to operate on
117 */
118static inline void nbcon_kthread_wake(struct console *con)
119{
120	/*
121	 * Guarantee any new records can be seen by tasks preparing to wait
122	 * before this context checks if the rcuwait is empty.
123	 *
124	 * The full memory barrier in rcuwait_wake_up() pairs with the full
125	 * memory barrier within set_current_state() of
126	 * ___rcuwait_wait_event(), which is called after prepare_to_rcuwait()
127	 * adds the waiter but before it has checked the wait condition.
128	 *
129	 * This pairs with nbcon_kthread_func:A.
130	 */
131	rcuwait_wake_up(&con->rcuwait); /* LMM(nbcon_kthread_wake:A) */
132}
133
134#else
135
136#define PRINTK_PREFIX_MAX	0
137#define PRINTK_MESSAGE_MAX	0
138#define PRINTKRB_RECORD_MAX	0
139
140#define printk_kthreads_running (false)
141#define printk_kthreads_ready (false)
142
143/*
144 * In !PRINTK builds we still export console_sem
145 * semaphore and some of console functions (console_unlock()/etc.), so
146 * printk-safe must preserve the existing local IRQ guarantees.
147 */
148#define printk_safe_enter_irqsave(flags) local_irq_save(flags)
149#define printk_safe_exit_irqrestore(flags) local_irq_restore(flags)
150
151static inline bool printk_percpu_data_ready(void) { return false; }
152static inline void defer_console_output(void) { }
153static inline bool is_printk_legacy_deferred(void) { return false; }
154static inline u64 nbcon_seq_read(struct console *con) { return 0; }
155static inline void nbcon_seq_force(struct console *con, u64 seq) { }
156static inline bool nbcon_alloc(struct console *con) { return false; }
157static inline void nbcon_free(struct console *con) { }
158static inline enum nbcon_prio nbcon_get_default_prio(void) { return NBCON_PRIO_NONE; }
159static inline void nbcon_atomic_flush_pending(void) { }
160static inline bool nbcon_legacy_emit_next_record(struct console *con, bool *handover,
161						 int cookie, bool use_atomic) { return false; }
162static inline void nbcon_kthread_wake(struct console *con) { }
163static inline void nbcon_kthreads_wake(void) { }
164
165#endif /* CONFIG_PRINTK */
166
167extern bool have_boot_console;
168extern bool have_nbcon_console;
169extern bool have_legacy_console;
170extern bool legacy_allow_panic_sync;
171
172/**
173 * struct console_flush_type - Define available console flush methods
174 * @nbcon_atomic:	Flush directly using nbcon_atomic() callback
175 * @nbcon_offload:	Offload flush to printer thread
176 * @legacy_direct:	Call the legacy loop in this context
177 * @legacy_offload:	Offload the legacy loop into IRQ or legacy thread
178 *
179 * Note that the legacy loop also flushes the nbcon consoles.
180 */
181struct console_flush_type {
182	bool	nbcon_atomic;
183	bool	nbcon_offload;
184	bool	legacy_direct;
185	bool	legacy_offload;
186};
187
188extern bool console_irqwork_blocked;
189
190/*
191 * Identify which console flushing methods should be used in the context of
192 * the caller.
193 */
194static inline void printk_get_console_flush_type(struct console_flush_type *ft)
195{
196	memset(ft, 0, sizeof(*ft));
197
198	switch (nbcon_get_default_prio()) {
199	case NBCON_PRIO_NORMAL:
200		if (have_nbcon_console && !have_boot_console) {
201			if (printk_kthreads_running && !console_irqwork_blocked)
202				ft->nbcon_offload = true;
203			else
204				ft->nbcon_atomic = true;
205		}
206
207		/* Legacy consoles are flushed directly when possible. */
208		if (have_legacy_console || have_boot_console) {
209			if (!is_printk_legacy_deferred())
210				ft->legacy_direct = true;
211			else if (!console_irqwork_blocked)
212				ft->legacy_offload = true;
213		}
214		break;
215
216	case NBCON_PRIO_EMERGENCY:
217		if (have_nbcon_console && !have_boot_console)
218			ft->nbcon_atomic = true;
219
220		/* Legacy consoles are flushed directly when possible. */
221		if (have_legacy_console || have_boot_console) {
222			if (!is_printk_legacy_deferred())
223				ft->legacy_direct = true;
224			else if (!console_irqwork_blocked)
225				ft->legacy_offload = true;
226		}
227		break;
228
229	case NBCON_PRIO_PANIC:
230		/*
231		 * In panic, the nbcon consoles will directly print. But
232		 * only allowed if there are no boot consoles.
233		 */
234		if (have_nbcon_console && !have_boot_console)
235			ft->nbcon_atomic = true;
236
237		if (have_legacy_console || have_boot_console) {
238			/*
239			 * This is the same decision as NBCON_PRIO_NORMAL
240			 * except that offloading never occurs in panic.
241			 *
242			 * Note that console_flush_on_panic() will flush
243			 * legacy consoles anyway, even if unsafe.
244			 */
245			if (!is_printk_legacy_deferred())
246				ft->legacy_direct = true;
247
248			/*
249			 * In panic, if nbcon atomic printing occurs,
250			 * the legacy consoles must remain silent until
251			 * explicitly allowed.
252			 */
253			if (ft->nbcon_atomic && !legacy_allow_panic_sync)
254				ft->legacy_direct = false;
255		}
256		break;
257
258	default:
259		WARN_ON_ONCE(1);
260		break;
261	}
262}
263
264extern struct printk_buffers printk_shared_pbufs;
265
266/**
267 * struct printk_buffers - Buffers to read/format/output printk messages.
268 * @outbuf:	After formatting, contains text to output.
269 * @scratchbuf:	Used as temporary ringbuffer reading and string-print space.
270 */
271struct printk_buffers {
272	char	outbuf[PRINTK_MESSAGE_MAX];
273	char	scratchbuf[PRINTKRB_RECORD_MAX];
274};
275
276/**
277 * struct printk_message - Container for a prepared printk message.
278 * @pbufs:	printk buffers used to prepare the message.
279 * @outbuf_len:	The length of prepared text in @pbufs->outbuf to output. This
280 *		does not count the terminator. A value of 0 means there is
281 *		nothing to output and this record should be skipped.
282 * @seq:	The sequence number of the record used for @pbufs->outbuf.
283 * @dropped:	The number of dropped records from reading @seq.
284 */
285struct printk_message {
286	struct printk_buffers	*pbufs;
287	unsigned int		outbuf_len;
288	u64			seq;
289	unsigned long		dropped;
290};
291
292bool printk_get_next_message(struct printk_message *pmsg, u64 seq,
293			     bool is_extended, bool may_supress);
294
295#ifdef CONFIG_PRINTK
296void console_prepend_dropped(struct printk_message *pmsg, unsigned long dropped);
297void console_prepend_replay(struct printk_message *pmsg);
298#endif
299
300#ifdef CONFIG_SMP
301bool is_printk_cpu_sync_owner(void);
302#else
303static inline bool is_printk_cpu_sync_owner(void) { return false; }
304#endif