2171 lines · 51.0 KB · C
RawDownload
{	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_stackchar *symbol_string(char *buf, char *end, void *ptr,		    struct printf_spec spec, char ext){	unsigned long value = (unsigned long) ptr;#ifdef CONFIG_KALLSYMS	char sym[KSYM_SYMBOL_LEN];	if (ext == 'B')		sprint_backtrace(sym, value);	else if (ext != 'f' && ext != '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_stackchar *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;	}	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_stackchar *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; 	if (fmt[1] == 'F') {		/* FDDI canonical format */		separator = '-';	} else {		separator = ':';	} 	for (i = 0; i < 6; i++) {		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_stackchar *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[3];	/* 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_stackchar *ip6_compressed_string(char *p, const char *addr){	int i, j, range;	unsigned char zerolength[8];	int longest = 1;	int colonpos = -1;	u16 word;	u8 hi, lo;	bool needcolon = false;	bool useIPv4;	struct in6_addr in6; 	memcpy(&in6, addr, sizeof(struct in6_addr)); 	useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 	memset(zerolength, 0, sizeof(zerolength)); 	if (useIPv4)		range = 6;	else		range = 8; 	/* find position of longest 0 run */	for (i = 0; i < range; i++) {		for (j = i; j < range; j++) {			if (in6.s6_addr16[j] != 0)				break;			zerolength[i]++;		}	}	for (i = 0; i < range; i++) {		if (zerolength[i] > longest) {			longest = zerolength[i];			colonpos = i;		}	}	if (longest == 1)		/* don't compress a single 0 */		colonpos = -1; 	/* emit address */	for (i = 0; i < range; i++) {		if (i == colonpos) {			if (needcolon || i == 0)				*p++ = ':';			*p++ = ':';			needcolon = false;			i += longest - 1;			continue;		}		if (needcolon) {			*p++ = ':';			needcolon = false;		}		/* hex u16 without leading 0s */		word = ntohs(in6.s6_addr16[i]);		hi = word >> 8;		lo = word & 0xff;		if (hi) {			if (hi > 0x0f)				p = hex_byte_pack(p, hi);			else				*p++ = hex_asc_lo(hi);			p = hex_byte_pack(p, lo);		}		else if (lo > 0x0f)			p = hex_byte_pack(p, lo);		else			*p++ = hex_asc_lo(lo);		needcolon = true;	} 	if (useIPv4) {		if (needcolon)			*p++ = ':';		p = ip4_string(p, &in6.s6_addr[12], "I4");	}	*p = '\0'; 	return p;} static noinline_for_stackchar *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++);		if (fmt[0] == 'I' && i != 7)			*p++ = ':';	}	*p = '\0'; 	return p;} static noinline_for_stackchar *ip6_addr_string(char *buf, char *end, const u8 *addr,		      struct printf_spec spec, const char *fmt){	char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 	if (fmt[0] == 'I' && fmt[2] == 'c')		ip6_compressed_string(ip6_addr, addr);	else		ip6_string(ip6_addr, addr, fmt); 	return string(buf, end, ip6_addr, spec);} static noinline_for_stackchar *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);} static noinline_for_stackchar *uuid_string(char *buf, char *end, const u8 *addr,		  struct printf_spec spec, const char *fmt){	char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];	char *p = uuid;	int i;	static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};	static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};	const u8 *index = be;	bool uc = false; 	switch (*(++fmt)) {	case 'L':		uc = true;		/* fall-through */	case 'l':		index = le;		break;	case 'B':		uc = true;		break;	} 	for (i = 0; i < 16; i++) {		p = hex_byte_pack(p, addr[index[i]]);		switch (i) {		case 3:		case 5:		case 7:		case 9:			*p++ = '-';			break;		}	} 	*p = 0; 	if (uc) {		p = uuid;		do {			*p = toupper(*p);		} while (*(++p));	} 	return string(buf, end, uuid, spec);} staticchar *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; /* * 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 * - '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] * - '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 * - '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 * - '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) * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order * - 'I6c' for IPv6 addresses printed as specified by *       http://tools.ietf.org/html/rfc5952 * - '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 * * 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_stackchar *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);	} 	switch (*fmt) {	case 'F':	case 'f':		ptr = dereference_function_descriptor(ptr);		/* Fallthrough */	case 'S':	case 's':	case 'B':		return symbol_string(buf, end, ptr, spec, *fmt);	case 'R':	case 'r':		return resource_string(buf, end, ptr, spec, fmt);	case 'M':			/* Colon separated: 00:01:02:03:04:05 */	case 'm':			/* Contiguous: 000102030405 */					/* [mM]F (FDDI, bit reversed) */		return mac_address_string(buf, end, ptr, spec, fmt);	case 'I':			/* Formatted IP supported

Lines 501–1000 of 2171. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t