Subversion Repositories Kolibri OS

/*

 *  linux/lib/vsprintf.c

 *

 *  Copyright (C) 1991, 1992  Linus Torvalds

 */

/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */

/*

 * Wirzenius wrote this portably, Torvalds fucked it up :-)

 */

/*

 * Fri Jul 13 2001 Crutcher Dunnavant 

 * - changed to provide snprintf and vsnprintf functions

 * So Feb  1 16:51:32 CET 2004 Juergen Quade 

 * - scnprintf and vscnprintf

 */

#include 

#include 	/* for KSYM_SYMBOL_LEN */

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 		/* for PAGE_SIZE */

#define ZERO_SIZE_PTR ((void *)16)

#define ZERO_OR_NULL_PTR(x) ((unsigned long)(x) <= \

                                (unsigned long)ZERO_SIZE_PTR)

#ifndef dereference_function_descriptor

#define dereference_function_descriptor(p) (p)

#endif

#define KSTRTOX_OVERFLOW        (1U << 31)

const char hex_asc[] = "0123456789abcdef";

const char hex_asc_upper[] = "0123456789ABCDEF";

/* Works only for digits and letters, but small and fast */

#define TOLOWER(x) ((x) | 0x20)

char *skip_spaces(const char *str)

{

        while (isspace(*str))

                ++str;

        return (char *)str;

}

EXPORT_SYMBOL(skip_spaces);

const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)

{

    if (*base == 0) {

        if (s[0] == '0') {

            if (_tolower(s[1]) == 'x' && isxdigit(s[2]))

                *base = 16;

            else

                *base = 8;

        } else

            *base = 10;

    }

    if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')

        s += 2;

    return s;

}

/*

 * Convert non-negative integer string representation in explicitly given radix

 * to an integer.

 * Return number of characters consumed maybe or-ed with overflow bit.

 * If overflow occurs, result integer (incorrect) is still returned.

 *

 * Don't you dare use this function.

 */

unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)

{

    unsigned long long res;

    unsigned int rv;

    int overflow;

    res = 0;

    rv = 0;

    overflow = 0;

    while (*s) {

        unsigned int val;

        if ('0' <= *s && *s <= '9')

            val = *s - '0';

        else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')

            val = _tolower(*s) - 'a' + 10;

        else

            break;

        if (val >= base)

            break;

        /*

         * Check for overflow only if we are within range of

         * it in the max base we support (16)

         */

        if (unlikely(res & (~0ull << 60))) {

            if (res > div_u64(ULLONG_MAX - val, base))

                overflow = 1;

        }

        res = res * base + val;

        rv++;

        s++;

    }

    *p = res;

    if (overflow)

        rv |= KSTRTOX_OVERFLOW;

    return rv;

}

/**

 * 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;

	cp = _parse_integer_fixup_radix(cp, &base);

	rv = _parse_integer(cp, base, &result);

	/* FIXME */

	cp += (rv & ~KSTRTOX_OVERFLOW);

	if (endp)

		*endp = (char *)cp;

	return result;

}

EXPORT_SYMBOL(simple_strtoull);

/**

 * simple_strtoul - convert a string to an unsigned 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 kstrtoul instead.

 */

unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)

{

	return simple_strtoull(cp, endp, base);

}

EXPORT_SYMBOL(simple_strtoul);

/**

 * simple_strtol - convert a string to a signed 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 kstrtol instead.

 */

long simple_strtol(const char *cp, char **endp, unsigned int base)

{

	if (*cp == '-')

		return -simple_strtoul(cp + 1, endp, base);

	return simple_strtoul(cp, endp, base);

}

EXPORT_SYMBOL(simple_strtol);

/**

 * simple_strtoll - convert a string to a signed 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 kstrtoll instead.

 */

long long simple_strtoll(const char *cp, char **endp, unsigned int base)

{

	if (*cp == '-')

		return -simple_strtoull(cp + 1, endp, base);

	return simple_strtoull(cp, endp, base);

}

EXPORT_SYMBOL(simple_strtoll);

static noinline_for_stack

int skip_atoi(const char **s)

{

	int i = 0;

	do {

		i = i*10 + *((*s)++) - '0';

	} while (isdigit(**s));

	return i;

}

/*

 * 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 by emitting

 * two characters at a time, using a 200 byte lookup table. This

 * roughly halves the number of multiplications compared to computing

 * the digits one at a time. Implementation strongly inspired by the

 * previous version, which in turn used ideas described at

 *  (with permission

 * from the author, Douglas W. Jones).

 *

 * It turns out there is precisely one 26 bit fixed-point

 * approximation a of 64/100 for which x/100 == (x * (u64)a) >> 32

 * holds for all x in [0, 10^8-1], namely a = 0x28f5c29. The actual

 * range happens to be somewhat larger (x <= 1073741898), but that's

 * irrelevant for our purpose.

 *

 * For dividing a number in the range [10^4, 10^6-1] by 100, we still

 * need a 32x32->64 bit multiply, so we simply use the same constant.

 *

 * For dividing a number in the range [100, 10^4-1] by 100, there are

 * several options. The simplest is (x * 0x147b) >> 19, which is valid

 * for all x <= 43698.

 */

static const u16 decpair[100] = {

#define _(x) (__force u16) cpu_to_le16(((x % 10) | ((x / 10) << 8)) + 0x3030)

	_( 0), _( 1), _( 2), _( 3), _( 4), _( 5), _( 6), _( 7), _( 8), _( 9),

	_(10), _(11), _(12), _(13), _(14), _(15), _(16), _(17), _(18), _(19),

	_(20), _(21), _(22), _(23), _(24), _(25), _(26), _(27), _(28), _(29),

	_(30), _(31), _(32), _(33), _(34), _(35), _(36), _(37), _(38), _(39),

	_(40), _(41), _(42), _(43), _(44), _(45), _(46), _(47), _(48), _(49),

	_(50), _(51), _(52), _(53), _(54), _(55), _(56), _(57), _(58), _(59),

	_(60), _(61), _(62), _(63), _(64), _(65), _(66), _(67), _(68), _(69),

	_(70), _(71), _(72), _(73), _(74), _(75), _(76), _(77), _(78), _(79),

	_(80), _(81), _(82), _(83), _(84), _(85), _(86), _(87), _(88), _(89),

	_(90), _(91), _(92), _(93), _(94), _(95), _(96), _(97), _(98), _(99),

#undef _

};

/*

 * This will print a single '0' even if r == 0, since we would

 * immediately jump to out_r where two 0s would be written but only

 * one of them accounted for in buf. This is needed by ip4_string

 * below. All other callers pass a non-zero value of r.

*/

static noinline_for_stack

char *put_dec_trunc8(char *buf, unsigned r)

{

	unsigned q;

	/* 1 <= r < 10^8 */

	if (r < 100)

		goto out_r;

	/* 100 <= r < 10^8 */

	q = (r * (u64)0x28f5c29) >> 32;

	*((u16 *)buf) = decpair[r - 100*q];

	buf += 2;

	/* 1 <= q < 10^6 */

	if (q < 100)

		goto out_q;

	/*  100 <= q < 10^6 */

	r = (q * (u64)0x28f5c29) >> 32;

	*((u16 *)buf) = decpair[q - 100*r];

	buf += 2;

	/* 1 <= r < 10^4 */

	if (r < 100)

		goto out_r;

	/* 100 <= r < 10^4 */

	q = (r * 0x147b) >> 19;

	*((u16 *)buf) = decpair[r - 100*q];

	buf += 2;

out_q:

	/* 1 <= q < 100 */

	r = q;

out_r:

	/* 1 <= r < 100 */

	*((u16 *)buf) = decpair[r];

	buf += r < 10 ? 1 : 2;

	return buf;

}

#if BITS_PER_LONG == 64 && BITS_PER_LONG_LONG == 64

static noinline_for_stack

char *put_dec_full8(char *buf, unsigned r)

{

	unsigned q;

	/* 0 <= r < 10^8 */

	q = (r * (u64)0x28f5c29) >> 32;

	*((u16 *)buf) = decpair[r - 100*q];

	buf += 2;

	/* 0 <= q < 10^6 */

	r = (q * (u64)0x28f5c29) >> 32;

	*((u16 *)buf) = decpair[q - 100*r];

	buf += 2;

	/* 0 <= r < 10^4 */

	q = (r * 0x147b) >> 19;

	*((u16 *)buf) = decpair[r - 100*q];

	buf += 2;

	/* 0 <= q < 100 */

	*((u16 *)buf) = decpair[q];

	buf += 2;

	return buf;

}

static noinline_for_stack

char *put_dec(char *buf, unsigned long long n)

{

		if (n >= 100*1000*1000)

		buf = put_dec_full8(buf, do_div(n, 100*1000*1000));

	/* 1 <= n <= 1.6e11 */

	if (n >= 100*1000*1000)

		buf = put_dec_full8(buf, do_div(n, 100*1000*1000));

	/* 1 <= n < 1e8 */

	return put_dec_trunc8(buf, n);

}

#elif BITS_PER_LONG == 32 && BITS_PER_LONG_LONG == 64

static void

put_dec_full4(char *buf, unsigned r)

{

	unsigned q;

	/* 0 <= r < 10^4 */

	q = (r * 0x147b) >> 19;

	*((u16 *)buf) = decpair[r - 100*q];

	buf += 2;

	/* 0 <= q < 100 */

	*((u16 *)buf) = decpair[q];

}

/*

 * 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.

 * (second call in the put_dec code, assuming n is all-ones).

 */

static noinline_for_stack

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

 * 

 * (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)

{

	uint32_t d3, d2, d1, q, h;

	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" */

	/* n = 2^48 d3 + 2^32 d2 + 2^16 d1 + d0

	     = 281_4749_7671_0656 d3 + 42_9496_7296 d2 + 6_5536 d1 + d0 */

	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;

	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)

{

	/* put_dec requires 2-byte alignment of the buffer. */

	char tmp[sizeof(num) * 3] __aligned(2);

	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;

	}

	if (len > size)

		return 0;

	for (idx = 0; idx < len; ++idx)

		buf[idx] = tmp[len - idx - 1];

	return len;

}

#define SIGN	1		/* unsigned/signed, must be 1 */

#define LEFT	2		/* left justified */

#define PLUS	4		/* show plus */

#define SPACE	8		/* space if plus */

#define ZEROPAD	16		/* pad with zero, must be 16 == '0' - ' ' */

#define SMALL	32		/* use lowercase in hex (must be 32 == 0x20) */

#define SPECIAL	64		/* prefix hex with "0x", octal with "0" */

enum format_type {

	FORMAT_TYPE_NONE, /* Just a string part */

	FORMAT_TYPE_WIDTH,

	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_UBYTE,

	FORMAT_TYPE_BYTE,

	FORMAT_TYPE_USHORT,

	FORMAT_TYPE_SHORT,

	FORMAT_TYPE_UINT,

	FORMAT_TYPE_INT,

	FORMAT_TYPE_SIZE_T,

	FORMAT_TYPE_PTRDIFF

};

struct printf_spec {

	u8	type;		/* format_type enum */

	u8	flags;		/* flags to number() */

	u8	base;		/* number base, 8, 10 or 16 only */

	u8	qualifier;	/* number qualifier, one of 'hHlLtzZ' */

	s16	field_width;	/* width of output field */

	s16	precision;	/* # of digits/chars */

};

static noinline_for_stack

char *number(char *buf, char *end, unsigned long long num,

	     struct printf_spec spec)

{

	/* put_dec requires 2-byte alignment of the buffer. */

	char tmp[3 * sizeof(num)] __aligned(2);

	char sign;

	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 */

	locase = (spec.flags & SMALL);

	if (spec.flags & LEFT)

		spec.flags &= ~ZEROPAD;

	sign = 0;

	if (spec.flags & SIGN) {

		if ((signed long long)num < 0) {

			sign = '-';

			num = -(signed long long)num;

			spec.field_width--;

		} else if (spec.flags & PLUS) {

			sign = '+';

			spec.field_width--;

		} else if (spec.flags & SPACE) {

			sign = ' ';

			spec.field_width--;

		}

	}

	if (need_pfx) {

		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++] = hex_asc_upper[num] | locase;

	else if (spec.base != 10) { /* 8 or 16 */

		int mask = spec.base - 1;

		int shift = 3;

		if (spec.base == 16)

			shift = 4;

		do {

			tmp[i++] = (hex_asc_upper[((unsigned char)num) & mask] | locase);

			num >>= shift;

		} while (num);

	} else { /* base 10 */

		i = put_dec(tmp, num) - tmp;

	}

	/* printing 100 using %2d gives "100", not "00" */

	if (i > spec.precision)

		spec.precision = i;

	/* leading space padding */

	spec.field_width -= spec.precision;

	if (!(spec.flags & (ZEROPAD | LEFT))) {

		while (--spec.field_width >= 0) {

			if (buf < end)

				*buf = ' ';

			++buf;

		}

	}

	/* sign */

	if (sign) {

		if (buf < end)

			*buf = sign;

		++buf;

	}

	/* "0x" / "0" prefix */

	if (need_pfx) {

		if (spec.base == 16 || !is_zero) {

		if (buf < end)

			*buf = '0';

		++buf;

		}

		if (spec.base == 16) {

			if (buf < end)

				*buf = ('X' | locase);

			++buf;

		}

	}

	/* zero or space padding */

	if (!(spec.flags & LEFT)) {

		char c = ' ' + (spec.flags & ZEROPAD);

		BUILD_BUG_ON(' ' + ZEROPAD != '0');

		while (--spec.field_width >= 0) {

			if (buf < end)

				*buf = c;

			++buf;

		}

	}

	/* hmm even more zero padding? */

	while (i <= --spec.precision) {

		if (buf < end)

			*buf = '0';

		++buf;

	}

	/* actual digits of result */

	while (--i >= 0) {

		if (buf < end)

			*buf = tmp[i];

		++buf;

	}

	/* trailing space padding */

	while (--spec.field_width >= 0) {

		if (buf < end)

			*buf = ' ';

		++buf;

	}

	return buf;

}

static noinline_for_stack

char *string(char *buf, char *end, const char *s, struct printf_spec spec)

{

	int len, i;

	if ((unsigned long)s < PAGE_SIZE)

		s = "(null)";

	len = strnlen(s, spec.precision);

	if (!(spec.flags & LEFT)) {

		while (len < spec.field_width--) {

			if (buf < end)

				*buf = ' ';

			++buf;

		}

	}

	for (i = 0; i < len; ++i) {

		if (buf < end)

			*buf = *s;

		++buf; ++s;

	}

	while (len < spec.field_width--) {

		if (buf < end)

			*buf = ' ';

		++buf;

	}

	return buf;

}

static noinline_for_stack

char *symbol_string(char *buf, char *end, void *ptr,

		    struct printf_spec spec, const char *fmt)

{

	unsigned long value;

#ifdef CONFIG_KALLSYMS

	char sym[KSYM_SYMBOL_LEN];

#endif

	if (fmt[1] == 'R')

		ptr = __builtin_extract_return_addr(ptr);

	value = (unsigned long)ptr;

#ifdef CONFIG_KALLSYMS

	if (*fmt == 'B')

		sprint_backtrace(sym, value);

	else if (*fmt != 'f' && *fmt != 's')

		sprint_symbol(sym, value);

	else

		sprint_symbol_no_offset(sym, value);

	return string(buf, end, sym, spec);

#else

	spec.field_width = 2 * sizeof(void *);

	spec.flags |= SPECIAL | SMALL | ZEROPAD;

	spec.base = 16;

	return number(buf, end, value, spec);

#endif

}

static noinline_for_stack

char *resource_string(char *buf, char *end, struct resource *res,

		      struct printf_spec spec, const char *fmt)

{

#ifndef IO_RSRC_PRINTK_SIZE

#define IO_RSRC_PRINTK_SIZE	6

#endif

#ifndef MEM_RSRC_PRINTK_SIZE

#define MEM_RSRC_PRINTK_SIZE	10

#endif

	static const struct printf_spec io_spec = {

		.base = 16,

		.field_width = IO_RSRC_PRINTK_SIZE,

		.precision = -1,

		.flags = SPECIAL | SMALL | ZEROPAD,

	};

	static const struct printf_spec mem_spec = {

		.base = 16,

		.field_width = MEM_RSRC_PRINTK_SIZE,

		.precision = -1,

		.flags = SPECIAL | SMALL | ZEROPAD,

	};

	static const struct printf_spec bus_spec = {

		.base = 16,

		.field_width = 2,

		.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) */

#define RSRC_BUF_SIZE		((2 * sizeof(resource_size_t)) + 4)

#define FLAG_BUF_SIZE		(2 * sizeof(res->flags))

#define DECODED_BUF_SIZE	sizeof("[mem - 64bit pref window disabled]")

#define RAW_BUF_SIZE		sizeof("[mem - flags 0x]")

	char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,

		     2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];

	char *p = sym, *pend = sym + sizeof(sym);

	int decode = (fmt[0] == 'R') ? 1 : 0;

	const struct printf_spec *specp;

	*p++ = '[';

	if (res->flags & IORESOURCE_IO) {

		p = string(p, pend, "io  ", str_spec);

		specp = &io_spec;

	} else if (res->flags & IORESOURCE_MEM) {

		p = string(p, pend, "mem ", str_spec);

		specp = &mem_spec;

	} else if (res->flags & IORESOURCE_IRQ) {

		p = string(p, pend, "irq ", str_spec);

		specp = &dec_spec;

	} else if (res->flags & IORESOURCE_DMA) {

		p = string(p, pend, "dma ", str_spec);

		specp = &dec_spec;

	} else if (res->flags & IORESOURCE_BUS) {

		p = string(p, pend, "bus ", str_spec);

		specp = &bus_spec;

	} else {

		p = string(p, pend, "??? ", str_spec);

		specp = &mem_spec;

		decode = 0;

	}

	if (decode && res->flags & IORESOURCE_UNSET) {

		p = string(p, pend, "size ", str_spec);

		p = number(p, pend, resource_size(res), *specp);

	} else {

	p = number(p, pend, res->start, *specp);

	if (res->start != res->end) {

		*p++ = '-';

		p = number(p, pend, res->end, *specp);

		}

	}

	if (decode) {

		if (res->flags & IORESOURCE_MEM_64)

			p = string(p, pend, " 64bit", str_spec);

		if (res->flags & IORESOURCE_PREFETCH)

			p = string(p, pend, " pref", str_spec);

		if (res->flags & IORESOURCE_WINDOW)

			p = string(p, pend, " window", str_spec);

		if (res->flags & IORESOURCE_DISABLED)

			p = string(p, pend, " disabled", str_spec);

	} else {

		p = string(p, pend, " flags ", str_spec);

		p = number(p, pend, res->flags, flag_spec);

	}

	*p++ = ']';

	*p = '\0';

	return string(buf, end, sym, spec);

}

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 width 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; ++i) {

		if (buf < end)

			*buf = hex_asc_hi(addr[i]);

		++buf;

		if (buf < end)

			*buf = hex_asc_lo(addr[i]);

		++buf;

		if (separator && i != len - 1) {

			if (buf < end)

				*buf = separator;

			++buf;

		}

	}

	return buf;

}

static noinline_for_stack

char *bitmap_string(char *buf, char *end, unsigned long *bitmap,

		    struct printf_spec spec, const char *fmt)

{

	const int CHUNKSZ = 32;

	int nr_bits = max_t(int, spec.field_width, 0);

	int i, chunksz;

	bool first = true;

	/* reused to print numbers */

	spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };

	chunksz = nr_bits & (CHUNKSZ - 1);

	if (chunksz == 0)

		chunksz = CHUNKSZ;

	i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ;

	for (; i >= 0; i -= CHUNKSZ) {

		u32 chunkmask, val;

		int word, bit;

		chunkmask = ((1ULL << chunksz) - 1);

		word = i / BITS_PER_LONG;

		bit = i % BITS_PER_LONG;

		val = (bitmap[word] >> bit) & chunkmask;

		if (!first) {

			if (buf < end)

				*buf = ',';

			buf++;

		}

		first = false;

		spec.field_width = DIV_ROUND_UP(chunksz, 4);

		buf = number(buf, end, val, spec);

		chunksz = CHUNKSZ;

	}

	return buf;

}

static noinline_for_stack

char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,

			 struct printf_spec spec, const char *fmt)

{

	int nr_bits = max_t(int, spec.field_width, 0);

	/* current bit is 'cur', most recently seen range is [rbot, rtop] */

	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;

		cur = find_next_bit(bitmap, nr_bits, cur + 1);

		if (cur < nr_bits && cur <= rtop + 1)

			continue;

		if (!first) {

			if (buf < end)

				*buf = ',';

			buf++;

		}

		first = false;

		buf = number(buf, end, rbot, spec);

		if (rbot < rtop) {

			if (buf < end)

				*buf = '-';

			buf++;

			buf = number(buf, end, rtop, spec);

	}

		rbot = cur;

	}

	return buf;

}

static noinline_for_stack

char *mac_address_string(char *buf, char *end, u8 *addr,

			 struct printf_spec spec, const char *fmt)

{

	char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];

	char *p = mac_addr;

	int i;

	char separator;

	bool reversed = false;

	switch (fmt[1]) {

	case 'F':

		separator = '-';

		break;

	case 'R':

		reversed = true;

		/* fall through */

	default:

		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]);

		if (fmt[0] == 'M' && i != 5)

			*p++ = separator;

	}

	*p = '\0';

	return string(buf, end, mac_addr, spec);

}

static noinline_for_stack

char *ip4_string(char *p, const u8 *addr, const char *fmt)

{

	int i;

	bool leading_zeros = (fmt[0] == 'i');

	int index;

	int step;

	switch (fmt[2]) {

	case 'h':

#ifdef __BIG_ENDIAN

		index = 0;

		step = 1;

#else

		index = 3;

		step = -1;

#endif

		break;

	case 'l':

		index = 3;

		step = -1;

		break;

	case 'n':

	case 'b':

	default:

		index = 0;

		step = 1;

		break;

	}

	for (i = 0; i < 4; i++) {

		char temp[4] __aligned(2);	/* hold each IP quad in reverse order */

		int digits = put_dec_trunc8(temp, addr[index]) - temp;

		if (leading_zeros) {

			if (digits < 3)

				*p++ = '0';

			if (digits < 2)

				*p++ = '0';

		}

		/* reverse the digits in the quad */

		while (digits--)

			*p++ = temp[digits];

		if (i < 3)

			*p++ = '.';

		index += step;

	}

	*p = '\0';

	return p;

}

static noinline_for_stack

char *ip4_addr_string(char *buf, char *end, const u8 *addr,

		      struct printf_spec spec, const char *fmt)

{

	char ip4_addr[sizeof("255.255.255.255")];

	ip4_string(ip4_addr, addr, fmt);

	return string(buf, end, ip4_addr, spec);

}

int kptr_restrict = 1;

/*

 * Show a '%p' thing.  A kernel extension is that the '%p' is followed

 * by an extra set of alphanumeric characters that are extended format

 * specifiers.

 *

 * 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

 * - '[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]

 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]

 * - 'b[l]' For a bitmap, the number of bits is determined by the field

 *       width which must be explicitly specified either as part of the

 *       format string '%32b[l]' or through '%*b[l]', [l] selects

 *       range-list format instead of hex format

 * - 'M' For a 6-byte MAC address, it prints the address in the

 *       usual colon-separated hex notation

 * - '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

 *       [S][pfs]

 *       Generic IPv4/IPv6 address (struct sockaddr *) that falls back to

 *       [4] or [6] and is able to print port [p], flowinfo [f], scope [s]

 * - 'i' [46] for 'raw' IPv4/IPv6 addresses

 *       IPv6 omits the colons (01020304...0f)

 *       IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)

 *       [S][pfs]

 *       Generic IPv4/IPv6 address (struct sockaddr *) that falls back to

 *       [4] or [6] and is able to print port [p], flowinfo [f], scope [s]

 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order

 * - 'I[6S]c' for IPv6 addresses printed as specified by

 *       http://tools.ietf.org/html/rfc5952

 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination

 *                of the following flags (see string_escape_mem() for the

 *                details):

 *                  a - ESCAPE_ANY

 *                  c - ESCAPE_SPECIAL

 *                  h - ESCAPE_HEX

 *                  n - ESCAPE_NULL

 *                  o - ESCAPE_OCTAL

 *                  p - ESCAPE_NP

 *                  s - ESCAPE_SPACE

 *                By default ESCAPE_ANY_NP is used.

 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form

 *       "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

 *       Options for %pU are:

 *         b big endian lower case hex (default)

 *         B big endian UPPER case hex

 *         l little endian lower case hex

 *         L little endian UPPER case hex

 *           big endian output byte order is:

 *             [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]

 *           little endian output byte order is:

 *             [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]

 * - 'V' For a struct va_format which contains a format string * and va_list *,

 *       call vsnprintf(->format, *->va_list).

 *       Implements a "recursive vsnprintf".

 *       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.

 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives

 *           (default assumed to be phys_addr_t, passed by reference)

 * - 'd[234]' For a dentry name (optionally 2-4 last components)

 * - 'D[234]' Same as 'd' but for a struct file

 * - 'C' For a clock, it prints the name (Common Clock Framework) or address

 *       (legacy clock framework) of the clock

 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address

 *        (legacy clock framework) of the clock

 * - 'Cr' For a clock, it prints the current rate of the clock

 *

 * 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.

 */

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;

		return string(buf, end, "(null)", spec);

	}