--- zzzz-none-000/linux-4.4.271/kernel/printk/printk.c 2021-06-03 06:22:09.000000000 +0000 +++ hawkeye-5590-750/linux-4.4.271/kernel/printk/printk.c 2023-04-19 10:22:30.000000000 +0000 @@ -16,6 +16,11 @@ * 01Mar01 Andrew Morton */ +#ifdef CONFIG_AVM_FASTIRQ +#include +#define CLIENT_FIQ_PRIO FIQ_PRIO_WATCHDOG +#endif + #include #include #include @@ -46,6 +51,13 @@ #include #include #include +#include +#ifdef CONFIG_AVM_DEBUG +#include +#if defined(CONFIG_SMP) && defined(CONFIG_MIPS) +#include +#endif /*--- #if defined(CONFIG_SMP) && defined(CONFIG_MIPS) ---*/ +#endif /*--- #ifdef CONFIG_AVM_DEBUG ---*/ #include @@ -101,22 +113,26 @@ * macros instead of functions so that _RET_IP_ contains useful information. */ #define down_console_sem() do { \ - down(&console_sem);\ + __raw_rte_down(&console_sem);\ mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);\ } while (0) static int __down_trylock_console_sem(unsigned long ip) { - if (down_trylock(&console_sem)) + if (__raw_rte_down_trylock(&console_sem)) return 1; - mutex_acquire(&console_lock_dep_map, 0, 1, ip); + if (!__raw_is_rte_context()) { + mutex_acquire(&console_lock_dep_map, 0, 1, ip); + } return 0; } #define down_trylock_console_sem() __down_trylock_console_sem(_RET_IP_) -#define up_console_sem() do { \ - mutex_release(&console_lock_dep_map, 1, _RET_IP_);\ - up(&console_sem);\ +#define up_console_sem() do { \ + if (!__raw_is_rte_context()) { \ + mutex_release(&console_lock_dep_map, 1, _RET_IP_); \ + } \ + __raw_rte_up(&console_sem); \ } while (0) /* @@ -232,6 +248,9 @@ u8 facility; /* syslog facility */ u8 flags:5; /* internal record flags */ u8 level:3; /* syslog level */ +#if defined(CONFIG_AVM_DEBUG) + u8 cpu; +#endif/*--- #if defined(CONFIG_AVM_DEBUG) ---*/ }; /* @@ -282,7 +301,8 @@ #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; +u32 log_buf_len = __LOG_BUF_LEN; +EXPORT_SYMBOL(log_buf_len); /* Return log buffer address */ char *log_buf_addr_get(void) @@ -465,10 +485,17 @@ msg->facility = facility; msg->level = level & 7; msg->flags = flags & 0x1f; +#if defined(CONFIG_AVM_DEBUG) + if (!__raw_is_rte_context()) { + msg->cpu = raw_smp_processor_id(); + } else { + msg->cpu = raw_smp_processor_id() | 0x80; + } +#endif/*--- #if defined(CONFIG_AVM_DEBUG) ---*/ if (ts_nsec > 0) msg->ts_nsec = ts_nsec; else - msg->ts_nsec = local_clock(); + msg->ts_nsec = __raw_rte_local_clock(); memset(log_dict(msg) + dict_len, 0, pad_len); msg->len = size; @@ -670,6 +697,7 @@ struct printk_log *msg; size_t len; ssize_t ret; + unsigned long flags; if (!user) return -EBADF; @@ -677,20 +705,20 @@ ret = mutex_lock_interruptible(&user->lock); if (ret) return ret; - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); while (user->seq == log_next_seq) { if (file->f_flags & O_NONBLOCK) { ret = -EAGAIN; - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); goto out; } - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); ret = wait_event_interruptible(log_wait, user->seq != log_next_seq); if (ret) goto out; - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); } if (user->seq < log_first_seq) { @@ -698,7 +726,7 @@ user->idx = log_first_idx; user->seq = log_first_seq; ret = -EPIPE; - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); goto out; } @@ -712,7 +740,7 @@ user->prev = msg->flags; user->idx = log_next(user->idx); user->seq++; - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); if (len > count) { ret = -EINVAL; @@ -733,13 +761,14 @@ { struct devkmsg_user *user = file->private_data; loff_t ret = 0; + unsigned long flags; if (!user) return -EBADF; if (offset) return -ESPIPE; - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); switch (whence) { case SEEK_SET: /* the first record */ @@ -763,7 +792,7 @@ default: ret = -EINVAL; } - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); return ret; } @@ -771,13 +800,14 @@ { struct devkmsg_user *user = file->private_data; int ret = 0; + unsigned long flags; if (!user) return POLLERR|POLLNVAL; poll_wait(file, &log_wait, wait); - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (user->seq < log_next_seq) { /* return error when data has vanished underneath us */ if (user->seq < log_first_seq) @@ -785,7 +815,7 @@ else ret = POLLIN|POLLRDNORM; } - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); return ret; } @@ -794,6 +824,7 @@ { struct devkmsg_user *user; int err; + unsigned long flags; /* write-only does not need any file context */ if ((file->f_flags & O_ACCMODE) == O_WRONLY) @@ -810,10 +841,10 @@ mutex_init(&user->lock); - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); user->idx = log_first_idx; user->seq = log_first_seq; - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); file->private_data = user; return 0; @@ -962,13 +993,13 @@ return; } - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); log_buf_len = new_log_buf_len; log_buf = new_log_buf; new_log_buf_len = 0; free = __LOG_BUF_LEN - log_next_idx; memcpy(log_buf, __log_buf, __LOG_BUF_LEN); - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); pr_info("log_buf_len: %u bytes\n", log_buf_len); pr_info("early log buf free: %u(%u%%)\n", @@ -1084,6 +1115,12 @@ } len += print_time(msg->ts_nsec, buf ? buf + len : NULL); +#if defined(CONFIG_AVM_DEBUG) && defined(CONFIG_SMP) + if(buf) { + if(len && buf[len-1] == ' ') len--; + len += sprintf(&buf[len], "[%s%x] ", msg->cpu & 0x80 ? "F" : "", msg->cpu & ~0x80); + } +#endif /*--- #if defined(CONFIG_AVM_DEBUG) && defined(CONFIG_SMP) ---*/ return len; } @@ -1151,6 +1188,7 @@ char *text; struct printk_log *msg; int len = 0; + unsigned long flags; text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL); if (!text) @@ -1160,7 +1198,7 @@ size_t n; size_t skip; - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (syslog_seq < log_first_seq) { /* messages are gone, move to first one */ syslog_seq = log_first_seq; @@ -1169,7 +1207,7 @@ syslog_partial = 0; } if (syslog_seq == log_next_seq) { - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); break; } @@ -1190,7 +1228,7 @@ syslog_partial += n; } else n = 0; - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); if (!n) break; @@ -1214,12 +1252,13 @@ { char *text; int len = 0; + unsigned long flags; text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL); if (!text) return -ENOMEM; - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (buf) { u64 next_seq; u64 seq; @@ -1279,12 +1318,12 @@ seq++; prev = msg->flags; - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); if (copy_to_user(buf + len, text, textlen)) len = -EFAULT; else len += textlen; - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (seq < log_first_seq) { /* messages are gone, move to next one */ @@ -1299,7 +1338,7 @@ clear_seq = log_next_seq; clear_idx = log_next_idx; } - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); kfree(text); return len; @@ -1310,6 +1349,7 @@ bool clear = false; static int saved_console_loglevel = LOGLEVEL_DEFAULT; int error; + unsigned long flags; error = check_syslog_permissions(type, source); if (error) @@ -1386,7 +1426,7 @@ break; /* Number of chars in the log buffer */ case SYSLOG_ACTION_SIZE_UNREAD: - raw_spin_lock_irq(&logbuf_lock); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (syslog_seq < log_first_seq) { /* messages are gone, move to first one */ syslog_seq = log_first_seq; @@ -1417,7 +1457,7 @@ } error -= syslog_partial; } - raw_spin_unlock_irq(&logbuf_lock); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); break; /* Size of the log buffer */ case SYSLOG_ACTION_SIZE_BUFFER: @@ -1440,6 +1480,7 @@ * Call the console drivers, asking them to write out * log_buf[start] to log_buf[end - 1]. * The console_lock must be held. + * FASTIRQ-Kontext-fest */ static void call_console_drivers(int level, const char *ext_text, size_t ext_len, @@ -1459,9 +1500,11 @@ continue; if (!(con->flags & CON_ENABLED)) continue; + if (con->flags & CON_MUTED) + continue; if (!con->write) continue; - if (!cpu_online(smp_processor_id()) && + if (!cpu_online(raw_smp_processor_id()) && !(con->flags & CON_ANYTIME)) continue; if (con->flags & CON_EXTENDED) @@ -1488,7 +1531,7 @@ debug_locks_off(); /* If a crash is occurring, make sure we can't deadlock */ - raw_spin_lock_init(&logbuf_lock); + __raw_rte_raw_spin_lock_init(&logbuf_lock); /* And make sure that we print immediately */ sema_init(&console_sem, 1); } @@ -1525,10 +1568,11 @@ * messages from a 'printk'. Return true (and with the * console_lock held, and 'console_locked' set) if it * is successful, false otherwise. + * FASTIRQ-Kontext fest */ static int console_trylock_for_printk(void) { - unsigned int cpu = smp_processor_id(); + unsigned int cpu = raw_smp_processor_id() & ~0x80; if (!console_trylock()) return 0; @@ -1624,7 +1668,7 @@ cont.facility = facility; cont.level = level; cont.owner = current; - cont.ts_nsec = local_clock(); + cont.ts_nsec = __raw_rte_local_clock(); cont.flags = 0; cont.cons = 0; cont.flushed = false; @@ -1676,25 +1720,29 @@ char *text = textbuf; size_t text_len = 0; enum log_flags lflags = 0; - unsigned long flags; + unsigned long flags = 0; int this_cpu; int printed_len = 0; bool in_sched = false; /* cpu currently holding logbuf_lock in this function */ static unsigned int logbuf_cpu = UINT_MAX; + this_cpu = raw_smp_processor_id(); + if (level == LOGLEVEL_SCHED) { level = LOGLEVEL_DEFAULT; in_sched = true; } - - boot_delay_msec(level); - printk_delay(); + if (!is_rte_context()) { + boot_delay_msec(level); + printk_delay(); + } else { + this_cpu |= 0x80; + in_sched = true; + } /* This stops the holder of console_sem just where we want him */ - local_irq_save(flags); - this_cpu = smp_processor_id(); - + __raw_rte_local_irq_save(flags); /* * Ouch, printk recursed into itself! */ @@ -1708,14 +1756,14 @@ */ if (!oops_in_progress && !lockdep_recursing(current)) { recursion_bug = 1; - local_irq_restore(flags); + __raw_rte_local_irq_restore(flags); return 0; } zap_locks(); } lockdep_off(); - raw_spin_lock(&logbuf_lock); + __raw_rte_raw_spin_lock(&logbuf_lock); logbuf_cpu = this_cpu; if (unlikely(recursion_bug)) { @@ -1812,9 +1860,9 @@ } logbuf_cpu = UINT_MAX; - raw_spin_unlock(&logbuf_lock); + __raw_rte_raw_spin_unlock(&logbuf_lock); lockdep_on(); - local_irq_restore(flags); + __raw_rte_local_irq_restore(flags); /* If called from the scheduler, we can not call up(). */ if (!in_sched) { @@ -1930,10 +1978,18 @@ } EXPORT_SYMBOL(printk); +#ifdef CONFIG_QCA_MINIDUMP +void minidump_get_log_buf_info(uint64_t *plog_buf, uint64_t *plog_buf_len) +{ + *plog_buf = (uint64_t)(uintptr_t)log_buf; + *plog_buf_len = (uint64_t)__pa(&log_buf_len); +} +#endif + #else /* CONFIG_PRINTK */ -#define LOG_LINE_MAX 0 -#define PREFIX_MAX 0 +#define LOG_LINE_MAX 0 +#define PREFIX_MAX 0 static u64 syslog_seq; static u32 syslog_idx; @@ -2197,12 +2253,15 @@ return console_locked; } +/*--------------------------------------------------------------------------------*\ + * FASTIRQ-Kontext fest +\*--------------------------------------------------------------------------------*/ static void console_cont_flush(char *text, size_t size) { unsigned long flags; size_t len; - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (!cont.len) goto out; @@ -2216,14 +2275,15 @@ goto out; len = cont_print_text(text, size); - raw_spin_unlock(&logbuf_lock); - stop_critical_timings(); + __raw_rte_raw_spin_unlock(&logbuf_lock); + __raw_rte_stop_critical_timings(); call_console_drivers(cont.level, NULL, 0, text, len); - start_critical_timings(); - local_irq_restore(flags); + + __raw_rte_start_critical_timings(); + __raw_rte_local_irq_restore(flags); return; out: - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); } /** @@ -2239,6 +2299,7 @@ * If there is output waiting, we wake /dev/kmsg and syslog() users. * * console_unlock(); may be called from any context. + * FASTIRQ-Kontext fest */ void console_unlock(void) { @@ -2276,7 +2337,7 @@ size_t len; int level; - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (seen_seq != log_next_seq) { wake_klogd = true; seen_seq = log_next_seq; @@ -2330,12 +2391,12 @@ console_idx = log_next(console_idx); console_seq++; console_prev = msg->flags; - raw_spin_unlock(&logbuf_lock); + __raw_rte_raw_spin_unlock(&logbuf_lock); - stop_critical_timings(); /* don't trace print latency */ + __raw_rte_stop_critical_timings(); /* don't trace print latency */ call_console_drivers(level, ext_text, ext_len, text, len); - start_critical_timings(); - local_irq_restore(flags); + __raw_rte_start_critical_timings(); + __raw_rte_local_irq_restore(flags); if (do_cond_resched) cond_resched(); @@ -2346,7 +2407,7 @@ if (unlikely(exclusive_console)) exclusive_console = NULL; - raw_spin_unlock(&logbuf_lock); + __raw_rte_raw_spin_unlock(&logbuf_lock); up_console_sem(); @@ -2356,14 +2417,14 @@ * there's a new owner and the console_unlock() from them will do the * flush, no worries. */ - raw_spin_lock(&logbuf_lock); + __raw_rte_raw_spin_lock(&logbuf_lock); retry = console_seq != log_next_seq; - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); if (retry && console_trylock()) goto again; - if (wake_klogd) + if (wake_klogd && !is_rte_context()) wake_up_klogd(); } EXPORT_SYMBOL(console_unlock); @@ -2466,6 +2527,35 @@ } EXPORT_SYMBOL(console_start); + +void console_mute(struct console *console) +{ + console_lock(); + console_mute_nolock(console); + console_unlock(); +} +EXPORT_SYMBOL(console_mute); + +void console_mute_nolock(struct console *console) +{ + console->flags |= CON_MUTED; +} +EXPORT_SYMBOL(console_mute_nolock); + +void console_unmute(struct console *console) +{ + console_lock(); + console_unmute_nolock(console); + console_unlock(); +} +EXPORT_SYMBOL(console_unmute); + +void console_unmute_nolock(struct console *console) +{ + console->flags &= ~CON_MUTED; +} +EXPORT_SYMBOL(console_unmute_nolock); + static int __read_mostly keep_bootcon; static int __init keep_bootcon_setup(char *str) @@ -2621,11 +2711,11 @@ * console_unlock(); will print out the buffered messages * for us. */ - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); console_seq = syslog_seq; console_idx = syslog_idx; console_prev = syslog_prev; - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); /* * We're about to replay the log buffer. Only do this to the * just-registered console to avoid excessive message spam to @@ -2661,7 +2751,7 @@ int unregister_console(struct console *console) { - struct console *a, *b; + struct console *a, *b; int res; pr_info("%sconsole [%s%d] disabled\n", @@ -2830,14 +2920,14 @@ if (!dumper->dump) return -EINVAL; - spin_lock_irqsave(&dump_list_lock, flags); + __raw_rte_spin_lock_irqsave(&dump_list_lock, flags); /* Don't allow registering multiple times */ if (!dumper->registered) { dumper->registered = 1; list_add_tail_rcu(&dumper->list, &dump_list); err = 0; } - spin_unlock_irqrestore(&dump_list_lock, flags); + __raw_rte_spin_unlock_irqrestore(&dump_list_lock, flags); return err; } @@ -2855,13 +2945,13 @@ unsigned long flags; int err = -EINVAL; - spin_lock_irqsave(&dump_list_lock, flags); + __raw_rte_spin_lock_irqsave(&dump_list_lock, flags); if (dumper->registered) { dumper->registered = 0; list_del_rcu(&dumper->list); err = 0; } - spin_unlock_irqrestore(&dump_list_lock, flags); + __raw_rte_spin_unlock_irqrestore(&dump_list_lock, flags); synchronize_rcu(); return err; @@ -2895,12 +2985,12 @@ /* initialize iterator with data about the stored records */ dumper->active = true; - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); dumper->cur_seq = clear_seq; dumper->cur_idx = clear_idx; dumper->next_seq = log_next_seq; dumper->next_idx = log_next_idx; - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); /* invoke dumper which will iterate over records */ dumper->dump(dumper, reason); @@ -2985,9 +3075,9 @@ unsigned long flags; bool ret; - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len); - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); return ret; } @@ -3027,7 +3117,7 @@ if (!dumper->active) goto out; - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); if (dumper->cur_seq < log_first_seq) { /* messages are gone, move to first available one */ dumper->cur_seq = log_first_seq; @@ -3036,7 +3126,7 @@ /* last entry */ if (dumper->cur_seq >= dumper->next_seq) { - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); goto out; } @@ -3083,7 +3173,7 @@ dumper->next_seq = next_seq; dumper->next_idx = next_idx; ret = true; - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); out: if (len) *len = l; @@ -3121,9 +3211,9 @@ { unsigned long flags; - raw_spin_lock_irqsave(&logbuf_lock, flags); + __raw_rte_raw_spin_lock_irqsave(&logbuf_lock, flags); kmsg_dump_rewind_nolock(dumper); - raw_spin_unlock_irqrestore(&logbuf_lock, flags); + __raw_rte_raw_spin_unlock_irqrestore(&logbuf_lock, flags); } EXPORT_SYMBOL_GPL(kmsg_dump_rewind);