/* * printk.c * * printk for vivi * * Based from linux/include/asm-arm/div64.h linux/lib/vsprintf.c  *            linux/kernel/printk.c  * * Author: Yong-iL Joh <tolkien@mizi.com> * Date  : $Date: 2004/02/04 06:22:25 $  * * $Revision: 1.1.1.1 $ */#include <config.h>#include <stdarg.h>#include <types.h>#include <string.h>#include <ctype.h>#ifdef CONFIG_SERIAL#include <serial.h>#endif#ifdef CONFIG_SERIAL#define PUTC(x)		putc(x)#else#define PUTC(x)#endif/* We're not 64-bit, but... */#define do_div(n,base)						\({								\	int __res;						\	__res = ((unsigned long)n) % (unsigned int)base;	\	n = ((unsigned long)n) / (unsigned int)base;		\	__res;							\})static int skip_atoi(const char **s){	int i=0;	while (isdigit(**s))		i = i*10 + *((*s)++) - '0';	return i;}/** strnlen - Find the length of a length-limited string* @s: The string to be sized* @count: The maximum number of bytes to search*/size_t strnlen(const char * s, size_t count){	const char *sc;	for (sc = s; count-- && *sc != '\0'; ++sc)		/* nothing */;	return sc - s; }#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 SPECIAL	32		/* 0x */#define LARGE	64		/* use 'ABCDEF' instead of 'abcdef' */static char * number(char * buf, char * end, long long num, int base, int size, int precision, int type){	char c,sign,tmp[66];	const char *digits;	const char small_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";	const char large_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";	int i;	digits = (type & LARGE) ? large_digits : small_digits;	if (type & LEFT)		type &= ~ZEROPAD;	if (base < 2 || base > 36)		return 0;	c = (type & ZEROPAD) ? '0' : ' ';	sign = 0;	if (type & SIGN) {		if (num < 0) {			sign = '-';			num = -num;			size--;		} else if (type & PLUS) {			sign = '+';			size--;		} else if (type & SPACE) {			sign = ' ';			size--;		}	}	if (type & SPECIAL) {		if (base == 16)			size -= 2;		else if (base == 8)			size--;	}	i = 0;	if (num == 0)		tmp[i++]='0';	else while (num != 0)		tmp[i++] = digits[do_div(num,base)];	if (i > precision)		precision = i;	size -= precision;	if (!(type&(ZEROPAD+LEFT))) {		while(size-->0) {			if (buf <= end)				*buf = ' ';			++buf;		}	}	if (sign) {		if (buf <= end)			*buf = sign;		++buf;	}	if (type & SPECIAL) {		if (base==8) {			if (buf <= end)				*buf = '0';			++buf;		} else if (base==16) {			if (buf <= end)				*buf = '0';			++buf;			if (buf <= end)				*buf = digits[33];			++buf;		}	}	if (!(type & LEFT)) {		while (size-- > 0) {			if (buf <= end)				*buf = c;			++buf;		}	}	while (i < precision--) {		if (buf <= end)			*buf = '0';		++buf;	}	while (i-- > 0) {		if (buf <= end)			*buf = tmp[i];		++buf;	}	while (size-- > 0) {		if (buf <= end)			*buf = ' ';		++buf;	}	return buf;}/*** vsnprintf - Format a string 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* @args: Arguments for the format string** Call this function if you are already dealing with a va_list.* You probably want snprintf instead. */int vsnprintf(char *buf, size_t size, const char *fmt, va_list args){	int len;	unsigned long long num;	int i, base;	char *str, *end, c;	const char *s;	int flags;		/* flags to number() */	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 */	str = buf;	end = buf + size - 1;	if (end < buf - 1) {		end = ((void *) -1);		size = end - buf + 1;	}	for (; *fmt ; ++fmt) {		if (*fmt != '%') {			if (str <= end)				*str = *fmt;			++str;			continue;		}		/* process flags */		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 */		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 */		precision = -1;		if (*fmt == '.') {			++fmt;				if (isdigit(*fmt))				precision = skip_atoi(&fmt);			else if (*fmt == '*') {				++fmt;				/* it's the next argument */				precision = va_arg(args, int);			}			if (precision < 0)				precision = 0;		}		/* get the conversion qualifier */		qualifier = -1;		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt =='Z') {			qualifier = *fmt;			++fmt;			if (qualifier == 'l' && *fmt == 'l') {				qualifier = 'L';				++fmt;			}		}		/* default base */		base = 10;		switch (*fmt) {			case 'c':				if (!(flags & LEFT)) {					while (--field_width > 0) {						if (str <= end)							*str = ' ';						++str;					}				}				c = (unsigned char) va_arg(args, int);				if (str <= end)					*str = c;				++str;				while (--field_width > 0) {					if (str <= end)						*str = ' ';					++str;				}				continue;			case 's':				s = va_arg(args, char *);				if (!s)					s = "<NULL>";				len = strnlen(s, precision);				if (!(flags & LEFT)) {					while (len < field_width--) {						if (str <= end)							*str = ' ';						++str;					}				}				for (i = 0; i < len; ++i) {					if (str <= end)						*str = *s;					++str; ++s;				}				while (len < field_width--) {					if (str <= end)						*str = ' ';					++str;				}				continue;			case 'p':				if (field_width == -1) {					field_width = 2*sizeof(void *);					flags |= ZEROPAD;				}				str = number(str, end,						(unsigned long) va_arg(args, void *),						16, field_width, precision, flags);				continue;			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') {					size_t * ip = va_arg(args, size_t *);					*ip = (str - buf);				} else {					int * ip = va_arg(args, int *);					*ip = (str - buf);				}				continue;			case '%':				if (str <= end)					*str = '%';				++str;				continue;				/* integer number formats - set up the flags and "break" */			case 'o':				base = 8;				break;			case 'X':				flags |= LARGE;			case 'x':				base = 16;				break;			case 'd':			case 'i':				flags |= SIGN;			case 'u':				break;			default:				if (str <= end)					*str = '%';				++str;				if (*fmt) {					if (str <= end)						*str = *fmt;					++str;				} else {					--fmt;				}				continue;		}		if (qualifier == 'L')			num = va_arg(args, long long);		else if (qualifier == 'l') {			num = va_arg(args, unsigned long);			if (flags & SIGN)				num = (signed long) num;		} else if (qualifier == 'Z') {			num = va_arg(args, size_t);		} else if (qualifier == 'h') {			num = (unsigned short) va_arg(args, int);			if (flags & SIGN)				num = (signed short) num;		} else {			num = va_arg(args, unsigned int);			if (flags & SIGN)				num = (signed int) num;		}		str = number(str, end, num, base,				field_width, precision, flags);	}	if (str <= end)		*str = '\0';	else if (size > 0)		/* don't write out a null byte if the buf size is zero */		*end = '\0';	/* the trailing null byte doesn't count towards the total	* ++str;	*/	return str-buf;}/* * This is printk.  It can be called from any context.  We want it to work. *  * We try to grab the console_sem.  If we succeed, it's easy - we log the output and * call the console drivers.  If we fail to get the semaphore we place the output * into the log buffer and return.  The current holder of the console_sem will * notice the new output in release_console_sem() and will send it to the * consoles before releasing the semaphore. * * One effect of this deferred printing is that code which calls printk() and * then changes console_loglevel may break. This is because console_loglevel * is inspected when the actual printing occurs. */int printk(const char *fmt, ...){	va_list args;	int printed_len;	char *p;	static char printk_buf[1024];	/* Emit the output into the temporary buffer */	va_start(args, fmt);	printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);	va_end(args);	/*	 * Copy the output into log_buf.  If the caller didn't provide	 * appropriate log level tags, we insert them here	 */	for (p = printk_buf; *p; p++) {		if (*p == '\n')			PUTC('\r');		PUTC(*p);	}	return printed_len;}