Commit 546e5354 authored by Ingo Molnar's avatar Ingo Molnar

Merge branch 'core/printk' into tracing/ftrace

parents af438c0f fef20d9c
...@@ -242,6 +242,19 @@ extern struct ratelimit_state printk_ratelimit_state; ...@@ -242,6 +242,19 @@ extern struct ratelimit_state printk_ratelimit_state;
extern int printk_ratelimit(void); extern int printk_ratelimit(void);
extern bool printk_timed_ratelimit(unsigned long *caller_jiffies, extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
unsigned int interval_msec); unsigned int interval_msec);
/*
* Print a one-time message (analogous to WARN_ONCE() et al):
*/
#define printk_once(x...) ({ \
static int __print_once = 1; \
\
if (__print_once) { \
__print_once = 0; \
printk(x); \
} \
})
#else #else
static inline int vprintk(const char *s, va_list args) static inline int vprintk(const char *s, va_list args)
__attribute__ ((format (printf, 1, 0))); __attribute__ ((format (printf, 1, 0)));
...@@ -253,6 +266,10 @@ static inline int printk_ratelimit(void) { return 0; } ...@@ -253,6 +266,10 @@ static inline int printk_ratelimit(void) { return 0; }
static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies, \ static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies, \
unsigned int interval_msec) \ unsigned int interval_msec) \
{ return false; } { return false; }
/* No effect, but we still get type checking even in the !PRINTK case: */
#define printk_once(x...) printk(x)
#endif #endif
extern int printk_needs_cpu(int cpu); extern int printk_needs_cpu(int cpu);
......
...@@ -10,6 +10,7 @@ ...@@ -10,6 +10,7 @@
#include <linux/compiler.h> /* for inline */ #include <linux/compiler.h> /* for inline */
#include <linux/types.h> /* for size_t */ #include <linux/types.h> /* for size_t */
#include <linux/stddef.h> /* for NULL */ #include <linux/stddef.h> /* for NULL */
#include <stdarg.h>
extern char *strndup_user(const char __user *, long); extern char *strndup_user(const char __user *, long);
...@@ -111,6 +112,12 @@ extern void argv_free(char **argv); ...@@ -111,6 +112,12 @@ extern void argv_free(char **argv);
extern bool sysfs_streq(const char *s1, const char *s2); extern bool sysfs_streq(const char *s1, const char *s2);
#ifdef CONFIG_BINARY_PRINTF
int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
#endif
extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
const void *from, size_t available); const void *from, size_t available);
......
...@@ -2,6 +2,9 @@ ...@@ -2,6 +2,9 @@
# Library configuration # Library configuration
# #
config BINARY_PRINTF
def_bool n
menu "Library routines" menu "Library routines"
config BITREVERSE config BITREVERSE
......
...@@ -396,7 +396,38 @@ static noinline char* put_dec(char *buf, unsigned long long num) ...@@ -396,7 +396,38 @@ static noinline char* put_dec(char *buf, unsigned long long num)
#define SMALL 32 /* Must be 32 == 0x20 */ #define SMALL 32 /* Must be 32 == 0x20 */
#define SPECIAL 64 /* 0x */ #define SPECIAL 64 /* 0x */
static char *number(char *buf, char *end, unsigned long long num, int base, int size, int precision, int type) enum format_type {
FORMAT_TYPE_NONE, /* Just a string part */
FORMAT_TYPE_WITDH,
FORMAT_TYPE_PRECISION,
FORMAT_TYPE_CHAR,
FORMAT_TYPE_STR,
FORMAT_TYPE_PTR,
FORMAT_TYPE_PERCENT_CHAR,
FORMAT_TYPE_INVALID,
FORMAT_TYPE_LONG_LONG,
FORMAT_TYPE_ULONG,
FORMAT_TYPE_LONG,
FORMAT_TYPE_USHORT,
FORMAT_TYPE_SHORT,
FORMAT_TYPE_UINT,
FORMAT_TYPE_INT,
FORMAT_TYPE_NRCHARS,
FORMAT_TYPE_SIZE_T,
FORMAT_TYPE_PTRDIFF
};
struct printf_spec {
enum format_type type;
int flags; /* flags to number() */
int field_width; /* width of output field */
int base;
int precision; /* # of digits/chars */
int qualifier;
};
static char *number(char *buf, char *end, unsigned long long num,
struct printf_spec spec)
{ {
/* we are called with base 8, 10 or 16, only, thus don't need "G..." */ /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
...@@ -404,32 +435,32 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int ...@@ -404,32 +435,32 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int
char tmp[66]; char tmp[66];
char sign; char sign;
char locase; char locase;
int need_pfx = ((type & SPECIAL) && base != 10); int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
int i; int i;
/* locase = 0 or 0x20. ORing digits or letters with 'locase' /* locase = 0 or 0x20. ORing digits or letters with 'locase'
* produces same digits or (maybe lowercased) letters */ * produces same digits or (maybe lowercased) letters */
locase = (type & SMALL); locase = (spec.flags & SMALL);
if (type & LEFT) if (spec.flags & LEFT)
type &= ~ZEROPAD; spec.flags &= ~ZEROPAD;
sign = 0; sign = 0;
if (type & SIGN) { if (spec.flags & SIGN) {
if ((signed long long) num < 0) { if ((signed long long) num < 0) {
sign = '-'; sign = '-';
num = - (signed long long) num; num = - (signed long long) num;
size--; spec.field_width--;
} else if (type & PLUS) { } else if (spec.flags & PLUS) {
sign = '+'; sign = '+';
size--; spec.field_width--;
} else if (type & SPACE) { } else if (spec.flags & SPACE) {
sign = ' '; sign = ' ';
size--; spec.field_width--;
} }
} }
if (need_pfx) { if (need_pfx) {
size--; spec.field_width--;
if (base == 16) if (spec.base == 16)
size--; spec.field_width--;
} }
/* generate full string in tmp[], in reverse order */ /* generate full string in tmp[], in reverse order */
...@@ -441,10 +472,10 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int ...@@ -441,10 +472,10 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int
tmp[i++] = (digits[do_div(num,base)] | locase); tmp[i++] = (digits[do_div(num,base)] | locase);
} while (num != 0); } while (num != 0);
*/ */
else if (base != 10) { /* 8 or 16 */ else if (spec.base != 10) { /* 8 or 16 */
int mask = base - 1; int mask = spec.base - 1;
int shift = 3; int shift = 3;
if (base == 16) shift = 4; if (spec.base == 16) shift = 4;
do { do {
tmp[i++] = (digits[((unsigned char)num) & mask] | locase); tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
num >>= shift; num >>= shift;
...@@ -454,12 +485,12 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int ...@@ -454,12 +485,12 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int
} }
/* printing 100 using %2d gives "100", not "00" */ /* printing 100 using %2d gives "100", not "00" */
if (i > precision) if (i > spec.precision)
precision = i; spec.precision = i;
/* leading space padding */ /* leading space padding */
size -= precision; spec.field_width -= spec.precision;
if (!(type & (ZEROPAD+LEFT))) { if (!(spec.flags & (ZEROPAD+LEFT))) {
while(--size >= 0) { while(--spec.field_width >= 0) {
if (buf < end) if (buf < end)
*buf = ' '; *buf = ' ';
++buf; ++buf;
...@@ -476,23 +507,23 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int ...@@ -476,23 +507,23 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int
if (buf < end) if (buf < end)
*buf = '0'; *buf = '0';
++buf; ++buf;
if (base == 16) { if (spec.base == 16) {
if (buf < end) if (buf < end)
*buf = ('X' | locase); *buf = ('X' | locase);
++buf; ++buf;
} }
} }
/* zero or space padding */ /* zero or space padding */
if (!(type & LEFT)) { if (!(spec.flags & LEFT)) {
char c = (type & ZEROPAD) ? '0' : ' '; char c = (spec.flags & ZEROPAD) ? '0' : ' ';
while (--size >= 0) { while (--spec.field_width >= 0) {
if (buf < end) if (buf < end)
*buf = c; *buf = c;
++buf; ++buf;
} }
} }
/* hmm even more zero padding? */ /* hmm even more zero padding? */
while (i <= --precision) { while (i <= --spec.precision) {
if (buf < end) if (buf < end)
*buf = '0'; *buf = '0';
++buf; ++buf;
...@@ -504,7 +535,7 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int ...@@ -504,7 +535,7 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int
++buf; ++buf;
} }
/* trailing space padding */ /* trailing space padding */
while (--size >= 0) { while (--spec.field_width >= 0) {
if (buf < end) if (buf < end)
*buf = ' '; *buf = ' ';
++buf; ++buf;
...@@ -512,17 +543,17 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int ...@@ -512,17 +543,17 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int
return buf; return buf;
} }
static char *string(char *buf, char *end, char *s, int field_width, int precision, int flags) static char *string(char *buf, char *end, char *s, struct printf_spec spec)
{ {
int len, i; int len, i;
if ((unsigned long)s < PAGE_SIZE) if ((unsigned long)s < PAGE_SIZE)
s = "<NULL>"; s = "<NULL>";
len = strnlen(s, precision); len = strnlen(s, spec.precision);
if (!(flags & LEFT)) { if (!(spec.flags & LEFT)) {
while (len < field_width--) { while (len < spec.field_width--) {
if (buf < end) if (buf < end)
*buf = ' '; *buf = ' ';
++buf; ++buf;
...@@ -533,7 +564,7 @@ static char *string(char *buf, char *end, char *s, int field_width, int precisio ...@@ -533,7 +564,7 @@ static char *string(char *buf, char *end, char *s, int field_width, int precisio
*buf = *s; *buf = *s;
++buf; ++s; ++buf; ++s;
} }
while (len < field_width--) { while (len < spec.field_width--) {
if (buf < end) if (buf < end)
*buf = ' '; *buf = ' ';
++buf; ++buf;
...@@ -541,21 +572,24 @@ static char *string(char *buf, char *end, char *s, int field_width, int precisio ...@@ -541,21 +572,24 @@ static char *string(char *buf, char *end, char *s, int field_width, int precisio
return buf; return buf;
} }
static char *symbol_string(char *buf, char *end, void *ptr, int field_width, int precision, int flags) static char *symbol_string(char *buf, char *end, void *ptr,
struct printf_spec spec)
{ {
unsigned long value = (unsigned long) ptr; unsigned long value = (unsigned long) ptr;
#ifdef CONFIG_KALLSYMS #ifdef CONFIG_KALLSYMS
char sym[KSYM_SYMBOL_LEN]; char sym[KSYM_SYMBOL_LEN];
sprint_symbol(sym, value); sprint_symbol(sym, value);
return string(buf, end, sym, field_width, precision, flags); return string(buf, end, sym, spec);
#else #else
field_width = 2*sizeof(void *); spec.field_width = 2*sizeof(void *);
flags |= SPECIAL | SMALL | ZEROPAD; spec.flags |= SPECIAL | SMALL | ZEROPAD;
return number(buf, end, value, 16, field_width, precision, flags); spec.base = 16;
return number(buf, end, value, spec);
#endif #endif
} }
static char *resource_string(char *buf, char *end, struct resource *res, int field_width, int precision, int flags) static char *resource_string(char *buf, char *end, struct resource *res,
struct printf_spec spec)
{ {
#ifndef IO_RSRC_PRINTK_SIZE #ifndef IO_RSRC_PRINTK_SIZE
#define IO_RSRC_PRINTK_SIZE 4 #define IO_RSRC_PRINTK_SIZE 4
...@@ -564,7 +598,11 @@ static char *resource_string(char *buf, char *end, struct resource *res, int fie ...@@ -564,7 +598,11 @@ static char *resource_string(char *buf, char *end, struct resource *res, int fie
#ifndef MEM_RSRC_PRINTK_SIZE #ifndef MEM_RSRC_PRINTK_SIZE
#define MEM_RSRC_PRINTK_SIZE 8 #define MEM_RSRC_PRINTK_SIZE 8
#endif #endif
struct printf_spec num_spec = {
.base = 16,
.precision = -1,
.flags = SPECIAL | SMALL | ZEROPAD,
};
/* room for the actual numbers, the two "0x", -, [, ] and the final zero */ /* room for the actual numbers, the two "0x", -, [, ] and the final zero */
char sym[4*sizeof(resource_size_t) + 8]; char sym[4*sizeof(resource_size_t) + 8];
char *p = sym, *pend = sym + sizeof(sym); char *p = sym, *pend = sym + sizeof(sym);
...@@ -576,17 +614,18 @@ static char *resource_string(char *buf, char *end, struct resource *res, int fie ...@@ -576,17 +614,18 @@ static char *resource_string(char *buf, char *end, struct resource *res, int fie
size = MEM_RSRC_PRINTK_SIZE; size = MEM_RSRC_PRINTK_SIZE;
*p++ = '['; *p++ = '[';
p = number(p, pend, res->start, 16, size, -1, SPECIAL | SMALL | ZEROPAD); num_spec.field_width = size;
p = number(p, pend, res->start, num_spec);
*p++ = '-'; *p++ = '-';
p = number(p, pend, res->end, 16, size, -1, SPECIAL | SMALL | ZEROPAD); p = number(p, pend, res->end, num_spec);
*p++ = ']'; *p++ = ']';
*p = 0; *p = 0;
return string(buf, end, sym, field_width, precision, flags); return string(buf, end, sym, spec);
} }
static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width, static char *mac_address_string(char *buf, char *end, u8 *addr,
int precision, int flags) struct printf_spec spec)
{ {
char mac_addr[6 * 3]; /* (6 * 2 hex digits), 5 colons and trailing zero */ char mac_addr[6 * 3]; /* (6 * 2 hex digits), 5 colons and trailing zero */
char *p = mac_addr; char *p = mac_addr;
...@@ -594,16 +633,17 @@ static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width, ...@@ -594,16 +633,17 @@ static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
p = pack_hex_byte(p, addr[i]); p = pack_hex_byte(p, addr[i]);
if (!(flags & SPECIAL) && i != 5) if (!(spec.flags & SPECIAL) && i != 5)
*p++ = ':'; *p++ = ':';
} }
*p = '\0'; *p = '\0';
spec.flags &= ~SPECIAL;
return string(buf, end, mac_addr, field_width, precision, flags & ~SPECIAL); return string(buf, end, mac_addr, spec);
} }
static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width, static char *ip6_addr_string(char *buf, char *end, u8 *addr,
int precision, int flags) struct printf_spec spec)
{ {
char ip6_addr[8 * 5]; /* (8 * 4 hex digits), 7 colons and trailing zero */ char ip6_addr[8 * 5]; /* (8 * 4 hex digits), 7 colons and trailing zero */
char *p = ip6_addr; char *p = ip6_addr;
...@@ -612,16 +652,17 @@ static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width, ...@@ -612,16 +652,17 @@ static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
p = pack_hex_byte(p, addr[2 * i]); p = pack_hex_byte(p, addr[2 * i]);
p = pack_hex_byte(p, addr[2 * i + 1]); p = pack_hex_byte(p, addr[2 * i + 1]);
if (!(flags & SPECIAL) && i != 7) if (!(spec.flags & SPECIAL) && i != 7)
*p++ = ':'; *p++ = ':';
} }
*p = '\0'; *p = '\0';
spec.flags &= ~SPECIAL;
return string(buf, end, ip6_addr, field_width, precision, flags & ~SPECIAL); return string(buf, end, ip6_addr, spec);
} }
static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, static char *ip4_addr_string(char *buf, char *end, u8 *addr,
int precision, int flags) struct printf_spec spec)
{ {
char ip4_addr[4 * 4]; /* (4 * 3 decimal digits), 3 dots and trailing zero */ char ip4_addr[4 * 4]; /* (4 * 3 decimal digits), 3 dots and trailing zero */
char temp[3]; /* hold each IP quad in reverse order */ char temp[3]; /* hold each IP quad in reverse order */
...@@ -637,8 +678,9 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, ...@@ -637,8 +678,9 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
*p++ = '.'; *p++ = '.';
} }
*p = '\0'; *p = '\0';
spec.flags &= ~SPECIAL;
return string(buf, end, ip4_addr, field_width, precision, flags & ~SPECIAL); return string(buf, end, ip4_addr, spec);
} }
/* /*
...@@ -663,41 +705,234 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, ...@@ -663,41 +705,234 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
* function pointers are really function descriptors, which contain a * function pointers are really function descriptors, which contain a
* pointer to the real address. * pointer to the real address.
*/ */
static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field_width, int precision, int flags) static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
struct printf_spec spec)
{ {
if (!ptr) if (!ptr)
return string(buf, end, "(null)", field_width, precision, flags); return string(buf, end, "(null)", spec);
switch (*fmt) { switch (*fmt) {
case 'F': case 'F':
ptr = dereference_function_descriptor(ptr); ptr = dereference_function_descriptor(ptr);
/* Fallthrough */ /* Fallthrough */
case 'S': case 'S':
return symbol_string(buf, end, ptr, field_width, precision, flags); return symbol_string(buf, end, ptr, spec);
case 'R': case 'R':
return resource_string(buf, end, ptr, field_width, precision, flags); return resource_string(buf, end, ptr, spec);
case 'm': case 'm':
flags |= SPECIAL; spec.flags |= SPECIAL;
/* Fallthrough */ /* Fallthrough */
case 'M': case 'M':
return mac_address_string(buf, end, ptr, field_width, precision, flags); return mac_address_string(buf, end, ptr, spec);
case 'i': case 'i':
flags |= SPECIAL; spec.flags |= SPECIAL;
/* Fallthrough */ /* Fallthrough */
case 'I': case 'I':
if (fmt[1] == '6') if (fmt[1] == '6')
return ip6_addr_string(buf, end, ptr, field_width, precision, flags); return ip6_addr_string(buf, end, ptr, spec);
if (fmt[1] == '4') if (fmt[1] == '4')
return ip4_addr_string(buf, end, ptr, field_width, precision, flags); return ip4_addr_string(buf, end, ptr, spec);
flags &= ~SPECIAL; spec.flags &= ~SPECIAL;
break;
}
spec.flags |= SMALL;
if (spec.field_width == -1) {
spec.field_width = 2*sizeof(void *);
spec.flags |= ZEROPAD;
}
spec.base = 16;
return number(buf, end, (unsigned long) ptr, spec);
}
/*
* Helper function to decode printf style format.
* Each call decode a token from the format and return the
* number of characters read (or likely the delta where it wants
* to go on the next call).
* The decoded token is returned through the parameters
*
* 'h', 'l', or 'L' for integer fields
* 'z' support added 23/7/1999 S.H.
* 'z' changed to 'Z' --davidm 1/25/99
* 't' added for ptrdiff_t
*
* @fmt: the format string
* @type of the token returned
* @flags: various flags such as +, -, # tokens..
* @field_width: overwritten width
* @base: base of the number (octal, hex, ...)
* @precision: precision of a number
* @qualifier: qualifier of a number (long, size_t, ...)
*/
static int format_decode(const char *fmt, struct printf_spec *spec)
{
const char *start = fmt;
bool sign = false;
/* we finished early by reading the field width */
if (spec->type == FORMAT_TYPE_WITDH) {
if (spec->field_width < 0) {
spec->field_width = -spec->field_width;
spec->flags |= LEFT;
}
spec->type = FORMAT_TYPE_NONE;
goto precision;
}
/* we finished early by reading the precision */
if (spec->type == FORMAT_TYPE_PRECISION) {
if (spec->precision < 0)
spec->precision = 0;
spec->type = FORMAT_TYPE_NONE;
goto qualifier;
}
/* By default */
spec->type = FORMAT_TYPE_NONE;
for (; *fmt ; ++fmt) {
if (*fmt == '%')
break;
}
/* Return the current non-format string */
if (fmt != start || !*fmt)
return fmt - start;
/* Process flags */
spec->flags = 0;
while (1) { /* this also skips first '%' */
bool found = true;
++fmt;
switch (*fmt) {
case '-': spec->flags |= LEFT; break;
case '+': spec->flags |= PLUS; break;
case ' ': spec->flags |= SPACE; break;
case '#': spec->flags |= SPECIAL; break;
case '0': spec->flags |= ZEROPAD; break;
default: found = false;
}
if (!found)
break;
}
/* get field width */
spec->field_width = -1;
if (isdigit(*fmt))
spec->field_width = skip_atoi(&fmt);
else if (*fmt == '*') {
/* it's the next argument */
spec->type = FORMAT_TYPE_WITDH;
return ++fmt - start;
}
precision:
/* get the precision */
spec->precision = -1;
if (*fmt == '.') {
++fmt;
if (isdigit(*fmt)) {
spec->precision = skip_atoi(&fmt);
if (spec->precision < 0)
spec->precision = 0;
} else if (*fmt == '*') {
/* it's the next argument */
spec->type = FORMAT_TYPE_WITDH;
return ++fmt - start;
}
}
qualifier:
/* get the conversion qualifier */
spec->qualifier = -1;
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
*fmt == 'Z' || *fmt == 'z' || *fmt == 't') {
spec->qualifier = *fmt;
++fmt;
if (spec->qualifier == 'l' && *fmt == 'l') {
spec->qualifier = 'L';
++fmt;
}
}
/* default base */
spec->base = 10;
switch (*fmt) {
case 'c':
spec->type = FORMAT_TYPE_CHAR;
return ++fmt - start;
case 's':
spec->type = FORMAT_TYPE_STR;
return ++fmt - start;
case 'p':
spec->type = FORMAT_TYPE_PTR;
return fmt - start;
/* skip alnum */
case 'n':
spec->type = FORMAT_TYPE_NRCHARS;
return ++fmt - start;
case '%':
spec->type = FORMAT_TYPE_PERCENT_CHAR;
return ++fmt - start;
/* integer number formats - set up the flags and "break" */
case 'o':
spec->base = 8;
break;
case 'x':
spec->flags |= SMALL;
case 'X':
spec->base = 16;
break;
case 'd':
case 'i':
sign = true;
case 'u':
break; break;
default:
spec->type = FORMAT_TYPE_INVALID;
return fmt - start;
} }
flags |= SMALL;
if (field_width == -1) { if (spec->qualifier == 'L')
field_width = 2*sizeof(void *); spec->type = FORMAT_TYPE_LONG_LONG;
flags |= ZEROPAD; else if (spec->qualifier == 'l') {
if (sign)
spec->type = FORMAT_TYPE_LONG;
else
spec->type = FORMAT_TYPE_ULONG;
} else if (spec->qualifier == 'Z' || spec->qualifier == 'z') {
spec->type = FORMAT_TYPE_SIZE_T;
} else if (spec->qualifier == 't') {
spec->type = FORMAT_TYPE_PTRDIFF;
} else if (spec->qualifier == 'h') {
if (sign)
spec->type = FORMAT_TYPE_SHORT;
else
spec->type = FORMAT_TYPE_USHORT;
} else {
if (sign)
spec->type = FORMAT_TYPE_INT;
else
spec->type = FORMAT_TYPE_UINT;
} }
return number(buf, end, (unsigned long) ptr, 16, field_width, precision, flags);
return ++fmt - start;
} }
/** /**
...@@ -726,18 +961,9 @@ static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field ...@@ -726,18 +961,9 @@ static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
{ {
unsigned long long num; unsigned long long num;
int base;
char *str, *end, c; char *str, *end, c;
int read;
int flags; /* flags to number() */ struct printf_spec spec = {0};
int field_width; /* width of output field */
int precision; /* min. # of digits for integers; max
number of chars for from string */
int qualifier; /* 'h', 'l', or 'L' for integer fields */
/* 'z' support added 23/7/1999 S.H. */
/* 'z' changed to 'Z' --davidm 1/25/99 */
/* 't' added for ptrdiff_t */
/* Reject out-of-range values early. Large positive sizes are /* Reject out-of-range values early. Large positive sizes are
used for unknown buffer sizes. */ used for unknown buffer sizes. */
...@@ -758,142 +984,71 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) ...@@ -758,142 +984,71 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
size = end - buf; size = end - buf;
} }
for (; *fmt ; ++fmt) { while (*fmt) {
if (*fmt != '%') { const char *old_fmt = fmt;
if (str < end)
*str = *fmt;
++str;
continue;
}
/* process flags */ read = format_decode(fmt, &spec);
flags = 0;
repeat:
++fmt; /* this also skips first '%' */
switch (*fmt) {
case '-': flags |= LEFT; goto repeat;
case '+': flags |= PLUS; goto repeat;
case ' ': flags |= SPACE; goto repeat;
case '#': flags |= SPECIAL; goto repeat;
case '0': flags |= ZEROPAD; goto repeat;
}
/* get field width */ fmt += read;
field_width = -1;
if (isdigit(*fmt))
field_width = skip_atoi(&fmt);
else if (*fmt == '*') {
++fmt;
/* it's the next argument */
field_width = va_arg(args, int);
if (field_width < 0) {
field_width = -field_width;
flags |= LEFT;
}
}
/* get the precision */ switch (spec.type) {
precision = -1; case FORMAT_TYPE_NONE: {
if (*fmt == '.') { int copy = read;
++fmt; if (str < end) {
if (isdigit(*fmt)) if (copy > end - str)
precision = skip_atoi(&fmt); copy = end - str;
else if (*fmt == '*') { memcpy(str, old_fmt, copy);
++fmt;
/* it's the next argument */
precision = va_arg(args, int);
} }
if (precision < 0) str += read;
precision = 0; break;
} }
/* get the conversion qualifier */ case FORMAT_TYPE_WITDH:
qualifier = -1; spec.field_width = va_arg(args, int);
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || break;
*fmt =='Z' || *fmt == 'z' || *fmt == 't') {
qualifier = *fmt;
++fmt;
if (qualifier == 'l' && *fmt == 'l') {
qualifier = 'L';
++fmt;
}
}
/* default base */ case FORMAT_TYPE_PRECISION:
base = 10; spec.precision = va_arg(args, int);
break;
switch (*fmt) { case FORMAT_TYPE_CHAR:
case 'c': if (!(spec.flags & LEFT)) {
if (!(flags & LEFT)) { while (--spec.field_width > 0) {
while (--field_width > 0) {
if (str < end) if (str < end)
*str = ' '; *str = ' ';
++str; ++str;
} }
} }
c = (unsigned char) va_arg(args, int); c = (unsigned char) va_arg(args, int);
if (str < end) if (str < end)
*str = c; *str = c;
++str; ++str;
while (--field_width > 0) { while (--spec.field_width > 0) {
if (str < end) if (str < end)
*str = ' '; *str = ' ';
++str; ++str;
} }
continue; break;
case 's': case FORMAT_TYPE_STR:
str = string(str, end, va_arg(args, char *), field_width, precision, flags); str = string(str, end, va_arg(args, char *), spec);
continue; break;
case 'p': case FORMAT_TYPE_PTR:
str = pointer(fmt+1, str, end, str = pointer(fmt+1, str, end, va_arg(args, void *),
va_arg(args, void *), spec);
field_width, precision, flags); while (isalnum(*fmt))
/* Skip all alphanumeric pointer suffixes */
while (isalnum(fmt[1]))
fmt++; fmt++;
continue; break;
case 'n':
/* FIXME:
* What does C99 say about the overflow case here? */
if (qualifier == 'l') {
long * ip = va_arg(args, long *);
*ip = (str - buf);
} else if (qualifier == 'Z' || qualifier == 'z') {
size_t * ip = va_arg(args, size_t *);
*ip = (str - buf);
} else {
int * ip = va_arg(args, int *);
*ip = (str - buf);
}
continue;
case '%': case FORMAT_TYPE_PERCENT_CHAR:
if (str < end) if (str < end)
*str = '%'; *str = '%';
++str; ++str;
continue;
/* integer number formats - set up the flags and "break" */
case 'o':
base = 8;
break;
case 'x':
flags |= SMALL;
case 'X':
base = 16;
break; break;
case 'd': case FORMAT_TYPE_INVALID:
case 'i':
flags |= SIGN;
case 'u':
break;
default:
if (str < end) if (str < end)
*str = '%'; *str = '%';
++str; ++str;
...@@ -904,38 +1059,69 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) ...@@ -904,38 +1059,69 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
} else { } else {
--fmt; --fmt;
} }
continue; break;
case FORMAT_TYPE_NRCHARS: {
int qualifier = spec.qualifier;
if (qualifier == 'l') {
long *ip = va_arg(args, long *);
*ip = (str - buf);
} else if (qualifier == 'Z' ||
qualifier == 'z') {
size_t *ip = va_arg(args, size_t *);
*ip = (str - buf);
} else {
int *ip = va_arg(args, int *);
*ip = (str - buf);
}
break;
} }
if (qualifier == 'L')
default:
switch (spec.type) {
case FORMAT_TYPE_LONG_LONG:
num = va_arg(args, long long); num = va_arg(args, long long);
else if (qualifier == 'l') { break;
case FORMAT_TYPE_ULONG:
num = va_arg(args, unsigned long); num = va_arg(args, unsigned long);
if (flags & SIGN) break;
num = (signed long) num; case FORMAT_TYPE_LONG:
} else if (qualifier == 'Z' || qualifier == 'z') { num = va_arg(args, long);
break;
case FORMAT_TYPE_SIZE_T:
num = va_arg(args, size_t); num = va_arg(args, size_t);
} else if (qualifier == 't') { break;
case FORMAT_TYPE_PTRDIFF:
num = va_arg(args, ptrdiff_t); num = va_arg(args, ptrdiff_t);
} else if (qualifier == 'h') { break;
case FORMAT_TYPE_USHORT:
num = (unsigned short) va_arg(args, int); num = (unsigned short) va_arg(args, int);
if (flags & SIGN) break;
num = (signed short) num; case FORMAT_TYPE_SHORT:
} else { num = (short) va_arg(args, int);
break;
case FORMAT_TYPE_UINT:
num = va_arg(args, unsigned int);
break;
default:
num = va_arg(args, unsigned int); num = va_arg(args, unsigned int);
if (flags & SIGN)
num = (signed int) num;
} }
str = number(str, end, num, base,
field_width, precision, flags); str = number(str, end, num, spec);
}
} }
if (size > 0) { if (size > 0) {
if (str < end) if (str < end)
*str = '\0'; *str = '\0';
else else
end[-1] = '\0'; end[-1] = '\0';
} }
/* the trailing null byte doesn't count towards the total */ /* the trailing null byte doesn't count towards the total */
return str-buf; return str-buf;
} }
EXPORT_SYMBOL(vsnprintf); EXPORT_SYMBOL(vsnprintf);
...@@ -1058,6 +1244,372 @@ int sprintf(char * buf, const char *fmt, ...) ...@@ -1058,6 +1244,372 @@ int sprintf(char * buf, const char *fmt, ...)
} }
EXPORT_SYMBOL(sprintf); EXPORT_SYMBOL(sprintf);
#ifdef CONFIG_BINARY_PRINTF
/*
* bprintf service:
* vbin_printf() - VA arguments to binary data
* bstr_printf() - Binary data to text string
*/
/**
* vbin_printf - Parse a format string and place args' binary value in a buffer
* @bin_buf: The buffer to place args' binary value
* @size: The size of the buffer(by words(32bits), not characters)
* @fmt: The format string to use
* @args: Arguments for the format string
*
* The format follows C99 vsnprintf, except %n is ignored, and its argument
* is skiped.
*
* The return value is the number of words(32bits) which would be generated for
* the given input.
*
* NOTE:
* If the return value is greater than @size, the resulting bin_buf is NOT
* valid for bstr_printf().
*/
int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
{
struct printf_spec spec = {0};
char *str, *end;
int read;
str = (char *)bin_buf;
end = (char *)(bin_buf + size);
#define save_arg(type) \
do { \
if (sizeof(type) == 8) { \
unsigned long long value; \
str = PTR_ALIGN(str, sizeof(u32)); \
value = va_arg(args, unsigned long long); \
if (str + sizeof(type) <= end) { \
*(u32 *)str = *(u32 *)&value; \
*(u32 *)(str + 4) = *((u32 *)&value + 1); \
} \
} else { \
unsigned long value; \
str = PTR_ALIGN(str, sizeof(type)); \
value = va_arg(args, int); \
if (str + sizeof(type) <= end) \
*(typeof(type) *)str = (type)value; \
} \
str += sizeof(type); \
} while (0)
while (*fmt) {
read = format_decode(fmt, &spec);
fmt += read;
switch (spec.type) {
case FORMAT_TYPE_NONE:
break;
case FORMAT_TYPE_WITDH:
case FORMAT_TYPE_PRECISION:
save_arg(int);
break;
case FORMAT_TYPE_CHAR:
save_arg(char);
break;
case FORMAT_TYPE_STR: {
const char *save_str = va_arg(args, char *);
size_t len;
if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
|| (unsigned long)save_str < PAGE_SIZE)
save_str = "<NULL>";
len = strlen(save_str);
if (str + len + 1 < end)
memcpy(str, save_str, len + 1);
str += len + 1;
break;
}
case FORMAT_TYPE_PTR:
save_arg(void *);
/* skip all alphanumeric pointer suffixes */
while (isalnum(*fmt))
fmt++;
break;
case FORMAT_TYPE_PERCENT_CHAR:
break;
case FORMAT_TYPE_INVALID:
if (!*fmt)
--fmt;
break;
case FORMAT_TYPE_NRCHARS: {
/* skip %n 's argument */
int qualifier = spec.qualifier;
void *skip_arg;
if (qualifier == 'l')
skip_arg = va_arg(args, long *);
else if (qualifier == 'Z' || qualifier == 'z')
skip_arg = va_arg(args, size_t *);
else
skip_arg = va_arg(args, int *);
break;
}
default:
switch (spec.type) {
case FORMAT_TYPE_LONG_LONG:
save_arg(long long);
break;
case FORMAT_TYPE_ULONG:
case FORMAT_TYPE_LONG:
save_arg(unsigned long);
break;
case FORMAT_TYPE_SIZE_T:
save_arg(size_t);
break;
case FORMAT_TYPE_PTRDIFF:
save_arg(ptrdiff_t);
break;
case FORMAT_TYPE_USHORT:
case FORMAT_TYPE_SHORT:
save_arg(short);
break;
default:
save_arg(int);
}
}
}
return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
#undef save_arg
}
EXPORT_SYMBOL_GPL(vbin_printf);
/**
* bstr_printf - Format a string from binary arguments and place it in a buffer
* @buf: The buffer to place the result into
* @size: The size of the buffer, including the trailing null space
* @fmt: The format string to use
* @bin_buf: Binary arguments for the format string
*
* This function like C99 vsnprintf, but the difference is that vsnprintf gets
* arguments from stack, and bstr_printf gets arguments from @bin_buf which is
* a binary buffer that generated by vbin_printf.
*
* The format follows C99 vsnprintf, but has some extensions:
* %pS output the name of a text symbol
* %pF output the name of a function pointer
* %pR output the address range in a struct resource
* %n is ignored
*
* 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
* number of characters written into @buf as return value
* (not including the trailing '\0'), use vscnprintf(). If the
* return is greater than or equal to @size, the resulting
* string is truncated.
*/
int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
{
unsigned long long num;
char *str, *end, c;
const char *args = (const char *)bin_buf;
struct printf_spec spec = {0};
if (unlikely((int) size < 0)) {
/* There can be only one.. */
static char warn = 1;
WARN_ON(warn);
warn = 0;
return 0;
}
str = buf;
end = buf + size;
#define get_arg(type) \
({ \
typeof(type) value; \
if (sizeof(type) == 8) { \
args = PTR_ALIGN(args, sizeof(u32)); \
*(u32 *)&value = *(u32 *)args; \
*((u32 *)&value + 1) = *(u32 *)(args + 4); \
} else { \
args = PTR_ALIGN(args, sizeof(type)); \
value = *(typeof(type) *)args; \
} \
args += sizeof(type); \
value; \
})
/* Make sure end is always >= buf */
if (end < buf) {
end = ((void *)-1);
size = end - buf;
}
while (*fmt) {
int read;
const char *old_fmt = fmt;
read = format_decode(fmt, &spec);
fmt += read;
switch (spec.type) {
case FORMAT_TYPE_NONE: {
int copy = read;
if (str < end) {
if (copy > end - str)
copy = end - str;
memcpy(str, old_fmt, copy);
}
str += read;
break;
}
case FORMAT_TYPE_WITDH:
spec.field_width = get_arg(int);
break;
case FORMAT_TYPE_PRECISION:
spec.precision = get_arg(int);
break;
case FORMAT_TYPE_CHAR:
if (!(spec.flags & LEFT)) {
while (--spec.field_width > 0) {
if (str < end)
*str = ' ';
++str;
}
}
c = (unsigned char) get_arg(char);
if (str < end)
*str = c;
++str;
while (--spec.field_width > 0) {
if (str < end)
*str = ' ';
++str;
}
break;
case FORMAT_TYPE_STR: {
const char *str_arg = args;
size_t len = strlen(str_arg);
args += len + 1;
str = string(str, end, (char *)str_arg, spec);
break;
}
case FORMAT_TYPE_PTR:
str = pointer(fmt+1, str, end, get_arg(void *), spec);
while (isalnum(*fmt))
fmt++;
break;
case FORMAT_TYPE_PERCENT_CHAR:
if (str < end)
*str = '%';
++str;
break;
case FORMAT_TYPE_INVALID:
if (str < end)
*str = '%';
++str;
if (*fmt) {
if (str < end)
*str = *fmt;
++str;
} else {
--fmt;
}
break;
case FORMAT_TYPE_NRCHARS:
/* skip */
break;
default:
switch (spec.type) {
case FORMAT_TYPE_LONG_LONG:
num = get_arg(long long);
break;
case FORMAT_TYPE_ULONG:
num = get_arg(unsigned long);
break;
case FORMAT_TYPE_LONG:
num = get_arg(unsigned long);
break;
case FORMAT_TYPE_SIZE_T:
num = get_arg(size_t);
break;
case FORMAT_TYPE_PTRDIFF:
num = get_arg(ptrdiff_t);
break;
case FORMAT_TYPE_USHORT:
num = get_arg(unsigned short);
break;
case FORMAT_TYPE_SHORT:
num = get_arg(short);
break;
case FORMAT_TYPE_UINT:
num = get_arg(unsigned int);
break;
default:
num = get_arg(int);
}
str = number(str, end, num, spec);
}
}
if (size > 0) {
if (str < end)
*str = '\0';
else
end[-1] = '\0';
}
#undef get_arg
/* the trailing null byte doesn't count towards the total */
return str - buf;
}
EXPORT_SYMBOL_GPL(bstr_printf);
/**
* bprintf - Parse a format string and place args' binary value in a buffer
* @bin_buf: The buffer to place args' binary value
* @size: The size of the buffer(by words(32bits), not characters)
* @fmt: The format string to use
* @...: Arguments for the format string
*
* The function returns the number of words(u32) written
* into @bin_buf.
*/
int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
{
va_list args;
int ret;
va_start(args, fmt);
ret = vbin_printf(bin_buf, size, fmt, args);
va_end(args);
return ret;
}
EXPORT_SYMBOL_GPL(bprintf);
#endif /* CONFIG_BINARY_PRINTF */
/** /**
* vsscanf - Unformat a buffer into a list of arguments * vsscanf - Unformat a buffer into a list of arguments
* @buf: input buffer * @buf: input buffer
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment