console.h

  1/*
  2 *  linux/include/linux/console.h
  3 *
  4 *  Copyright (C) 1993        Hamish Macdonald
  5 *
  6 * This file is subject to the terms and conditions of the GNU General Public
  7 * License.  See the file COPYING in the main directory of this archive
  8 * for more details.
  9 *
 10 * Changed:
 11 * 10-Mar-94: Arno Griffioen: Conversion for vt100 emulator port from PC LINUX
 12 */
 13
 14#ifndef _LINUX_CONSOLE_H_
 15#define _LINUX_CONSOLE_H_ 1
 16
 17#include <linux/atomic.h>
 18#include <linux/bits.h>
 19#include <linux/irq_work.h>
 20#include <linux/rculist.h>
 21#include <linux/rcuwait.h>
 22#include <linux/smp.h>
 23#include <linux/types.h>
 24#include <linux/vesa.h>
 25
 26struct vc_data;
 27struct console_font_op;
 28struct console_font;
 29struct module;
 30struct tty_struct;
 31struct notifier_block;
 32
 33enum con_scroll {
 34	SM_UP,
 35	SM_DOWN,
 36};
 37
 38enum vc_intensity;
 39
 40/**
 41 * struct consw - callbacks for consoles
 42 *
 43 * @owner:      the module to get references of when this console is used
 44 * @con_startup: set up the console and return its name (like VGA, EGA, ...)
 45 * @con_init:   initialize the console on @vc. @init is true for the very first
 46 *		call on this @vc.
 47 * @con_deinit: deinitialize the console from @vc.
 48 * @con_clear:  erase @count characters at [@x, @y] on @vc. @count >= 1.
 49 * @con_putc:   emit one character with attributes @ca to [@x, @y] on @vc.
 50 *		(optional -- @con_putcs would be called instead)
 51 * @con_putcs:  emit @count characters with attributes @s to [@x, @y] on @vc.
 52 * @con_cursor: enable/disable cursor depending on @enable
 53 * @con_scroll: move lines from @top to @bottom in direction @dir by @lines.
 54 *		Return true if no generic handling should be done.
 55 *		Invoked by csi_M and printing to the console.
 56 * @con_switch: notifier about the console switch; it is supposed to return
 57 *		true if a redraw is needed.
 58 * @con_blank:  blank/unblank the console. The target mode is passed in @blank.
 59 *		@mode_switch is set if changing from/to text/graphics. The hook
 60 *		is supposed to return true if a redraw is needed.
 61 * @con_font_set: set console @vc font to @font with height @vpitch. @flags can
 62 *		be %KD_FONT_FLAG_DONT_RECALC. (optional)
 63 * @con_font_get: fetch the current font on @vc of height @vpitch into @font.
 64 *		(optional)
 65 * @con_font_default: set default font on @vc. @name can be %NULL or font name
 66 *		to search for. @font can be filled back. (optional)
 67 * @con_resize:	resize the @vc console to @width x @height. @from_user is true
 68 *		when this change comes from the user space.
 69 * @con_set_palette: sets the palette of the console @vc to @table (optional)
 70 * @con_scrolldelta: the contents of the console should be scrolled by @lines.
 71 *		     Invoked by user. (optional)
 72 * @con_set_origin: set origin (see &vc_data::vc_origin) of the @vc. If not
 73 *		provided or returns false, the origin is set to
 74 *		@vc->vc_screenbuf. (optional)
 75 * @con_save_screen: save screen content into @vc->vc_screenbuf. Called e.g.
 76 *		upon entering graphics. (optional)
 77 * @con_build_attr: build attributes based on @color, @intensity and other
 78 *		parameters. The result is used for both normal and erase
 79 *		characters. (optional)
 80 * @con_invert_region: invert a region of length @count on @vc starting at @p.
 81 *		(optional)
 82 * @con_debug_enter: prepare the console for the debugger. This includes, but
 83 *		is not limited to, unblanking the console, loading an
 84 *		appropriate palette, and allowing debugger generated output.
 85 *		(optional)
 86 * @con_debug_leave: restore the console to its pre-debug state as closely as
 87 *		possible. (optional)
 88 */
 89struct consw {
 90	struct module *owner;
 91	const char *(*con_startup)(void);
 92	void	(*con_init)(struct vc_data *vc, bool init);
 93	void	(*con_deinit)(struct vc_data *vc);
 94	void	(*con_clear)(struct vc_data *vc, unsigned int y,
 95			     unsigned int x, unsigned int count);
 96	void	(*con_putc)(struct vc_data *vc, u16 ca, unsigned int y,
 97			    unsigned int x);
 98	void	(*con_putcs)(struct vc_data *vc, const u16 *s,
 99			     unsigned int count, unsigned int ypos,
100			     unsigned int xpos);
101	void	(*con_cursor)(struct vc_data *vc, bool enable);
102	bool	(*con_scroll)(struct vc_data *vc, unsigned int top,
103			unsigned int bottom, enum con_scroll dir,
104			unsigned int lines);
105	bool	(*con_switch)(struct vc_data *vc);
106	bool	(*con_blank)(struct vc_data *vc, enum vesa_blank_mode blank,
107			     bool mode_switch);
108	int	(*con_font_set)(struct vc_data *vc,
109				const struct console_font *font,
110				unsigned int vpitch, unsigned int flags);
111	int	(*con_font_get)(struct vc_data *vc, struct console_font *font,
112			unsigned int vpitch);
113	int	(*con_font_default)(struct vc_data *vc,
114			struct console_font *font, const char *name);
115	int     (*con_resize)(struct vc_data *vc, unsigned int width,
116			      unsigned int height, bool from_user);
117	void	(*con_set_palette)(struct vc_data *vc,
118			const unsigned char *table);
119	void	(*con_scrolldelta)(struct vc_data *vc, int lines);
120	bool	(*con_set_origin)(struct vc_data *vc);
121	void	(*con_save_screen)(struct vc_data *vc);
122	u8	(*con_build_attr)(struct vc_data *vc, u8 color,
123			enum vc_intensity intensity,
124			bool blink, bool underline, bool reverse, bool italic);
125	void	(*con_invert_region)(struct vc_data *vc, u16 *p, int count);
126	void	(*con_debug_enter)(struct vc_data *vc);
127	void	(*con_debug_leave)(struct vc_data *vc);
128};
129
130extern const struct consw *conswitchp;
131
132extern const struct consw dummy_con;	/* dummy console buffer */
133extern const struct consw vga_con;	/* VGA text console */
134extern const struct consw newport_con;	/* SGI Newport console  */
135
136struct screen_info;
137#ifdef CONFIG_VGA_CONSOLE
138void vgacon_register_screen(struct screen_info *si);
139#else
140static inline void vgacon_register_screen(struct screen_info *si) { }
141#endif
142
143int con_is_bound(const struct consw *csw);
144int do_unregister_con_driver(const struct consw *csw);
145int do_take_over_console(const struct consw *sw, int first, int last, int deflt);
146void give_up_console(const struct consw *sw);
147#ifdef CONFIG_VT
148void con_debug_enter(struct vc_data *vc);
149void con_debug_leave(void);
150#else
151static inline void con_debug_enter(struct vc_data *vc) { }
152static inline void con_debug_leave(void) { }
153#endif
154
155/*
156 * The interface for a console, or any other device that wants to capture
157 * console messages (printer driver?)
158 */
159
160/**
161 * enum cons_flags - General console flags
162 * @CON_PRINTBUFFER:	Used by newly registered consoles to avoid duplicate
163 *			output of messages that were already shown by boot
164 *			consoles or read by userspace via syslog() syscall.
165 * @CON_CONSDEV:	Indicates that the console driver is backing
166 *			/dev/console.
167 * @CON_ENABLED:	Indicates if a console is allowed to print records. If
168 *			false, the console also will not advance to later
169 *			records.
170 * @CON_BOOT:		Marks the console driver as early console driver which
171 *			is used during boot before the real driver becomes
172 *			available. It will be automatically unregistered
173 *			when the real console driver is registered unless
174 *			"keep_bootcon" parameter is used.
175 * @CON_ANYTIME:	A misnomed historical flag which tells the core code
176 *			that the legacy @console::write callback can be invoked
177 *			on a CPU which is marked OFFLINE. That is misleading as
178 *			it suggests that there is no contextual limit for
179 *			invoking the callback. The original motivation was
180 *			readiness of the per-CPU areas.
181 * @CON_BRL:		Indicates a braille device which is exempt from
182 *			receiving the printk spam for obvious reasons.
183 * @CON_EXTENDED:	The console supports the extended output format of
184 *			/dev/kmesg which requires a larger output buffer.
185 * @CON_SUSPENDED:	Indicates if a console is suspended. If true, the
186 *			printing callbacks must not be called.
187 * @CON_NBCON:		Console can operate outside of the legacy style console_lock
188 *			constraints.
189 * @CON_NBCON_ATOMIC_UNSAFE: The write_atomic() callback is not safe and is
190 *			therefore only used by nbcon_atomic_flush_unsafe().
191 */
192enum cons_flags {
193	CON_PRINTBUFFER		= BIT(0),
194	CON_CONSDEV		= BIT(1),
195	CON_ENABLED		= BIT(2),
196	CON_BOOT		= BIT(3),
197	CON_ANYTIME		= BIT(4),
198	CON_BRL			= BIT(5),
199	CON_EXTENDED		= BIT(6),
200	CON_SUSPENDED		= BIT(7),
201	CON_NBCON		= BIT(8),
202	CON_NBCON_ATOMIC_UNSAFE	= BIT(9),
203};
204
205/**
206 * struct nbcon_state - console state for nbcon consoles
207 * @atom:	Compound of the state fields for atomic operations
208 *
209 * @req_prio:		The priority of a handover request
210 * @prio:		The priority of the current owner
211 * @unsafe:		Console is busy in a non takeover region
212 * @unsafe_takeover:	A hostile takeover in an unsafe state happened in the
213 *			past. The console cannot be safe until re-initialized.
214 * @cpu:		The CPU on which the owner runs
215 *
216 * To be used for reading and preparing of the value stored in the nbcon
217 * state variable @console::nbcon_state.
218 *
219 * The @prio and @req_prio fields are particularly important to allow
220 * spin-waiting to timeout and give up without the risk of a waiter being
221 * assigned the lock after giving up.
222 */
223struct nbcon_state {
224	union {
225		unsigned int	atom;
226		struct {
227			unsigned int prio		:  2;
228			unsigned int req_prio		:  2;
229			unsigned int unsafe		:  1;
230			unsigned int unsafe_takeover	:  1;
231			unsigned int cpu		: 24;
232		};
233	};
234};
235
236/*
237 * The nbcon_state struct is used to easily create and interpret values that
238 * are stored in the @console::nbcon_state variable. Ensure this struct stays
239 * within the size boundaries of the atomic variable's underlying type in
240 * order to avoid any accidental truncation.
241 */
242static_assert(sizeof(struct nbcon_state) <= sizeof(int));
243
244/**
245 * enum nbcon_prio - console owner priority for nbcon consoles
246 * @NBCON_PRIO_NONE:		Unused
247 * @NBCON_PRIO_NORMAL:		Normal (non-emergency) usage
248 * @NBCON_PRIO_EMERGENCY:	Emergency output (WARN/OOPS...)
249 * @NBCON_PRIO_PANIC:		Panic output
250 * @NBCON_PRIO_MAX:		The number of priority levels
251 *
252 * A higher priority context can takeover the console when it is
253 * in the safe state. The final attempt to flush consoles in panic()
254 * can be allowed to do so even in an unsafe state (Hope and pray).
255 */
256enum nbcon_prio {
257	NBCON_PRIO_NONE = 0,
258	NBCON_PRIO_NORMAL,
259	NBCON_PRIO_EMERGENCY,
260	NBCON_PRIO_PANIC,
261	NBCON_PRIO_MAX,
262};
263
264struct console;
265struct printk_buffers;
266
267/**
268 * struct nbcon_context - Context for console acquire/release
269 * @console:			The associated console
270 * @spinwait_max_us:		Limit for spin-wait acquire
271 * @prio:			Priority of the context
272 * @allow_unsafe_takeover:	Allow performing takeover even if unsafe. Can
273 *				be used only with NBCON_PRIO_PANIC @prio. It
274 *				might cause a system freeze when the console
275 *				is used later.
276 * @backlog:			Ringbuffer has pending records
277 * @pbufs:			Pointer to the text buffer for this context
278 * @seq:			The sequence number to print for this context
279 */
280struct nbcon_context {
281	/* members set by caller */
282	struct console		*console;
283	unsigned int		spinwait_max_us;
284	enum nbcon_prio		prio;
285	unsigned int		allow_unsafe_takeover	: 1;
286
287	/* members set by emit */
288	unsigned int		backlog			: 1;
289
290	/* members set by acquire */
291	struct printk_buffers	*pbufs;
292	u64			seq;
293};
294
295/**
296 * struct nbcon_write_context - Context handed to the nbcon write callbacks
297 * @ctxt:		The core console context
298 * @outbuf:		Pointer to the text buffer for output
299 * @len:		Length to write
300 * @unsafe_takeover:	If a hostile takeover in an unsafe state has occurred
301 */
302struct nbcon_write_context {
303	struct nbcon_context	__private ctxt;
304	char			*outbuf;
305	unsigned int		len;
306	bool			unsafe_takeover;
307};
308
309/**
310 * struct console - The console descriptor structure
311 * @name:		The name of the console driver
312 * @write:		Legacy write callback to output messages (Optional)
313 * @read:		Read callback for console input (Optional)
314 * @device:		The underlying TTY device driver (Optional)
315 * @unblank:		Callback to unblank the console (Optional)
316 * @setup:		Callback for initializing the console (Optional)
317 * @exit:		Callback for teardown of the console (Optional)
318 * @match:		Callback for matching a console (Optional)
319 * @flags:		Console flags. See enum cons_flags
320 * @index:		Console index, e.g. port number
321 * @cflag:		TTY control mode flags
322 * @ispeed:		TTY input speed
323 * @ospeed:		TTY output speed
324 * @seq:		Sequence number of the next ringbuffer record to print
325 * @dropped:		Number of unreported dropped ringbuffer records
326 * @data:		Driver private data
327 * @node:		hlist node for the console list
328 *
329 * @nbcon_state:	State for nbcon consoles
330 * @nbcon_seq:		Sequence number of the next record for nbcon to print
331 * @nbcon_device_ctxt:	Context available for non-printing operations
332 * @nbcon_prev_seq:	Seq num the previous nbcon owner was assigned to print
333 * @pbufs:		Pointer to nbcon private buffer
334 * @kthread:		Printer kthread for this console
335 * @rcuwait:		RCU-safe wait object for @kthread waking
336 * @irq_work:		Defer @kthread waking to IRQ work context
337 */
338struct console {
339	char			name[16];
340	void			(*write)(struct console *co, const char *s, unsigned int count);
341	int			(*read)(struct console *co, char *s, unsigned int count);
342	struct tty_driver	*(*device)(struct console *co, int *index);
343	void			(*unblank)(void);
344	int			(*setup)(struct console *co, char *options);
345	int			(*exit)(struct console *co);
346	int			(*match)(struct console *co, char *name, int idx, char *options);
347	short			flags;
348	short			index;
349	int			cflag;
350	uint			ispeed;
351	uint			ospeed;
352	u64			seq;
353	unsigned long		dropped;
354	void			*data;
355	struct hlist_node	node;
356
357	/* nbcon console specific members */
358
359	/**
360	 * @write_atomic:
361	 *
362	 * NBCON callback to write out text in any context. (Optional)
363	 *
364	 * This callback is called with the console already acquired. However,
365	 * a higher priority context is allowed to take it over by default.
366	 *
367	 * The callback must call nbcon_enter_unsafe() and nbcon_exit_unsafe()
368	 * around any code where the takeover is not safe, for example, when
369	 * manipulating the serial port registers.
370	 *
371	 * nbcon_enter_unsafe() will fail if the context has lost the console
372	 * ownership in the meantime. In this case, the callback is no longer
373	 * allowed to go forward. It must back out immediately and carefully.
374	 * The buffer content is also no longer trusted since it no longer
375	 * belongs to the context.
376	 *
377	 * The callback should allow the takeover whenever it is safe. It
378	 * increases the chance to see messages when the system is in trouble.
379	 * If the driver must reacquire ownership in order to finalize or
380	 * revert hardware changes, nbcon_reacquire_nobuf() can be used.
381	 * However, on reacquire the buffer content is no longer available. A
382	 * reacquire cannot be used to resume printing.
383	 *
384	 * The callback can be called from any context (including NMI).
385	 * Therefore it must avoid usage of any locking and instead rely
386	 * on the console ownership for synchronization.
387	 */
388	void (*write_atomic)(struct console *con, struct nbcon_write_context *wctxt);
389
390	/**
391	 * @write_thread:
392	 *
393	 * NBCON callback to write out text in task context.
394	 *
395	 * This callback must be called only in task context with both
396	 * device_lock() and the nbcon console acquired with
397	 * NBCON_PRIO_NORMAL.
398	 *
399	 * The same rules for console ownership verification and unsafe
400	 * sections handling applies as with write_atomic().
401	 *
402	 * The console ownership handling is necessary for synchronization
403	 * against write_atomic() which is synchronized only via the context.
404	 *
405	 * The device_lock() provides the primary serialization for operations
406	 * on the device. It might be as relaxed (mutex)[*] or as tight
407	 * (disabled preemption and interrupts) as needed. It allows
408	 * the kthread to operate in the least restrictive mode[**].
409	 *
410	 * [*] Standalone nbcon_context_try_acquire() is not safe with
411	 *     the preemption enabled, see nbcon_owner_matches(). But it
412	 *     can be safe when always called in the preemptive context
413	 *     under the device_lock().
414	 *
415	 * [**] The device_lock() makes sure that nbcon_context_try_acquire()
416	 *      would never need to spin which is important especially with
417	 *      PREEMPT_RT.
418	 */
419	void (*write_thread)(struct console *con, struct nbcon_write_context *wctxt);
420
421	/**
422	 * @device_lock:
423	 *
424	 * NBCON callback to begin synchronization with driver code.
425	 *
426	 * Console drivers typically must deal with access to the hardware
427	 * via user input/output (such as an interactive login shell) and
428	 * output of kernel messages via printk() calls. This callback is
429	 * called by the printk-subsystem whenever it needs to synchronize
430	 * with hardware access by the driver. It should be implemented to
431	 * use whatever synchronization mechanism the driver is using for
432	 * itself (for example, the port lock for uart serial consoles).
433	 *
434	 * The callback is always called from task context. It may use any
435	 * synchronization method required by the driver.
436	 *
437	 * IMPORTANT: The callback MUST disable migration. The console driver
438	 *	may be using a synchronization mechanism that already takes
439	 *	care of this (such as spinlocks). Otherwise this function must
440	 *	explicitly call migrate_disable().
441	 *
442	 * The flags argument is provided as a convenience to the driver. It
443	 * will be passed again to device_unlock(). It can be ignored if the
444	 * driver does not need it.
445	 */
446	void (*device_lock)(struct console *con, unsigned long *flags);
447
448	/**
449	 * @device_unlock:
450	 *
451	 * NBCON callback to finish synchronization with driver code.
452	 *
453	 * It is the counterpart to device_lock().
454	 *
455	 * This callback is always called from task context. It must
456	 * appropriately re-enable migration (depending on how device_lock()
457	 * disabled migration).
458	 *
459	 * The flags argument is the value of the same variable that was
460	 * passed to device_lock().
461	 */
462	void (*device_unlock)(struct console *con, unsigned long flags);
463
464	atomic_t		__private nbcon_state;
465	atomic_long_t		__private nbcon_seq;
466	struct nbcon_context	__private nbcon_device_ctxt;
467	atomic_long_t           __private nbcon_prev_seq;
468
469	struct printk_buffers	*pbufs;
470	struct task_struct	*kthread;
471	struct rcuwait		rcuwait;
472	struct irq_work		irq_work;
473};
474
475#ifdef CONFIG_LOCKDEP
476extern void lockdep_assert_console_list_lock_held(void);
477#else
478static inline void lockdep_assert_console_list_lock_held(void)
479{
480}
481#endif
482
483#ifdef CONFIG_DEBUG_LOCK_ALLOC
484extern bool console_srcu_read_lock_is_held(void);
485#else
486static inline bool console_srcu_read_lock_is_held(void)
487{
488	return 1;
489}
490#endif
491
492extern int console_srcu_read_lock(void);
493extern void console_srcu_read_unlock(int cookie);
494
495extern void console_list_lock(void) __acquires(console_mutex);
496extern void console_list_unlock(void) __releases(console_mutex);
497
498extern struct hlist_head console_list;
499
500/**
501 * console_srcu_read_flags - Locklessly read flags of a possibly registered
502 *				console
503 * @con:	struct console pointer of console to read flags from
504 *
505 * Locklessly reading @con->flags provides a consistent read value because
506 * there is at most one CPU modifying @con->flags and that CPU is using only
507 * read-modify-write operations to do so.
508 *
509 * Requires console_srcu_read_lock to be held, which implies that @con might
510 * be a registered console. The purpose of holding console_srcu_read_lock is
511 * to guarantee that the console state is valid (CON_SUSPENDED/CON_ENABLED)
512 * and that no exit/cleanup routines will run if the console is currently
513 * undergoing unregistration.
514 *
515 * If the caller is holding the console_list_lock or it is _certain_ that
516 * @con is not and will not become registered, the caller may read
517 * @con->flags directly instead.
518 *
519 * Context: Any context.
520 * Return: The current value of the @con->flags field.
521 */
522static inline short console_srcu_read_flags(const struct console *con)
523{
524	WARN_ON_ONCE(!console_srcu_read_lock_is_held());
525
526	/*
527	 * The READ_ONCE() matches the WRITE_ONCE() when @flags are modified
528	 * for registered consoles with console_srcu_write_flags().
529	 */
530	return data_race(READ_ONCE(con->flags));
531}
532
533/**
534 * console_srcu_write_flags - Write flags for a registered console
535 * @con:	struct console pointer of console to write flags to
536 * @flags:	new flags value to write
537 *
538 * Only use this function to write flags for registered consoles. It
539 * requires holding the console_list_lock.
540 *
541 * Context: Any context.
542 */
543static inline void console_srcu_write_flags(struct console *con, short flags)
544{
545	lockdep_assert_console_list_lock_held();
546
547	/* This matches the READ_ONCE() in console_srcu_read_flags(). */
548	WRITE_ONCE(con->flags, flags);
549}
550
551/* Variant of console_is_registered() when the console_list_lock is held. */
552static inline bool console_is_registered_locked(const struct console *con)
553{
554	lockdep_assert_console_list_lock_held();
555	return !hlist_unhashed(&con->node);
556}
557
558/*
559 * console_is_registered - Check if the console is registered
560 * @con:	struct console pointer of console to check
561 *
562 * Context: Process context. May sleep while acquiring console list lock.
563 * Return: true if the console is in the console list, otherwise false.
564 *
565 * If false is returned for a console that was previously registered, it
566 * can be assumed that the console's unregistration is fully completed,
567 * including the exit() callback after console list removal.
568 */
569static inline bool console_is_registered(const struct console *con)
570{
571	bool ret;
572
573	console_list_lock();
574	ret = console_is_registered_locked(con);
575	console_list_unlock();
576	return ret;
577}
578
579/**
580 * for_each_console_srcu() - Iterator over registered consoles
581 * @con:	struct console pointer used as loop cursor
582 *
583 * Although SRCU guarantees the console list will be consistent, the
584 * struct console fields may be updated by other CPUs while iterating.
585 *
586 * Requires console_srcu_read_lock to be held. Can be invoked from
587 * any context.
588 */
589#define for_each_console_srcu(con)					\
590	hlist_for_each_entry_srcu(con, &console_list, node,		\
591				  console_srcu_read_lock_is_held())
592
593/**
594 * for_each_console() - Iterator over registered consoles
595 * @con:	struct console pointer used as loop cursor
596 *
597 * The console list and the &console.flags are immutable while iterating.
598 *
599 * Requires console_list_lock to be held.
600 */
601#define for_each_console(con)						\
602	lockdep_assert_console_list_lock_held();			\
603	hlist_for_each_entry(con, &console_list, node)
604
605#ifdef CONFIG_PRINTK
606extern void nbcon_cpu_emergency_enter(void);
607extern void nbcon_cpu_emergency_exit(void);
608extern bool nbcon_can_proceed(struct nbcon_write_context *wctxt);
609extern void nbcon_write_context_set_buf(struct nbcon_write_context *wctxt,
610					char *buf, unsigned int len);
611extern bool nbcon_enter_unsafe(struct nbcon_write_context *wctxt);
612extern bool nbcon_exit_unsafe(struct nbcon_write_context *wctxt);
613extern void nbcon_reacquire_nobuf(struct nbcon_write_context *wctxt);
614extern bool nbcon_allow_unsafe_takeover(void);
615extern bool nbcon_kdb_try_acquire(struct console *con,
616				  struct nbcon_write_context *wctxt);
617extern void nbcon_kdb_release(struct nbcon_write_context *wctxt);
618
619/*
620 * Check if the given console is currently capable and allowed to print
621 * records. Note that this function does not consider the current context,
622 * which can also play a role in deciding if @con can be used to print
623 * records.
624 */
625static inline bool console_is_usable(struct console *con, short flags, bool use_atomic)
626{
627	if (!(flags & CON_ENABLED))
628		return false;
629
630	if ((flags & CON_SUSPENDED))
631		return false;
632
633	if (flags & CON_NBCON) {
634		if (use_atomic) {
635			/* The write_atomic() callback is optional. */
636			if (!con->write_atomic)
637				return false;
638
639			/*
640			 * An unsafe write_atomic() callback is only usable
641			 * when unsafe takeovers are allowed.
642			 */
643			if ((flags & CON_NBCON_ATOMIC_UNSAFE) && !nbcon_allow_unsafe_takeover())
644				return false;
645		}
646
647		/*
648		 * For the !use_atomic case, @printk_kthreads_running is not
649		 * checked because the write_thread() callback is also used
650		 * via the legacy loop when the printer threads are not
651		 * available.
652		 */
653	} else {
654		if (!con->write)
655			return false;
656	}
657
658	/*
659	 * Console drivers may assume that per-cpu resources have been
660	 * allocated. So unless they're explicitly marked as being able to
661	 * cope (CON_ANYTIME) don't call them until this CPU is officially up.
662	 */
663	if (!cpu_online(raw_smp_processor_id()) && !(flags & CON_ANYTIME))
664		return false;
665
666	return true;
667}
668
669#else
670static inline void nbcon_cpu_emergency_enter(void) { }
671static inline void nbcon_cpu_emergency_exit(void) { }
672static inline bool nbcon_can_proceed(struct nbcon_write_context *wctxt) { return false; }
673static inline void nbcon_write_context_set_buf(struct nbcon_write_context *wctxt,
674					       char *buf, unsigned int len) { }
675static inline bool nbcon_enter_unsafe(struct nbcon_write_context *wctxt) { return false; }
676static inline bool nbcon_exit_unsafe(struct nbcon_write_context *wctxt) { return false; }
677static inline void nbcon_reacquire_nobuf(struct nbcon_write_context *wctxt) { }
678static inline bool nbcon_kdb_try_acquire(struct console *con,
679					 struct nbcon_write_context *wctxt) { return false; }
680static inline void nbcon_kdb_release(struct nbcon_write_context *wctxt) { }
681static inline bool console_is_usable(struct console *con, short flags,
682				     bool use_atomic) { return false; }
683#endif
684
685extern int console_set_on_cmdline;
686extern struct console *early_console;
687
688enum con_flush_mode {
689	CONSOLE_FLUSH_PENDING,
690	CONSOLE_REPLAY_ALL,
691};
692
693extern int add_preferred_console(const char *name, const short idx, char *options);
694extern void console_force_preferred_locked(struct console *con);
695extern void register_console(struct console *);
696extern int unregister_console(struct console *);
697extern void console_lock(void);
698extern int console_trylock(void);
699extern void console_unlock(void);
700extern void console_conditional_schedule(void);
701extern void console_unblank(void);
702extern void console_flush_on_panic(enum con_flush_mode mode);
703extern struct tty_driver *console_device(int *);
704extern void console_suspend(struct console *);
705extern void console_resume(struct console *);
706extern int is_console_locked(void);
707extern int braille_register_console(struct console *, int index,
708		char *console_options, char *braille_options);
709extern int braille_unregister_console(struct console *);
710#ifdef CONFIG_TTY
711extern void console_sysfs_notify(void);
712#else
713static inline void console_sysfs_notify(void)
714{ }
715#endif
716extern bool console_suspend_enabled;
717
718/* Suspend and resume console messages over PM events */
719extern void console_suspend_all(void);
720extern void console_resume_all(void);
721
722int mda_console_init(void);
723
724void vcs_make_sysfs(int index);
725void vcs_remove_sysfs(int index);
726
727/* Some debug stub to catch some of the obvious races in the VT code */
728#define WARN_CONSOLE_UNLOCKED()						\
729	WARN_ON(!atomic_read(&ignore_console_lock_warning) &&		\
730		!is_console_locked() && !oops_in_progress)
731/*
732 * Increment ignore_console_lock_warning if you need to quiet
733 * WARN_CONSOLE_UNLOCKED() for debugging purposes.
734 */
735extern atomic_t ignore_console_lock_warning;
736
737DEFINE_LOCK_GUARD_0(console_lock, console_lock(), console_unlock());
738
739extern void console_init(void);
740
741/* For deferred console takeover */
742void dummycon_register_output_notifier(struct notifier_block *nb);
743void dummycon_unregister_output_notifier(struct notifier_block *nb);
744
745#endif /* _LINUX_CONSOLE_H */