/* *  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 <crutcher+kernel@datastacks.com> * - changed to provide snprintf and vsnprintf functions * So Feb  1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de> * - scnprintf and vscnprintf */ #include <stdarg.h>#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/uaccess.h>#include <linux/ioport.h> #include <asm/page.h>		/* for PAGE_SIZE */#include <asm/div64.h>#include <asm/sections.h>	/* for dereference_function_descriptor() */ /* Works only for digits and letters, but small and fast */#define TOLOWER(x) ((x) | 0x20) 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_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 */unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base){	unsigned long result = 0; 	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;	return result;}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 */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_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 */unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base){	unsigned long long result = 0; 	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;	return result;}EXPORT_SYMBOL(simple_strtoull); /** * 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 */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);} /** * strict_strtoul - convert a string to an unsigned long strictly * @cp: The string to be converted * @base: The number base to use * @res: The converted result value * * strict_strtoul converts a string to an unsigned long only if the * string is really an unsigned long string, any string containing * any invalid char at the tail will be rejected and -EINVAL is returned, * only a newline char at the tail is acceptible because people generally * change a module parameter in the following way: * * 	echo 1024 > /sys/module/e1000/parameters/copybreak * * echo will append a newline to the tail. * * It returns 0 if conversion is successful and *res is set to the converted * value, otherwise it returns -EINVAL and *res is set to 0. * * simple_strtoul just ignores the successive invalid characters and * return the converted value of prefix part of the string. */int strict_strtoul(const char *cp, unsigned int base, unsigned long *res){	char *tail;	unsigned long val;	size_t len; 	*res = 0;	len = strlen(cp);	if (len == 0)		return -EINVAL; 	val = simple_strtoul(cp, &tail, base);	if (tail == cp)		return -EINVAL;	if ((*tail == '\0') ||		((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {		*res = val;		return 0;	} 	return -EINVAL;}EXPORT_SYMBOL(strict_strtoul); /** * strict_strtol - convert a string to a long strictly * @cp: The string to be converted * @base: The number base to use * @res: The converted result value * * strict_strtol is similiar to strict_strtoul, but it allows the first * character of a string is '-'. * * It returns 0 if conversion is successful and *res is set to the converted * value, otherwise it returns -EINVAL and *res is set to 0. */int strict_strtol(const char *cp, unsigned int base, long *res){	int ret;	if (*cp == '-') {		ret = strict_strtoul(cp + 1, base, (unsigned long *)res);		if (!ret)			*res = -(*res);	} else {		ret = strict_strtoul(cp, base, (unsigned long *)res);	} 	return ret;}EXPORT_SYMBOL(strict_strtol); /** * strict_strtoull - convert a string to an unsigned long long strictly * @cp: The string to be converted * @base: The number base to use * @res: The converted result value * * strict_strtoull converts a string to an unsigned long long only if the * string is really an unsigned long long string, any string containing * any invalid char at the tail will be rejected and -EINVAL is returned, * only a newline char at the tail is acceptible because people generally * change a module parameter in the following way: * * 	echo 1024 > /sys/module/e1000/parameters/copybreak * * echo will append a newline to the tail of the string. * * It returns 0 if conversion is successful and *res is set to the converted * value, otherwise it returns -EINVAL and *res is set to 0. * * simple_strtoull just ignores the successive invalid characters and * return the converted value of prefix part of the string. */int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res){	char *tail;	unsigned long long val;	size_t len; 	*res = 0;	len = strlen(cp);	if (len == 0)		return -EINVAL; 	val = simple_strtoull(cp, &tail, base);	if (tail == cp)		return -EINVAL;	if ((*tail == '\0') ||		((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {		*res = val;		return 0;	} 	return -EINVAL;}EXPORT_SYMBOL(strict_strtoull); /** * strict_strtoll - convert a string to a long long strictly * @cp: The string to be converted * @base: The number base to use * @res: The converted result value * * strict_strtoll is similiar to strict_strtoull, but it allows the first * character of a string is '-'. * * It returns 0 if conversion is successful and *res is set to the converted * value, otherwise it returns -EINVAL and *res is set to 0. */int strict_strtoll(const char *cp, unsigned int base, long long *res){	int ret;	if (*cp == '-') {		ret = strict_strtoull(cp + 1, base, (unsigned long long *)res);		if (!ret)			*res = -(*res);	} else {		ret = strict_strtoull(cp, base, (unsigned long long *)res);	} 	return ret;}EXPORT_SYMBOL(strict_strtoll); static int skip_atoi(const char **s){	int i=0; 	while (isdigit(**s))		i = i*10 + *((*s)++) - '0';	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 * using code from * http://www.cs.uiowa.edu/~jones/bcd/decimal.html * (with permission from the author, Douglas W. Jones). */ /* 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 char* put_dec_trunc(char *buf, unsigned q){	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 */			}		}	}	return buf;}/* Same with if's removed. Always emits five digits */static char* put_dec_full(char *buf, unsigned q){	/* 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); 	/* 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;}/* No inlining helps gcc to use registers better */static noinline char* put_dec(char *buf, unsigned long long num){	while (1) {		unsigned rem;		if (num < 100000)			return put_dec_trunc(buf, num);		rem = do_div(num, 100000);		buf = put_dec_full(buf, rem);	}} #define ZEROPAD	1		/* pad with zero */#define SIGN	2		/* unsigned/signed long */#define PLUS	4		/* show plus */#define SPACE	8		/* space if plus */#define LEFT	16		/* left justified */#define SMALL	32		/* Must be 32 == 0x20 */#define SPECIAL	64		/* 0x */ static char *number(char *buf, char *end, unsigned long long num, int base, int size, int precision, int type){	/* we are called with base 8, 10 or 16, only, thus don't need "G..."  */	static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ 	char tmp[66];	char sign;	char locase;	int need_pfx = ((type & SPECIAL) && base != 10);	int i; 	/* locase = 0 or 0x20. ORing digits or letters with 'locase'	 * produces same digits or (maybe lowercased) letters */	locase = (type & SMALL);	if (type & LEFT)		type &= ~ZEROPAD;	sign = 0;	if (type & SIGN) {		if ((signed long long) num < 0) {			sign = '-';			num = - (signed long long) num;			size--;		} else if (type & PLUS) {			sign = '+';			size--;		} else if (type & SPACE) {			sign = ' ';			size--;		}	}	if (need_pfx) {		size--;		if (base == 16)			size--;	} 	/* generate full string in tmp[], in reverse order */	i = 0;	if (num == 0)		tmp[i++] = '0';	/* Generic code, for any base:	else do {		tmp[i++] = (digits[do_div(num,base)] | locase);	} while (num != 0);	*/	else if (base != 10) { /* 8 or 16 */		int mask = base - 1;		int shift = 3;		if (base == 16) shift = 4;		do {			tmp[i++] = (digits[((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 > precision)		precision = i;	/* leading space padding */	size -= precision;	if (!(type & (ZEROPAD+LEFT))) {		while(--size >= 0) {			if (buf < end)				*buf = ' ';			++buf;		}	}	/* sign */	if (sign) {		if (buf < end)			*buf = sign;		++buf;	}	/* "0x" / "0" prefix */	if (need_pfx) {		if (buf < end)			*buf = '0';		++buf;		if (base == 16) {			if (buf < end)				*buf = ('X' | locase);			++buf;		}	}	/* zero or space padding */	if (!(type & LEFT)) {		char c = (type & ZEROPAD) ? '0' : ' ';		while (--size >= 0) {			if (buf < end)				*buf = c;			++buf;		}	}	/* hmm even more zero padding? */	while (i <= --precision) {		if (buf < end)			*buf = '0';		++buf;	}	/* actual digits of result */

Lines 1–500 of 1305. Load more