lkml.org 
[lkml]   [2019]   [Feb]   [12]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RFC PATCH v1 25/25] printk: remove unused code
    Date
    Code relating to the safe context and anything dealing with the
    previous log buffer implementation is no longer in use. Remove it.

    Signed-off-by: John Ogness <john.ogness@linutronix.de>
    ---
    kernel/printk/internal.h | 53 ---------------
    kernel/printk/printk.c | 167 ++++-------------------------------------------
    lib/bust_spinlocks.c | 3 +-
    3 files changed, 13 insertions(+), 210 deletions(-)
    delete mode 100644 kernel/printk/internal.h

    diff --git a/kernel/printk/internal.h b/kernel/printk/internal.h
    deleted file mode 100644
    index 59ad43dba837..000000000000
    --- a/kernel/printk/internal.h
    +++ /dev/null
    @@ -1,53 +0,0 @@
    -/*
    - * internal.h - printk internal definitions
    - *
    - * This program is free software; you can redistribute it and/or
    - * modify it under the terms of the GNU General Public License
    - * as published by the Free Software Foundation; either version 2
    - * of the License, or (at your option) any later version.
    - *
    - * This program is distributed in the hope that it will be useful,
    - * but WITHOUT ANY WARRANTY; without even the implied warranty of
    - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    - * GNU General Public License for more details.
    - *
    - * You should have received a copy of the GNU General Public License
    - * along with this program; if not, see <http://www.gnu.org/licenses/>.
    - */
    -#include <linux/percpu.h>
    -
    -#ifdef CONFIG_PRINTK
    -
    -#define PRINTK_SAFE_CONTEXT_MASK 0x3fffffff
    -#define PRINTK_NMI_DIRECT_CONTEXT_MASK 0x40000000
    -#define PRINTK_NMI_CONTEXT_MASK 0x80000000
    -
    -extern raw_spinlock_t logbuf_lock;
    -
    -__printf(5, 0)
    -int vprintk_store(int facility, int level,
    - const char *dict, size_t dictlen,
    - const char *fmt, va_list args);
    -
    -__printf(1, 0) int vprintk_default(const char *fmt, va_list args);
    -__printf(1, 0) int vprintk_deferred(const char *fmt, va_list args);
    -__printf(1, 0) int vprintk_func(const char *fmt, va_list args);
    -
    -void defer_console_output(void);
    -
    -#else
    -
    -__printf(1, 0) int vprintk_func(const char *fmt, va_list args) { return 0; }
    -
    -/*
    - * In !PRINTK builds we still export logbuf_lock spin_lock, console_sem
    - * semaphore and some of console functions (console_unlock()/etc.), so
    - * printk-safe must preserve the existing local IRQ guarantees.
    - */
    -#endif /* CONFIG_PRINTK */
    -
    -#define printk_safe_enter_irqsave(flags) local_irq_save(flags)
    -#define printk_safe_exit_irqrestore(flags) local_irq_restore(flags)
    -
    -#define printk_safe_enter_irq() local_irq_disable()
    -#define printk_safe_exit_irq() local_irq_enable()
    diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
    index 6d5bb7f5f584..8ef35c398887 100644
    --- a/kernel/printk/printk.c
    +++ b/kernel/printk/printk.c
    @@ -60,7 +60,6 @@

    #include "console_cmdline.h"
    #include "braille.h"
    -#include "internal.h"

    int console_printk[5] = {
    CONSOLE_LOGLEVEL_DEFAULT, /* console_loglevel */
    @@ -346,41 +345,6 @@ __packed __aligned(4)
    #endif
    ;

    -/*
    - * The logbuf_lock protects kmsg buffer, indices, counters. This can be taken
    - * within the scheduler's rq lock. It must be released before calling
    - * console_unlock() or anything else that might wake up a process.
    - */
    -DEFINE_RAW_SPINLOCK(logbuf_lock);
    -
    -/*
    - * Helper macros to lock/unlock logbuf_lock and switch between
    - * printk-safe/unsafe modes.
    - */
    -#define logbuf_lock_irq() \
    - do { \
    - printk_safe_enter_irq(); \
    - raw_spin_lock(&logbuf_lock); \
    - } while (0)
    -
    -#define logbuf_unlock_irq() \
    - do { \
    - raw_spin_unlock(&logbuf_lock); \
    - printk_safe_exit_irq(); \
    - } while (0)
    -
    -#define logbuf_lock_irqsave(flags) \
    - do { \
    - printk_safe_enter_irqsave(flags); \
    - raw_spin_lock(&logbuf_lock); \
    - } while (0)
    -
    -#define logbuf_unlock_irqrestore(flags) \
    - do { \
    - raw_spin_unlock(&logbuf_lock); \
    - printk_safe_exit_irqrestore(flags); \
    - } while (0)
    -
    DECLARE_STATIC_PRINTKRB_CPULOCK(printk_cpulock);

    #ifdef CONFIG_PRINTK
    @@ -390,23 +354,15 @@ DECLARE_STATIC_PRINTKRB(printk_rb, CONFIG_LOG_BUF_SHIFT, &printk_cpulock);
    static DEFINE_MUTEX(syslog_lock);
    DECLARE_STATIC_PRINTKRB_ITER(syslog_iter, &printk_rb);

    -DECLARE_WAIT_QUEUE_HEAD(log_wait);
    -/* the next printk record to read by syslog(READ) or /proc/kmsg */
    +/* the last printk record read by syslog(READ) or /proc/kmsg */
    static u64 syslog_seq;
    static size_t syslog_partial;
    static bool syslog_time;

    -/* index and sequence number of the first record stored in the buffer */
    -static u32 log_first_idx;
    -
    -/* index and sequence number of the next record to store in the buffer */
    -static u32 log_next_idx;
    -
    static DEFINE_MUTEX(kmsg_dump_lock);

    -/* the next printk record to read after the last 'clear' command */
    +/* the last printk record at the last 'clear' command */
    static u64 clear_seq;
    -static u32 clear_idx;

    #define PREFIX_MAX 32
    #define LOG_LINE_MAX (1024 - PREFIX_MAX)
    @@ -414,26 +370,6 @@ static u32 clear_idx;
    #define LOG_LEVEL(v) ((v) & 0x07)
    #define LOG_FACILITY(v) ((v) >> 3 & 0xff)

    -/* record buffer */
    -#define LOG_ALIGN __alignof__(struct printk_log)
    -#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
    -#define LOG_BUF_LEN_MAX (u32)(1 << 31)
    -static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
    -static char *log_buf = __log_buf;
    -static u32 log_buf_len = __LOG_BUF_LEN;
    -
    -/* Return log buffer address */
    -char *log_buf_addr_get(void)
    -{
    - return log_buf;
    -}
    -
    -/* Return log buffer size */
    -u32 log_buf_len_get(void)
    -{
    - return log_buf_len;
    -}
    -
    /* human readable text of the record */
    static char *log_text(const struct printk_log *msg)
    {
    @@ -944,11 +880,6 @@ const struct file_operations kmsg_fops = {
    */
    void log_buf_vmcoreinfo_setup(void)
    {
    - VMCOREINFO_SYMBOL(log_buf);
    - VMCOREINFO_SYMBOL(log_buf_len);
    - VMCOREINFO_SYMBOL(log_first_idx);
    - VMCOREINFO_SYMBOL(clear_idx);
    - VMCOREINFO_SYMBOL(log_next_idx);
    /*
    * Export struct printk_log size and field offsets. User space tools can
    * parse it and detect any changes to structure down the line.
    @@ -961,6 +892,8 @@ void log_buf_vmcoreinfo_setup(void)
    }
    #endif

    +/* FIXME: no support for buffer resizing */
    +#if 0
    /* requested log_buf_len from kernel cmdline */
    static unsigned long __initdata new_log_buf_len;

    @@ -1026,9 +959,12 @@ static void __init log_buf_add_cpu(void)
    #else /* !CONFIG_SMP */
    static inline void log_buf_add_cpu(void) {}
    #endif /* CONFIG_SMP */
    +#endif /* 0 */

    void __init setup_log_buf(int early)
    {
    +/* FIXME: no support for buffer resizing */
    +#if 0
    unsigned long flags;
    char *new_log_buf;
    unsigned int free;
    @@ -1067,6 +1003,7 @@ void __init setup_log_buf(int early)
    pr_info("log_buf_len: %u bytes\n", log_buf_len);
    pr_info("early log buf free: %u(%u%%)\n",
    free, (free * 100) / __LOG_BUF_LEN);
    +#endif
    }

    static bool __read_mostly ignore_loglevel;
    @@ -2023,31 +1960,6 @@ asmlinkage __visible int printk(const char *fmt, ...)
    return r;
    }
    EXPORT_SYMBOL(printk);
    -
    -#else /* CONFIG_PRINTK */
    -
    -#define LOG_LINE_MAX 0
    -#define PREFIX_MAX 0
    -#define printk_time false
    -
    -static u64 syslog_seq;
    -static u32 log_first_idx;
    -static char *log_text(const struct printk_log *msg) { return NULL; }
    -static char *log_dict(const struct printk_log *msg) { return NULL; }
    -static struct printk_log *log_from_idx(u32 idx) { return NULL; }
    -static u32 log_next(u32 idx) { return 0; }
    -static ssize_t msg_print_ext_header(char *buf, size_t size,
    - struct printk_log *msg,
    - u64 seq) { return 0; }
    -static ssize_t msg_print_ext_body(char *buf, size_t size,
    - char *dict, size_t dict_len,
    - char *text, size_t text_len) { return 0; }
    -static void call_console_drivers(u64 seq, const char *ext_text, size_t ext_len,
    - const char *text, size_t len, int level) {}
    -static size_t msg_print_text(const struct printk_log *msg, bool syslog,
    - bool time, char *buf, size_t size) { return 0; }
    -static bool suppress_message_printing(int level) { return false; }
    -
    #endif /* CONFIG_PRINTK */

    #ifdef CONFIG_EARLY_PRINTK
    @@ -2343,15 +2255,10 @@ void console_unblank(void)
    void console_flush_on_panic(void)
    {
    /*
    - * If someone else is holding the console lock, trylock will fail
    - * and may_schedule may be set. Ignore and proceed to unlock so
    - * that messages are flushed out. As this can be called from any
    - * context and we don't want to get preempted while flushing,
    - * ensure may_schedule is cleared.
    + * FIXME: This is currently a NOP. Emergency messages will have been
    + * printed, but what about if write_atomic is not available on the
    + * console? What if the printk kthread is still alive?
    */
    - console_trylock();
    - console_may_schedule = 0;
    - console_unlock();
    }

    /*
    @@ -2700,43 +2607,6 @@ static int __init printk_late_init(void)
    late_initcall(printk_late_init);

    #if defined CONFIG_PRINTK
    -/*
    - * Delayed printk version, for scheduler-internal messages:
    - */
    -#define PRINTK_PENDING_WAKEUP 0x01
    -#define PRINTK_PENDING_OUTPUT 0x02
    -
    -static DEFINE_PER_CPU(int, printk_pending);
    -
    -static void wake_up_klogd_work_func(struct irq_work *irq_work)
    -{
    - int pending = __this_cpu_xchg(printk_pending, 0);
    -
    - if (pending & PRINTK_PENDING_OUTPUT) {
    - /* If trylock fails, someone else is doing the printing */
    - if (console_trylock())
    - console_unlock();
    - }
    -
    - if (pending & PRINTK_PENDING_WAKEUP)
    - wake_up_interruptible(&log_wait);
    -}
    -
    -static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
    - .func = wake_up_klogd_work_func,
    - .flags = IRQ_WORK_LAZY,
    -};
    -
    -void wake_up_klogd(void)
    -{
    - preempt_disable();
    - if (waitqueue_active(&log_wait)) {
    - this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
    - irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
    - }
    - preempt_enable();
    -}
    -
    static int printk_kthread_func(void *data)
    {
    struct prb_iterator iter;
    @@ -2802,22 +2672,9 @@ static int __init init_printk_kthread(void)
    }
    late_initcall(init_printk_kthread);

    -void defer_console_output(void)
    -{
    - preempt_disable();
    - __this_cpu_or(printk_pending, PRINTK_PENDING_OUTPUT);
    - irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
    - preempt_enable();
    -}
    -
    int vprintk_deferred(const char *fmt, va_list args)
    {
    - int r;
    -
    - r = vprintk_emit(0, LOGLEVEL_SCHED, NULL, 0, fmt, args);
    - defer_console_output();
    -
    - return r;
    + return vprintk_emit(0, LOGLEVEL_SCHED, NULL, 0, fmt, args);
    }

    int printk_deferred(const char *fmt, ...)
    diff --git a/lib/bust_spinlocks.c b/lib/bust_spinlocks.c
    index 8be59f84eaea..c6e083323d1b 100644
    --- a/lib/bust_spinlocks.c
    +++ b/lib/bust_spinlocks.c
    @@ -26,7 +26,6 @@ void bust_spinlocks(int yes)
    unblank_screen();
    #endif
    console_unblank();
    - if (--oops_in_progress == 0)
    - wake_up_klogd();
    + --oops_in_progress;
    }
    }
    --
    2.11.0
    \
     
     \ /
      Last update: 2019-02-12 15:31    [W:2.917 / U:0.456 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site