Patched in Tegra support.

1 files changed, 198 insertions, 418 deletions

diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index fab33a9c531..d7222a9c826 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -17,40 +17,57 @@
  */
 
 #include <stdarg.h>
-#include <linux/module.h>       /* for KSYM_SYMBOL_LEN */
+#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <linux/kernel.h>
 #include <linux/kallsyms.h>
-#include <linux/math64.h>
 #include <linux/uaccess.h>
 #include <linux/ioport.h>
 #include <net/addrconf.h>
 
 #include <asm/page.h>           /* for PAGE_SIZE */
+#include <asm/div64.h>
 #include <asm/sections.h>       /* for dereference_function_descriptor() */
 
-#include "kstrtox.h"
+static unsigned int simple_guess_base(const char *cp)
+{
+        if (cp[0] == '0') {
+                if (_tolower(cp[1]) == 'x' && isxdigit(cp[2]))
+                        return 16;
+                else
+                        return 8;
+        } else {
+                return 10;
+        }
+}
 
 /**
  * simple_strtoull - convert a string to an unsigned long long
  * @cp: The start of the string
  * @endp: A pointer to the end of the parsed string will be placed here
  * @base: The number base to use
- *
- * This function is obsolete. Please use kstrtoull instead.
  */
 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
 {
-        unsigned long long result;
-        unsigned int rv;
+        unsigned long long result = 0;
 
-        cp = _parse_integer_fixup_radix(cp, &base);
-        rv = _parse_integer(cp, base, &result);
-        /* FIXME */
-        cp += (rv & ~KSTRTOX_OVERFLOW);
+        if (!base)
+                base = simple_guess_base(cp);
 
+        if (base == 16 && cp[0] == '0' && _tolower(cp[1]) == 'x')
+                cp += 2;
+
+        while (isxdigit(*cp)) {
+                unsigned int value;
+
+                value = isdigit(*cp) ? *cp - '0' : _tolower(*cp) - 'a' + 10;
+                if (value >= base)
+                        break;
+                result = result * base + value;
+                cp++;
+        }
         if (endp)
                 *endp = (char *)cp;
 
@@ -63,8 +80,6 @@ EXPORT_SYMBOL(simple_strtoull);
  * @cp: The start of the string
  * @endp: A pointer to the end of the parsed string will be placed here
  * @base: The number base to use
- *
- * This function is obsolete. Please use kstrtoul instead.
  */
 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
 {
@@ -77,8 +92,6 @@ EXPORT_SYMBOL(simple_strtoul);
  * @cp: The start of the string
  * @endp: A pointer to the end of the parsed string will be placed here
  * @base: The number base to use
- *
- * This function is obsolete. Please use kstrtol instead.
  */
 long simple_strtol(const char *cp, char **endp, unsigned int base)
 {
@@ -94,8 +107,6 @@ EXPORT_SYMBOL(simple_strtol);
  * @cp: The start of the string
  * @endp: A pointer to the end of the parsed string will be placed here
  * @base: The number base to use
- *
- * This function is obsolete. Please use kstrtoll instead.
  */
 long long simple_strtoll(const char *cp, char **endp, unsigned int base)
 {
@@ -120,220 +131,104 @@ int skip_atoi(const char **s)
 /* Decimal conversion is by far the most typical, and is used
  * for /proc and /sys data. This directly impacts e.g. top performance
  * with many processes running. We optimize it for speed
- * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
- * (with permission from the author, Douglas W. Jones).
- */
-
-#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
-/* Formats correctly any integer in [0, 999999999] */
-static noinline_for_stack
-char *put_dec_full9(char *buf, unsigned q)
-{
-        unsigned r;
-
-        /*
-         * Possible ways to approx. divide by 10
-         * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
-         * (x * 0xcccd) >> 19     x <      81920 (x < 262149 when 64-bit mul)
-         * (x * 0x6667) >> 18     x <      43699
-         * (x * 0x3334) >> 17     x <      16389
-         * (x * 0x199a) >> 16     x <      16389
-         * (x * 0x0ccd) >> 15     x <      16389
-         * (x * 0x0667) >> 14     x <       2739
-         * (x * 0x0334) >> 13     x <       1029
-         * (x * 0x019a) >> 12     x <       1029
-         * (x * 0x00cd) >> 11     x <       1029 shorter code than * 0x67 (on i386)
-         * (x * 0x0067) >> 10     x <        179
-         * (x * 0x0034) >>  9     x <         69 same
-         * (x * 0x001a) >>  8     x <         69 same
-         * (x * 0x000d) >>  7     x <         69 same, shortest code (on i386)
-         * (x * 0x0007) >>  6     x <         19
-         * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
-         */
-        r      = (q * (uint64_t)0x1999999a) >> 32;
-        *buf++ = (q - 10 * r) + '0'; /* 1 */
-        q      = (r * (uint64_t)0x1999999a) >> 32;
-        *buf++ = (r - 10 * q) + '0'; /* 2 */
-        r      = (q * (uint64_t)0x1999999a) >> 32;
-        *buf++ = (q - 10 * r) + '0'; /* 3 */
-        q      = (r * (uint64_t)0x1999999a) >> 32;
-        *buf++ = (r - 10 * q) + '0'; /* 4 */
-        r      = (q * (uint64_t)0x1999999a) >> 32;
-        *buf++ = (q - 10 * r) + '0'; /* 5 */
-        /* Now value is under 10000, can avoid 64-bit multiply */
-        q      = (r * 0x199a) >> 16;
-        *buf++ = (r - 10 * q)  + '0'; /* 6 */
-        r      = (q * 0xcd) >> 11;
-        *buf++ = (q - 10 * r)  + '0'; /* 7 */
-        q      = (r * 0xcd) >> 11;
-        *buf++ = (r - 10 * q) + '0'; /* 8 */
-        *buf++ = q + '0'; /* 9 */
-        return buf;
-}
-#endif
+ * using code from
+ * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
+ * (with permission from the author, Douglas W. Jones). */
 
-/* Similar to above but do not pad with zeros.
- * Code can be easily arranged to print 9 digits too, but our callers
- * always call put_dec_full9() instead when the number has 9 decimal digits.
- */
+/* Formats correctly any integer in [0,99999].
+ * Outputs from one to five digits depending on input.
+ * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
 static noinline_for_stack
-char *put_dec_trunc8(char *buf, unsigned r)
+char *put_dec_trunc(char *buf, unsigned q)
 {
-        unsigned q;
-
-        /* Copy of previous function's body with added early returns */
-        while (r >= 10000) {
-                q = r + '0';
-                r  = (r * (uint64_t)0x1999999a) >> 32;
-                *buf++ = q - 10*r;
+        unsigned d3, d2, d1, d0;
+        d1 = (q>>4) & 0xf;
+        d2 = (q>>8) & 0xf;
+        d3 = (q>>12);
+
+        d0 = 6*(d3 + d2 + d1) + (q & 0xf);
+        q = (d0 * 0xcd) >> 11;
+        d0 = d0 - 10*q;
+        *buf++ = d0 + '0'; /* least significant digit */
+        d1 = q + 9*d3 + 5*d2 + d1;
+        if (d1 != 0) {
+                q = (d1 * 0xcd) >> 11;
+                d1 = d1 - 10*q;
+                *buf++ = d1 + '0'; /* next digit */
+
+                d2 = q + 2*d2;
+                if ((d2 != 0) || (d3 != 0)) {
+                        q = (d2 * 0xd) >> 7;
+                        d2 = d2 - 10*q;
+                        *buf++ = d2 + '0'; /* next digit */
+
+                        d3 = q + 4*d3;
+                        if (d3 != 0) {
+                                q = (d3 * 0xcd) >> 11;
+                                d3 = d3 - 10*q;
+                                *buf++ = d3 + '0';  /* next digit */
+                                if (q != 0)
+                                        *buf++ = q + '0'; /* most sign. digit */
+                        }
+                }
         }
 
-        q      = (r * 0x199a) >> 16;    /* r <= 9999 */
-        *buf++ = (r - 10 * q)  + '0';
-        if (q == 0)
-                return buf;
-        r      = (q * 0xcd) >> 11;      /* q <= 999 */
-        *buf++ = (q - 10 * r)  + '0';
-        if (r == 0)
-                return buf;
-        q      = (r * 0xcd) >> 11;      /* r <= 99 */
-        *buf++ = (r - 10 * q) + '0';
-        if (q == 0)
-                return buf;
-        *buf++ = q + '0';                /* q <= 9 */
         return buf;
 }
-
-/* There are two algorithms to print larger numbers.
- * One is generic: divide by 1000000000 and repeatedly print
- * groups of (up to) 9 digits. It's conceptually simple,
- * but requires a (unsigned long long) / 1000000000 division.
- *
- * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
- * manipulates them cleverly and generates groups of 4 decimal digits.
- * It so happens that it does NOT require long long division.
- *
- * If long is > 32 bits, division of 64-bit values is relatively easy,
- * and we will use the first algorithm.
- * If long long is > 64 bits (strange architecture with VERY large long long),
- * second algorithm can't be used, and we again use the first one.
- *
- * Else (if long is 32 bits and long long is 64 bits) we use second one.
- */
-
-#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
-
-/* First algorithm: generic */
-
-static
-char *put_dec(char *buf, unsigned long long n)
-{
-        if (n >= 100*1000*1000) {
-                while (n >= 1000*1000*1000)
-                        buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
-                if (n >= 100*1000*1000)
-                        return put_dec_full9(buf, n);
-        }
-        return put_dec_trunc8(buf, n);
-}
-
-#else
-
-/* Second algorithm: valid only for 64-bit long longs */
-
-/* See comment in put_dec_full9 for choice of constants */
+/* Same with if's removed. Always emits five digits */
 static noinline_for_stack
-void put_dec_full4(char *buf, unsigned q)
-{
-        unsigned r;
-        r      = (q * 0xccd) >> 15;
-        buf[0] = (q - 10 * r) + '0';
-        q      = (r * 0xcd) >> 11;
-        buf[1] = (r - 10 * q)  + '0';
-        r      = (q * 0xcd) >> 11;
-        buf[2] = (q - 10 * r)  + '0';
-        buf[3] = r + '0';
-}
-
-/*
- * Call put_dec_full4 on x % 10000, return x / 10000.
- * The approximation x/10000 == (x * 0x346DC5D7) >> 43
- * holds for all x < 1,128,869,999.  The largest value this
- * helper will ever be asked to convert is 1,125,520,955.
- * (d1 in the put_dec code, assuming n is all-ones).
- */
-static
-unsigned put_dec_helper4(char *buf, unsigned x)
-{
-        uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
-
-        put_dec_full4(buf, x - q * 10000);
-        return q;
-}
-
-/* Based on code by Douglas W. Jones found at
- * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
- * (with permission from the author).
- * Performs no 64-bit division and hence should be fast on 32-bit machines.
- */
-static
-char *put_dec(char *buf, unsigned long long n)
+char *put_dec_full(char *buf, unsigned q)
 {
-        uint32_t d3, d2, d1, q, h;
+        /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
+        /* but anyway, gcc produces better code with full-sized ints */
+        unsigned d3, d2, d1, d0;
+        d1 = (q>>4) & 0xf;
+        d2 = (q>>8) & 0xf;
+        d3 = (q>>12);
 
-        if (n < 100*1000*1000)
-                return put_dec_trunc8(buf, n);
-
-        d1  = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
-        h   = (n >> 32);
-        d2  = (h      ) & 0xffff;
-        d3  = (h >> 16); /* implicit "& 0xffff" */
-
-        q   = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
-        q = put_dec_helper4(buf, q);
-
-        q += 7671 * d3 + 9496 * d2 + 6 * d1;
-        q = put_dec_helper4(buf+4, q);
-
-        q += 4749 * d3 + 42 * d2;
-        q = put_dec_helper4(buf+8, q);
-
-        q += 281 * d3;
-        buf += 12;
-        if (q)
-                buf = put_dec_trunc8(buf, q);
-        else while (buf[-1] == '0')
-                --buf;
+        /*
+         * Possible ways to approx. divide by 10
+         * gcc -O2 replaces multiply with shifts and adds
+         * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
+         * (x * 0x67) >> 10:  1100111
+         * (x * 0x34) >> 9:    110100 - same
+         * (x * 0x1a) >> 8:     11010 - same
+         * (x * 0x0d) >> 7:      1101 - same, shortest code (on i386)
+         */
+        d0 = 6*(d3 + d2 + d1) + (q & 0xf);
+        q = (d0 * 0xcd) >> 11;
+        d0 = d0 - 10*q;
+        *buf++ = d0 + '0';
+        d1 = q + 9*d3 + 5*d2 + d1;
+                q = (d1 * 0xcd) >> 11;
+                d1 = d1 - 10*q;
+                *buf++ = d1 + '0';
+
+                d2 = q + 2*d2;
+                        q = (d2 * 0xd) >> 7;
+                        d2 = d2 - 10*q;
+                        *buf++ = d2 + '0';
+
+                        d3 = q + 4*d3;
+                                q = (d3 * 0xcd) >> 11; /* - shorter code */
+                                /* q = (d3 * 0x67) >> 10; - would also work */
+                                d3 = d3 - 10*q;
+                                *buf++ = d3 + '0';
+                                        *buf++ = q + '0';
 
         return buf;
 }
-
-#endif
-
-/*
- * Convert passed number to decimal string.
- * Returns the length of string.  On buffer overflow, returns 0.
- *
- * If speed is not important, use snprintf(). It's easy to read the code.
- */
-int num_to_str(char *buf, int size, unsigned long long num)
+/* No inlining helps gcc to use registers better */
+static noinline_for_stack
+char *put_dec(char *buf, unsigned long long num)
 {
-        char tmp[sizeof(num) * 3];
-        int idx, len;
-
-        /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
-        if (num <= 9) {
-                tmp[0] = '0' + num;
-                len = 1;
-        } else {
-                len = put_dec(tmp, num) - tmp;
+        while (1) {
+                unsigned rem;
+                if (num < 100000)
+                        return put_dec_trunc(buf, num);
+                rem = do_div(num, 100000);
+                buf = put_dec_full(buf, rem);
         }
-
-        if (len > size)
-                return 0;
-        for (idx = 0; idx < len; ++idx)
-                buf[idx] = tmp[len - idx - 1];
-        return len;
 }
 
 #define ZEROPAD 1               /* pad with zero */
@@ -388,7 +283,6 @@ char *number(char *buf, char *end, unsigned long long num,
         char locase;
         int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
         int i;
-        bool is_zero = num == 0LL;
 
         /* locase = 0 or 0x20. ORing digits or letters with 'locase'
          * produces same digits or (maybe lowercased) letters */
@@ -410,16 +304,15 @@ char *number(char *buf, char *end, unsigned long long num,
                 }
         }
         if (need_pfx) {
+                spec.field_width--;
                 if (spec.base == 16)
-                        spec.field_width -= 2;
-                else if (!is_zero)
                         spec.field_width--;
         }
 
         /* generate full string in tmp[], in reverse order */
         i = 0;
-        if (num < spec.base)
-                tmp[i++] = digits[num] | locase;
+        if (num == 0)
+                tmp[i++] = '0';
         /* Generic code, for any base:
         else do {
                 tmp[i++] = (digits[do_div(num,base)] | locase);
@@ -459,11 +352,9 @@ char *number(char *buf, char *end, unsigned long long num,
         }
         /* "0x" / "0" prefix */
         if (need_pfx) {
-                if (spec.base == 16 || !is_zero) {
-                        if (buf < end)
-                                *buf = '0';
-                        ++buf;
-                }
+                if (buf < end)
+                        *buf = '0';
+                ++buf;
                 if (spec.base == 16) {
                         if (buf < end)
                                 *buf = ('X' | locase);
@@ -544,7 +435,7 @@ char *symbol_string(char *buf, char *end, void *ptr,
         else if (ext != 'f' && ext != 's')
                 sprint_symbol(sym, value);
         else
-                sprint_symbol_no_offset(sym, value);
+                kallsyms_lookup(value, NULL, NULL, NULL, sym);
 
         return string(buf, end, sym, spec);
 #else
@@ -660,50 +551,6 @@ char *resource_string(char *buf, char *end, struct resource *res,
 }
 
 static noinline_for_stack
-char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
-                 const char *fmt)
-{
-        int i, len = 1;         /* if we pass '%ph[CDN]', field witdh remains
-                                   negative value, fallback to the default */
-        char separator;
-
-        if (spec.field_width == 0)
-                /* nothing to print */
-                return buf;
-
-        if (ZERO_OR_NULL_PTR(addr))
-                /* NULL pointer */
-                return string(buf, end, NULL, spec);
-
-        switch (fmt[1]) {
-        case 'C':
-                separator = ':';
-                break;
-        case 'D':
-                separator = '-';
-                break;
-        case 'N':
-                separator = 0;
-                break;
-        default:
-                separator = ' ';
-                break;
-        }
-
-        if (spec.field_width > 0)
-                len = min_t(int, spec.field_width, 64);
-
-        for (i = 0; i < len && buf < end - 1; i++) {
-                buf = hex_byte_pack(buf, addr[i]);
-
-                if (buf < end && separator && i != len - 1)
-                        *buf++ = separator;
-        }
-
-        return buf;
-}
-
-static noinline_for_stack
 char *mac_address_string(char *buf, char *end, u8 *addr,
                          struct printf_spec spec, const char *fmt)
 {
@@ -711,28 +558,15 @@ char *mac_address_string(char *buf, char *end, u8 *addr,
         char *p = mac_addr;
         int i;
         char separator;
-        bool reversed = false;
 
-        switch (fmt[1]) {
-        case 'F':
+        if (fmt[1] == 'F') {            /* FDDI canonical format */
                 separator = '-';
-                break;
-
-        case 'R':
-                reversed = true;
-                /* fall through */
-
-        default:
+        } else {
                 separator = ':';
-                break;
         }
 
         for (i = 0; i < 6; i++) {
-                if (reversed)
-                        p = hex_byte_pack(p, addr[5 - i]);
-                else
-                        p = hex_byte_pack(p, addr[i]);
-
+                p = pack_hex_byte(p, addr[i]);
                 if (fmt[0] == 'M' && i != 5)
                         *p++ = separator;
         }
@@ -772,7 +606,7 @@ char *ip4_string(char *p, const u8 *addr, const char *fmt)
         }
         for (i = 0; i < 4; i++) {
                 char temp[3];   /* hold each IP quad in reverse order */
-                int digits = put_dec_trunc8(temp, addr[index]) - temp;
+                int digits = put_dec_trunc(temp, addr[index]) - temp;
                 if (leading_zeros) {
                         if (digits < 3)
                                 *p++ = '0';
@@ -852,13 +686,13 @@ char *ip6_compressed_string(char *p, const char *addr)
                 lo = word & 0xff;
                 if (hi) {
                         if (hi > 0x0f)
-                                p = hex_byte_pack(p, hi);
+                                p = pack_hex_byte(p, hi);
                         else
                                 *p++ = hex_asc_lo(hi);
-                        p = hex_byte_pack(p, lo);
+                        p = pack_hex_byte(p, lo);
                 }
                 else if (lo > 0x0f)
-                        p = hex_byte_pack(p, lo);
+                        p = pack_hex_byte(p, lo);
                 else
                         *p++ = hex_asc_lo(lo);
                 needcolon = true;
@@ -880,8 +714,8 @@ char *ip6_string(char *p, const char *addr, const char *fmt)
         int i;
 
         for (i = 0; i < 8; i++) {
-                p = hex_byte_pack(p, *addr++);
-                p = hex_byte_pack(p, *addr++);
+                p = pack_hex_byte(p, *addr++);
+                p = pack_hex_byte(p, *addr++);
                 if (fmt[0] == 'I' && i != 7)
                         *p++ = ':';
         }
@@ -939,7 +773,7 @@ char *uuid_string(char *buf, char *end, const u8 *addr,
         }
 
         for (i = 0; i < 16; i++) {
-                p = hex_byte_pack(p, addr[index[i]]);
+                p = pack_hex_byte(p, addr[index[i]]);
                 switch (i) {
                 case 3:
                 case 5:
@@ -962,18 +796,6 @@ char *uuid_string(char *buf, char *end, const u8 *addr,
         return string(buf, end, uuid, spec);
 }
 
-static
-char *netdev_feature_string(char *buf, char *end, const u8 *addr,
-                      struct printf_spec spec)
-{
-        spec.flags |= SPECIAL | SMALL | ZEROPAD;
-        if (spec.field_width == -1)
-                spec.field_width = 2 + 2 * sizeof(netdev_features_t);
-        spec.base = 16;
-
-        return number(buf, end, *(const netdev_features_t *)addr, spec);
-}
-
 int kptr_restrict __read_mostly;
 
 /*
@@ -995,7 +817,6 @@ int kptr_restrict __read_mostly;
  * - 'm' For a 6-byte MAC address, it prints the hex address without colons
  * - 'MF' For a 6-byte MAC FDDI address, it prints the address
  *       with a dash-separated hex notation
- * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)
  * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
  *       IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
  *       IPv6 uses colon separated network-order 16 bit hex with leading 0's
@@ -1022,14 +843,6 @@ int kptr_restrict __read_mostly;
  *       Do not use this feature without some mechanism to verify the
  *       correctness of the format string and va_list arguments.
  * - 'K' For a kernel pointer that should be hidden from unprivileged users
- * - 'NF' For a netdev_features_t
- * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
- *            a certain separator (' ' by default):
- *              C colon
- *              D dash
- *              N no separator
- *            The maximum supported length is 64 bytes of the input. Consider
- *            to use print_hex_dump() for the larger input.
  *
  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
  * function pointers are really function descriptors, which contain a
@@ -1039,15 +852,13 @@ static noinline_for_stack
 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
               struct printf_spec spec)
 {
-        int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
-
         if (!ptr && *fmt != 'K') {
                 /*
                  * Print (null) with the same width as a pointer so it makes
                  * tabular output look nice.
                  */
                 if (spec.field_width == -1)
-                        spec.field_width = default_width;
+                        spec.field_width = 2 * sizeof(void *);
                 return string(buf, end, "(null)", spec);
         }
 
@@ -1063,12 +874,9 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
         case 'R':
         case 'r':
                 return resource_string(buf, end, ptr, spec, fmt);
-        case 'h':
-                return hex_string(buf, end, ptr, spec, fmt);
         case 'M':                       /* Colon separated: 00:01:02:03:04:05 */
         case 'm':                       /* Contiguous: 000102030405 */
-                                        /* [mM]F (FDDI) */
-                                        /* [mM]R (Reverse order; Bluetooth) */
+                                        /* [mM]F (FDDI, bit reversed) */
                 return mac_address_string(buf, end, ptr, spec, fmt);
         case 'I':                       /* Formatted IP supported
                                          * 4:   1.2.3.4
@@ -1089,24 +897,17 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
         case 'U':
                 return uuid_string(buf, end, ptr, spec, fmt);
         case 'V':
-                {
-                        va_list va;
-
-                        va_copy(va, *((struct va_format *)ptr)->va);
-                        buf += vsnprintf(buf, end > buf ? end - buf : 0,
-                                         ((struct va_format *)ptr)->fmt, va);
-                        va_end(va);
-                        return buf;
-                }
+                return buf + vsnprintf(buf, end > buf ? end - buf : 0,
+                                       ((struct va_format *)ptr)->fmt,
+                                       *(((struct va_format *)ptr)->va));
         case 'K':
                 /*
                  * %pK cannot be used in IRQ context because its test
                  * for CAP_SYSLOG would be meaningless.
                  */
-                if (kptr_restrict && (in_irq() || in_serving_softirq() ||
-                                      in_nmi())) {
+                if (in_irq() || in_serving_softirq() || in_nmi()) {
                         if (spec.field_width == -1)
-                                spec.field_width = default_width;
+                                spec.field_width = 2 * sizeof(void *);
                         return string(buf, end, "pK-error", spec);
                 }
                 if (!((kptr_restrict == 0) ||
@@ -1114,16 +915,10 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
                        has_capability_noaudit(current, CAP_SYSLOG))))
                         ptr = NULL;
                 break;
-        case 'N':
-                switch (fmt[1]) {
-                case 'F':
-                        return netdev_feature_string(buf, end, ptr, spec);
-                }
-                break;
         }
         spec.flags |= SMALL;
         if (spec.field_width == -1) {
-                spec.field_width = default_width;
+                spec.field_width = 2 * sizeof(void *);
                 spec.flags |= ZEROPAD;
         }
         spec.base = 16;
@@ -1346,10 +1141,7 @@ qualifier:
  * %pR output the address range in a struct resource with decoded flags
  * %pr output the address range in a struct resource with raw flags
  * %pM output a 6-byte MAC address with colons
- * %pMR output a 6-byte MAC address with colons in reversed order
- * %pMF output a 6-byte MAC address with dashes
  * %pm output a 6-byte MAC address without colons
- * %pmR output a 6-byte MAC address without colons in reversed order
  * %pI4 print an IPv4 address without leading zeros
  * %pi4 print an IPv4 address with leading zeros
  * %pI6 print an IPv6 address with colons
@@ -1357,12 +1149,8 @@ qualifier:
  * %pI6c print an IPv6 address as specified by RFC 5952
  * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
  *   case.
- * %*ph[CDN] a variable-length hex string with a separator (supports up to 64
- *           bytes of the input)
  * %n is ignored
  *
- * ** Please update Documentation/printk-formats.txt when making changes **
- *
  * The return value is the number of characters which would
  * be generated for the given input, excluding the trailing
  * '\0', as per ISO C99. If you want to have the exact
@@ -1493,10 +1281,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                                 num = va_arg(args, long);
                                 break;
                         case FORMAT_TYPE_SIZE_T:
-                                if (spec.flags & SIGN)
-                                        num = va_arg(args, ssize_t);
-                                else
-                                        num = va_arg(args, size_t);
+                                num = va_arg(args, size_t);
                                 break;
                         case FORMAT_TYPE_PTRDIFF:
                                 num = va_arg(args, ptrdiff_t);
@@ -2024,15 +1809,11 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
         char digit;
         int num = 0;
         u8 qualifier;
-        unsigned int base;
-        union {
-                long long s;
-                unsigned long long u;
-        } val;
+        u8 base;
         s16 field_width;
         bool is_sign;
 
-        while (*fmt) {
+        while (*fmt && *str) {
                 /* skip any white space in format */
                 /* white space in format matchs any amount of
                  * white space, including none, in the input.
@@ -2057,8 +1838,6 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
                  * advance both strings to next white space
                  */
                 if (*fmt == '*') {
-                        if (!*str)
-                                break;
                         while (!isspace(*fmt) && *fmt != '%' && *fmt)
                                 fmt++;
                         while (!isspace(*str) && *str)
@@ -2068,11 +1847,8 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
 
                 /* get field width */
                 field_width = -1;
-                if (isdigit(*fmt)) {
+                if (isdigit(*fmt))
                         field_width = skip_atoi(&fmt);
-                        if (field_width <= 0)
-                                break;
-                }
 
                 /* get conversion qualifier */
                 qualifier = -1;
@@ -2090,17 +1866,7 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
                         }
                 }
 
-                if (!*fmt)
-                        break;
-
-                if (*fmt == 'n') {
-                        /* return number of characters read so far */
-                        *va_arg(args, int *) = str - buf;
-                        ++fmt;
-                        continue;
-                }
-
-                if (!*str)
+                if (!*fmt || !*str)
                         break;
 
                 base = 10;
@@ -2133,6 +1899,13 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
                         num++;
                 }
                 continue;
+                case 'n':
+                        /* return number of characters read so far */
+                {
+                        int *i = (int *)va_arg(args, int*);
+                        *i = str - buf;
+                }
+                continue;
                 case 'o':
                         base = 8;
                         break;
@@ -2172,61 +1945,58 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
                     || (base == 0 && !isdigit(digit)))
                         break;
 
-                if (is_sign)
-                        val.s = qualifier != 'L' ?
-                                simple_strtol(str, &next, base) :
-                                simple_strtoll(str, &next, base);
-                else
-                        val.u = qualifier != 'L' ?
-                                simple_strtoul(str, &next, base) :
-                                simple_strtoull(str, &next, base);
-
-                if (field_width > 0 && next - str > field_width) {
-                        if (base == 0)
-                                _parse_integer_fixup_radix(str, &base);
-                        while (next - str > field_width) {
-                                if (is_sign)
-                                        val.s = div_s64(val.s, base);
-                                else
-                                        val.u = div_u64(val.u, base);
-                                --next;
-                        }
-                }
-
                 switch (qualifier) {
                 case 'H':       /* that's 'hh' in format */
-                        if (is_sign)
-                                *va_arg(args, signed char *) = val.s;
-                        else
-                                *va_arg(args, unsigned char *) = val.u;
+                        if (is_sign) {
+                                signed char *s = (signed char *)va_arg(args, signed char *);
+                                *s = (signed char)simple_strtol(str, &next, base);
+                        } else {
+                                unsigned char *s = (unsigned char *)va_arg(args, unsigned char *);
+                                *s = (unsigned char)simple_strtoul(str, &next, base);
+                        }
                         break;
                 case 'h':
-                        if (is_sign)
-                                *va_arg(args, short *) = val.s;
-                        else
-                                *va_arg(args, unsigned short *) = val.u;
+                        if (is_sign) {
+                                short *s = (short *)va_arg(args, short *);
+                                *s = (short)simple_strtol(str, &next, base);
+                        } else {
+                                unsigned short *s = (unsigned short *)va_arg(args, unsigned short *);
+                                *s = (unsigned short)simple_strtoul(str, &next, base);
+                        }
                         break;
                 case 'l':
-                        if (is_sign)
-                                *va_arg(args, long *) = val.s;
-                        else
-                                *va_arg(args, unsigned long *) = val.u;
+                        if (is_sign) {
+                                long *l = (long *)va_arg(args, long *);
+                                *l = simple_strtol(str, &next, base);
+                        } else {
+                                unsigned long *l = (unsigned long *)va_arg(args, unsigned long *);
+                                *l = simple_strtoul(str, &next, base);
+                        }
                         break;
                 case 'L':
-                        if (is_sign)
-                                *va_arg(args, long long *) = val.s;
-                        else
-                                *va_arg(args, unsigned long long *) = val.u;
+                        if (is_sign) {
+                                long long *l = (long long *)va_arg(args, long long *);
+                                *l = simple_strtoll(str, &next, base);
+                        } else {
+                                unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *);
+                                *l = simple_strtoull(str, &next, base);
+                        }
                         break;
                 case 'Z':
                 case 'z':
-                        *va_arg(args, size_t *) = val.u;
-                        break;
+                {
+                        size_t *s = (size_t *)va_arg(args, size_t *);
+                        *s = (size_t)simple_strtoul(str, &next, base);
+                }
+                break;
                 default:
-                        if (is_sign)
-                                *va_arg(args, int *) = val.s;
-                        else
-                                *va_arg(args, unsigned int *) = val.u;
+                        if (is_sign) {
+                                int *i = (int *)va_arg(args, int *);
+                                *i = (int)simple_strtol(str, &next, base);
+                        } else {
+                                unsigned int *i = (unsigned int *)va_arg(args, unsigned int*);
+                                *i = (unsigned int)simple_strtoul(str, &next, base);
+                        }
                         break;
                 }
                 num++;
@@ -2236,6 +2006,16 @@ int vsscanf(const char *buf, const char *fmt, va_list args)
                 str = next;
         }
 
+        /*
+         * Now we've come all the way through so either the input string or the
+         * format ended. In the former case, there can be a %n at the current
+         * position in the format that needs to be filled.
+         */
+        if (*fmt == '%' && *(fmt + 1) == 'n') {
+                int *p = (int *)va_arg(args, int *);
+                *p = str - buf;
+        }
+
         return num;
 }
 EXPORT_SYMBOL(vsscanf);