Merge branch 'for-4.18-vsprintf-pcr-removal' into for-4.18

diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 704e55129c3af254210be32ca2396f74a9e937be..fba995b305b104791099cdcff329d35a5b7eab7b 100644 (file)
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -1907,6 +1907,7 @@ asmlinkage int vprintk_emit(int facility, int level,
                preempt_enable();
        }
 
+       wake_up_klogd();
        return printed_len;
 }
 EXPORT_SYMBOL(vprintk_emit);
@@ -2288,9 +2289,7 @@ void console_unlock(void)
 {
        static char ext_text[CONSOLE_EXT_LOG_MAX];
        static char text[LOG_LINE_MAX + PREFIX_MAX];
-       static u64 seen_seq;
        unsigned long flags;
-       bool wake_klogd = false;
        bool do_cond_resched, retry;
 
        if (console_suspended) {
@@ -2334,11 +2333,6 @@ void console_unlock(void)
 
                printk_safe_enter_irqsave(flags);
                raw_spin_lock(&logbuf_lock);
-               if (seen_seq != log_next_seq) {
-                       wake_klogd = true;
-                       seen_seq = log_next_seq;
-               }
-
                if (console_seq < log_first_seq) {
                        len = sprintf(text, "** %u printk messages dropped **\n",
                                      (unsigned)(log_first_seq - console_seq));
@@ -2396,7 +2390,7 @@ void console_unlock(void)
 
                if (console_lock_spinning_disable_and_check()) {
                        printk_safe_exit_irqrestore(flags);
-                       goto out;
+                       return;
                }
 
                printk_safe_exit_irqrestore(flags);
@@ -2428,10 +2422,6 @@ void console_unlock(void)
 
        if (retry && console_trylock())
                goto again;
-
-out:
-       if (wake_klogd)
-               wake_up_klogd();
 }
 EXPORT_SYMBOL(console_unlock);
 

diff --git a/kernel/printk/printk_safe.c b/kernel/printk/printk_safe.c
index 3e3c2004bb232661bae666e00e4645fad438aee6..d7d0913090546a95497c2a70deb63fbf3062bf1d 100644 (file)
--- a/kernel/printk/printk_safe.c
+++ b/kernel/printk/printk_safe.c
@@ -82,6 +82,7 @@ static __printf(2, 0) int printk_safe_log_store(struct printk_safe_seq_buf *s,
 {
        int add;
        size_t len;
+       va_list ap;
 
 again:
        len = atomic_read(&s->len);
@@ -100,7 +101,9 @@ static __printf(2, 0) int printk_safe_log_store(struct printk_safe_seq_buf *s,
        if (!len)
                smp_rmb();
 
-       add = vscnprintf(s->buffer + len, sizeof(s->buffer) - len, fmt, args);
+       va_copy(ap, args);
+       add = vscnprintf(s->buffer + len, sizeof(s->buffer) - len, fmt, ap);
+       va_end(ap);
        if (!add)
                return 0;
 
@@ -278,7 +281,7 @@ void printk_safe_flush_on_panic(void)
         * Make sure that we could access the main ring buffer.
         * Do not risk a double release when more CPUs are up.
         */
-       if (in_nmi() && raw_spin_is_locked(&logbuf_lock)) {
+       if (raw_spin_is_locked(&logbuf_lock)) {
                if (num_online_cpus() > 1)
                        return;
 

diff --git a/lib/test_printf.c b/lib/test_printf.c
index 71ebfa43ad05f2bdbbd011989dc92b5efac2cdd6..cea592f402ed029d6d5dd63addd2d2bc8a8391f1 100644 (file)
--- a/lib/test_printf.c
+++ b/lib/test_printf.c
@@ -204,7 +204,7 @@ test_string(void)
 #if BITS_PER_LONG == 64
 
 #define PTR_WIDTH 16
-#define PTR ((void *)0xffff0123456789ab)
+#define PTR ((void *)0xffff0123456789abUL)
 #define PTR_STR "ffff0123456789ab"
 #define ZEROS "00000000"       /* hex 32 zero bits */
 

diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 8f28036f5c1d0db4bf97f5fd186f541eab8c7da6..8999202ad43b0d29ddbb1278d6d45cb2ff1040a5 100644 (file)
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -693,6 +693,22 @@ char *symbol_string(char *buf, char *end, void *ptr,
 #endif
 }
 
+static const struct printf_spec default_str_spec = {
+       .field_width = -1,
+       .precision = -1,
+};
+
+static const struct printf_spec default_flag_spec = {
+       .base = 16,
+       .precision = -1,
+       .flags = SPECIAL | SMALL,
+};
+
+static const struct printf_spec default_dec_spec = {
+       .base = 10,
+       .precision = -1,
+};
+
 static noinline_for_stack
 char *resource_string(char *buf, char *end, struct resource *res,
                      struct printf_spec spec, const char *fmt)
@@ -722,21 +738,11 @@ char *resource_string(char *buf, char *end, struct resource *res,
                .precision = -1,
                .flags = SMALL | ZEROPAD,
        };
-       static const struct printf_spec dec_spec = {
-               .base = 10,
-               .precision = -1,
-               .flags = 0,
-       };
        static const struct printf_spec str_spec = {
                .field_width = -1,
                .precision = 10,
                .flags = LEFT,
        };
-       static const struct printf_spec flag_spec = {
-               .base = 16,
-               .precision = -1,
-               .flags = SPECIAL | SMALL,
-       };
 
        /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
         * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
@@ -760,10 +766,10 @@ char *resource_string(char *buf, char *end, struct resource *res,
                specp = &mem_spec;
        } else if (res->flags & IORESOURCE_IRQ) {
                p = string(p, pend, "irq ", str_spec);
-               specp = &dec_spec;
+               specp = &default_dec_spec;
        } else if (res->flags & IORESOURCE_DMA) {
                p = string(p, pend, "dma ", str_spec);
-               specp = &dec_spec;
+               specp = &default_dec_spec;
        } else if (res->flags & IORESOURCE_BUS) {
                p = string(p, pend, "bus ", str_spec);
                specp = &bus_spec;
@@ -793,7 +799,7 @@ char *resource_string(char *buf, char *end, struct resource *res,
                        p = string(p, pend, " disabled", str_spec);
        } else {
                p = string(p, pend, " flags ", str_spec);
-               p = number(p, pend, res->flags, flag_spec);
+               p = number(p, pend, res->flags, default_flag_spec);
        }
        *p++ = ']';
        *p = '\0';
@@ -903,9 +909,6 @@ char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,
        int cur, rbot, rtop;
        bool first = true;
 
-       /* reused to print numbers */
-       spec = (struct printf_spec){ .base = 10 };
-
        rbot = cur = find_first_bit(bitmap, nr_bits);
        while (cur < nr_bits) {
                rtop = cur;
@@ -920,13 +923,13 @@ char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,
                }
                first = false;
 
-               buf = number(buf, end, rbot, spec);
+               buf = number(buf, end, rbot, default_dec_spec);
                if (rbot < rtop) {
                        if (buf < end)
                                *buf = '-';
                        buf++;
 
-                       buf = number(buf, end, rtop, spec);
+                       buf = number(buf, end, rtop, default_dec_spec);
                }
 
                rbot = cur;
@@ -1344,11 +1347,9 @@ char *uuid_string(char *buf, char *end, const u8 *addr,
        return string(buf, end, uuid, spec);
 }
 
-int kptr_restrict __read_mostly;
-
 static noinline_for_stack
-char *restricted_pointer(char *buf, char *end, const void *ptr,
-                        struct printf_spec spec)
+char *pointer_string(char *buf, char *end, const void *ptr,
+                    struct printf_spec spec)
 {
        spec.base = 16;
        spec.flags |= SMALL;
@@ -1357,6 +1358,15 @@ char *restricted_pointer(char *buf, char *end, const void *ptr,
                spec.flags |= ZEROPAD;
        }
 
+       return number(buf, end, (unsigned long int)ptr, spec);
+}
+
+int kptr_restrict __read_mostly;
+
+static noinline_for_stack
+char *restricted_pointer(char *buf, char *end, const void *ptr,
+                        struct printf_spec spec)
+{
        switch (kptr_restrict) {
        case 0:
                /* Always print %pK values */
@@ -1368,8 +1378,11 @@ char *restricted_pointer(char *buf, char *end, const void *ptr,
                 * kptr_restrict==1 cannot be used in IRQ context
                 * because its test for CAP_SYSLOG would be meaningless.
                 */
-               if (in_irq() || in_serving_softirq() || in_nmi())
+               if (in_irq() || in_serving_softirq() || in_nmi()) {
+                       if (spec.field_width == -1)
+                               spec.field_width = 2 * sizeof(ptr);
                        return string(buf, end, "pK-error", spec);
+               }
 
                /*
                 * Only print the real pointer value if the current
@@ -1394,7 +1407,7 @@ char *restricted_pointer(char *buf, char *end, const void *ptr,
                break;
        }
 
-       return number(buf, end, (unsigned long)ptr, spec);
+       return pointer_string(buf, end, ptr, spec);
 }
 
 static noinline_for_stack
@@ -1461,23 +1474,13 @@ char *format_flags(char *buf, char *end, unsigned long flags,
                                        const struct trace_print_flags *names)
 {
        unsigned long mask;
-       const struct printf_spec strspec = {
-               .field_width = -1,
-               .precision = -1,
-       };
-       const struct printf_spec numspec = {
-               .flags = SPECIAL|SMALL,
-               .field_width = -1,
-               .precision = -1,
-               .base = 16,
-       };
 
        for ( ; flags && names->name; names++) {
                mask = names->mask;
                if ((flags & mask) != mask)
                        continue;
 
-               buf = string(buf, end, names->name, strspec);
+               buf = string(buf, end, names->name, default_str_spec);
 
                flags &= ~mask;
                if (flags) {
@@ -1488,7 +1491,7 @@ char *format_flags(char *buf, char *end, unsigned long flags,
        }
 
        if (flags)
-               buf = number(buf, end, flags, numspec);
+               buf = number(buf, end, flags, default_flag_spec);
 
        return buf;
 }
@@ -1535,22 +1538,18 @@ char *device_node_gen_full_name(const struct device_node *np, char *buf, char *e
 {
        int depth;
        const struct device_node *parent = np->parent;
-       static const struct printf_spec strspec = {
-               .field_width = -1,
-               .precision = -1,
-       };
 
        /* special case for root node */
        if (!parent)
-               return string(buf, end, "/", strspec);
+               return string(buf, end, "/", default_str_spec);
 
        for (depth = 0; parent->parent; depth++)
                parent = parent->parent;
 
        for ( ; depth >= 0; depth--) {
-               buf = string(buf, end, "/", strspec);
+               buf = string(buf, end, "/", default_str_spec);
                buf = string(buf, end, device_node_name_for_depth(np, depth),
-                            strspec);
+                            default_str_spec);
        }
        return buf;
 }
@@ -1642,20 +1641,6 @@ char *device_node_string(char *buf, char *end, struct device_node *dn,
        return widen_string(buf, buf - buf_start, end, spec);
 }
 
-static noinline_for_stack
-char *pointer_string(char *buf, char *end, const void *ptr,
-                    struct printf_spec spec)
-{
-       spec.base = 16;
-       spec.flags |= SMALL;
-       if (spec.field_width == -1) {
-               spec.field_width = 2 * sizeof(ptr);
-               spec.flags |= ZEROPAD;
-       }
-
-       return number(buf, end, (unsigned long int)ptr, spec);
-}
-
 static bool have_filled_random_ptr_key __read_mostly;
 static siphash_key_t ptr_key __read_mostly;
 
@@ -1693,13 +1678,13 @@ early_initcall(initialize_ptr_random);
 /* Maps a pointer to a 32 bit unique identifier. */
 static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec)
 {
+       const char *str = sizeof(ptr) == 8 ? "(____ptrval____)" : "(ptrval)";
        unsigned long hashval;
-       const int default_width = 2 * sizeof(ptr);
 
        if (unlikely(!have_filled_random_ptr_key)) {
-               spec.field_width = default_width;
+               spec.field_width = 2 * sizeof(ptr);
                /* string length must be less than default_width */
-               return string(buf, end, "(ptrval)", spec);
+               return string(buf, end, str, spec);
        }
 
 #ifdef CONFIG_64BIT
@@ -1712,15 +1697,7 @@ static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec)
 #else
        hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key);
 #endif
-
-       spec.flags |= SMALL;
-       if (spec.field_width == -1) {
-               spec.field_width = default_width;
-               spec.flags |= ZEROPAD;
-       }
-       spec.base = 16;
-
-       return number(buf, end, hashval, spec);
+       return pointer_string(buf, end, (const void *)hashval, spec);
 }
 
 /*
@@ -1733,10 +1710,10 @@ static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec)
  *
  * Right now we handle:
  *
- * - 'F' For symbolic function descriptor pointers with offset
- * - 'f' For simple symbolic function names without offset
- * - 'S' For symbolic direct pointers with offset
- * - 's' For symbolic direct pointers without offset
+ * - 'S' For symbolic direct pointers (or function descriptors) with offset
+ * - 's' For symbolic direct pointers (or function descriptors) without offset
+ * - 'F' Same as 'S'
+ * - 'f' Same as 's'
  * - '[FfSs]R' as above with __builtin_extract_return_addr() translation
  * - 'B' For backtraced symbolic direct pointers with offset
  * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
@@ -1833,10 +1810,6 @@ static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec)
  * ** When making changes please also update:
  *     Documentation/core-api/printk-formats.rst
  *
- * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
- * function pointers are really function descriptors, which contain a
- * pointer to the real address.
- *
  * Note: The default behaviour (unadorned %p) is to hash the address,
  * rendering it useful as a unique identifier.
  */
@@ -2112,6 +2085,7 @@ int format_decode(const char *fmt, struct printf_spec *spec)
 
        case 'x':
                spec->flags |= SMALL;
+               /* fall through */
 
        case 'X':
                spec->base = 16;
@@ -3066,8 +3040,10 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
                        break;
                case 'i':
                        base = 0;
+                       /* fall through */
                case 'd':
                        is_sign = true;
+                       /* fall through */
                case 'u':
                        break;
                case '%':