11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/lib/vsprintf.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds 51da177e4SLinus Torvalds */ 61da177e4SLinus Torvalds 71da177e4SLinus Torvalds /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */ 81da177e4SLinus Torvalds /* 91da177e4SLinus Torvalds * Wirzenius wrote this portably, Torvalds fucked it up :-) 101da177e4SLinus Torvalds */ 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds /* 131da177e4SLinus Torvalds * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com> 141da177e4SLinus Torvalds * - changed to provide snprintf and vsnprintf functions 151da177e4SLinus Torvalds * So Feb 1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de> 161da177e4SLinus Torvalds * - scnprintf and vscnprintf 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds #include <stdarg.h> 200d1d7a55SStephen Boyd #include <linux/clk.h> 21900cca29SGeert Uytterhoeven #include <linux/clk-provider.h> 228bc3bcc9SPaul Gortmaker #include <linux/module.h> /* for KSYM_SYMBOL_LEN */ 231da177e4SLinus Torvalds #include <linux/types.h> 241da177e4SLinus Torvalds #include <linux/string.h> 251da177e4SLinus Torvalds #include <linux/ctype.h> 261da177e4SLinus Torvalds #include <linux/kernel.h> 270fe1ef24SLinus Torvalds #include <linux/kallsyms.h> 2853809751SJan Beulich #include <linux/math64.h> 290fe1ef24SLinus Torvalds #include <linux/uaccess.h> 30332d2e78SLinus Torvalds #include <linux/ioport.h> 314b6ccca7SAl Viro #include <linux/dcache.h> 32312b4e22SRyan Mallon #include <linux/cred.h> 332b1b0d66SAndy Shevchenko #include <linux/uuid.h> 34ce4fecf1SPantelis Antoniou #include <linux/of.h> 358a27f7c9SJoe Perches #include <net/addrconf.h> 36ad67b74dSTobin C. Harding #include <linux/siphash.h> 37ad67b74dSTobin C. Harding #include <linux/compiler.h> 381031bc58SDmitry Monakhov #ifdef CONFIG_BLOCK 391031bc58SDmitry Monakhov #include <linux/blkdev.h> 401031bc58SDmitry Monakhov #endif 411da177e4SLinus Torvalds 42edf14cdbSVlastimil Babka #include "../mm/internal.h" /* For the trace_print_flags arrays */ 43edf14cdbSVlastimil Babka 444e57b681STim Schmielau #include <asm/page.h> /* for PAGE_SIZE */ 457c43d9a3SRasmus Villemoes #include <asm/byteorder.h> /* cpu_to_le16 */ 461da177e4SLinus Torvalds 4771dca95dSAndy Shevchenko #include <linux/string_helpers.h> 481dff46d6SAlexey Dobriyan #include "kstrtox.h" 49aa46a63eSHarvey Harrison 501da177e4SLinus Torvalds /** 511da177e4SLinus Torvalds * simple_strtoull - convert a string to an unsigned long long 521da177e4SLinus Torvalds * @cp: The start of the string 531da177e4SLinus Torvalds * @endp: A pointer to the end of the parsed string will be placed here 541da177e4SLinus Torvalds * @base: The number base to use 55462e4711SEldad Zack * 56462e4711SEldad Zack * This function is obsolete. Please use kstrtoull instead. 571da177e4SLinus Torvalds */ 581da177e4SLinus Torvalds unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base) 591da177e4SLinus Torvalds { 601dff46d6SAlexey Dobriyan unsigned long long result; 611dff46d6SAlexey Dobriyan unsigned int rv; 621da177e4SLinus Torvalds 631dff46d6SAlexey Dobriyan cp = _parse_integer_fixup_radix(cp, &base); 641dff46d6SAlexey Dobriyan rv = _parse_integer(cp, base, &result); 651dff46d6SAlexey Dobriyan /* FIXME */ 661dff46d6SAlexey Dobriyan cp += (rv & ~KSTRTOX_OVERFLOW); 67aa46a63eSHarvey Harrison 681da177e4SLinus Torvalds if (endp) 691da177e4SLinus Torvalds *endp = (char *)cp; 707b9186f5SAndré Goddard Rosa 711da177e4SLinus Torvalds return result; 721da177e4SLinus Torvalds } 731da177e4SLinus Torvalds EXPORT_SYMBOL(simple_strtoull); 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /** 76922ac25cSAndré Goddard Rosa * simple_strtoul - convert a string to an unsigned long 77922ac25cSAndré Goddard Rosa * @cp: The start of the string 78922ac25cSAndré Goddard Rosa * @endp: A pointer to the end of the parsed string will be placed here 79922ac25cSAndré Goddard Rosa * @base: The number base to use 80462e4711SEldad Zack * 81462e4711SEldad Zack * This function is obsolete. Please use kstrtoul instead. 82922ac25cSAndré Goddard Rosa */ 83922ac25cSAndré Goddard Rosa unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base) 84922ac25cSAndré Goddard Rosa { 85922ac25cSAndré Goddard Rosa return simple_strtoull(cp, endp, base); 86922ac25cSAndré Goddard Rosa } 87922ac25cSAndré Goddard Rosa EXPORT_SYMBOL(simple_strtoul); 88922ac25cSAndré Goddard Rosa 89922ac25cSAndré Goddard Rosa /** 90922ac25cSAndré Goddard Rosa * simple_strtol - convert a string to a signed long 91922ac25cSAndré Goddard Rosa * @cp: The start of the string 92922ac25cSAndré Goddard Rosa * @endp: A pointer to the end of the parsed string will be placed here 93922ac25cSAndré Goddard Rosa * @base: The number base to use 94462e4711SEldad Zack * 95462e4711SEldad Zack * This function is obsolete. Please use kstrtol instead. 96922ac25cSAndré Goddard Rosa */ 97922ac25cSAndré Goddard Rosa long simple_strtol(const char *cp, char **endp, unsigned int base) 98922ac25cSAndré Goddard Rosa { 99922ac25cSAndré Goddard Rosa if (*cp == '-') 100922ac25cSAndré Goddard Rosa return -simple_strtoul(cp + 1, endp, base); 101922ac25cSAndré Goddard Rosa 102922ac25cSAndré Goddard Rosa return simple_strtoul(cp, endp, base); 103922ac25cSAndré Goddard Rosa } 104922ac25cSAndré Goddard Rosa EXPORT_SYMBOL(simple_strtol); 105922ac25cSAndré Goddard Rosa 106922ac25cSAndré Goddard Rosa /** 1071da177e4SLinus Torvalds * simple_strtoll - convert a string to a signed long long 1081da177e4SLinus Torvalds * @cp: The start of the string 1091da177e4SLinus Torvalds * @endp: A pointer to the end of the parsed string will be placed here 1101da177e4SLinus Torvalds * @base: The number base to use 111462e4711SEldad Zack * 112462e4711SEldad Zack * This function is obsolete. Please use kstrtoll instead. 1131da177e4SLinus Torvalds */ 1141da177e4SLinus Torvalds long long simple_strtoll(const char *cp, char **endp, unsigned int base) 1151da177e4SLinus Torvalds { 1161da177e4SLinus Torvalds if (*cp == '-') 1171da177e4SLinus Torvalds return -simple_strtoull(cp + 1, endp, base); 1187b9186f5SAndré Goddard Rosa 1191da177e4SLinus Torvalds return simple_strtoull(cp, endp, base); 1201da177e4SLinus Torvalds } 12198d5ce0dSHans Verkuil EXPORT_SYMBOL(simple_strtoll); 1221da177e4SLinus Torvalds 123cf3b429bSJoe Perches static noinline_for_stack 124cf3b429bSJoe Perches int skip_atoi(const char **s) 1251da177e4SLinus Torvalds { 1261da177e4SLinus Torvalds int i = 0; 1271da177e4SLinus Torvalds 12843e5b666SRasmus Villemoes do { 1291da177e4SLinus Torvalds i = i*10 + *((*s)++) - '0'; 13043e5b666SRasmus Villemoes } while (isdigit(**s)); 1317b9186f5SAndré Goddard Rosa 1321da177e4SLinus Torvalds return i; 1331da177e4SLinus Torvalds } 1341da177e4SLinus Torvalds 1357c43d9a3SRasmus Villemoes /* 1367c43d9a3SRasmus Villemoes * Decimal conversion is by far the most typical, and is used for 1377c43d9a3SRasmus Villemoes * /proc and /sys data. This directly impacts e.g. top performance 1387c43d9a3SRasmus Villemoes * with many processes running. We optimize it for speed by emitting 1397c43d9a3SRasmus Villemoes * two characters at a time, using a 200 byte lookup table. This 1407c43d9a3SRasmus Villemoes * roughly halves the number of multiplications compared to computing 1417c43d9a3SRasmus Villemoes * the digits one at a time. Implementation strongly inspired by the 1427c43d9a3SRasmus Villemoes * previous version, which in turn used ideas described at 1437c43d9a3SRasmus Villemoes * <http://www.cs.uiowa.edu/~jones/bcd/divide.html> (with permission 1447c43d9a3SRasmus Villemoes * from the author, Douglas W. Jones). 1457c43d9a3SRasmus Villemoes * 1467c43d9a3SRasmus Villemoes * It turns out there is precisely one 26 bit fixed-point 1477c43d9a3SRasmus Villemoes * approximation a of 64/100 for which x/100 == (x * (u64)a) >> 32 1487c43d9a3SRasmus Villemoes * holds for all x in [0, 10^8-1], namely a = 0x28f5c29. The actual 1497c43d9a3SRasmus Villemoes * range happens to be somewhat larger (x <= 1073741898), but that's 1507c43d9a3SRasmus Villemoes * irrelevant for our purpose. 1517c43d9a3SRasmus Villemoes * 1527c43d9a3SRasmus Villemoes * For dividing a number in the range [10^4, 10^6-1] by 100, we still 1537c43d9a3SRasmus Villemoes * need a 32x32->64 bit multiply, so we simply use the same constant. 1547c43d9a3SRasmus Villemoes * 1557c43d9a3SRasmus Villemoes * For dividing a number in the range [100, 10^4-1] by 100, there are 1567c43d9a3SRasmus Villemoes * several options. The simplest is (x * 0x147b) >> 19, which is valid 1577c43d9a3SRasmus Villemoes * for all x <= 43698. 158133fd9f5SDenys Vlasenko */ 1594277eeddSDenis Vlasenko 1607c43d9a3SRasmus Villemoes static const u16 decpair[100] = { 1617c43d9a3SRasmus Villemoes #define _(x) (__force u16) cpu_to_le16(((x % 10) | ((x / 10) << 8)) + 0x3030) 1627c43d9a3SRasmus Villemoes _( 0), _( 1), _( 2), _( 3), _( 4), _( 5), _( 6), _( 7), _( 8), _( 9), 1637c43d9a3SRasmus Villemoes _(10), _(11), _(12), _(13), _(14), _(15), _(16), _(17), _(18), _(19), 1647c43d9a3SRasmus Villemoes _(20), _(21), _(22), _(23), _(24), _(25), _(26), _(27), _(28), _(29), 1657c43d9a3SRasmus Villemoes _(30), _(31), _(32), _(33), _(34), _(35), _(36), _(37), _(38), _(39), 1667c43d9a3SRasmus Villemoes _(40), _(41), _(42), _(43), _(44), _(45), _(46), _(47), _(48), _(49), 1677c43d9a3SRasmus Villemoes _(50), _(51), _(52), _(53), _(54), _(55), _(56), _(57), _(58), _(59), 1687c43d9a3SRasmus Villemoes _(60), _(61), _(62), _(63), _(64), _(65), _(66), _(67), _(68), _(69), 1697c43d9a3SRasmus Villemoes _(70), _(71), _(72), _(73), _(74), _(75), _(76), _(77), _(78), _(79), 1707c43d9a3SRasmus Villemoes _(80), _(81), _(82), _(83), _(84), _(85), _(86), _(87), _(88), _(89), 1717c43d9a3SRasmus Villemoes _(90), _(91), _(92), _(93), _(94), _(95), _(96), _(97), _(98), _(99), 1727c43d9a3SRasmus Villemoes #undef _ 1737c43d9a3SRasmus Villemoes }; 1744277eeddSDenis Vlasenko 1757b9186f5SAndré Goddard Rosa /* 1767c43d9a3SRasmus Villemoes * This will print a single '0' even if r == 0, since we would 177675cf53cSRasmus Villemoes * immediately jump to out_r where two 0s would be written but only 178675cf53cSRasmus Villemoes * one of them accounted for in buf. This is needed by ip4_string 179675cf53cSRasmus Villemoes * below. All other callers pass a non-zero value of r. 180133fd9f5SDenys Vlasenko */ 181133fd9f5SDenys Vlasenko static noinline_for_stack 182133fd9f5SDenys Vlasenko char *put_dec_trunc8(char *buf, unsigned r) 183133fd9f5SDenys Vlasenko { 184133fd9f5SDenys Vlasenko unsigned q; 1854277eeddSDenis Vlasenko 1867c43d9a3SRasmus Villemoes /* 1 <= r < 10^8 */ 1877c43d9a3SRasmus Villemoes if (r < 100) 1887c43d9a3SRasmus Villemoes goto out_r; 189cb239d0aSGeorge Spelvin 1907c43d9a3SRasmus Villemoes /* 100 <= r < 10^8 */ 1917c43d9a3SRasmus Villemoes q = (r * (u64)0x28f5c29) >> 32; 1927c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[r - 100*q]; 1937c43d9a3SRasmus Villemoes buf += 2; 1947c43d9a3SRasmus Villemoes 1957c43d9a3SRasmus Villemoes /* 1 <= q < 10^6 */ 1967c43d9a3SRasmus Villemoes if (q < 100) 1977c43d9a3SRasmus Villemoes goto out_q; 1987c43d9a3SRasmus Villemoes 1997c43d9a3SRasmus Villemoes /* 100 <= q < 10^6 */ 2007c43d9a3SRasmus Villemoes r = (q * (u64)0x28f5c29) >> 32; 2017c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[q - 100*r]; 2027c43d9a3SRasmus Villemoes buf += 2; 2037c43d9a3SRasmus Villemoes 2047c43d9a3SRasmus Villemoes /* 1 <= r < 10^4 */ 2057c43d9a3SRasmus Villemoes if (r < 100) 2067c43d9a3SRasmus Villemoes goto out_r; 2077c43d9a3SRasmus Villemoes 2087c43d9a3SRasmus Villemoes /* 100 <= r < 10^4 */ 2097c43d9a3SRasmus Villemoes q = (r * 0x147b) >> 19; 2107c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[r - 100*q]; 2117c43d9a3SRasmus Villemoes buf += 2; 2127c43d9a3SRasmus Villemoes out_q: 2137c43d9a3SRasmus Villemoes /* 1 <= q < 100 */ 2147c43d9a3SRasmus Villemoes r = q; 2157c43d9a3SRasmus Villemoes out_r: 2167c43d9a3SRasmus Villemoes /* 1 <= r < 100 */ 2177c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[r]; 218675cf53cSRasmus Villemoes buf += r < 10 ? 1 : 2; 219133fd9f5SDenys Vlasenko return buf; 220133fd9f5SDenys Vlasenko } 221133fd9f5SDenys Vlasenko 2227c43d9a3SRasmus Villemoes #if BITS_PER_LONG == 64 && BITS_PER_LONG_LONG == 64 2237c43d9a3SRasmus Villemoes static noinline_for_stack 2247c43d9a3SRasmus Villemoes char *put_dec_full8(char *buf, unsigned r) 2257c43d9a3SRasmus Villemoes { 2267c43d9a3SRasmus Villemoes unsigned q; 227133fd9f5SDenys Vlasenko 2287c43d9a3SRasmus Villemoes /* 0 <= r < 10^8 */ 2297c43d9a3SRasmus Villemoes q = (r * (u64)0x28f5c29) >> 32; 2307c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[r - 100*q]; 2317c43d9a3SRasmus Villemoes buf += 2; 232133fd9f5SDenys Vlasenko 2337c43d9a3SRasmus Villemoes /* 0 <= q < 10^6 */ 2347c43d9a3SRasmus Villemoes r = (q * (u64)0x28f5c29) >> 32; 2357c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[q - 100*r]; 2367c43d9a3SRasmus Villemoes buf += 2; 237133fd9f5SDenys Vlasenko 2387c43d9a3SRasmus Villemoes /* 0 <= r < 10^4 */ 2397c43d9a3SRasmus Villemoes q = (r * 0x147b) >> 19; 2407c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[r - 100*q]; 2417c43d9a3SRasmus Villemoes buf += 2; 2427c43d9a3SRasmus Villemoes 2437c43d9a3SRasmus Villemoes /* 0 <= q < 100 */ 2447c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[q]; 2457c43d9a3SRasmus Villemoes buf += 2; 2467c43d9a3SRasmus Villemoes return buf; 2477c43d9a3SRasmus Villemoes } 2487c43d9a3SRasmus Villemoes 2497c43d9a3SRasmus Villemoes static noinline_for_stack 250133fd9f5SDenys Vlasenko char *put_dec(char *buf, unsigned long long n) 251133fd9f5SDenys Vlasenko { 252133fd9f5SDenys Vlasenko if (n >= 100*1000*1000) 2537c43d9a3SRasmus Villemoes buf = put_dec_full8(buf, do_div(n, 100*1000*1000)); 2547c43d9a3SRasmus Villemoes /* 1 <= n <= 1.6e11 */ 2557c43d9a3SRasmus Villemoes if (n >= 100*1000*1000) 2567c43d9a3SRasmus Villemoes buf = put_dec_full8(buf, do_div(n, 100*1000*1000)); 2577c43d9a3SRasmus Villemoes /* 1 <= n < 1e8 */ 258133fd9f5SDenys Vlasenko return put_dec_trunc8(buf, n); 259133fd9f5SDenys Vlasenko } 260133fd9f5SDenys Vlasenko 2617c43d9a3SRasmus Villemoes #elif BITS_PER_LONG == 32 && BITS_PER_LONG_LONG == 64 262133fd9f5SDenys Vlasenko 2637c43d9a3SRasmus Villemoes static void 2647c43d9a3SRasmus Villemoes put_dec_full4(char *buf, unsigned r) 265133fd9f5SDenys Vlasenko { 2667c43d9a3SRasmus Villemoes unsigned q; 2677c43d9a3SRasmus Villemoes 2687c43d9a3SRasmus Villemoes /* 0 <= r < 10^4 */ 2697c43d9a3SRasmus Villemoes q = (r * 0x147b) >> 19; 2707c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[r - 100*q]; 2717c43d9a3SRasmus Villemoes buf += 2; 2727c43d9a3SRasmus Villemoes /* 0 <= q < 100 */ 2737c43d9a3SRasmus Villemoes *((u16 *)buf) = decpair[q]; 2742359172aSGeorge Spelvin } 2752359172aSGeorge Spelvin 2762359172aSGeorge Spelvin /* 2772359172aSGeorge Spelvin * Call put_dec_full4 on x % 10000, return x / 10000. 2782359172aSGeorge Spelvin * The approximation x/10000 == (x * 0x346DC5D7) >> 43 2792359172aSGeorge Spelvin * holds for all x < 1,128,869,999. The largest value this 2802359172aSGeorge Spelvin * helper will ever be asked to convert is 1,125,520,955. 2817c43d9a3SRasmus Villemoes * (second call in the put_dec code, assuming n is all-ones). 2822359172aSGeorge Spelvin */ 2837c43d9a3SRasmus Villemoes static noinline_for_stack 2842359172aSGeorge Spelvin unsigned put_dec_helper4(char *buf, unsigned x) 2852359172aSGeorge Spelvin { 2862359172aSGeorge Spelvin uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43; 2872359172aSGeorge Spelvin 2882359172aSGeorge Spelvin put_dec_full4(buf, x - q * 10000); 2892359172aSGeorge Spelvin return q; 290133fd9f5SDenys Vlasenko } 291133fd9f5SDenys Vlasenko 292133fd9f5SDenys Vlasenko /* Based on code by Douglas W. Jones found at 293133fd9f5SDenys Vlasenko * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour> 294133fd9f5SDenys Vlasenko * (with permission from the author). 295133fd9f5SDenys Vlasenko * Performs no 64-bit division and hence should be fast on 32-bit machines. 296133fd9f5SDenys Vlasenko */ 297133fd9f5SDenys Vlasenko static 298133fd9f5SDenys Vlasenko char *put_dec(char *buf, unsigned long long n) 299133fd9f5SDenys Vlasenko { 300133fd9f5SDenys Vlasenko uint32_t d3, d2, d1, q, h; 301133fd9f5SDenys Vlasenko 302133fd9f5SDenys Vlasenko if (n < 100*1000*1000) 303133fd9f5SDenys Vlasenko return put_dec_trunc8(buf, n); 304133fd9f5SDenys Vlasenko 305133fd9f5SDenys Vlasenko d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */ 306133fd9f5SDenys Vlasenko h = (n >> 32); 307133fd9f5SDenys Vlasenko d2 = (h ) & 0xffff; 308133fd9f5SDenys Vlasenko d3 = (h >> 16); /* implicit "& 0xffff" */ 309133fd9f5SDenys Vlasenko 3107c43d9a3SRasmus Villemoes /* n = 2^48 d3 + 2^32 d2 + 2^16 d1 + d0 3117c43d9a3SRasmus Villemoes = 281_4749_7671_0656 d3 + 42_9496_7296 d2 + 6_5536 d1 + d0 */ 312133fd9f5SDenys Vlasenko q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff); 3132359172aSGeorge Spelvin q = put_dec_helper4(buf, q); 314133fd9f5SDenys Vlasenko 3152359172aSGeorge Spelvin q += 7671 * d3 + 9496 * d2 + 6 * d1; 3162359172aSGeorge Spelvin q = put_dec_helper4(buf+4, q); 317133fd9f5SDenys Vlasenko 3182359172aSGeorge Spelvin q += 4749 * d3 + 42 * d2; 3192359172aSGeorge Spelvin q = put_dec_helper4(buf+8, q); 320133fd9f5SDenys Vlasenko 3212359172aSGeorge Spelvin q += 281 * d3; 3222359172aSGeorge Spelvin buf += 12; 3232359172aSGeorge Spelvin if (q) 3242359172aSGeorge Spelvin buf = put_dec_trunc8(buf, q); 3252359172aSGeorge Spelvin else while (buf[-1] == '0') 326133fd9f5SDenys Vlasenko --buf; 3277b9186f5SAndré Goddard Rosa 3284277eeddSDenis Vlasenko return buf; 3294277eeddSDenis Vlasenko } 330133fd9f5SDenys Vlasenko 331133fd9f5SDenys Vlasenko #endif 3324277eeddSDenis Vlasenko 3331ac101a5SKAMEZAWA Hiroyuki /* 3341ac101a5SKAMEZAWA Hiroyuki * Convert passed number to decimal string. 3351ac101a5SKAMEZAWA Hiroyuki * Returns the length of string. On buffer overflow, returns 0. 3361ac101a5SKAMEZAWA Hiroyuki * 3371ac101a5SKAMEZAWA Hiroyuki * If speed is not important, use snprintf(). It's easy to read the code. 3381ac101a5SKAMEZAWA Hiroyuki */ 3391ac101a5SKAMEZAWA Hiroyuki int num_to_str(char *buf, int size, unsigned long long num) 3401ac101a5SKAMEZAWA Hiroyuki { 3417c43d9a3SRasmus Villemoes /* put_dec requires 2-byte alignment of the buffer. */ 3427c43d9a3SRasmus Villemoes char tmp[sizeof(num) * 3] __aligned(2); 3431ac101a5SKAMEZAWA Hiroyuki int idx, len; 3441ac101a5SKAMEZAWA Hiroyuki 345133fd9f5SDenys Vlasenko /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */ 346133fd9f5SDenys Vlasenko if (num <= 9) { 347133fd9f5SDenys Vlasenko tmp[0] = '0' + num; 348133fd9f5SDenys Vlasenko len = 1; 349133fd9f5SDenys Vlasenko } else { 3501ac101a5SKAMEZAWA Hiroyuki len = put_dec(tmp, num) - tmp; 351133fd9f5SDenys Vlasenko } 3521ac101a5SKAMEZAWA Hiroyuki 3531ac101a5SKAMEZAWA Hiroyuki if (len > size) 3541ac101a5SKAMEZAWA Hiroyuki return 0; 3551ac101a5SKAMEZAWA Hiroyuki for (idx = 0; idx < len; ++idx) 3561ac101a5SKAMEZAWA Hiroyuki buf[idx] = tmp[len - idx - 1]; 3571ac101a5SKAMEZAWA Hiroyuki return len; 3581ac101a5SKAMEZAWA Hiroyuki } 3591ac101a5SKAMEZAWA Hiroyuki 36051be17dfSRasmus Villemoes #define SIGN 1 /* unsigned/signed, must be 1 */ 361d1c1b121SRasmus Villemoes #define LEFT 2 /* left justified */ 3621da177e4SLinus Torvalds #define PLUS 4 /* show plus */ 3631da177e4SLinus Torvalds #define SPACE 8 /* space if plus */ 364d1c1b121SRasmus Villemoes #define ZEROPAD 16 /* pad with zero, must be 16 == '0' - ' ' */ 365b89dc5d6SBjorn Helgaas #define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */ 366b89dc5d6SBjorn Helgaas #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */ 3671da177e4SLinus Torvalds 368fef20d9cSFrederic Weisbecker enum format_type { 369fef20d9cSFrederic Weisbecker FORMAT_TYPE_NONE, /* Just a string part */ 370ed681a91SVegard Nossum FORMAT_TYPE_WIDTH, 371fef20d9cSFrederic Weisbecker FORMAT_TYPE_PRECISION, 372fef20d9cSFrederic Weisbecker FORMAT_TYPE_CHAR, 373fef20d9cSFrederic Weisbecker FORMAT_TYPE_STR, 374fef20d9cSFrederic Weisbecker FORMAT_TYPE_PTR, 375fef20d9cSFrederic Weisbecker FORMAT_TYPE_PERCENT_CHAR, 376fef20d9cSFrederic Weisbecker FORMAT_TYPE_INVALID, 377fef20d9cSFrederic Weisbecker FORMAT_TYPE_LONG_LONG, 378fef20d9cSFrederic Weisbecker FORMAT_TYPE_ULONG, 379fef20d9cSFrederic Weisbecker FORMAT_TYPE_LONG, 380a4e94ef0SZhaolei FORMAT_TYPE_UBYTE, 381a4e94ef0SZhaolei FORMAT_TYPE_BYTE, 382fef20d9cSFrederic Weisbecker FORMAT_TYPE_USHORT, 383fef20d9cSFrederic Weisbecker FORMAT_TYPE_SHORT, 384fef20d9cSFrederic Weisbecker FORMAT_TYPE_UINT, 385fef20d9cSFrederic Weisbecker FORMAT_TYPE_INT, 386fef20d9cSFrederic Weisbecker FORMAT_TYPE_SIZE_T, 387fef20d9cSFrederic Weisbecker FORMAT_TYPE_PTRDIFF 388fef20d9cSFrederic Weisbecker }; 389fef20d9cSFrederic Weisbecker 390fef20d9cSFrederic Weisbecker struct printf_spec { 391d0484193SRasmus Villemoes unsigned int type:8; /* format_type enum */ 392d0484193SRasmus Villemoes signed int field_width:24; /* width of output field */ 393d0484193SRasmus Villemoes unsigned int flags:8; /* flags to number() */ 394d0484193SRasmus Villemoes unsigned int base:8; /* number base, 8, 10 or 16 only */ 395d0484193SRasmus Villemoes signed int precision:16; /* # of digits/chars */ 396d0484193SRasmus Villemoes } __packed; 3974d72ba01SRasmus Villemoes #define FIELD_WIDTH_MAX ((1 << 23) - 1) 3984d72ba01SRasmus Villemoes #define PRECISION_MAX ((1 << 15) - 1) 399fef20d9cSFrederic Weisbecker 400cf3b429bSJoe Perches static noinline_for_stack 401cf3b429bSJoe Perches char *number(char *buf, char *end, unsigned long long num, 402fef20d9cSFrederic Weisbecker struct printf_spec spec) 4031da177e4SLinus Torvalds { 4047c43d9a3SRasmus Villemoes /* put_dec requires 2-byte alignment of the buffer. */ 4057c43d9a3SRasmus Villemoes char tmp[3 * sizeof(num)] __aligned(2); 4069b706aeeSDenys Vlasenko char sign; 4079b706aeeSDenys Vlasenko char locase; 408fef20d9cSFrederic Weisbecker int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10); 4091da177e4SLinus Torvalds int i; 4107c203422SPierre Carrier bool is_zero = num == 0LL; 4111c7a8e62SRasmus Villemoes int field_width = spec.field_width; 4121c7a8e62SRasmus Villemoes int precision = spec.precision; 4131da177e4SLinus Torvalds 414d0484193SRasmus Villemoes BUILD_BUG_ON(sizeof(struct printf_spec) != 8); 415d0484193SRasmus Villemoes 4169b706aeeSDenys Vlasenko /* locase = 0 or 0x20. ORing digits or letters with 'locase' 4179b706aeeSDenys Vlasenko * produces same digits or (maybe lowercased) letters */ 418fef20d9cSFrederic Weisbecker locase = (spec.flags & SMALL); 419fef20d9cSFrederic Weisbecker if (spec.flags & LEFT) 420fef20d9cSFrederic Weisbecker spec.flags &= ~ZEROPAD; 4211da177e4SLinus Torvalds sign = 0; 422fef20d9cSFrederic Weisbecker if (spec.flags & SIGN) { 4231da177e4SLinus Torvalds if ((signed long long)num < 0) { 4241da177e4SLinus Torvalds sign = '-'; 4251da177e4SLinus Torvalds num = -(signed long long)num; 4261c7a8e62SRasmus Villemoes field_width--; 427fef20d9cSFrederic Weisbecker } else if (spec.flags & PLUS) { 4281da177e4SLinus Torvalds sign = '+'; 4291c7a8e62SRasmus Villemoes field_width--; 430fef20d9cSFrederic Weisbecker } else if (spec.flags & SPACE) { 4311da177e4SLinus Torvalds sign = ' '; 4321c7a8e62SRasmus Villemoes field_width--; 4331da177e4SLinus Torvalds } 4341da177e4SLinus Torvalds } 435b39a7340SDenis Vlasenko if (need_pfx) { 436fef20d9cSFrederic Weisbecker if (spec.base == 16) 4371c7a8e62SRasmus Villemoes field_width -= 2; 4387c203422SPierre Carrier else if (!is_zero) 4391c7a8e62SRasmus Villemoes field_width--; 4401da177e4SLinus Torvalds } 441b39a7340SDenis Vlasenko 442b39a7340SDenis Vlasenko /* generate full string in tmp[], in reverse order */ 4431da177e4SLinus Torvalds i = 0; 444133fd9f5SDenys Vlasenko if (num < spec.base) 4453ea8d440SRasmus Villemoes tmp[i++] = hex_asc_upper[num] | locase; 446fef20d9cSFrederic Weisbecker else if (spec.base != 10) { /* 8 or 16 */ 447fef20d9cSFrederic Weisbecker int mask = spec.base - 1; 448b39a7340SDenis Vlasenko int shift = 3; 4497b9186f5SAndré Goddard Rosa 4507b9186f5SAndré Goddard Rosa if (spec.base == 16) 4517b9186f5SAndré Goddard Rosa shift = 4; 452b39a7340SDenis Vlasenko do { 4533ea8d440SRasmus Villemoes tmp[i++] = (hex_asc_upper[((unsigned char)num) & mask] | locase); 454b39a7340SDenis Vlasenko num >>= shift; 455b39a7340SDenis Vlasenko } while (num); 4564277eeddSDenis Vlasenko } else { /* base 10 */ 4574277eeddSDenis Vlasenko i = put_dec(tmp, num) - tmp; 4584277eeddSDenis Vlasenko } 459b39a7340SDenis Vlasenko 460b39a7340SDenis Vlasenko /* printing 100 using %2d gives "100", not "00" */ 4611c7a8e62SRasmus Villemoes if (i > precision) 4621c7a8e62SRasmus Villemoes precision = i; 463b39a7340SDenis Vlasenko /* leading space padding */ 4641c7a8e62SRasmus Villemoes field_width -= precision; 46551be17dfSRasmus Villemoes if (!(spec.flags & (ZEROPAD | LEFT))) { 4661c7a8e62SRasmus Villemoes while (--field_width >= 0) { 467f796937aSJeremy Fitzhardinge if (buf < end) 4681da177e4SLinus Torvalds *buf = ' '; 4691da177e4SLinus Torvalds ++buf; 4701da177e4SLinus Torvalds } 4711da177e4SLinus Torvalds } 472b39a7340SDenis Vlasenko /* sign */ 4731da177e4SLinus Torvalds if (sign) { 474f796937aSJeremy Fitzhardinge if (buf < end) 4751da177e4SLinus Torvalds *buf = sign; 4761da177e4SLinus Torvalds ++buf; 4771da177e4SLinus Torvalds } 478b39a7340SDenis Vlasenko /* "0x" / "0" prefix */ 479b39a7340SDenis Vlasenko if (need_pfx) { 4807c203422SPierre Carrier if (spec.base == 16 || !is_zero) { 481f796937aSJeremy Fitzhardinge if (buf < end) 4821da177e4SLinus Torvalds *buf = '0'; 4831da177e4SLinus Torvalds ++buf; 4847c203422SPierre Carrier } 485fef20d9cSFrederic Weisbecker if (spec.base == 16) { 486f796937aSJeremy Fitzhardinge if (buf < end) 4879b706aeeSDenys Vlasenko *buf = ('X' | locase); 4881da177e4SLinus Torvalds ++buf; 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds } 491b39a7340SDenis Vlasenko /* zero or space padding */ 492fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 493d1c1b121SRasmus Villemoes char c = ' ' + (spec.flags & ZEROPAD); 494d1c1b121SRasmus Villemoes BUILD_BUG_ON(' ' + ZEROPAD != '0'); 4951c7a8e62SRasmus Villemoes while (--field_width >= 0) { 496f796937aSJeremy Fitzhardinge if (buf < end) 4971da177e4SLinus Torvalds *buf = c; 4981da177e4SLinus Torvalds ++buf; 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds } 501b39a7340SDenis Vlasenko /* hmm even more zero padding? */ 5021c7a8e62SRasmus Villemoes while (i <= --precision) { 503f796937aSJeremy Fitzhardinge if (buf < end) 5041da177e4SLinus Torvalds *buf = '0'; 5051da177e4SLinus Torvalds ++buf; 5061da177e4SLinus Torvalds } 507b39a7340SDenis Vlasenko /* actual digits of result */ 508b39a7340SDenis Vlasenko while (--i >= 0) { 509f796937aSJeremy Fitzhardinge if (buf < end) 5101da177e4SLinus Torvalds *buf = tmp[i]; 5111da177e4SLinus Torvalds ++buf; 5121da177e4SLinus Torvalds } 513b39a7340SDenis Vlasenko /* trailing space padding */ 5141c7a8e62SRasmus Villemoes while (--field_width >= 0) { 515f796937aSJeremy Fitzhardinge if (buf < end) 5161da177e4SLinus Torvalds *buf = ' '; 5171da177e4SLinus Torvalds ++buf; 5181da177e4SLinus Torvalds } 5197b9186f5SAndré Goddard Rosa 5201da177e4SLinus Torvalds return buf; 5211da177e4SLinus Torvalds } 5221da177e4SLinus Torvalds 5233cab1e71SAndy Shevchenko static noinline_for_stack 5243cab1e71SAndy Shevchenko char *special_hex_number(char *buf, char *end, unsigned long long num, int size) 5253cab1e71SAndy Shevchenko { 5263cab1e71SAndy Shevchenko struct printf_spec spec; 5273cab1e71SAndy Shevchenko 5283cab1e71SAndy Shevchenko spec.type = FORMAT_TYPE_PTR; 5293cab1e71SAndy Shevchenko spec.field_width = 2 + 2 * size; /* 0x + hex */ 5303cab1e71SAndy Shevchenko spec.flags = SPECIAL | SMALL | ZEROPAD; 5313cab1e71SAndy Shevchenko spec.base = 16; 5323cab1e71SAndy Shevchenko spec.precision = -1; 5333cab1e71SAndy Shevchenko 5343cab1e71SAndy Shevchenko return number(buf, end, num, spec); 5353cab1e71SAndy Shevchenko } 5363cab1e71SAndy Shevchenko 537cfccde04SRasmus Villemoes static void move_right(char *buf, char *end, unsigned len, unsigned spaces) 5384b6ccca7SAl Viro { 5394b6ccca7SAl Viro size_t size; 5404b6ccca7SAl Viro if (buf >= end) /* nowhere to put anything */ 5414b6ccca7SAl Viro return; 5424b6ccca7SAl Viro size = end - buf; 5434b6ccca7SAl Viro if (size <= spaces) { 5444b6ccca7SAl Viro memset(buf, ' ', size); 5454b6ccca7SAl Viro return; 5464b6ccca7SAl Viro } 5474b6ccca7SAl Viro if (len) { 5484b6ccca7SAl Viro if (len > size - spaces) 5494b6ccca7SAl Viro len = size - spaces; 5504b6ccca7SAl Viro memmove(buf + spaces, buf, len); 5514b6ccca7SAl Viro } 5524b6ccca7SAl Viro memset(buf, ' ', spaces); 5534b6ccca7SAl Viro } 5544b6ccca7SAl Viro 555cfccde04SRasmus Villemoes /* 556cfccde04SRasmus Villemoes * Handle field width padding for a string. 557cfccde04SRasmus Villemoes * @buf: current buffer position 558cfccde04SRasmus Villemoes * @n: length of string 559cfccde04SRasmus Villemoes * @end: end of output buffer 560cfccde04SRasmus Villemoes * @spec: for field width and flags 561cfccde04SRasmus Villemoes * Returns: new buffer position after padding. 562cfccde04SRasmus Villemoes */ 563cfccde04SRasmus Villemoes static noinline_for_stack 564cfccde04SRasmus Villemoes char *widen_string(char *buf, int n, char *end, struct printf_spec spec) 565cfccde04SRasmus Villemoes { 566cfccde04SRasmus Villemoes unsigned spaces; 567cfccde04SRasmus Villemoes 568cfccde04SRasmus Villemoes if (likely(n >= spec.field_width)) 569cfccde04SRasmus Villemoes return buf; 570cfccde04SRasmus Villemoes /* we want to pad the sucker */ 571cfccde04SRasmus Villemoes spaces = spec.field_width - n; 572cfccde04SRasmus Villemoes if (!(spec.flags & LEFT)) { 573cfccde04SRasmus Villemoes move_right(buf - n, end, n, spaces); 574cfccde04SRasmus Villemoes return buf + spaces; 575cfccde04SRasmus Villemoes } 576cfccde04SRasmus Villemoes while (spaces--) { 577cfccde04SRasmus Villemoes if (buf < end) 578cfccde04SRasmus Villemoes *buf = ' '; 579cfccde04SRasmus Villemoes ++buf; 580cfccde04SRasmus Villemoes } 581cfccde04SRasmus Villemoes return buf; 582cfccde04SRasmus Villemoes } 583cfccde04SRasmus Villemoes 5844b6ccca7SAl Viro static noinline_for_stack 58595508cfaSRasmus Villemoes char *string(char *buf, char *end, const char *s, struct printf_spec spec) 58695508cfaSRasmus Villemoes { 58734fc8b90SRasmus Villemoes int len = 0; 58834fc8b90SRasmus Villemoes size_t lim = spec.precision; 58995508cfaSRasmus Villemoes 59095508cfaSRasmus Villemoes if ((unsigned long)s < PAGE_SIZE) 59195508cfaSRasmus Villemoes s = "(null)"; 59295508cfaSRasmus Villemoes 59334fc8b90SRasmus Villemoes while (lim--) { 59434fc8b90SRasmus Villemoes char c = *s++; 59534fc8b90SRasmus Villemoes if (!c) 59634fc8b90SRasmus Villemoes break; 59795508cfaSRasmus Villemoes if (buf < end) 59834fc8b90SRasmus Villemoes *buf = c; 59995508cfaSRasmus Villemoes ++buf; 60034fc8b90SRasmus Villemoes ++len; 60195508cfaSRasmus Villemoes } 60234fc8b90SRasmus Villemoes return widen_string(buf, len, end, spec); 60395508cfaSRasmus Villemoes } 60495508cfaSRasmus Villemoes 60595508cfaSRasmus Villemoes static noinline_for_stack 6064b6ccca7SAl Viro char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec, 6074b6ccca7SAl Viro const char *fmt) 6084b6ccca7SAl Viro { 6094b6ccca7SAl Viro const char *array[4], *s; 6104b6ccca7SAl Viro const struct dentry *p; 6114b6ccca7SAl Viro int depth; 6124b6ccca7SAl Viro int i, n; 6134b6ccca7SAl Viro 6144b6ccca7SAl Viro switch (fmt[1]) { 6154b6ccca7SAl Viro case '2': case '3': case '4': 6164b6ccca7SAl Viro depth = fmt[1] - '0'; 6174b6ccca7SAl Viro break; 6184b6ccca7SAl Viro default: 6194b6ccca7SAl Viro depth = 1; 6204b6ccca7SAl Viro } 6214b6ccca7SAl Viro 6224b6ccca7SAl Viro rcu_read_lock(); 6234b6ccca7SAl Viro for (i = 0; i < depth; i++, d = p) { 6246aa7de05SMark Rutland p = READ_ONCE(d->d_parent); 6256aa7de05SMark Rutland array[i] = READ_ONCE(d->d_name.name); 6264b6ccca7SAl Viro if (p == d) { 6274b6ccca7SAl Viro if (i) 6284b6ccca7SAl Viro array[i] = ""; 6294b6ccca7SAl Viro i++; 6304b6ccca7SAl Viro break; 6314b6ccca7SAl Viro } 6324b6ccca7SAl Viro } 6334b6ccca7SAl Viro s = array[--i]; 6344b6ccca7SAl Viro for (n = 0; n != spec.precision; n++, buf++) { 6354b6ccca7SAl Viro char c = *s++; 6364b6ccca7SAl Viro if (!c) { 6374b6ccca7SAl Viro if (!i) 6384b6ccca7SAl Viro break; 6394b6ccca7SAl Viro c = '/'; 6404b6ccca7SAl Viro s = array[--i]; 6414b6ccca7SAl Viro } 6424b6ccca7SAl Viro if (buf < end) 6434b6ccca7SAl Viro *buf = c; 6444b6ccca7SAl Viro } 6454b6ccca7SAl Viro rcu_read_unlock(); 646cfccde04SRasmus Villemoes return widen_string(buf, n, end, spec); 6474b6ccca7SAl Viro } 6484b6ccca7SAl Viro 6491031bc58SDmitry Monakhov #ifdef CONFIG_BLOCK 6501031bc58SDmitry Monakhov static noinline_for_stack 6511031bc58SDmitry Monakhov char *bdev_name(char *buf, char *end, struct block_device *bdev, 6521031bc58SDmitry Monakhov struct printf_spec spec, const char *fmt) 6531031bc58SDmitry Monakhov { 6541031bc58SDmitry Monakhov struct gendisk *hd = bdev->bd_disk; 6551031bc58SDmitry Monakhov 6561031bc58SDmitry Monakhov buf = string(buf, end, hd->disk_name, spec); 6571031bc58SDmitry Monakhov if (bdev->bd_part->partno) { 6581031bc58SDmitry Monakhov if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) { 6591031bc58SDmitry Monakhov if (buf < end) 6601031bc58SDmitry Monakhov *buf = 'p'; 6611031bc58SDmitry Monakhov buf++; 6621031bc58SDmitry Monakhov } 6631031bc58SDmitry Monakhov buf = number(buf, end, bdev->bd_part->partno, spec); 6641031bc58SDmitry Monakhov } 6651031bc58SDmitry Monakhov return buf; 6661031bc58SDmitry Monakhov } 6671031bc58SDmitry Monakhov #endif 6681031bc58SDmitry Monakhov 669cf3b429bSJoe Perches static noinline_for_stack 670cf3b429bSJoe Perches char *symbol_string(char *buf, char *end, void *ptr, 671b0d33c2bSJoe Perches struct printf_spec spec, const char *fmt) 6720fe1ef24SLinus Torvalds { 673b0d33c2bSJoe Perches unsigned long value; 6740fe1ef24SLinus Torvalds #ifdef CONFIG_KALLSYMS 6750fe1ef24SLinus Torvalds char sym[KSYM_SYMBOL_LEN]; 676b0d33c2bSJoe Perches #endif 677b0d33c2bSJoe Perches 678b0d33c2bSJoe Perches if (fmt[1] == 'R') 679b0d33c2bSJoe Perches ptr = __builtin_extract_return_addr(ptr); 680b0d33c2bSJoe Perches value = (unsigned long)ptr; 681b0d33c2bSJoe Perches 682b0d33c2bSJoe Perches #ifdef CONFIG_KALLSYMS 683b0d33c2bSJoe Perches if (*fmt == 'B') 6840f77a8d3SNamhyung Kim sprint_backtrace(sym, value); 685b0d33c2bSJoe Perches else if (*fmt != 'f' && *fmt != 's') 6860fe1ef24SLinus Torvalds sprint_symbol(sym, value); 6870c8b946eSFrederic Weisbecker else 6884796dd20SStephen Boyd sprint_symbol_no_offset(sym, value); 6897b9186f5SAndré Goddard Rosa 690fef20d9cSFrederic Weisbecker return string(buf, end, sym, spec); 6910fe1ef24SLinus Torvalds #else 6923cab1e71SAndy Shevchenko return special_hex_number(buf, end, value, sizeof(void *)); 6930fe1ef24SLinus Torvalds #endif 6940fe1ef24SLinus Torvalds } 6950fe1ef24SLinus Torvalds 696abd4fe62SAndy Shevchenko static const struct printf_spec default_str_spec = { 697abd4fe62SAndy Shevchenko .field_width = -1, 698abd4fe62SAndy Shevchenko .precision = -1, 699abd4fe62SAndy Shevchenko }; 700abd4fe62SAndy Shevchenko 701*54433973SAndy Shevchenko static const struct printf_spec default_flag_spec = { 702*54433973SAndy Shevchenko .base = 16, 703*54433973SAndy Shevchenko .precision = -1, 704*54433973SAndy Shevchenko .flags = SPECIAL | SMALL, 705*54433973SAndy Shevchenko }; 706*54433973SAndy Shevchenko 707ce0b4910SAndy Shevchenko static const struct printf_spec default_dec_spec = { 708ce0b4910SAndy Shevchenko .base = 10, 709ce0b4910SAndy Shevchenko .precision = -1, 710ce0b4910SAndy Shevchenko }; 711ce0b4910SAndy Shevchenko 712cf3b429bSJoe Perches static noinline_for_stack 713cf3b429bSJoe Perches char *resource_string(char *buf, char *end, struct resource *res, 714fd95541eSBjorn Helgaas struct printf_spec spec, const char *fmt) 715332d2e78SLinus Torvalds { 716332d2e78SLinus Torvalds #ifndef IO_RSRC_PRINTK_SIZE 71728405372SBjorn Helgaas #define IO_RSRC_PRINTK_SIZE 6 718332d2e78SLinus Torvalds #endif 719332d2e78SLinus Torvalds 720332d2e78SLinus Torvalds #ifndef MEM_RSRC_PRINTK_SIZE 72128405372SBjorn Helgaas #define MEM_RSRC_PRINTK_SIZE 10 722332d2e78SLinus Torvalds #endif 7234da0b66cSBjorn Helgaas static const struct printf_spec io_spec = { 724fef20d9cSFrederic Weisbecker .base = 16, 7254da0b66cSBjorn Helgaas .field_width = IO_RSRC_PRINTK_SIZE, 726fef20d9cSFrederic Weisbecker .precision = -1, 727fef20d9cSFrederic Weisbecker .flags = SPECIAL | SMALL | ZEROPAD, 728fef20d9cSFrederic Weisbecker }; 7294da0b66cSBjorn Helgaas static const struct printf_spec mem_spec = { 7304da0b66cSBjorn Helgaas .base = 16, 7314da0b66cSBjorn Helgaas .field_width = MEM_RSRC_PRINTK_SIZE, 7324da0b66cSBjorn Helgaas .precision = -1, 7334da0b66cSBjorn Helgaas .flags = SPECIAL | SMALL | ZEROPAD, 7344da0b66cSBjorn Helgaas }; 7350f4050c7SBjorn Helgaas static const struct printf_spec bus_spec = { 7360f4050c7SBjorn Helgaas .base = 16, 7370f4050c7SBjorn Helgaas .field_width = 2, 7380f4050c7SBjorn Helgaas .precision = -1, 7390f4050c7SBjorn Helgaas .flags = SMALL | ZEROPAD, 7400f4050c7SBjorn Helgaas }; 7414da0b66cSBjorn Helgaas static const struct printf_spec str_spec = { 742fd95541eSBjorn Helgaas .field_width = -1, 743fd95541eSBjorn Helgaas .precision = 10, 744fd95541eSBjorn Helgaas .flags = LEFT, 745fd95541eSBjorn Helgaas }; 746c7dabef8SBjorn Helgaas 747c7dabef8SBjorn Helgaas /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8) 748c7dabef8SBjorn Helgaas * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */ 749c7dabef8SBjorn Helgaas #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4) 750c7dabef8SBjorn Helgaas #define FLAG_BUF_SIZE (2 * sizeof(res->flags)) 7519d7cca04SBjorn Helgaas #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]") 752c7dabef8SBjorn Helgaas #define RAW_BUF_SIZE sizeof("[mem - flags 0x]") 753c7dabef8SBjorn Helgaas char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, 754c7dabef8SBjorn Helgaas 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)]; 755c7dabef8SBjorn Helgaas 756332d2e78SLinus Torvalds char *p = sym, *pend = sym + sizeof(sym); 757c7dabef8SBjorn Helgaas int decode = (fmt[0] == 'R') ? 1 : 0; 7584da0b66cSBjorn Helgaas const struct printf_spec *specp; 759332d2e78SLinus Torvalds 760332d2e78SLinus Torvalds *p++ = '['; 7614da0b66cSBjorn Helgaas if (res->flags & IORESOURCE_IO) { 762fd95541eSBjorn Helgaas p = string(p, pend, "io ", str_spec); 7634da0b66cSBjorn Helgaas specp = &io_spec; 7644da0b66cSBjorn Helgaas } else if (res->flags & IORESOURCE_MEM) { 765fd95541eSBjorn Helgaas p = string(p, pend, "mem ", str_spec); 7664da0b66cSBjorn Helgaas specp = &mem_spec; 7674da0b66cSBjorn Helgaas } else if (res->flags & IORESOURCE_IRQ) { 768fd95541eSBjorn Helgaas p = string(p, pend, "irq ", str_spec); 769ce0b4910SAndy Shevchenko specp = &default_dec_spec; 7704da0b66cSBjorn Helgaas } else if (res->flags & IORESOURCE_DMA) { 771fd95541eSBjorn Helgaas p = string(p, pend, "dma ", str_spec); 772ce0b4910SAndy Shevchenko specp = &default_dec_spec; 7730f4050c7SBjorn Helgaas } else if (res->flags & IORESOURCE_BUS) { 7740f4050c7SBjorn Helgaas p = string(p, pend, "bus ", str_spec); 7750f4050c7SBjorn Helgaas specp = &bus_spec; 7764da0b66cSBjorn Helgaas } else { 777c7dabef8SBjorn Helgaas p = string(p, pend, "??? ", str_spec); 7784da0b66cSBjorn Helgaas specp = &mem_spec; 779c7dabef8SBjorn Helgaas decode = 0; 780fd95541eSBjorn Helgaas } 781d19cb803SBjorn Helgaas if (decode && res->flags & IORESOURCE_UNSET) { 782d19cb803SBjorn Helgaas p = string(p, pend, "size ", str_spec); 783d19cb803SBjorn Helgaas p = number(p, pend, resource_size(res), *specp); 784d19cb803SBjorn Helgaas } else { 7854da0b66cSBjorn Helgaas p = number(p, pend, res->start, *specp); 786c91d3376SBjorn Helgaas if (res->start != res->end) { 787332d2e78SLinus Torvalds *p++ = '-'; 7884da0b66cSBjorn Helgaas p = number(p, pend, res->end, *specp); 789c91d3376SBjorn Helgaas } 790d19cb803SBjorn Helgaas } 791c7dabef8SBjorn Helgaas if (decode) { 792fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_MEM_64) 793fd95541eSBjorn Helgaas p = string(p, pend, " 64bit", str_spec); 794fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_PREFETCH) 795fd95541eSBjorn Helgaas p = string(p, pend, " pref", str_spec); 7969d7cca04SBjorn Helgaas if (res->flags & IORESOURCE_WINDOW) 7979d7cca04SBjorn Helgaas p = string(p, pend, " window", str_spec); 798fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_DISABLED) 799fd95541eSBjorn Helgaas p = string(p, pend, " disabled", str_spec); 800c7dabef8SBjorn Helgaas } else { 801fd95541eSBjorn Helgaas p = string(p, pend, " flags ", str_spec); 802*54433973SAndy Shevchenko p = number(p, pend, res->flags, default_flag_spec); 803fd95541eSBjorn Helgaas } 804332d2e78SLinus Torvalds *p++ = ']'; 805c7dabef8SBjorn Helgaas *p = '\0'; 806332d2e78SLinus Torvalds 807fef20d9cSFrederic Weisbecker return string(buf, end, sym, spec); 808332d2e78SLinus Torvalds } 809332d2e78SLinus Torvalds 810cf3b429bSJoe Perches static noinline_for_stack 81131550a16SAndy Shevchenko char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec, 81231550a16SAndy Shevchenko const char *fmt) 81331550a16SAndy Shevchenko { 814360603a1SSteven Rostedt int i, len = 1; /* if we pass '%ph[CDN]', field width remains 81531550a16SAndy Shevchenko negative value, fallback to the default */ 81631550a16SAndy Shevchenko char separator; 81731550a16SAndy Shevchenko 81831550a16SAndy Shevchenko if (spec.field_width == 0) 81931550a16SAndy Shevchenko /* nothing to print */ 82031550a16SAndy Shevchenko return buf; 82131550a16SAndy Shevchenko 82231550a16SAndy Shevchenko if (ZERO_OR_NULL_PTR(addr)) 82331550a16SAndy Shevchenko /* NULL pointer */ 82431550a16SAndy Shevchenko return string(buf, end, NULL, spec); 82531550a16SAndy Shevchenko 82631550a16SAndy Shevchenko switch (fmt[1]) { 82731550a16SAndy Shevchenko case 'C': 82831550a16SAndy Shevchenko separator = ':'; 82931550a16SAndy Shevchenko break; 83031550a16SAndy Shevchenko case 'D': 83131550a16SAndy Shevchenko separator = '-'; 83231550a16SAndy Shevchenko break; 83331550a16SAndy Shevchenko case 'N': 83431550a16SAndy Shevchenko separator = 0; 83531550a16SAndy Shevchenko break; 83631550a16SAndy Shevchenko default: 83731550a16SAndy Shevchenko separator = ' '; 83831550a16SAndy Shevchenko break; 83931550a16SAndy Shevchenko } 84031550a16SAndy Shevchenko 84131550a16SAndy Shevchenko if (spec.field_width > 0) 84231550a16SAndy Shevchenko len = min_t(int, spec.field_width, 64); 84331550a16SAndy Shevchenko 8449c98f235SRasmus Villemoes for (i = 0; i < len; ++i) { 8459c98f235SRasmus Villemoes if (buf < end) 8469c98f235SRasmus Villemoes *buf = hex_asc_hi(addr[i]); 8479c98f235SRasmus Villemoes ++buf; 8489c98f235SRasmus Villemoes if (buf < end) 8499c98f235SRasmus Villemoes *buf = hex_asc_lo(addr[i]); 8509c98f235SRasmus Villemoes ++buf; 85131550a16SAndy Shevchenko 8529c98f235SRasmus Villemoes if (separator && i != len - 1) { 8539c98f235SRasmus Villemoes if (buf < end) 8549c98f235SRasmus Villemoes *buf = separator; 8559c98f235SRasmus Villemoes ++buf; 8569c98f235SRasmus Villemoes } 85731550a16SAndy Shevchenko } 85831550a16SAndy Shevchenko 85931550a16SAndy Shevchenko return buf; 86031550a16SAndy Shevchenko } 86131550a16SAndy Shevchenko 86231550a16SAndy Shevchenko static noinline_for_stack 863dbc760bcSTejun Heo char *bitmap_string(char *buf, char *end, unsigned long *bitmap, 864dbc760bcSTejun Heo struct printf_spec spec, const char *fmt) 865dbc760bcSTejun Heo { 866dbc760bcSTejun Heo const int CHUNKSZ = 32; 867dbc760bcSTejun Heo int nr_bits = max_t(int, spec.field_width, 0); 868dbc760bcSTejun Heo int i, chunksz; 869dbc760bcSTejun Heo bool first = true; 870dbc760bcSTejun Heo 871dbc760bcSTejun Heo /* reused to print numbers */ 872dbc760bcSTejun Heo spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 }; 873dbc760bcSTejun Heo 874dbc760bcSTejun Heo chunksz = nr_bits & (CHUNKSZ - 1); 875dbc760bcSTejun Heo if (chunksz == 0) 876dbc760bcSTejun Heo chunksz = CHUNKSZ; 877dbc760bcSTejun Heo 878dbc760bcSTejun Heo i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ; 879dbc760bcSTejun Heo for (; i >= 0; i -= CHUNKSZ) { 880dbc760bcSTejun Heo u32 chunkmask, val; 881dbc760bcSTejun Heo int word, bit; 882dbc760bcSTejun Heo 883dbc760bcSTejun Heo chunkmask = ((1ULL << chunksz) - 1); 884dbc760bcSTejun Heo word = i / BITS_PER_LONG; 885dbc760bcSTejun Heo bit = i % BITS_PER_LONG; 886dbc760bcSTejun Heo val = (bitmap[word] >> bit) & chunkmask; 887dbc760bcSTejun Heo 888dbc760bcSTejun Heo if (!first) { 889dbc760bcSTejun Heo if (buf < end) 890dbc760bcSTejun Heo *buf = ','; 891dbc760bcSTejun Heo buf++; 892dbc760bcSTejun Heo } 893dbc760bcSTejun Heo first = false; 894dbc760bcSTejun Heo 895dbc760bcSTejun Heo spec.field_width = DIV_ROUND_UP(chunksz, 4); 896dbc760bcSTejun Heo buf = number(buf, end, val, spec); 897dbc760bcSTejun Heo 898dbc760bcSTejun Heo chunksz = CHUNKSZ; 899dbc760bcSTejun Heo } 900dbc760bcSTejun Heo return buf; 901dbc760bcSTejun Heo } 902dbc760bcSTejun Heo 903dbc760bcSTejun Heo static noinline_for_stack 904dbc760bcSTejun Heo char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap, 905dbc760bcSTejun Heo struct printf_spec spec, const char *fmt) 906dbc760bcSTejun Heo { 907dbc760bcSTejun Heo int nr_bits = max_t(int, spec.field_width, 0); 908dbc760bcSTejun Heo /* current bit is 'cur', most recently seen range is [rbot, rtop] */ 909dbc760bcSTejun Heo int cur, rbot, rtop; 910dbc760bcSTejun Heo bool first = true; 911dbc760bcSTejun Heo 912dbc760bcSTejun Heo rbot = cur = find_first_bit(bitmap, nr_bits); 913dbc760bcSTejun Heo while (cur < nr_bits) { 914dbc760bcSTejun Heo rtop = cur; 915dbc760bcSTejun Heo cur = find_next_bit(bitmap, nr_bits, cur + 1); 916dbc760bcSTejun Heo if (cur < nr_bits && cur <= rtop + 1) 917dbc760bcSTejun Heo continue; 918dbc760bcSTejun Heo 919dbc760bcSTejun Heo if (!first) { 920dbc760bcSTejun Heo if (buf < end) 921dbc760bcSTejun Heo *buf = ','; 922dbc760bcSTejun Heo buf++; 923dbc760bcSTejun Heo } 924dbc760bcSTejun Heo first = false; 925dbc760bcSTejun Heo 926ce0b4910SAndy Shevchenko buf = number(buf, end, rbot, default_dec_spec); 927dbc760bcSTejun Heo if (rbot < rtop) { 928dbc760bcSTejun Heo if (buf < end) 929dbc760bcSTejun Heo *buf = '-'; 930dbc760bcSTejun Heo buf++; 931dbc760bcSTejun Heo 932ce0b4910SAndy Shevchenko buf = number(buf, end, rtop, default_dec_spec); 933dbc760bcSTejun Heo } 934dbc760bcSTejun Heo 935dbc760bcSTejun Heo rbot = cur; 936dbc760bcSTejun Heo } 937dbc760bcSTejun Heo return buf; 938dbc760bcSTejun Heo } 939dbc760bcSTejun Heo 940dbc760bcSTejun Heo static noinline_for_stack 941cf3b429bSJoe Perches char *mac_address_string(char *buf, char *end, u8 *addr, 9428a27f7c9SJoe Perches struct printf_spec spec, const char *fmt) 943dd45c9cfSHarvey Harrison { 9448a27f7c9SJoe Perches char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")]; 945dd45c9cfSHarvey Harrison char *p = mac_addr; 946dd45c9cfSHarvey Harrison int i; 947bc7259a2SJoe Perches char separator; 94876597ff9SAndrei Emeltchenko bool reversed = false; 949bc7259a2SJoe Perches 95076597ff9SAndrei Emeltchenko switch (fmt[1]) { 95176597ff9SAndrei Emeltchenko case 'F': 952bc7259a2SJoe Perches separator = '-'; 95376597ff9SAndrei Emeltchenko break; 95476597ff9SAndrei Emeltchenko 95576597ff9SAndrei Emeltchenko case 'R': 95676597ff9SAndrei Emeltchenko reversed = true; 95776597ff9SAndrei Emeltchenko /* fall through */ 95876597ff9SAndrei Emeltchenko 95976597ff9SAndrei Emeltchenko default: 960bc7259a2SJoe Perches separator = ':'; 96176597ff9SAndrei Emeltchenko break; 962bc7259a2SJoe Perches } 963dd45c9cfSHarvey Harrison 964dd45c9cfSHarvey Harrison for (i = 0; i < 6; i++) { 96576597ff9SAndrei Emeltchenko if (reversed) 96676597ff9SAndrei Emeltchenko p = hex_byte_pack(p, addr[5 - i]); 96776597ff9SAndrei Emeltchenko else 96855036ba7SAndy Shevchenko p = hex_byte_pack(p, addr[i]); 96976597ff9SAndrei Emeltchenko 9708a27f7c9SJoe Perches if (fmt[0] == 'M' && i != 5) 971bc7259a2SJoe Perches *p++ = separator; 972dd45c9cfSHarvey Harrison } 973dd45c9cfSHarvey Harrison *p = '\0'; 974dd45c9cfSHarvey Harrison 975fef20d9cSFrederic Weisbecker return string(buf, end, mac_addr, spec); 976dd45c9cfSHarvey Harrison } 977dd45c9cfSHarvey Harrison 978cf3b429bSJoe Perches static noinline_for_stack 979cf3b429bSJoe Perches char *ip4_string(char *p, const u8 *addr, const char *fmt) 980689afa7dSHarvey Harrison { 981689afa7dSHarvey Harrison int i; 9820159f24eSJoe Perches bool leading_zeros = (fmt[0] == 'i'); 9830159f24eSJoe Perches int index; 9840159f24eSJoe Perches int step; 985689afa7dSHarvey Harrison 9860159f24eSJoe Perches switch (fmt[2]) { 9870159f24eSJoe Perches case 'h': 9880159f24eSJoe Perches #ifdef __BIG_ENDIAN 9890159f24eSJoe Perches index = 0; 9900159f24eSJoe Perches step = 1; 9910159f24eSJoe Perches #else 9920159f24eSJoe Perches index = 3; 9930159f24eSJoe Perches step = -1; 9940159f24eSJoe Perches #endif 9950159f24eSJoe Perches break; 9960159f24eSJoe Perches case 'l': 9970159f24eSJoe Perches index = 3; 9980159f24eSJoe Perches step = -1; 9990159f24eSJoe Perches break; 10000159f24eSJoe Perches case 'n': 10010159f24eSJoe Perches case 'b': 10020159f24eSJoe Perches default: 10030159f24eSJoe Perches index = 0; 10040159f24eSJoe Perches step = 1; 10050159f24eSJoe Perches break; 10060159f24eSJoe Perches } 10078a27f7c9SJoe Perches for (i = 0; i < 4; i++) { 10087c43d9a3SRasmus Villemoes char temp[4] __aligned(2); /* hold each IP quad in reverse order */ 1009133fd9f5SDenys Vlasenko int digits = put_dec_trunc8(temp, addr[index]) - temp; 10108a27f7c9SJoe Perches if (leading_zeros) { 10118a27f7c9SJoe Perches if (digits < 3) 10128a27f7c9SJoe Perches *p++ = '0'; 10138a27f7c9SJoe Perches if (digits < 2) 10148a27f7c9SJoe Perches *p++ = '0'; 10158a27f7c9SJoe Perches } 10168a27f7c9SJoe Perches /* reverse the digits in the quad */ 10178a27f7c9SJoe Perches while (digits--) 10188a27f7c9SJoe Perches *p++ = temp[digits]; 10198a27f7c9SJoe Perches if (i < 3) 10208a27f7c9SJoe Perches *p++ = '.'; 10210159f24eSJoe Perches index += step; 10228a27f7c9SJoe Perches } 10238a27f7c9SJoe Perches *p = '\0'; 10247b9186f5SAndré Goddard Rosa 10258a27f7c9SJoe Perches return p; 10268a27f7c9SJoe Perches } 10278a27f7c9SJoe Perches 1028cf3b429bSJoe Perches static noinline_for_stack 1029cf3b429bSJoe Perches char *ip6_compressed_string(char *p, const char *addr) 10308a27f7c9SJoe Perches { 10317b9186f5SAndré Goddard Rosa int i, j, range; 10328a27f7c9SJoe Perches unsigned char zerolength[8]; 10338a27f7c9SJoe Perches int longest = 1; 10348a27f7c9SJoe Perches int colonpos = -1; 10358a27f7c9SJoe Perches u16 word; 10367b9186f5SAndré Goddard Rosa u8 hi, lo; 10378a27f7c9SJoe Perches bool needcolon = false; 1038eb78cd26SJoe Perches bool useIPv4; 1039eb78cd26SJoe Perches struct in6_addr in6; 1040eb78cd26SJoe Perches 1041eb78cd26SJoe Perches memcpy(&in6, addr, sizeof(struct in6_addr)); 1042eb78cd26SJoe Perches 1043eb78cd26SJoe Perches useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 10448a27f7c9SJoe Perches 10458a27f7c9SJoe Perches memset(zerolength, 0, sizeof(zerolength)); 10468a27f7c9SJoe Perches 10478a27f7c9SJoe Perches if (useIPv4) 10488a27f7c9SJoe Perches range = 6; 10498a27f7c9SJoe Perches else 10508a27f7c9SJoe Perches range = 8; 10518a27f7c9SJoe Perches 10528a27f7c9SJoe Perches /* find position of longest 0 run */ 10538a27f7c9SJoe Perches for (i = 0; i < range; i++) { 10548a27f7c9SJoe Perches for (j = i; j < range; j++) { 1055eb78cd26SJoe Perches if (in6.s6_addr16[j] != 0) 10568a27f7c9SJoe Perches break; 10578a27f7c9SJoe Perches zerolength[i]++; 10588a27f7c9SJoe Perches } 10598a27f7c9SJoe Perches } 10608a27f7c9SJoe Perches for (i = 0; i < range; i++) { 10618a27f7c9SJoe Perches if (zerolength[i] > longest) { 10628a27f7c9SJoe Perches longest = zerolength[i]; 10638a27f7c9SJoe Perches colonpos = i; 10648a27f7c9SJoe Perches } 10658a27f7c9SJoe Perches } 106629cf519eSJoe Perches if (longest == 1) /* don't compress a single 0 */ 106729cf519eSJoe Perches colonpos = -1; 10688a27f7c9SJoe Perches 10698a27f7c9SJoe Perches /* emit address */ 10708a27f7c9SJoe Perches for (i = 0; i < range; i++) { 10718a27f7c9SJoe Perches if (i == colonpos) { 10728a27f7c9SJoe Perches if (needcolon || i == 0) 10738a27f7c9SJoe Perches *p++ = ':'; 10748a27f7c9SJoe Perches *p++ = ':'; 10758a27f7c9SJoe Perches needcolon = false; 10768a27f7c9SJoe Perches i += longest - 1; 10778a27f7c9SJoe Perches continue; 10788a27f7c9SJoe Perches } 10798a27f7c9SJoe Perches if (needcolon) { 10808a27f7c9SJoe Perches *p++ = ':'; 10818a27f7c9SJoe Perches needcolon = false; 10828a27f7c9SJoe Perches } 10838a27f7c9SJoe Perches /* hex u16 without leading 0s */ 1084eb78cd26SJoe Perches word = ntohs(in6.s6_addr16[i]); 10858a27f7c9SJoe Perches hi = word >> 8; 10868a27f7c9SJoe Perches lo = word & 0xff; 10878a27f7c9SJoe Perches if (hi) { 10888a27f7c9SJoe Perches if (hi > 0x0f) 108955036ba7SAndy Shevchenko p = hex_byte_pack(p, hi); 10908a27f7c9SJoe Perches else 10918a27f7c9SJoe Perches *p++ = hex_asc_lo(hi); 109255036ba7SAndy Shevchenko p = hex_byte_pack(p, lo); 10938a27f7c9SJoe Perches } 1094b5ff992bSAndré Goddard Rosa else if (lo > 0x0f) 109555036ba7SAndy Shevchenko p = hex_byte_pack(p, lo); 10968a27f7c9SJoe Perches else 10978a27f7c9SJoe Perches *p++ = hex_asc_lo(lo); 10988a27f7c9SJoe Perches needcolon = true; 10998a27f7c9SJoe Perches } 11008a27f7c9SJoe Perches 11018a27f7c9SJoe Perches if (useIPv4) { 11028a27f7c9SJoe Perches if (needcolon) 11038a27f7c9SJoe Perches *p++ = ':'; 11040159f24eSJoe Perches p = ip4_string(p, &in6.s6_addr[12], "I4"); 11058a27f7c9SJoe Perches } 11068a27f7c9SJoe Perches *p = '\0'; 11077b9186f5SAndré Goddard Rosa 11088a27f7c9SJoe Perches return p; 11098a27f7c9SJoe Perches } 11108a27f7c9SJoe Perches 1111cf3b429bSJoe Perches static noinline_for_stack 1112cf3b429bSJoe Perches char *ip6_string(char *p, const char *addr, const char *fmt) 11138a27f7c9SJoe Perches { 11148a27f7c9SJoe Perches int i; 11157b9186f5SAndré Goddard Rosa 1116689afa7dSHarvey Harrison for (i = 0; i < 8; i++) { 111755036ba7SAndy Shevchenko p = hex_byte_pack(p, *addr++); 111855036ba7SAndy Shevchenko p = hex_byte_pack(p, *addr++); 11198a27f7c9SJoe Perches if (fmt[0] == 'I' && i != 7) 1120689afa7dSHarvey Harrison *p++ = ':'; 1121689afa7dSHarvey Harrison } 1122689afa7dSHarvey Harrison *p = '\0'; 11237b9186f5SAndré Goddard Rosa 11248a27f7c9SJoe Perches return p; 11258a27f7c9SJoe Perches } 11268a27f7c9SJoe Perches 1127cf3b429bSJoe Perches static noinline_for_stack 1128cf3b429bSJoe Perches char *ip6_addr_string(char *buf, char *end, const u8 *addr, 11298a27f7c9SJoe Perches struct printf_spec spec, const char *fmt) 11308a27f7c9SJoe Perches { 11318a27f7c9SJoe Perches char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 11328a27f7c9SJoe Perches 11338a27f7c9SJoe Perches if (fmt[0] == 'I' && fmt[2] == 'c') 1134eb78cd26SJoe Perches ip6_compressed_string(ip6_addr, addr); 11358a27f7c9SJoe Perches else 1136eb78cd26SJoe Perches ip6_string(ip6_addr, addr, fmt); 1137689afa7dSHarvey Harrison 1138fef20d9cSFrederic Weisbecker return string(buf, end, ip6_addr, spec); 1139689afa7dSHarvey Harrison } 1140689afa7dSHarvey Harrison 1141cf3b429bSJoe Perches static noinline_for_stack 1142cf3b429bSJoe Perches char *ip4_addr_string(char *buf, char *end, const u8 *addr, 11438a27f7c9SJoe Perches struct printf_spec spec, const char *fmt) 11444aa99606SHarvey Harrison { 11458a27f7c9SJoe Perches char ip4_addr[sizeof("255.255.255.255")]; 11464aa99606SHarvey Harrison 11470159f24eSJoe Perches ip4_string(ip4_addr, addr, fmt); 11484aa99606SHarvey Harrison 1149fef20d9cSFrederic Weisbecker return string(buf, end, ip4_addr, spec); 11504aa99606SHarvey Harrison } 11514aa99606SHarvey Harrison 1152cf3b429bSJoe Perches static noinline_for_stack 115310679643SDaniel Borkmann char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa, 115410679643SDaniel Borkmann struct printf_spec spec, const char *fmt) 115510679643SDaniel Borkmann { 115610679643SDaniel Borkmann bool have_p = false, have_s = false, have_f = false, have_c = false; 115710679643SDaniel Borkmann char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") + 115810679643SDaniel Borkmann sizeof(":12345") + sizeof("/123456789") + 115910679643SDaniel Borkmann sizeof("%1234567890")]; 116010679643SDaniel Borkmann char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr); 116110679643SDaniel Borkmann const u8 *addr = (const u8 *) &sa->sin6_addr; 116210679643SDaniel Borkmann char fmt6[2] = { fmt[0], '6' }; 116310679643SDaniel Borkmann u8 off = 0; 116410679643SDaniel Borkmann 116510679643SDaniel Borkmann fmt++; 116610679643SDaniel Borkmann while (isalpha(*++fmt)) { 116710679643SDaniel Borkmann switch (*fmt) { 116810679643SDaniel Borkmann case 'p': 116910679643SDaniel Borkmann have_p = true; 117010679643SDaniel Borkmann break; 117110679643SDaniel Borkmann case 'f': 117210679643SDaniel Borkmann have_f = true; 117310679643SDaniel Borkmann break; 117410679643SDaniel Borkmann case 's': 117510679643SDaniel Borkmann have_s = true; 117610679643SDaniel Borkmann break; 117710679643SDaniel Borkmann case 'c': 117810679643SDaniel Borkmann have_c = true; 117910679643SDaniel Borkmann break; 118010679643SDaniel Borkmann } 118110679643SDaniel Borkmann } 118210679643SDaniel Borkmann 118310679643SDaniel Borkmann if (have_p || have_s || have_f) { 118410679643SDaniel Borkmann *p = '['; 118510679643SDaniel Borkmann off = 1; 118610679643SDaniel Borkmann } 118710679643SDaniel Borkmann 118810679643SDaniel Borkmann if (fmt6[0] == 'I' && have_c) 118910679643SDaniel Borkmann p = ip6_compressed_string(ip6_addr + off, addr); 119010679643SDaniel Borkmann else 119110679643SDaniel Borkmann p = ip6_string(ip6_addr + off, addr, fmt6); 119210679643SDaniel Borkmann 119310679643SDaniel Borkmann if (have_p || have_s || have_f) 119410679643SDaniel Borkmann *p++ = ']'; 119510679643SDaniel Borkmann 119610679643SDaniel Borkmann if (have_p) { 119710679643SDaniel Borkmann *p++ = ':'; 119810679643SDaniel Borkmann p = number(p, pend, ntohs(sa->sin6_port), spec); 119910679643SDaniel Borkmann } 120010679643SDaniel Borkmann if (have_f) { 120110679643SDaniel Borkmann *p++ = '/'; 120210679643SDaniel Borkmann p = number(p, pend, ntohl(sa->sin6_flowinfo & 120310679643SDaniel Borkmann IPV6_FLOWINFO_MASK), spec); 120410679643SDaniel Borkmann } 120510679643SDaniel Borkmann if (have_s) { 120610679643SDaniel Borkmann *p++ = '%'; 120710679643SDaniel Borkmann p = number(p, pend, sa->sin6_scope_id, spec); 120810679643SDaniel Borkmann } 120910679643SDaniel Borkmann *p = '\0'; 121010679643SDaniel Borkmann 121110679643SDaniel Borkmann return string(buf, end, ip6_addr, spec); 121210679643SDaniel Borkmann } 121310679643SDaniel Borkmann 121410679643SDaniel Borkmann static noinline_for_stack 121510679643SDaniel Borkmann char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa, 121610679643SDaniel Borkmann struct printf_spec spec, const char *fmt) 121710679643SDaniel Borkmann { 121810679643SDaniel Borkmann bool have_p = false; 121910679643SDaniel Borkmann char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")]; 122010679643SDaniel Borkmann char *pend = ip4_addr + sizeof(ip4_addr); 122110679643SDaniel Borkmann const u8 *addr = (const u8 *) &sa->sin_addr.s_addr; 122210679643SDaniel Borkmann char fmt4[3] = { fmt[0], '4', 0 }; 122310679643SDaniel Borkmann 122410679643SDaniel Borkmann fmt++; 122510679643SDaniel Borkmann while (isalpha(*++fmt)) { 122610679643SDaniel Borkmann switch (*fmt) { 122710679643SDaniel Borkmann case 'p': 122810679643SDaniel Borkmann have_p = true; 122910679643SDaniel Borkmann break; 123010679643SDaniel Borkmann case 'h': 123110679643SDaniel Borkmann case 'l': 123210679643SDaniel Borkmann case 'n': 123310679643SDaniel Borkmann case 'b': 123410679643SDaniel Borkmann fmt4[2] = *fmt; 123510679643SDaniel Borkmann break; 123610679643SDaniel Borkmann } 123710679643SDaniel Borkmann } 123810679643SDaniel Borkmann 123910679643SDaniel Borkmann p = ip4_string(ip4_addr, addr, fmt4); 124010679643SDaniel Borkmann if (have_p) { 124110679643SDaniel Borkmann *p++ = ':'; 124210679643SDaniel Borkmann p = number(p, pend, ntohs(sa->sin_port), spec); 124310679643SDaniel Borkmann } 124410679643SDaniel Borkmann *p = '\0'; 124510679643SDaniel Borkmann 124610679643SDaniel Borkmann return string(buf, end, ip4_addr, spec); 124710679643SDaniel Borkmann } 124810679643SDaniel Borkmann 124910679643SDaniel Borkmann static noinline_for_stack 125071dca95dSAndy Shevchenko char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec, 125171dca95dSAndy Shevchenko const char *fmt) 125271dca95dSAndy Shevchenko { 125371dca95dSAndy Shevchenko bool found = true; 125471dca95dSAndy Shevchenko int count = 1; 125571dca95dSAndy Shevchenko unsigned int flags = 0; 125671dca95dSAndy Shevchenko int len; 125771dca95dSAndy Shevchenko 125871dca95dSAndy Shevchenko if (spec.field_width == 0) 125971dca95dSAndy Shevchenko return buf; /* nothing to print */ 126071dca95dSAndy Shevchenko 126171dca95dSAndy Shevchenko if (ZERO_OR_NULL_PTR(addr)) 126271dca95dSAndy Shevchenko return string(buf, end, NULL, spec); /* NULL pointer */ 126371dca95dSAndy Shevchenko 126471dca95dSAndy Shevchenko 126571dca95dSAndy Shevchenko do { 126671dca95dSAndy Shevchenko switch (fmt[count++]) { 126771dca95dSAndy Shevchenko case 'a': 126871dca95dSAndy Shevchenko flags |= ESCAPE_ANY; 126971dca95dSAndy Shevchenko break; 127071dca95dSAndy Shevchenko case 'c': 127171dca95dSAndy Shevchenko flags |= ESCAPE_SPECIAL; 127271dca95dSAndy Shevchenko break; 127371dca95dSAndy Shevchenko case 'h': 127471dca95dSAndy Shevchenko flags |= ESCAPE_HEX; 127571dca95dSAndy Shevchenko break; 127671dca95dSAndy Shevchenko case 'n': 127771dca95dSAndy Shevchenko flags |= ESCAPE_NULL; 127871dca95dSAndy Shevchenko break; 127971dca95dSAndy Shevchenko case 'o': 128071dca95dSAndy Shevchenko flags |= ESCAPE_OCTAL; 128171dca95dSAndy Shevchenko break; 128271dca95dSAndy Shevchenko case 'p': 128371dca95dSAndy Shevchenko flags |= ESCAPE_NP; 128471dca95dSAndy Shevchenko break; 128571dca95dSAndy Shevchenko case 's': 128671dca95dSAndy Shevchenko flags |= ESCAPE_SPACE; 128771dca95dSAndy Shevchenko break; 128871dca95dSAndy Shevchenko default: 128971dca95dSAndy Shevchenko found = false; 129071dca95dSAndy Shevchenko break; 129171dca95dSAndy Shevchenko } 129271dca95dSAndy Shevchenko } while (found); 129371dca95dSAndy Shevchenko 129471dca95dSAndy Shevchenko if (!flags) 129571dca95dSAndy Shevchenko flags = ESCAPE_ANY_NP; 129671dca95dSAndy Shevchenko 129771dca95dSAndy Shevchenko len = spec.field_width < 0 ? 1 : spec.field_width; 129871dca95dSAndy Shevchenko 129941416f23SRasmus Villemoes /* 130041416f23SRasmus Villemoes * string_escape_mem() writes as many characters as it can to 130141416f23SRasmus Villemoes * the given buffer, and returns the total size of the output 130241416f23SRasmus Villemoes * had the buffer been big enough. 130341416f23SRasmus Villemoes */ 130441416f23SRasmus Villemoes buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL); 130571dca95dSAndy Shevchenko 130671dca95dSAndy Shevchenko return buf; 130771dca95dSAndy Shevchenko } 130871dca95dSAndy Shevchenko 130971dca95dSAndy Shevchenko static noinline_for_stack 1310cf3b429bSJoe Perches char *uuid_string(char *buf, char *end, const u8 *addr, 13119ac6e44eSJoe Perches struct printf_spec spec, const char *fmt) 13129ac6e44eSJoe Perches { 13132b1b0d66SAndy Shevchenko char uuid[UUID_STRING_LEN + 1]; 13149ac6e44eSJoe Perches char *p = uuid; 13159ac6e44eSJoe Perches int i; 1316f9727a17SChristoph Hellwig const u8 *index = uuid_index; 13179ac6e44eSJoe Perches bool uc = false; 13189ac6e44eSJoe Perches 13199ac6e44eSJoe Perches switch (*(++fmt)) { 13209ac6e44eSJoe Perches case 'L': 13219ac6e44eSJoe Perches uc = true; /* fall-through */ 13229ac6e44eSJoe Perches case 'l': 1323f9727a17SChristoph Hellwig index = guid_index; 13249ac6e44eSJoe Perches break; 13259ac6e44eSJoe Perches case 'B': 13269ac6e44eSJoe Perches uc = true; 13279ac6e44eSJoe Perches break; 13289ac6e44eSJoe Perches } 13299ac6e44eSJoe Perches 13309ac6e44eSJoe Perches for (i = 0; i < 16; i++) { 1331aa4ea1c3SAndy Shevchenko if (uc) 1332aa4ea1c3SAndy Shevchenko p = hex_byte_pack_upper(p, addr[index[i]]); 1333aa4ea1c3SAndy Shevchenko else 133455036ba7SAndy Shevchenko p = hex_byte_pack(p, addr[index[i]]); 13359ac6e44eSJoe Perches switch (i) { 13369ac6e44eSJoe Perches case 3: 13379ac6e44eSJoe Perches case 5: 13389ac6e44eSJoe Perches case 7: 13399ac6e44eSJoe Perches case 9: 13409ac6e44eSJoe Perches *p++ = '-'; 13419ac6e44eSJoe Perches break; 13429ac6e44eSJoe Perches } 13439ac6e44eSJoe Perches } 13449ac6e44eSJoe Perches 13459ac6e44eSJoe Perches *p = 0; 13469ac6e44eSJoe Perches 13479ac6e44eSJoe Perches return string(buf, end, uuid, spec); 13489ac6e44eSJoe Perches } 13499ac6e44eSJoe Perches 135057e73442STobin C. Harding int kptr_restrict __read_mostly; 135157e73442STobin C. Harding 135257e73442STobin C. Harding static noinline_for_stack 135357e73442STobin C. Harding char *restricted_pointer(char *buf, char *end, const void *ptr, 135457e73442STobin C. Harding struct printf_spec spec) 135557e73442STobin C. Harding { 135657e73442STobin C. Harding spec.base = 16; 135757e73442STobin C. Harding spec.flags |= SMALL; 135857e73442STobin C. Harding if (spec.field_width == -1) { 135957e73442STobin C. Harding spec.field_width = 2 * sizeof(ptr); 136057e73442STobin C. Harding spec.flags |= ZEROPAD; 136157e73442STobin C. Harding } 136257e73442STobin C. Harding 136357e73442STobin C. Harding switch (kptr_restrict) { 136457e73442STobin C. Harding case 0: 136557e73442STobin C. Harding /* Always print %pK values */ 136657e73442STobin C. Harding break; 136757e73442STobin C. Harding case 1: { 136857e73442STobin C. Harding const struct cred *cred; 136957e73442STobin C. Harding 137057e73442STobin C. Harding /* 137157e73442STobin C. Harding * kptr_restrict==1 cannot be used in IRQ context 137257e73442STobin C. Harding * because its test for CAP_SYSLOG would be meaningless. 137357e73442STobin C. Harding */ 137457e73442STobin C. Harding if (in_irq() || in_serving_softirq() || in_nmi()) 137557e73442STobin C. Harding return string(buf, end, "pK-error", spec); 137657e73442STobin C. Harding 137757e73442STobin C. Harding /* 137857e73442STobin C. Harding * Only print the real pointer value if the current 137957e73442STobin C. Harding * process has CAP_SYSLOG and is running with the 138057e73442STobin C. Harding * same credentials it started with. This is because 138157e73442STobin C. Harding * access to files is checked at open() time, but %pK 138257e73442STobin C. Harding * checks permission at read() time. We don't want to 138357e73442STobin C. Harding * leak pointer values if a binary opens a file using 138457e73442STobin C. Harding * %pK and then elevates privileges before reading it. 138557e73442STobin C. Harding */ 138657e73442STobin C. Harding cred = current_cred(); 138757e73442STobin C. Harding if (!has_capability_noaudit(current, CAP_SYSLOG) || 138857e73442STobin C. Harding !uid_eq(cred->euid, cred->uid) || 138957e73442STobin C. Harding !gid_eq(cred->egid, cred->gid)) 139057e73442STobin C. Harding ptr = NULL; 139157e73442STobin C. Harding break; 139257e73442STobin C. Harding } 139357e73442STobin C. Harding case 2: 139457e73442STobin C. Harding default: 139557e73442STobin C. Harding /* Always print 0's for %pK */ 139657e73442STobin C. Harding ptr = NULL; 139757e73442STobin C. Harding break; 139857e73442STobin C. Harding } 139957e73442STobin C. Harding 140057e73442STobin C. Harding return number(buf, end, (unsigned long)ptr, spec); 140157e73442STobin C. Harding } 140257e73442STobin C. Harding 14035b17aecfSAndy Shevchenko static noinline_for_stack 14045b17aecfSAndy Shevchenko char *netdev_bits(char *buf, char *end, const void *addr, const char *fmt) 1405c8f44affSMichał Mirosław { 14065b17aecfSAndy Shevchenko unsigned long long num; 14075b17aecfSAndy Shevchenko int size; 14085b17aecfSAndy Shevchenko 14095b17aecfSAndy Shevchenko switch (fmt[1]) { 14105b17aecfSAndy Shevchenko case 'F': 14115b17aecfSAndy Shevchenko num = *(const netdev_features_t *)addr; 14125b17aecfSAndy Shevchenko size = sizeof(netdev_features_t); 14135b17aecfSAndy Shevchenko break; 14145b17aecfSAndy Shevchenko default: 14155b17aecfSAndy Shevchenko num = (unsigned long)addr; 14165b17aecfSAndy Shevchenko size = sizeof(unsigned long); 14175b17aecfSAndy Shevchenko break; 14185b17aecfSAndy Shevchenko } 1419c8f44affSMichał Mirosław 14203cab1e71SAndy Shevchenko return special_hex_number(buf, end, num, size); 1421c8f44affSMichał Mirosław } 1422c8f44affSMichał Mirosław 1423aaf07621SJoe Perches static noinline_for_stack 14243cab1e71SAndy Shevchenko char *address_val(char *buf, char *end, const void *addr, const char *fmt) 1425aaf07621SJoe Perches { 1426aaf07621SJoe Perches unsigned long long num; 14273cab1e71SAndy Shevchenko int size; 1428aaf07621SJoe Perches 1429aaf07621SJoe Perches switch (fmt[1]) { 1430aaf07621SJoe Perches case 'd': 1431aaf07621SJoe Perches num = *(const dma_addr_t *)addr; 14323cab1e71SAndy Shevchenko size = sizeof(dma_addr_t); 1433aaf07621SJoe Perches break; 1434aaf07621SJoe Perches case 'p': 1435aaf07621SJoe Perches default: 1436aaf07621SJoe Perches num = *(const phys_addr_t *)addr; 14373cab1e71SAndy Shevchenko size = sizeof(phys_addr_t); 1438aaf07621SJoe Perches break; 1439aaf07621SJoe Perches } 1440aaf07621SJoe Perches 14413cab1e71SAndy Shevchenko return special_hex_number(buf, end, num, size); 1442aaf07621SJoe Perches } 1443aaf07621SJoe Perches 1444900cca29SGeert Uytterhoeven static noinline_for_stack 1445900cca29SGeert Uytterhoeven char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec, 1446900cca29SGeert Uytterhoeven const char *fmt) 1447900cca29SGeert Uytterhoeven { 1448900cca29SGeert Uytterhoeven if (!IS_ENABLED(CONFIG_HAVE_CLK) || !clk) 1449900cca29SGeert Uytterhoeven return string(buf, end, NULL, spec); 1450900cca29SGeert Uytterhoeven 1451900cca29SGeert Uytterhoeven switch (fmt[1]) { 1452900cca29SGeert Uytterhoeven case 'r': 1453900cca29SGeert Uytterhoeven return number(buf, end, clk_get_rate(clk), spec); 1454900cca29SGeert Uytterhoeven 1455900cca29SGeert Uytterhoeven case 'n': 1456900cca29SGeert Uytterhoeven default: 1457900cca29SGeert Uytterhoeven #ifdef CONFIG_COMMON_CLK 1458900cca29SGeert Uytterhoeven return string(buf, end, __clk_get_name(clk), spec); 1459900cca29SGeert Uytterhoeven #else 14603cab1e71SAndy Shevchenko return special_hex_number(buf, end, (unsigned long)clk, sizeof(unsigned long)); 1461900cca29SGeert Uytterhoeven #endif 1462900cca29SGeert Uytterhoeven } 1463900cca29SGeert Uytterhoeven } 1464900cca29SGeert Uytterhoeven 1465edf14cdbSVlastimil Babka static 1466edf14cdbSVlastimil Babka char *format_flags(char *buf, char *end, unsigned long flags, 1467edf14cdbSVlastimil Babka const struct trace_print_flags *names) 1468edf14cdbSVlastimil Babka { 1469edf14cdbSVlastimil Babka unsigned long mask; 1470edf14cdbSVlastimil Babka 1471edf14cdbSVlastimil Babka for ( ; flags && names->name; names++) { 1472edf14cdbSVlastimil Babka mask = names->mask; 1473edf14cdbSVlastimil Babka if ((flags & mask) != mask) 1474edf14cdbSVlastimil Babka continue; 1475edf14cdbSVlastimil Babka 1476abd4fe62SAndy Shevchenko buf = string(buf, end, names->name, default_str_spec); 1477edf14cdbSVlastimil Babka 1478edf14cdbSVlastimil Babka flags &= ~mask; 1479edf14cdbSVlastimil Babka if (flags) { 1480edf14cdbSVlastimil Babka if (buf < end) 1481edf14cdbSVlastimil Babka *buf = '|'; 1482edf14cdbSVlastimil Babka buf++; 1483edf14cdbSVlastimil Babka } 1484edf14cdbSVlastimil Babka } 1485edf14cdbSVlastimil Babka 1486edf14cdbSVlastimil Babka if (flags) 1487*54433973SAndy Shevchenko buf = number(buf, end, flags, default_flag_spec); 1488edf14cdbSVlastimil Babka 1489edf14cdbSVlastimil Babka return buf; 1490edf14cdbSVlastimil Babka } 1491edf14cdbSVlastimil Babka 1492edf14cdbSVlastimil Babka static noinline_for_stack 1493edf14cdbSVlastimil Babka char *flags_string(char *buf, char *end, void *flags_ptr, const char *fmt) 1494edf14cdbSVlastimil Babka { 1495edf14cdbSVlastimil Babka unsigned long flags; 1496edf14cdbSVlastimil Babka const struct trace_print_flags *names; 1497edf14cdbSVlastimil Babka 1498edf14cdbSVlastimil Babka switch (fmt[1]) { 1499edf14cdbSVlastimil Babka case 'p': 1500edf14cdbSVlastimil Babka flags = *(unsigned long *)flags_ptr; 1501edf14cdbSVlastimil Babka /* Remove zone id */ 1502edf14cdbSVlastimil Babka flags &= (1UL << NR_PAGEFLAGS) - 1; 1503edf14cdbSVlastimil Babka names = pageflag_names; 1504edf14cdbSVlastimil Babka break; 1505edf14cdbSVlastimil Babka case 'v': 1506edf14cdbSVlastimil Babka flags = *(unsigned long *)flags_ptr; 1507edf14cdbSVlastimil Babka names = vmaflag_names; 1508edf14cdbSVlastimil Babka break; 1509edf14cdbSVlastimil Babka case 'g': 1510edf14cdbSVlastimil Babka flags = *(gfp_t *)flags_ptr; 1511edf14cdbSVlastimil Babka names = gfpflag_names; 1512edf14cdbSVlastimil Babka break; 1513edf14cdbSVlastimil Babka default: 1514edf14cdbSVlastimil Babka WARN_ONCE(1, "Unsupported flags modifier: %c\n", fmt[1]); 1515edf14cdbSVlastimil Babka return buf; 1516edf14cdbSVlastimil Babka } 1517edf14cdbSVlastimil Babka 1518edf14cdbSVlastimil Babka return format_flags(buf, end, flags, names); 1519edf14cdbSVlastimil Babka } 1520edf14cdbSVlastimil Babka 1521ce4fecf1SPantelis Antoniou static const char *device_node_name_for_depth(const struct device_node *np, int depth) 1522ce4fecf1SPantelis Antoniou { 1523ce4fecf1SPantelis Antoniou for ( ; np && depth; depth--) 1524ce4fecf1SPantelis Antoniou np = np->parent; 1525ce4fecf1SPantelis Antoniou 1526ce4fecf1SPantelis Antoniou return kbasename(np->full_name); 1527ce4fecf1SPantelis Antoniou } 1528ce4fecf1SPantelis Antoniou 1529ce4fecf1SPantelis Antoniou static noinline_for_stack 1530ce4fecf1SPantelis Antoniou char *device_node_gen_full_name(const struct device_node *np, char *buf, char *end) 1531ce4fecf1SPantelis Antoniou { 1532ce4fecf1SPantelis Antoniou int depth; 1533ce4fecf1SPantelis Antoniou const struct device_node *parent = np->parent; 1534ce4fecf1SPantelis Antoniou 1535ce4fecf1SPantelis Antoniou /* special case for root node */ 1536ce4fecf1SPantelis Antoniou if (!parent) 1537abd4fe62SAndy Shevchenko return string(buf, end, "/", default_str_spec); 1538ce4fecf1SPantelis Antoniou 1539ce4fecf1SPantelis Antoniou for (depth = 0; parent->parent; depth++) 1540ce4fecf1SPantelis Antoniou parent = parent->parent; 1541ce4fecf1SPantelis Antoniou 1542ce4fecf1SPantelis Antoniou for ( ; depth >= 0; depth--) { 1543abd4fe62SAndy Shevchenko buf = string(buf, end, "/", default_str_spec); 1544ce4fecf1SPantelis Antoniou buf = string(buf, end, device_node_name_for_depth(np, depth), 1545abd4fe62SAndy Shevchenko default_str_spec); 1546ce4fecf1SPantelis Antoniou } 1547ce4fecf1SPantelis Antoniou return buf; 1548ce4fecf1SPantelis Antoniou } 1549ce4fecf1SPantelis Antoniou 1550ce4fecf1SPantelis Antoniou static noinline_for_stack 1551ce4fecf1SPantelis Antoniou char *device_node_string(char *buf, char *end, struct device_node *dn, 1552ce4fecf1SPantelis Antoniou struct printf_spec spec, const char *fmt) 1553ce4fecf1SPantelis Antoniou { 1554ce4fecf1SPantelis Antoniou char tbuf[sizeof("xxxx") + 1]; 1555ce4fecf1SPantelis Antoniou const char *p; 1556ce4fecf1SPantelis Antoniou int ret; 1557ce4fecf1SPantelis Antoniou char *buf_start = buf; 1558ce4fecf1SPantelis Antoniou struct property *prop; 1559ce4fecf1SPantelis Antoniou bool has_mult, pass; 1560ce4fecf1SPantelis Antoniou static const struct printf_spec num_spec = { 1561ce4fecf1SPantelis Antoniou .flags = SMALL, 1562ce4fecf1SPantelis Antoniou .field_width = -1, 1563ce4fecf1SPantelis Antoniou .precision = -1, 1564ce4fecf1SPantelis Antoniou .base = 10, 1565ce4fecf1SPantelis Antoniou }; 1566ce4fecf1SPantelis Antoniou 1567ce4fecf1SPantelis Antoniou struct printf_spec str_spec = spec; 1568ce4fecf1SPantelis Antoniou str_spec.field_width = -1; 1569ce4fecf1SPantelis Antoniou 1570ce4fecf1SPantelis Antoniou if (!IS_ENABLED(CONFIG_OF)) 1571ce4fecf1SPantelis Antoniou return string(buf, end, "(!OF)", spec); 1572ce4fecf1SPantelis Antoniou 1573ce4fecf1SPantelis Antoniou if ((unsigned long)dn < PAGE_SIZE) 1574ce4fecf1SPantelis Antoniou return string(buf, end, "(null)", spec); 1575ce4fecf1SPantelis Antoniou 1576ce4fecf1SPantelis Antoniou /* simple case without anything any more format specifiers */ 1577ce4fecf1SPantelis Antoniou fmt++; 1578ce4fecf1SPantelis Antoniou if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0) 1579ce4fecf1SPantelis Antoniou fmt = "f"; 1580ce4fecf1SPantelis Antoniou 1581ce4fecf1SPantelis Antoniou for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) { 1582ce4fecf1SPantelis Antoniou if (pass) { 1583ce4fecf1SPantelis Antoniou if (buf < end) 1584ce4fecf1SPantelis Antoniou *buf = ':'; 1585ce4fecf1SPantelis Antoniou buf++; 1586ce4fecf1SPantelis Antoniou } 1587ce4fecf1SPantelis Antoniou 1588ce4fecf1SPantelis Antoniou switch (*fmt) { 1589ce4fecf1SPantelis Antoniou case 'f': /* full_name */ 1590ce4fecf1SPantelis Antoniou buf = device_node_gen_full_name(dn, buf, end); 1591ce4fecf1SPantelis Antoniou break; 1592ce4fecf1SPantelis Antoniou case 'n': /* name */ 1593ce4fecf1SPantelis Antoniou buf = string(buf, end, dn->name, str_spec); 1594ce4fecf1SPantelis Antoniou break; 1595ce4fecf1SPantelis Antoniou case 'p': /* phandle */ 1596ce4fecf1SPantelis Antoniou buf = number(buf, end, (unsigned int)dn->phandle, num_spec); 1597ce4fecf1SPantelis Antoniou break; 1598ce4fecf1SPantelis Antoniou case 'P': /* path-spec */ 1599ce4fecf1SPantelis Antoniou p = kbasename(of_node_full_name(dn)); 1600ce4fecf1SPantelis Antoniou if (!p[1]) 1601ce4fecf1SPantelis Antoniou p = "/"; 1602ce4fecf1SPantelis Antoniou buf = string(buf, end, p, str_spec); 1603ce4fecf1SPantelis Antoniou break; 1604ce4fecf1SPantelis Antoniou case 'F': /* flags */ 1605ce4fecf1SPantelis Antoniou tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; 1606ce4fecf1SPantelis Antoniou tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-'; 1607ce4fecf1SPantelis Antoniou tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-'; 1608ce4fecf1SPantelis Antoniou tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-'; 1609ce4fecf1SPantelis Antoniou tbuf[4] = 0; 1610ce4fecf1SPantelis Antoniou buf = string(buf, end, tbuf, str_spec); 1611ce4fecf1SPantelis Antoniou break; 1612ce4fecf1SPantelis Antoniou case 'c': /* major compatible string */ 1613ce4fecf1SPantelis Antoniou ret = of_property_read_string(dn, "compatible", &p); 1614ce4fecf1SPantelis Antoniou if (!ret) 1615ce4fecf1SPantelis Antoniou buf = string(buf, end, p, str_spec); 1616ce4fecf1SPantelis Antoniou break; 1617ce4fecf1SPantelis Antoniou case 'C': /* full compatible string */ 1618ce4fecf1SPantelis Antoniou has_mult = false; 1619ce4fecf1SPantelis Antoniou of_property_for_each_string(dn, "compatible", prop, p) { 1620ce4fecf1SPantelis Antoniou if (has_mult) 1621ce4fecf1SPantelis Antoniou buf = string(buf, end, ",", str_spec); 1622ce4fecf1SPantelis Antoniou buf = string(buf, end, "\"", str_spec); 1623ce4fecf1SPantelis Antoniou buf = string(buf, end, p, str_spec); 1624ce4fecf1SPantelis Antoniou buf = string(buf, end, "\"", str_spec); 1625ce4fecf1SPantelis Antoniou 1626ce4fecf1SPantelis Antoniou has_mult = true; 1627ce4fecf1SPantelis Antoniou } 1628ce4fecf1SPantelis Antoniou break; 1629ce4fecf1SPantelis Antoniou default: 1630ce4fecf1SPantelis Antoniou break; 1631ce4fecf1SPantelis Antoniou } 1632ce4fecf1SPantelis Antoniou } 1633ce4fecf1SPantelis Antoniou 1634ce4fecf1SPantelis Antoniou return widen_string(buf, buf - buf_start, end, spec); 1635ce4fecf1SPantelis Antoniou } 1636ce4fecf1SPantelis Antoniou 16377b1924a1STobin C. Harding static noinline_for_stack 16387b1924a1STobin C. Harding char *pointer_string(char *buf, char *end, const void *ptr, 16397b1924a1STobin C. Harding struct printf_spec spec) 16407b1924a1STobin C. Harding { 16417b1924a1STobin C. Harding spec.base = 16; 16427b1924a1STobin C. Harding spec.flags |= SMALL; 16437b1924a1STobin C. Harding if (spec.field_width == -1) { 16447b1924a1STobin C. Harding spec.field_width = 2 * sizeof(ptr); 16457b1924a1STobin C. Harding spec.flags |= ZEROPAD; 16467b1924a1STobin C. Harding } 16477b1924a1STobin C. Harding 16487b1924a1STobin C. Harding return number(buf, end, (unsigned long int)ptr, spec); 16497b1924a1STobin C. Harding } 16507b1924a1STobin C. Harding 1651ad67b74dSTobin C. Harding static bool have_filled_random_ptr_key __read_mostly; 1652ad67b74dSTobin C. Harding static siphash_key_t ptr_key __read_mostly; 1653ad67b74dSTobin C. Harding 1654ad67b74dSTobin C. Harding static void fill_random_ptr_key(struct random_ready_callback *unused) 1655ad67b74dSTobin C. Harding { 1656ad67b74dSTobin C. Harding get_random_bytes(&ptr_key, sizeof(ptr_key)); 1657ad67b74dSTobin C. Harding /* 1658ad67b74dSTobin C. Harding * have_filled_random_ptr_key==true is dependent on get_random_bytes(). 1659ad67b74dSTobin C. Harding * ptr_to_id() needs to see have_filled_random_ptr_key==true 1660ad67b74dSTobin C. Harding * after get_random_bytes() returns. 1661ad67b74dSTobin C. Harding */ 1662ad67b74dSTobin C. Harding smp_mb(); 1663ad67b74dSTobin C. Harding WRITE_ONCE(have_filled_random_ptr_key, true); 1664ad67b74dSTobin C. Harding } 1665ad67b74dSTobin C. Harding 1666ad67b74dSTobin C. Harding static struct random_ready_callback random_ready = { 1667ad67b74dSTobin C. Harding .func = fill_random_ptr_key 1668ad67b74dSTobin C. Harding }; 1669ad67b74dSTobin C. Harding 1670ad67b74dSTobin C. Harding static int __init initialize_ptr_random(void) 1671ad67b74dSTobin C. Harding { 1672ad67b74dSTobin C. Harding int ret = add_random_ready_callback(&random_ready); 1673ad67b74dSTobin C. Harding 1674ad67b74dSTobin C. Harding if (!ret) { 1675ad67b74dSTobin C. Harding return 0; 1676ad67b74dSTobin C. Harding } else if (ret == -EALREADY) { 1677ad67b74dSTobin C. Harding fill_random_ptr_key(&random_ready); 1678ad67b74dSTobin C. Harding return 0; 1679ad67b74dSTobin C. Harding } 1680ad67b74dSTobin C. Harding 1681ad67b74dSTobin C. Harding return ret; 1682ad67b74dSTobin C. Harding } 1683ad67b74dSTobin C. Harding early_initcall(initialize_ptr_random); 1684ad67b74dSTobin C. Harding 1685ad67b74dSTobin C. Harding /* Maps a pointer to a 32 bit unique identifier. */ 1686ad67b74dSTobin C. Harding static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec) 1687ad67b74dSTobin C. Harding { 1688ad67b74dSTobin C. Harding unsigned long hashval; 1689ad67b74dSTobin C. Harding const int default_width = 2 * sizeof(ptr); 1690ad67b74dSTobin C. Harding 1691ad67b74dSTobin C. Harding if (unlikely(!have_filled_random_ptr_key)) { 1692ad67b74dSTobin C. Harding spec.field_width = default_width; 1693ad67b74dSTobin C. Harding /* string length must be less than default_width */ 1694ad67b74dSTobin C. Harding return string(buf, end, "(ptrval)", spec); 1695ad67b74dSTobin C. Harding } 1696ad67b74dSTobin C. Harding 1697ad67b74dSTobin C. Harding #ifdef CONFIG_64BIT 1698ad67b74dSTobin C. Harding hashval = (unsigned long)siphash_1u64((u64)ptr, &ptr_key); 1699ad67b74dSTobin C. Harding /* 1700ad67b74dSTobin C. Harding * Mask off the first 32 bits, this makes explicit that we have 1701ad67b74dSTobin C. Harding * modified the address (and 32 bits is plenty for a unique ID). 1702ad67b74dSTobin C. Harding */ 1703ad67b74dSTobin C. Harding hashval = hashval & 0xffffffff; 1704ad67b74dSTobin C. Harding #else 1705ad67b74dSTobin C. Harding hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key); 1706ad67b74dSTobin C. Harding #endif 1707ad67b74dSTobin C. Harding 1708ad67b74dSTobin C. Harding spec.flags |= SMALL; 1709ad67b74dSTobin C. Harding if (spec.field_width == -1) { 1710ad67b74dSTobin C. Harding spec.field_width = default_width; 1711ad67b74dSTobin C. Harding spec.flags |= ZEROPAD; 1712ad67b74dSTobin C. Harding } 1713ad67b74dSTobin C. Harding spec.base = 16; 1714ad67b74dSTobin C. Harding 1715ad67b74dSTobin C. Harding return number(buf, end, hashval, spec); 1716ad67b74dSTobin C. Harding } 1717ad67b74dSTobin C. Harding 17184d8a743cSLinus Torvalds /* 17194d8a743cSLinus Torvalds * Show a '%p' thing. A kernel extension is that the '%p' is followed 17204d8a743cSLinus Torvalds * by an extra set of alphanumeric characters that are extended format 17214d8a743cSLinus Torvalds * specifiers. 17224d8a743cSLinus Torvalds * 17230b523769SJoe Perches * Please update scripts/checkpatch.pl when adding/removing conversion 17240b523769SJoe Perches * characters. (Search for "check for vsprintf extension"). 17250b523769SJoe Perches * 1726332d2e78SLinus Torvalds * Right now we handle: 17270fe1ef24SLinus Torvalds * 17280c8b946eSFrederic Weisbecker * - 'F' For symbolic function descriptor pointers with offset 17290c8b946eSFrederic Weisbecker * - 'f' For simple symbolic function names without offset 17300efb4d20SSteven Rostedt * - 'S' For symbolic direct pointers with offset 17310efb4d20SSteven Rostedt * - 's' For symbolic direct pointers without offset 1732b0d33c2bSJoe Perches * - '[FfSs]R' as above with __builtin_extract_return_addr() translation 17330f77a8d3SNamhyung Kim * - 'B' For backtraced symbolic direct pointers with offset 1734c7dabef8SBjorn Helgaas * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 1735c7dabef8SBjorn Helgaas * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 1736dbc760bcSTejun Heo * - 'b[l]' For a bitmap, the number of bits is determined by the field 1737dbc760bcSTejun Heo * width which must be explicitly specified either as part of the 1738dbc760bcSTejun Heo * format string '%32b[l]' or through '%*b[l]', [l] selects 1739dbc760bcSTejun Heo * range-list format instead of hex format 1740dd45c9cfSHarvey Harrison * - 'M' For a 6-byte MAC address, it prints the address in the 1741dd45c9cfSHarvey Harrison * usual colon-separated hex notation 17428a27f7c9SJoe Perches * - 'm' For a 6-byte MAC address, it prints the hex address without colons 1743bc7259a2SJoe Perches * - 'MF' For a 6-byte MAC FDDI address, it prints the address 1744c8e00060SJoe Perches * with a dash-separated hex notation 17457c59154eSAndy Shevchenko * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth) 17468a27f7c9SJoe Perches * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 17478a27f7c9SJoe Perches * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 17488a27f7c9SJoe Perches * IPv6 uses colon separated network-order 16 bit hex with leading 0's 174910679643SDaniel Borkmann * [S][pfs] 175010679643SDaniel Borkmann * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 175110679643SDaniel Borkmann * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 17528a27f7c9SJoe Perches * - 'i' [46] for 'raw' IPv4/IPv6 addresses 17538a27f7c9SJoe Perches * IPv6 omits the colons (01020304...0f) 17548a27f7c9SJoe Perches * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 175510679643SDaniel Borkmann * [S][pfs] 175610679643SDaniel Borkmann * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 175710679643SDaniel Borkmann * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 175810679643SDaniel Borkmann * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order 175910679643SDaniel Borkmann * - 'I[6S]c' for IPv6 addresses printed as specified by 176029cf519eSJoe Perches * http://tools.ietf.org/html/rfc5952 176171dca95dSAndy Shevchenko * - 'E[achnops]' For an escaped buffer, where rules are defined by combination 176271dca95dSAndy Shevchenko * of the following flags (see string_escape_mem() for the 176371dca95dSAndy Shevchenko * details): 176471dca95dSAndy Shevchenko * a - ESCAPE_ANY 176571dca95dSAndy Shevchenko * c - ESCAPE_SPECIAL 176671dca95dSAndy Shevchenko * h - ESCAPE_HEX 176771dca95dSAndy Shevchenko * n - ESCAPE_NULL 176871dca95dSAndy Shevchenko * o - ESCAPE_OCTAL 176971dca95dSAndy Shevchenko * p - ESCAPE_NP 177071dca95dSAndy Shevchenko * s - ESCAPE_SPACE 177171dca95dSAndy Shevchenko * By default ESCAPE_ANY_NP is used. 17729ac6e44eSJoe Perches * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 17739ac6e44eSJoe Perches * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 17749ac6e44eSJoe Perches * Options for %pU are: 17759ac6e44eSJoe Perches * b big endian lower case hex (default) 17769ac6e44eSJoe Perches * B big endian UPPER case hex 17779ac6e44eSJoe Perches * l little endian lower case hex 17789ac6e44eSJoe Perches * L little endian UPPER case hex 17799ac6e44eSJoe Perches * big endian output byte order is: 17809ac6e44eSJoe Perches * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 17819ac6e44eSJoe Perches * little endian output byte order is: 17829ac6e44eSJoe Perches * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 17837db6f5fbSJoe Perches * - 'V' For a struct va_format which contains a format string * and va_list *, 17847db6f5fbSJoe Perches * call vsnprintf(->format, *->va_list). 17857db6f5fbSJoe Perches * Implements a "recursive vsnprintf". 17867db6f5fbSJoe Perches * Do not use this feature without some mechanism to verify the 17877db6f5fbSJoe Perches * correctness of the format string and va_list arguments. 1788455cd5abSDan Rosenberg * - 'K' For a kernel pointer that should be hidden from unprivileged users 1789c8f44affSMichał Mirosław * - 'NF' For a netdev_features_t 179031550a16SAndy Shevchenko * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with 179131550a16SAndy Shevchenko * a certain separator (' ' by default): 179231550a16SAndy Shevchenko * C colon 179331550a16SAndy Shevchenko * D dash 179431550a16SAndy Shevchenko * N no separator 179531550a16SAndy Shevchenko * The maximum supported length is 64 bytes of the input. Consider 179631550a16SAndy Shevchenko * to use print_hex_dump() for the larger input. 1797aaf07621SJoe Perches * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives 1798aaf07621SJoe Perches * (default assumed to be phys_addr_t, passed by reference) 1799c0d92a57SOlof Johansson * - 'd[234]' For a dentry name (optionally 2-4 last components) 1800c0d92a57SOlof Johansson * - 'D[234]' Same as 'd' but for a struct file 18011031bc58SDmitry Monakhov * - 'g' For block_device name (gendisk + partition number) 1802900cca29SGeert Uytterhoeven * - 'C' For a clock, it prints the name (Common Clock Framework) or address 1803900cca29SGeert Uytterhoeven * (legacy clock framework) of the clock 1804900cca29SGeert Uytterhoeven * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address 1805900cca29SGeert Uytterhoeven * (legacy clock framework) of the clock 1806900cca29SGeert Uytterhoeven * - 'Cr' For a clock, it prints the current rate of the clock 1807edf14cdbSVlastimil Babka * - 'G' For flags to be printed as a collection of symbolic strings that would 1808edf14cdbSVlastimil Babka * construct the specific value. Supported flags given by option: 1809edf14cdbSVlastimil Babka * p page flags (see struct page) given as pointer to unsigned long 1810edf14cdbSVlastimil Babka * g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t 1811edf14cdbSVlastimil Babka * v vma flags (VM_*) given as pointer to unsigned long 1812ce4fecf1SPantelis Antoniou * - 'O' For a kobject based struct. Must be one of the following: 1813ce4fecf1SPantelis Antoniou * - 'OF[fnpPcCF]' For a device tree object 1814ce4fecf1SPantelis Antoniou * Without any optional arguments prints the full_name 1815ce4fecf1SPantelis Antoniou * f device node full_name 1816ce4fecf1SPantelis Antoniou * n device node name 1817ce4fecf1SPantelis Antoniou * p device node phandle 1818ce4fecf1SPantelis Antoniou * P device node path spec (name + @unit) 1819ce4fecf1SPantelis Antoniou * F device node flags 1820ce4fecf1SPantelis Antoniou * c major compatible string 1821ce4fecf1SPantelis Antoniou * C full compatible string 18225e4ee7b1SMartin Kletzander * 18237b1924a1STobin C. Harding * - 'x' For printing the address. Equivalent to "%lx". 18247b1924a1STobin C. Harding * 1825b3ed2321STobin C. Harding * ** When making changes please also update: 1826b3ed2321STobin C. Harding * Documentation/core-api/printk-formats.rst 18279ac6e44eSJoe Perches * 1828332d2e78SLinus Torvalds * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 1829332d2e78SLinus Torvalds * function pointers are really function descriptors, which contain a 1830332d2e78SLinus Torvalds * pointer to the real address. 1831ad67b74dSTobin C. Harding * 1832ad67b74dSTobin C. Harding * Note: The default behaviour (unadorned %p) is to hash the address, 1833ad67b74dSTobin C. Harding * rendering it useful as a unique identifier. 18344d8a743cSLinus Torvalds */ 1835cf3b429bSJoe Perches static noinline_for_stack 1836cf3b429bSJoe Perches char *pointer(const char *fmt, char *buf, char *end, void *ptr, 1837fef20d9cSFrederic Weisbecker struct printf_spec spec) 183878a8bf69SLinus Torvalds { 183980c9eb46SRasmus Villemoes const int default_width = 2 * sizeof(void *); 1840725fe002SGrant Likely 18413a129cc2SAdam Borowski if (!ptr && *fmt != 'K' && *fmt != 'x') { 18425e057981SJoe Perches /* 18435e057981SJoe Perches * Print (null) with the same width as a pointer so it makes 18445e057981SJoe Perches * tabular output look nice. 18455e057981SJoe Perches */ 18465e057981SJoe Perches if (spec.field_width == -1) 1847725fe002SGrant Likely spec.field_width = default_width; 1848fef20d9cSFrederic Weisbecker return string(buf, end, "(null)", spec); 18495e057981SJoe Perches } 1850d97106abSLinus Torvalds 18510fe1ef24SLinus Torvalds switch (*fmt) { 18520fe1ef24SLinus Torvalds case 'F': 18530c8b946eSFrederic Weisbecker case 'f': 18540fe1ef24SLinus Torvalds case 'S': 18559ac6e44eSJoe Perches case 's': 185604b8eb7aSSergey Senozhatsky ptr = dereference_symbol_descriptor(ptr); 185704b8eb7aSSergey Senozhatsky /* Fallthrough */ 18580f77a8d3SNamhyung Kim case 'B': 1859b0d33c2bSJoe Perches return symbol_string(buf, end, ptr, spec, fmt); 1860332d2e78SLinus Torvalds case 'R': 1861c7dabef8SBjorn Helgaas case 'r': 1862fd95541eSBjorn Helgaas return resource_string(buf, end, ptr, spec, fmt); 186331550a16SAndy Shevchenko case 'h': 186431550a16SAndy Shevchenko return hex_string(buf, end, ptr, spec, fmt); 1865dbc760bcSTejun Heo case 'b': 1866dbc760bcSTejun Heo switch (fmt[1]) { 1867dbc760bcSTejun Heo case 'l': 1868dbc760bcSTejun Heo return bitmap_list_string(buf, end, ptr, spec, fmt); 1869dbc760bcSTejun Heo default: 1870dbc760bcSTejun Heo return bitmap_string(buf, end, ptr, spec, fmt); 1871dbc760bcSTejun Heo } 18728a27f7c9SJoe Perches case 'M': /* Colon separated: 00:01:02:03:04:05 */ 18738a27f7c9SJoe Perches case 'm': /* Contiguous: 000102030405 */ 187476597ff9SAndrei Emeltchenko /* [mM]F (FDDI) */ 187576597ff9SAndrei Emeltchenko /* [mM]R (Reverse order; Bluetooth) */ 18768a27f7c9SJoe Perches return mac_address_string(buf, end, ptr, spec, fmt); 18778a27f7c9SJoe Perches case 'I': /* Formatted IP supported 18788a27f7c9SJoe Perches * 4: 1.2.3.4 18798a27f7c9SJoe Perches * 6: 0001:0203:...:0708 18808a27f7c9SJoe Perches * 6c: 1::708 or 1::1.2.3.4 18818a27f7c9SJoe Perches */ 18828a27f7c9SJoe Perches case 'i': /* Contiguous: 18838a27f7c9SJoe Perches * 4: 001.002.003.004 18848a27f7c9SJoe Perches * 6: 000102...0f 18858a27f7c9SJoe Perches */ 18868a27f7c9SJoe Perches switch (fmt[1]) { 18878a27f7c9SJoe Perches case '6': 18888a27f7c9SJoe Perches return ip6_addr_string(buf, end, ptr, spec, fmt); 18898a27f7c9SJoe Perches case '4': 18908a27f7c9SJoe Perches return ip4_addr_string(buf, end, ptr, spec, fmt); 189110679643SDaniel Borkmann case 'S': { 189210679643SDaniel Borkmann const union { 189310679643SDaniel Borkmann struct sockaddr raw; 189410679643SDaniel Borkmann struct sockaddr_in v4; 189510679643SDaniel Borkmann struct sockaddr_in6 v6; 189610679643SDaniel Borkmann } *sa = ptr; 189710679643SDaniel Borkmann 189810679643SDaniel Borkmann switch (sa->raw.sa_family) { 189910679643SDaniel Borkmann case AF_INET: 190010679643SDaniel Borkmann return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt); 190110679643SDaniel Borkmann case AF_INET6: 190210679643SDaniel Borkmann return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt); 190310679643SDaniel Borkmann default: 190410679643SDaniel Borkmann return string(buf, end, "(invalid address)", spec); 190510679643SDaniel Borkmann }} 19068a27f7c9SJoe Perches } 19074aa99606SHarvey Harrison break; 190871dca95dSAndy Shevchenko case 'E': 190971dca95dSAndy Shevchenko return escaped_string(buf, end, ptr, spec, fmt); 19109ac6e44eSJoe Perches case 'U': 19119ac6e44eSJoe Perches return uuid_string(buf, end, ptr, spec, fmt); 19127db6f5fbSJoe Perches case 'V': 19135756b76eSJan Beulich { 19145756b76eSJan Beulich va_list va; 19155756b76eSJan Beulich 19165756b76eSJan Beulich va_copy(va, *((struct va_format *)ptr)->va); 19175756b76eSJan Beulich buf += vsnprintf(buf, end > buf ? end - buf : 0, 19185756b76eSJan Beulich ((struct va_format *)ptr)->fmt, va); 19195756b76eSJan Beulich va_end(va); 19205756b76eSJan Beulich return buf; 19215756b76eSJan Beulich } 1922455cd5abSDan Rosenberg case 'K': 1923ef0010a3SLinus Torvalds if (!kptr_restrict) 1924ef0010a3SLinus Torvalds break; 192557e73442STobin C. Harding return restricted_pointer(buf, end, ptr, spec); 1926c8f44affSMichał Mirosław case 'N': 19275b17aecfSAndy Shevchenko return netdev_bits(buf, end, ptr, fmt); 19287d799210SStepan Moskovchenko case 'a': 19293cab1e71SAndy Shevchenko return address_val(buf, end, ptr, fmt); 19304b6ccca7SAl Viro case 'd': 19314b6ccca7SAl Viro return dentry_name(buf, end, ptr, spec, fmt); 1932900cca29SGeert Uytterhoeven case 'C': 1933900cca29SGeert Uytterhoeven return clock(buf, end, ptr, spec, fmt); 19344b6ccca7SAl Viro case 'D': 19354b6ccca7SAl Viro return dentry_name(buf, end, 19364b6ccca7SAl Viro ((const struct file *)ptr)->f_path.dentry, 19374b6ccca7SAl Viro spec, fmt); 19381031bc58SDmitry Monakhov #ifdef CONFIG_BLOCK 19391031bc58SDmitry Monakhov case 'g': 19401031bc58SDmitry Monakhov return bdev_name(buf, end, ptr, spec, fmt); 19411031bc58SDmitry Monakhov #endif 19421031bc58SDmitry Monakhov 1943edf14cdbSVlastimil Babka case 'G': 1944edf14cdbSVlastimil Babka return flags_string(buf, end, ptr, fmt); 1945ce4fecf1SPantelis Antoniou case 'O': 1946ce4fecf1SPantelis Antoniou switch (fmt[1]) { 1947ce4fecf1SPantelis Antoniou case 'F': 1948ce4fecf1SPantelis Antoniou return device_node_string(buf, end, ptr, spec, fmt + 1); 1949ce4fecf1SPantelis Antoniou } 19507b1924a1STobin C. Harding case 'x': 19517b1924a1STobin C. Harding return pointer_string(buf, end, ptr, spec); 19520fe1ef24SLinus Torvalds } 1953fef20d9cSFrederic Weisbecker 1954ad67b74dSTobin C. Harding /* default is to _not_ leak addresses, hash before printing */ 1955ad67b74dSTobin C. Harding return ptr_to_id(buf, end, ptr, spec); 1956fef20d9cSFrederic Weisbecker } 1957fef20d9cSFrederic Weisbecker 1958fef20d9cSFrederic Weisbecker /* 1959fef20d9cSFrederic Weisbecker * Helper function to decode printf style format. 1960fef20d9cSFrederic Weisbecker * Each call decode a token from the format and return the 1961fef20d9cSFrederic Weisbecker * number of characters read (or likely the delta where it wants 1962fef20d9cSFrederic Weisbecker * to go on the next call). 1963fef20d9cSFrederic Weisbecker * The decoded token is returned through the parameters 1964fef20d9cSFrederic Weisbecker * 1965fef20d9cSFrederic Weisbecker * 'h', 'l', or 'L' for integer fields 1966fef20d9cSFrederic Weisbecker * 'z' support added 23/7/1999 S.H. 1967fef20d9cSFrederic Weisbecker * 'z' changed to 'Z' --davidm 1/25/99 19685b5e0928SAlexey Dobriyan * 'Z' changed to 'z' --adobriyan 2017-01-25 1969fef20d9cSFrederic Weisbecker * 't' added for ptrdiff_t 1970fef20d9cSFrederic Weisbecker * 1971fef20d9cSFrederic Weisbecker * @fmt: the format string 1972fef20d9cSFrederic Weisbecker * @type of the token returned 1973fef20d9cSFrederic Weisbecker * @flags: various flags such as +, -, # tokens.. 1974fef20d9cSFrederic Weisbecker * @field_width: overwritten width 1975fef20d9cSFrederic Weisbecker * @base: base of the number (octal, hex, ...) 1976fef20d9cSFrederic Weisbecker * @precision: precision of a number 1977fef20d9cSFrederic Weisbecker * @qualifier: qualifier of a number (long, size_t, ...) 1978fef20d9cSFrederic Weisbecker */ 1979cf3b429bSJoe Perches static noinline_for_stack 1980cf3b429bSJoe Perches int format_decode(const char *fmt, struct printf_spec *spec) 1981fef20d9cSFrederic Weisbecker { 1982fef20d9cSFrederic Weisbecker const char *start = fmt; 1983d0484193SRasmus Villemoes char qualifier; 1984fef20d9cSFrederic Weisbecker 1985fef20d9cSFrederic Weisbecker /* we finished early by reading the field width */ 1986ed681a91SVegard Nossum if (spec->type == FORMAT_TYPE_WIDTH) { 1987fef20d9cSFrederic Weisbecker if (spec->field_width < 0) { 1988fef20d9cSFrederic Weisbecker spec->field_width = -spec->field_width; 1989fef20d9cSFrederic Weisbecker spec->flags |= LEFT; 1990fef20d9cSFrederic Weisbecker } 1991fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NONE; 1992fef20d9cSFrederic Weisbecker goto precision; 1993fef20d9cSFrederic Weisbecker } 1994fef20d9cSFrederic Weisbecker 1995fef20d9cSFrederic Weisbecker /* we finished early by reading the precision */ 1996fef20d9cSFrederic Weisbecker if (spec->type == FORMAT_TYPE_PRECISION) { 1997fef20d9cSFrederic Weisbecker if (spec->precision < 0) 1998fef20d9cSFrederic Weisbecker spec->precision = 0; 1999fef20d9cSFrederic Weisbecker 2000fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NONE; 2001fef20d9cSFrederic Weisbecker goto qualifier; 2002fef20d9cSFrederic Weisbecker } 2003fef20d9cSFrederic Weisbecker 2004fef20d9cSFrederic Weisbecker /* By default */ 2005fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NONE; 2006fef20d9cSFrederic Weisbecker 2007fef20d9cSFrederic Weisbecker for (; *fmt ; ++fmt) { 2008fef20d9cSFrederic Weisbecker if (*fmt == '%') 2009fef20d9cSFrederic Weisbecker break; 2010fef20d9cSFrederic Weisbecker } 2011fef20d9cSFrederic Weisbecker 2012fef20d9cSFrederic Weisbecker /* Return the current non-format string */ 2013fef20d9cSFrederic Weisbecker if (fmt != start || !*fmt) 2014fef20d9cSFrederic Weisbecker return fmt - start; 2015fef20d9cSFrederic Weisbecker 2016fef20d9cSFrederic Weisbecker /* Process flags */ 2017fef20d9cSFrederic Weisbecker spec->flags = 0; 2018fef20d9cSFrederic Weisbecker 2019fef20d9cSFrederic Weisbecker while (1) { /* this also skips first '%' */ 2020fef20d9cSFrederic Weisbecker bool found = true; 2021fef20d9cSFrederic Weisbecker 2022fef20d9cSFrederic Weisbecker ++fmt; 2023fef20d9cSFrederic Weisbecker 2024fef20d9cSFrederic Weisbecker switch (*fmt) { 2025fef20d9cSFrederic Weisbecker case '-': spec->flags |= LEFT; break; 2026fef20d9cSFrederic Weisbecker case '+': spec->flags |= PLUS; break; 2027fef20d9cSFrederic Weisbecker case ' ': spec->flags |= SPACE; break; 2028fef20d9cSFrederic Weisbecker case '#': spec->flags |= SPECIAL; break; 2029fef20d9cSFrederic Weisbecker case '0': spec->flags |= ZEROPAD; break; 2030fef20d9cSFrederic Weisbecker default: found = false; 2031fef20d9cSFrederic Weisbecker } 2032fef20d9cSFrederic Weisbecker 2033fef20d9cSFrederic Weisbecker if (!found) 2034fef20d9cSFrederic Weisbecker break; 2035fef20d9cSFrederic Weisbecker } 2036fef20d9cSFrederic Weisbecker 2037fef20d9cSFrederic Weisbecker /* get field width */ 2038fef20d9cSFrederic Weisbecker spec->field_width = -1; 2039fef20d9cSFrederic Weisbecker 2040fef20d9cSFrederic Weisbecker if (isdigit(*fmt)) 2041fef20d9cSFrederic Weisbecker spec->field_width = skip_atoi(&fmt); 2042fef20d9cSFrederic Weisbecker else if (*fmt == '*') { 2043fef20d9cSFrederic Weisbecker /* it's the next argument */ 2044ed681a91SVegard Nossum spec->type = FORMAT_TYPE_WIDTH; 2045fef20d9cSFrederic Weisbecker return ++fmt - start; 2046fef20d9cSFrederic Weisbecker } 2047fef20d9cSFrederic Weisbecker 2048fef20d9cSFrederic Weisbecker precision: 2049fef20d9cSFrederic Weisbecker /* get the precision */ 2050fef20d9cSFrederic Weisbecker spec->precision = -1; 2051fef20d9cSFrederic Weisbecker if (*fmt == '.') { 2052fef20d9cSFrederic Weisbecker ++fmt; 2053fef20d9cSFrederic Weisbecker if (isdigit(*fmt)) { 2054fef20d9cSFrederic Weisbecker spec->precision = skip_atoi(&fmt); 2055fef20d9cSFrederic Weisbecker if (spec->precision < 0) 2056fef20d9cSFrederic Weisbecker spec->precision = 0; 2057fef20d9cSFrederic Weisbecker } else if (*fmt == '*') { 2058fef20d9cSFrederic Weisbecker /* it's the next argument */ 2059adf26f84SVegard Nossum spec->type = FORMAT_TYPE_PRECISION; 2060fef20d9cSFrederic Weisbecker return ++fmt - start; 2061fef20d9cSFrederic Weisbecker } 2062fef20d9cSFrederic Weisbecker } 2063fef20d9cSFrederic Weisbecker 2064fef20d9cSFrederic Weisbecker qualifier: 2065fef20d9cSFrederic Weisbecker /* get the conversion qualifier */ 2066d0484193SRasmus Villemoes qualifier = 0; 206775fb8f26SAndy Shevchenko if (*fmt == 'h' || _tolower(*fmt) == 'l' || 20685b5e0928SAlexey Dobriyan *fmt == 'z' || *fmt == 't') { 2069d0484193SRasmus Villemoes qualifier = *fmt++; 2070d0484193SRasmus Villemoes if (unlikely(qualifier == *fmt)) { 2071d0484193SRasmus Villemoes if (qualifier == 'l') { 2072d0484193SRasmus Villemoes qualifier = 'L'; 2073fef20d9cSFrederic Weisbecker ++fmt; 2074d0484193SRasmus Villemoes } else if (qualifier == 'h') { 2075d0484193SRasmus Villemoes qualifier = 'H'; 2076a4e94ef0SZhaolei ++fmt; 2077a4e94ef0SZhaolei } 2078fef20d9cSFrederic Weisbecker } 2079fef20d9cSFrederic Weisbecker } 2080fef20d9cSFrederic Weisbecker 2081fef20d9cSFrederic Weisbecker /* default base */ 2082fef20d9cSFrederic Weisbecker spec->base = 10; 2083fef20d9cSFrederic Weisbecker switch (*fmt) { 2084fef20d9cSFrederic Weisbecker case 'c': 2085fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_CHAR; 2086fef20d9cSFrederic Weisbecker return ++fmt - start; 2087fef20d9cSFrederic Weisbecker 2088fef20d9cSFrederic Weisbecker case 's': 2089fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_STR; 2090fef20d9cSFrederic Weisbecker return ++fmt - start; 2091fef20d9cSFrederic Weisbecker 2092fef20d9cSFrederic Weisbecker case 'p': 2093fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_PTR; 2094ffbfed03SRasmus Villemoes return ++fmt - start; 2095fef20d9cSFrederic Weisbecker 2096fef20d9cSFrederic Weisbecker case '%': 2097fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_PERCENT_CHAR; 2098fef20d9cSFrederic Weisbecker return ++fmt - start; 2099fef20d9cSFrederic Weisbecker 2100fef20d9cSFrederic Weisbecker /* integer number formats - set up the flags and "break" */ 2101fef20d9cSFrederic Weisbecker case 'o': 2102fef20d9cSFrederic Weisbecker spec->base = 8; 2103fef20d9cSFrederic Weisbecker break; 2104fef20d9cSFrederic Weisbecker 2105fef20d9cSFrederic Weisbecker case 'x': 2106fef20d9cSFrederic Weisbecker spec->flags |= SMALL; 2107fef20d9cSFrederic Weisbecker 2108fef20d9cSFrederic Weisbecker case 'X': 2109fef20d9cSFrederic Weisbecker spec->base = 16; 2110fef20d9cSFrederic Weisbecker break; 2111fef20d9cSFrederic Weisbecker 2112fef20d9cSFrederic Weisbecker case 'd': 2113fef20d9cSFrederic Weisbecker case 'i': 211439e874f8SFrederic Weisbecker spec->flags |= SIGN; 2115fef20d9cSFrederic Weisbecker case 'u': 2116fef20d9cSFrederic Weisbecker break; 2117fef20d9cSFrederic Weisbecker 2118708d96fdSRyan Mallon case 'n': 2119708d96fdSRyan Mallon /* 2120b006f19bSRasmus Villemoes * Since %n poses a greater security risk than 2121b006f19bSRasmus Villemoes * utility, treat it as any other invalid or 2122b006f19bSRasmus Villemoes * unsupported format specifier. 2123708d96fdSRyan Mallon */ 2124708d96fdSRyan Mallon /* Fall-through */ 2125708d96fdSRyan Mallon 2126fef20d9cSFrederic Weisbecker default: 2127b006f19bSRasmus Villemoes WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt); 2128fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_INVALID; 2129fef20d9cSFrederic Weisbecker return fmt - start; 2130fef20d9cSFrederic Weisbecker } 2131fef20d9cSFrederic Weisbecker 2132d0484193SRasmus Villemoes if (qualifier == 'L') 2133fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_LONG_LONG; 2134d0484193SRasmus Villemoes else if (qualifier == 'l') { 213551be17dfSRasmus Villemoes BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 213651be17dfSRasmus Villemoes spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 21375b5e0928SAlexey Dobriyan } else if (qualifier == 'z') { 2138fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_SIZE_T; 2139d0484193SRasmus Villemoes } else if (qualifier == 't') { 2140fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_PTRDIFF; 2141d0484193SRasmus Villemoes } else if (qualifier == 'H') { 214251be17dfSRasmus Villemoes BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE); 214351be17dfSRasmus Villemoes spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN); 2144d0484193SRasmus Villemoes } else if (qualifier == 'h') { 214551be17dfSRasmus Villemoes BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT); 214651be17dfSRasmus Villemoes spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN); 2147fef20d9cSFrederic Weisbecker } else { 214851be17dfSRasmus Villemoes BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT); 214951be17dfSRasmus Villemoes spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN); 2150fef20d9cSFrederic Weisbecker } 2151fef20d9cSFrederic Weisbecker 2152fef20d9cSFrederic Weisbecker return ++fmt - start; 215378a8bf69SLinus Torvalds } 215478a8bf69SLinus Torvalds 21554d72ba01SRasmus Villemoes static void 21564d72ba01SRasmus Villemoes set_field_width(struct printf_spec *spec, int width) 21574d72ba01SRasmus Villemoes { 21584d72ba01SRasmus Villemoes spec->field_width = width; 21594d72ba01SRasmus Villemoes if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) { 21604d72ba01SRasmus Villemoes spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX); 21614d72ba01SRasmus Villemoes } 21624d72ba01SRasmus Villemoes } 21634d72ba01SRasmus Villemoes 21644d72ba01SRasmus Villemoes static void 21654d72ba01SRasmus Villemoes set_precision(struct printf_spec *spec, int prec) 21664d72ba01SRasmus Villemoes { 21674d72ba01SRasmus Villemoes spec->precision = prec; 21684d72ba01SRasmus Villemoes if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) { 21694d72ba01SRasmus Villemoes spec->precision = clamp(prec, 0, PRECISION_MAX); 21704d72ba01SRasmus Villemoes } 21714d72ba01SRasmus Villemoes } 21724d72ba01SRasmus Villemoes 21731da177e4SLinus Torvalds /** 21741da177e4SLinus Torvalds * vsnprintf - Format a string and place it in a buffer 21751da177e4SLinus Torvalds * @buf: The buffer to place the result into 21761da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 21771da177e4SLinus Torvalds * @fmt: The format string to use 21781da177e4SLinus Torvalds * @args: Arguments for the format string 21791da177e4SLinus Torvalds * 2180d7ec9a05SRasmus Villemoes * This function generally follows C99 vsnprintf, but has some 2181d7ec9a05SRasmus Villemoes * extensions and a few limitations: 2182d7ec9a05SRasmus Villemoes * 21836cc89134Smchehab@s-opensource.com * - ``%n`` is unsupported 21846cc89134Smchehab@s-opensource.com * - ``%p*`` is handled by pointer() 218520036fdcSAndi Kleen * 218627e7c0e8SJonathan Corbet * See pointer() or Documentation/core-api/printk-formats.rst for more 21875e4ee7b1SMartin Kletzander * extensive description. 21885e4ee7b1SMartin Kletzander * 21895e4ee7b1SMartin Kletzander * **Please update the documentation in both places when making changes** 219080f548e0SAndrew Morton * 21911da177e4SLinus Torvalds * The return value is the number of characters which would 21921da177e4SLinus Torvalds * be generated for the given input, excluding the trailing 21931da177e4SLinus Torvalds * '\0', as per ISO C99. If you want to have the exact 21941da177e4SLinus Torvalds * number of characters written into @buf as return value 219572fd4a35SRobert P. J. Day * (not including the trailing '\0'), use vscnprintf(). If the 21961da177e4SLinus Torvalds * return is greater than or equal to @size, the resulting 21971da177e4SLinus Torvalds * string is truncated. 21981da177e4SLinus Torvalds * 2199ba1835ebSUwe Kleine-König * If you're not already dealing with a va_list consider using snprintf(). 22001da177e4SLinus Torvalds */ 22011da177e4SLinus Torvalds int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 22021da177e4SLinus Torvalds { 22031da177e4SLinus Torvalds unsigned long long num; 2204d4be151bSAndré Goddard Rosa char *str, *end; 2205fef20d9cSFrederic Weisbecker struct printf_spec spec = {0}; 22061da177e4SLinus Torvalds 2207f796937aSJeremy Fitzhardinge /* Reject out-of-range values early. Large positive sizes are 2208f796937aSJeremy Fitzhardinge used for unknown buffer sizes. */ 22092aa2f9e2SRasmus Villemoes if (WARN_ON_ONCE(size > INT_MAX)) 22101da177e4SLinus Torvalds return 0; 22111da177e4SLinus Torvalds 22121da177e4SLinus Torvalds str = buf; 2213f796937aSJeremy Fitzhardinge end = buf + size; 22141da177e4SLinus Torvalds 2215f796937aSJeremy Fitzhardinge /* Make sure end is always >= buf */ 2216f796937aSJeremy Fitzhardinge if (end < buf) { 22171da177e4SLinus Torvalds end = ((void *)-1); 2218f796937aSJeremy Fitzhardinge size = end - buf; 22191da177e4SLinus Torvalds } 22201da177e4SLinus Torvalds 2221fef20d9cSFrederic Weisbecker while (*fmt) { 2222fef20d9cSFrederic Weisbecker const char *old_fmt = fmt; 2223d4be151bSAndré Goddard Rosa int read = format_decode(fmt, &spec); 2224fef20d9cSFrederic Weisbecker 2225fef20d9cSFrederic Weisbecker fmt += read; 2226fef20d9cSFrederic Weisbecker 2227fef20d9cSFrederic Weisbecker switch (spec.type) { 2228fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NONE: { 2229fef20d9cSFrederic Weisbecker int copy = read; 2230fef20d9cSFrederic Weisbecker if (str < end) { 2231fef20d9cSFrederic Weisbecker if (copy > end - str) 2232fef20d9cSFrederic Weisbecker copy = end - str; 2233fef20d9cSFrederic Weisbecker memcpy(str, old_fmt, copy); 2234fef20d9cSFrederic Weisbecker } 2235fef20d9cSFrederic Weisbecker str += read; 2236fef20d9cSFrederic Weisbecker break; 22371da177e4SLinus Torvalds } 22381da177e4SLinus Torvalds 2239ed681a91SVegard Nossum case FORMAT_TYPE_WIDTH: 22404d72ba01SRasmus Villemoes set_field_width(&spec, va_arg(args, int)); 2241fef20d9cSFrederic Weisbecker break; 22421da177e4SLinus Torvalds 2243fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PRECISION: 22444d72ba01SRasmus Villemoes set_precision(&spec, va_arg(args, int)); 2245fef20d9cSFrederic Weisbecker break; 22461da177e4SLinus Torvalds 2247d4be151bSAndré Goddard Rosa case FORMAT_TYPE_CHAR: { 2248d4be151bSAndré Goddard Rosa char c; 2249d4be151bSAndré Goddard Rosa 2250fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 2251fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 2252f796937aSJeremy Fitzhardinge if (str < end) 22531da177e4SLinus Torvalds *str = ' '; 22541da177e4SLinus Torvalds ++str; 2255fef20d9cSFrederic Weisbecker 22561da177e4SLinus Torvalds } 22571da177e4SLinus Torvalds } 22581da177e4SLinus Torvalds c = (unsigned char) va_arg(args, int); 2259f796937aSJeremy Fitzhardinge if (str < end) 22601da177e4SLinus Torvalds *str = c; 22611da177e4SLinus Torvalds ++str; 2262fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 2263f796937aSJeremy Fitzhardinge if (str < end) 22641da177e4SLinus Torvalds *str = ' '; 22651da177e4SLinus Torvalds ++str; 22661da177e4SLinus Torvalds } 2267fef20d9cSFrederic Weisbecker break; 2268d4be151bSAndré Goddard Rosa } 22691da177e4SLinus Torvalds 2270fef20d9cSFrederic Weisbecker case FORMAT_TYPE_STR: 2271fef20d9cSFrederic Weisbecker str = string(str, end, va_arg(args, char *), spec); 2272fef20d9cSFrederic Weisbecker break; 22731da177e4SLinus Torvalds 2274fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTR: 2275ffbfed03SRasmus Villemoes str = pointer(fmt, str, end, va_arg(args, void *), 2276fef20d9cSFrederic Weisbecker spec); 2277fef20d9cSFrederic Weisbecker while (isalnum(*fmt)) 22784d8a743cSLinus Torvalds fmt++; 2279fef20d9cSFrederic Weisbecker break; 22801da177e4SLinus Torvalds 2281fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PERCENT_CHAR: 2282f796937aSJeremy Fitzhardinge if (str < end) 22831da177e4SLinus Torvalds *str = '%'; 22841da177e4SLinus Torvalds ++str; 22851da177e4SLinus Torvalds break; 22861da177e4SLinus Torvalds 2287fef20d9cSFrederic Weisbecker case FORMAT_TYPE_INVALID: 2288b006f19bSRasmus Villemoes /* 2289b006f19bSRasmus Villemoes * Presumably the arguments passed gcc's type 2290b006f19bSRasmus Villemoes * checking, but there is no safe or sane way 2291b006f19bSRasmus Villemoes * for us to continue parsing the format and 2292b006f19bSRasmus Villemoes * fetching from the va_list; the remaining 2293b006f19bSRasmus Villemoes * specifiers and arguments would be out of 2294b006f19bSRasmus Villemoes * sync. 2295b006f19bSRasmus Villemoes */ 2296b006f19bSRasmus Villemoes goto out; 2297fef20d9cSFrederic Weisbecker 2298fef20d9cSFrederic Weisbecker default: 2299fef20d9cSFrederic Weisbecker switch (spec.type) { 2300fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG_LONG: 2301fef20d9cSFrederic Weisbecker num = va_arg(args, long long); 2302fef20d9cSFrederic Weisbecker break; 2303fef20d9cSFrederic Weisbecker case FORMAT_TYPE_ULONG: 2304fef20d9cSFrederic Weisbecker num = va_arg(args, unsigned long); 2305fef20d9cSFrederic Weisbecker break; 2306fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG: 2307fef20d9cSFrederic Weisbecker num = va_arg(args, long); 2308fef20d9cSFrederic Weisbecker break; 2309fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SIZE_T: 2310ef124960SJason Gunthorpe if (spec.flags & SIGN) 2311ef124960SJason Gunthorpe num = va_arg(args, ssize_t); 2312ef124960SJason Gunthorpe else 2313fef20d9cSFrederic Weisbecker num = va_arg(args, size_t); 2314fef20d9cSFrederic Weisbecker break; 2315fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTRDIFF: 2316fef20d9cSFrederic Weisbecker num = va_arg(args, ptrdiff_t); 2317fef20d9cSFrederic Weisbecker break; 2318a4e94ef0SZhaolei case FORMAT_TYPE_UBYTE: 2319a4e94ef0SZhaolei num = (unsigned char) va_arg(args, int); 2320a4e94ef0SZhaolei break; 2321a4e94ef0SZhaolei case FORMAT_TYPE_BYTE: 2322a4e94ef0SZhaolei num = (signed char) va_arg(args, int); 2323a4e94ef0SZhaolei break; 2324fef20d9cSFrederic Weisbecker case FORMAT_TYPE_USHORT: 2325fef20d9cSFrederic Weisbecker num = (unsigned short) va_arg(args, int); 2326fef20d9cSFrederic Weisbecker break; 2327fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SHORT: 2328fef20d9cSFrederic Weisbecker num = (short) va_arg(args, int); 2329fef20d9cSFrederic Weisbecker break; 233039e874f8SFrederic Weisbecker case FORMAT_TYPE_INT: 233139e874f8SFrederic Weisbecker num = (int) va_arg(args, int); 2332fef20d9cSFrederic Weisbecker break; 2333fef20d9cSFrederic Weisbecker default: 2334fef20d9cSFrederic Weisbecker num = va_arg(args, unsigned int); 23351da177e4SLinus Torvalds } 2336fef20d9cSFrederic Weisbecker 2337fef20d9cSFrederic Weisbecker str = number(str, end, num, spec); 23381da177e4SLinus Torvalds } 2339fef20d9cSFrederic Weisbecker } 2340fef20d9cSFrederic Weisbecker 2341b006f19bSRasmus Villemoes out: 2342f796937aSJeremy Fitzhardinge if (size > 0) { 2343f796937aSJeremy Fitzhardinge if (str < end) 23441da177e4SLinus Torvalds *str = '\0'; 2345f796937aSJeremy Fitzhardinge else 23460a6047eeSLinus Torvalds end[-1] = '\0'; 2347f796937aSJeremy Fitzhardinge } 2348fef20d9cSFrederic Weisbecker 2349f796937aSJeremy Fitzhardinge /* the trailing null byte doesn't count towards the total */ 23501da177e4SLinus Torvalds return str-buf; 2351fef20d9cSFrederic Weisbecker 23521da177e4SLinus Torvalds } 23531da177e4SLinus Torvalds EXPORT_SYMBOL(vsnprintf); 23541da177e4SLinus Torvalds 23551da177e4SLinus Torvalds /** 23561da177e4SLinus Torvalds * vscnprintf - Format a string and place it in a buffer 23571da177e4SLinus Torvalds * @buf: The buffer to place the result into 23581da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 23591da177e4SLinus Torvalds * @fmt: The format string to use 23601da177e4SLinus Torvalds * @args: Arguments for the format string 23611da177e4SLinus Torvalds * 23621da177e4SLinus Torvalds * The return value is the number of characters which have been written into 2363b921c69fSAnton Arapov * the @buf not including the trailing '\0'. If @size is == 0 the function 23641da177e4SLinus Torvalds * returns 0. 23651da177e4SLinus Torvalds * 2366ba1835ebSUwe Kleine-König * If you're not already dealing with a va_list consider using scnprintf(). 236720036fdcSAndi Kleen * 236820036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 23691da177e4SLinus Torvalds */ 23701da177e4SLinus Torvalds int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 23711da177e4SLinus Torvalds { 23721da177e4SLinus Torvalds int i; 23731da177e4SLinus Torvalds 23741da177e4SLinus Torvalds i = vsnprintf(buf, size, fmt, args); 23757b9186f5SAndré Goddard Rosa 2376b921c69fSAnton Arapov if (likely(i < size)) 2377b921c69fSAnton Arapov return i; 2378b921c69fSAnton Arapov if (size != 0) 2379b921c69fSAnton Arapov return size - 1; 2380b921c69fSAnton Arapov return 0; 23811da177e4SLinus Torvalds } 23821da177e4SLinus Torvalds EXPORT_SYMBOL(vscnprintf); 23831da177e4SLinus Torvalds 23841da177e4SLinus Torvalds /** 23851da177e4SLinus Torvalds * snprintf - Format a string and place it in a buffer 23861da177e4SLinus Torvalds * @buf: The buffer to place the result into 23871da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 23881da177e4SLinus Torvalds * @fmt: The format string to use 23891da177e4SLinus Torvalds * @...: Arguments for the format string 23901da177e4SLinus Torvalds * 23911da177e4SLinus Torvalds * The return value is the number of characters which would be 23921da177e4SLinus Torvalds * generated for the given input, excluding the trailing null, 23931da177e4SLinus Torvalds * as per ISO C99. If the return is greater than or equal to 23941da177e4SLinus Torvalds * @size, the resulting string is truncated. 239520036fdcSAndi Kleen * 239620036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 23971da177e4SLinus Torvalds */ 23981da177e4SLinus Torvalds int snprintf(char *buf, size_t size, const char *fmt, ...) 23991da177e4SLinus Torvalds { 24001da177e4SLinus Torvalds va_list args; 24011da177e4SLinus Torvalds int i; 24021da177e4SLinus Torvalds 24031da177e4SLinus Torvalds va_start(args, fmt); 24041da177e4SLinus Torvalds i = vsnprintf(buf, size, fmt, args); 24051da177e4SLinus Torvalds va_end(args); 24067b9186f5SAndré Goddard Rosa 24071da177e4SLinus Torvalds return i; 24081da177e4SLinus Torvalds } 24091da177e4SLinus Torvalds EXPORT_SYMBOL(snprintf); 24101da177e4SLinus Torvalds 24111da177e4SLinus Torvalds /** 24121da177e4SLinus Torvalds * scnprintf - Format a string and place it in a buffer 24131da177e4SLinus Torvalds * @buf: The buffer to place the result into 24141da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 24151da177e4SLinus Torvalds * @fmt: The format string to use 24161da177e4SLinus Torvalds * @...: Arguments for the format string 24171da177e4SLinus Torvalds * 24181da177e4SLinus Torvalds * The return value is the number of characters written into @buf not including 2419b903c0b8SChangli Gao * the trailing '\0'. If @size is == 0 the function returns 0. 24201da177e4SLinus Torvalds */ 24211da177e4SLinus Torvalds 24221da177e4SLinus Torvalds int scnprintf(char *buf, size_t size, const char *fmt, ...) 24231da177e4SLinus Torvalds { 24241da177e4SLinus Torvalds va_list args; 24251da177e4SLinus Torvalds int i; 24261da177e4SLinus Torvalds 24271da177e4SLinus Torvalds va_start(args, fmt); 2428b921c69fSAnton Arapov i = vscnprintf(buf, size, fmt, args); 24291da177e4SLinus Torvalds va_end(args); 24307b9186f5SAndré Goddard Rosa 2431b903c0b8SChangli Gao return i; 24321da177e4SLinus Torvalds } 24331da177e4SLinus Torvalds EXPORT_SYMBOL(scnprintf); 24341da177e4SLinus Torvalds 24351da177e4SLinus Torvalds /** 24361da177e4SLinus Torvalds * vsprintf - Format a string and place it in a buffer 24371da177e4SLinus Torvalds * @buf: The buffer to place the result into 24381da177e4SLinus Torvalds * @fmt: The format string to use 24391da177e4SLinus Torvalds * @args: Arguments for the format string 24401da177e4SLinus Torvalds * 24411da177e4SLinus Torvalds * The function returns the number of characters written 244272fd4a35SRobert P. J. Day * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 24431da177e4SLinus Torvalds * buffer overflows. 24441da177e4SLinus Torvalds * 2445ba1835ebSUwe Kleine-König * If you're not already dealing with a va_list consider using sprintf(). 244620036fdcSAndi Kleen * 244720036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 24481da177e4SLinus Torvalds */ 24491da177e4SLinus Torvalds int vsprintf(char *buf, const char *fmt, va_list args) 24501da177e4SLinus Torvalds { 24511da177e4SLinus Torvalds return vsnprintf(buf, INT_MAX, fmt, args); 24521da177e4SLinus Torvalds } 24531da177e4SLinus Torvalds EXPORT_SYMBOL(vsprintf); 24541da177e4SLinus Torvalds 24551da177e4SLinus Torvalds /** 24561da177e4SLinus Torvalds * sprintf - Format a string and place it in a buffer 24571da177e4SLinus Torvalds * @buf: The buffer to place the result into 24581da177e4SLinus Torvalds * @fmt: The format string to use 24591da177e4SLinus Torvalds * @...: Arguments for the format string 24601da177e4SLinus Torvalds * 24611da177e4SLinus Torvalds * The function returns the number of characters written 246272fd4a35SRobert P. J. Day * into @buf. Use snprintf() or scnprintf() in order to avoid 24631da177e4SLinus Torvalds * buffer overflows. 246420036fdcSAndi Kleen * 246520036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 24661da177e4SLinus Torvalds */ 24671da177e4SLinus Torvalds int sprintf(char *buf, const char *fmt, ...) 24681da177e4SLinus Torvalds { 24691da177e4SLinus Torvalds va_list args; 24701da177e4SLinus Torvalds int i; 24711da177e4SLinus Torvalds 24721da177e4SLinus Torvalds va_start(args, fmt); 24731da177e4SLinus Torvalds i = vsnprintf(buf, INT_MAX, fmt, args); 24741da177e4SLinus Torvalds va_end(args); 24757b9186f5SAndré Goddard Rosa 24761da177e4SLinus Torvalds return i; 24771da177e4SLinus Torvalds } 24781da177e4SLinus Torvalds EXPORT_SYMBOL(sprintf); 24791da177e4SLinus Torvalds 24804370aa4aSLai Jiangshan #ifdef CONFIG_BINARY_PRINTF 24814370aa4aSLai Jiangshan /* 24824370aa4aSLai Jiangshan * bprintf service: 24834370aa4aSLai Jiangshan * vbin_printf() - VA arguments to binary data 24844370aa4aSLai Jiangshan * bstr_printf() - Binary data to text string 24854370aa4aSLai Jiangshan */ 24864370aa4aSLai Jiangshan 24874370aa4aSLai Jiangshan /** 24884370aa4aSLai Jiangshan * vbin_printf - Parse a format string and place args' binary value in a buffer 24894370aa4aSLai Jiangshan * @bin_buf: The buffer to place args' binary value 24904370aa4aSLai Jiangshan * @size: The size of the buffer(by words(32bits), not characters) 24914370aa4aSLai Jiangshan * @fmt: The format string to use 24924370aa4aSLai Jiangshan * @args: Arguments for the format string 24934370aa4aSLai Jiangshan * 24944370aa4aSLai Jiangshan * The format follows C99 vsnprintf, except %n is ignored, and its argument 2495da3dae54SMasanari Iida * is skipped. 24964370aa4aSLai Jiangshan * 24974370aa4aSLai Jiangshan * The return value is the number of words(32bits) which would be generated for 24984370aa4aSLai Jiangshan * the given input. 24994370aa4aSLai Jiangshan * 25004370aa4aSLai Jiangshan * NOTE: 25014370aa4aSLai Jiangshan * If the return value is greater than @size, the resulting bin_buf is NOT 25024370aa4aSLai Jiangshan * valid for bstr_printf(). 25034370aa4aSLai Jiangshan */ 25044370aa4aSLai Jiangshan int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 25054370aa4aSLai Jiangshan { 2506fef20d9cSFrederic Weisbecker struct printf_spec spec = {0}; 25074370aa4aSLai Jiangshan char *str, *end; 2508841a915dSSteven Rostedt (VMware) int width; 25094370aa4aSLai Jiangshan 25104370aa4aSLai Jiangshan str = (char *)bin_buf; 25114370aa4aSLai Jiangshan end = (char *)(bin_buf + size); 25124370aa4aSLai Jiangshan 25134370aa4aSLai Jiangshan #define save_arg(type) \ 2514841a915dSSteven Rostedt (VMware) ({ \ 25154370aa4aSLai Jiangshan unsigned long long value; \ 2516841a915dSSteven Rostedt (VMware) if (sizeof(type) == 8) { \ 2517841a915dSSteven Rostedt (VMware) unsigned long long val8; \ 25184370aa4aSLai Jiangshan str = PTR_ALIGN(str, sizeof(u32)); \ 2519841a915dSSteven Rostedt (VMware) val8 = va_arg(args, unsigned long long); \ 25204370aa4aSLai Jiangshan if (str + sizeof(type) <= end) { \ 2521841a915dSSteven Rostedt (VMware) *(u32 *)str = *(u32 *)&val8; \ 2522841a915dSSteven Rostedt (VMware) *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \ 25234370aa4aSLai Jiangshan } \ 2524841a915dSSteven Rostedt (VMware) value = val8; \ 25254370aa4aSLai Jiangshan } else { \ 2526841a915dSSteven Rostedt (VMware) unsigned int val4; \ 25274370aa4aSLai Jiangshan str = PTR_ALIGN(str, sizeof(type)); \ 2528841a915dSSteven Rostedt (VMware) val4 = va_arg(args, int); \ 25294370aa4aSLai Jiangshan if (str + sizeof(type) <= end) \ 2530841a915dSSteven Rostedt (VMware) *(typeof(type) *)str = (type)(long)val4; \ 2531841a915dSSteven Rostedt (VMware) value = (unsigned long long)val4; \ 25324370aa4aSLai Jiangshan } \ 25334370aa4aSLai Jiangshan str += sizeof(type); \ 2534841a915dSSteven Rostedt (VMware) value; \ 2535841a915dSSteven Rostedt (VMware) }) 25364370aa4aSLai Jiangshan 2537fef20d9cSFrederic Weisbecker while (*fmt) { 2538d4be151bSAndré Goddard Rosa int read = format_decode(fmt, &spec); 25394370aa4aSLai Jiangshan 2540fef20d9cSFrederic Weisbecker fmt += read; 2541fef20d9cSFrederic Weisbecker 2542fef20d9cSFrederic Weisbecker switch (spec.type) { 2543fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NONE: 2544d4be151bSAndré Goddard Rosa case FORMAT_TYPE_PERCENT_CHAR: 2545fef20d9cSFrederic Weisbecker break; 2546b006f19bSRasmus Villemoes case FORMAT_TYPE_INVALID: 2547b006f19bSRasmus Villemoes goto out; 2548fef20d9cSFrederic Weisbecker 2549ed681a91SVegard Nossum case FORMAT_TYPE_WIDTH: 2550fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PRECISION: 2551841a915dSSteven Rostedt (VMware) width = (int)save_arg(int); 2552841a915dSSteven Rostedt (VMware) /* Pointers may require the width */ 2553841a915dSSteven Rostedt (VMware) if (*fmt == 'p') 2554841a915dSSteven Rostedt (VMware) set_field_width(&spec, width); 2555fef20d9cSFrederic Weisbecker break; 25564370aa4aSLai Jiangshan 2557fef20d9cSFrederic Weisbecker case FORMAT_TYPE_CHAR: 25584370aa4aSLai Jiangshan save_arg(char); 2559fef20d9cSFrederic Weisbecker break; 2560fef20d9cSFrederic Weisbecker 2561fef20d9cSFrederic Weisbecker case FORMAT_TYPE_STR: { 25624370aa4aSLai Jiangshan const char *save_str = va_arg(args, char *); 25634370aa4aSLai Jiangshan size_t len; 25646c356634SAndré Goddard Rosa 25654370aa4aSLai Jiangshan if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 25664370aa4aSLai Jiangshan || (unsigned long)save_str < PAGE_SIZE) 25670f4f81dcSAndré Goddard Rosa save_str = "(null)"; 25686c356634SAndré Goddard Rosa len = strlen(save_str) + 1; 25696c356634SAndré Goddard Rosa if (str + len < end) 25706c356634SAndré Goddard Rosa memcpy(str, save_str, len); 25716c356634SAndré Goddard Rosa str += len; 2572fef20d9cSFrederic Weisbecker break; 25734370aa4aSLai Jiangshan } 2574fef20d9cSFrederic Weisbecker 2575fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTR: 2576841a915dSSteven Rostedt (VMware) /* Dereferenced pointers must be done now */ 2577841a915dSSteven Rostedt (VMware) switch (*fmt) { 2578841a915dSSteven Rostedt (VMware) /* Dereference of functions is still OK */ 2579841a915dSSteven Rostedt (VMware) case 'S': 2580841a915dSSteven Rostedt (VMware) case 's': 2581841a915dSSteven Rostedt (VMware) case 'F': 2582841a915dSSteven Rostedt (VMware) case 'f': 25834370aa4aSLai Jiangshan save_arg(void *); 2584841a915dSSteven Rostedt (VMware) break; 2585841a915dSSteven Rostedt (VMware) default: 2586841a915dSSteven Rostedt (VMware) if (!isalnum(*fmt)) { 2587841a915dSSteven Rostedt (VMware) save_arg(void *); 2588841a915dSSteven Rostedt (VMware) break; 2589841a915dSSteven Rostedt (VMware) } 2590841a915dSSteven Rostedt (VMware) str = pointer(fmt, str, end, va_arg(args, void *), 2591841a915dSSteven Rostedt (VMware) spec); 2592841a915dSSteven Rostedt (VMware) if (str + 1 < end) 2593841a915dSSteven Rostedt (VMware) *str++ = '\0'; 2594841a915dSSteven Rostedt (VMware) else 2595841a915dSSteven Rostedt (VMware) end[-1] = '\0'; /* Must be nul terminated */ 2596841a915dSSteven Rostedt (VMware) } 25974370aa4aSLai Jiangshan /* skip all alphanumeric pointer suffixes */ 2598fef20d9cSFrederic Weisbecker while (isalnum(*fmt)) 25994370aa4aSLai Jiangshan fmt++; 2600fef20d9cSFrederic Weisbecker break; 2601fef20d9cSFrederic Weisbecker 2602fef20d9cSFrederic Weisbecker default: 2603fef20d9cSFrederic Weisbecker switch (spec.type) { 2604fef20d9cSFrederic Weisbecker 2605fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG_LONG: 2606fef20d9cSFrederic Weisbecker save_arg(long long); 2607fef20d9cSFrederic Weisbecker break; 2608fef20d9cSFrederic Weisbecker case FORMAT_TYPE_ULONG: 2609fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG: 2610fef20d9cSFrederic Weisbecker save_arg(unsigned long); 2611fef20d9cSFrederic Weisbecker break; 2612fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SIZE_T: 2613fef20d9cSFrederic Weisbecker save_arg(size_t); 2614fef20d9cSFrederic Weisbecker break; 2615fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTRDIFF: 2616fef20d9cSFrederic Weisbecker save_arg(ptrdiff_t); 2617fef20d9cSFrederic Weisbecker break; 2618a4e94ef0SZhaolei case FORMAT_TYPE_UBYTE: 2619a4e94ef0SZhaolei case FORMAT_TYPE_BYTE: 2620a4e94ef0SZhaolei save_arg(char); 2621a4e94ef0SZhaolei break; 2622fef20d9cSFrederic Weisbecker case FORMAT_TYPE_USHORT: 2623fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SHORT: 2624fef20d9cSFrederic Weisbecker save_arg(short); 2625fef20d9cSFrederic Weisbecker break; 2626fef20d9cSFrederic Weisbecker default: 2627fef20d9cSFrederic Weisbecker save_arg(int); 2628fef20d9cSFrederic Weisbecker } 2629fef20d9cSFrederic Weisbecker } 2630fef20d9cSFrederic Weisbecker } 2631fef20d9cSFrederic Weisbecker 2632b006f19bSRasmus Villemoes out: 26337b9186f5SAndré Goddard Rosa return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 2634fef20d9cSFrederic Weisbecker #undef save_arg 26354370aa4aSLai Jiangshan } 26364370aa4aSLai Jiangshan EXPORT_SYMBOL_GPL(vbin_printf); 26374370aa4aSLai Jiangshan 26384370aa4aSLai Jiangshan /** 26394370aa4aSLai Jiangshan * bstr_printf - Format a string from binary arguments and place it in a buffer 26404370aa4aSLai Jiangshan * @buf: The buffer to place the result into 26414370aa4aSLai Jiangshan * @size: The size of the buffer, including the trailing null space 26424370aa4aSLai Jiangshan * @fmt: The format string to use 26434370aa4aSLai Jiangshan * @bin_buf: Binary arguments for the format string 26444370aa4aSLai Jiangshan * 26454370aa4aSLai Jiangshan * This function like C99 vsnprintf, but the difference is that vsnprintf gets 26464370aa4aSLai Jiangshan * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 26474370aa4aSLai Jiangshan * a binary buffer that generated by vbin_printf. 26484370aa4aSLai Jiangshan * 26494370aa4aSLai Jiangshan * The format follows C99 vsnprintf, but has some extensions: 26500efb4d20SSteven Rostedt * see vsnprintf comment for details. 26514370aa4aSLai Jiangshan * 26524370aa4aSLai Jiangshan * The return value is the number of characters which would 26534370aa4aSLai Jiangshan * be generated for the given input, excluding the trailing 26544370aa4aSLai Jiangshan * '\0', as per ISO C99. If you want to have the exact 26554370aa4aSLai Jiangshan * number of characters written into @buf as return value 26564370aa4aSLai Jiangshan * (not including the trailing '\0'), use vscnprintf(). If the 26574370aa4aSLai Jiangshan * return is greater than or equal to @size, the resulting 26584370aa4aSLai Jiangshan * string is truncated. 26594370aa4aSLai Jiangshan */ 26604370aa4aSLai Jiangshan int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 26614370aa4aSLai Jiangshan { 2662fef20d9cSFrederic Weisbecker struct printf_spec spec = {0}; 2663d4be151bSAndré Goddard Rosa char *str, *end; 2664d4be151bSAndré Goddard Rosa const char *args = (const char *)bin_buf; 26654370aa4aSLai Jiangshan 2666762abb51SRasmus Villemoes if (WARN_ON_ONCE(size > INT_MAX)) 26674370aa4aSLai Jiangshan return 0; 26684370aa4aSLai Jiangshan 26694370aa4aSLai Jiangshan str = buf; 26704370aa4aSLai Jiangshan end = buf + size; 26714370aa4aSLai Jiangshan 26724370aa4aSLai Jiangshan #define get_arg(type) \ 26734370aa4aSLai Jiangshan ({ \ 26744370aa4aSLai Jiangshan typeof(type) value; \ 26754370aa4aSLai Jiangshan if (sizeof(type) == 8) { \ 26764370aa4aSLai Jiangshan args = PTR_ALIGN(args, sizeof(u32)); \ 26774370aa4aSLai Jiangshan *(u32 *)&value = *(u32 *)args; \ 26784370aa4aSLai Jiangshan *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 26794370aa4aSLai Jiangshan } else { \ 26804370aa4aSLai Jiangshan args = PTR_ALIGN(args, sizeof(type)); \ 26814370aa4aSLai Jiangshan value = *(typeof(type) *)args; \ 26824370aa4aSLai Jiangshan } \ 26834370aa4aSLai Jiangshan args += sizeof(type); \ 26844370aa4aSLai Jiangshan value; \ 26854370aa4aSLai Jiangshan }) 26864370aa4aSLai Jiangshan 26874370aa4aSLai Jiangshan /* Make sure end is always >= buf */ 26884370aa4aSLai Jiangshan if (end < buf) { 26894370aa4aSLai Jiangshan end = ((void *)-1); 26904370aa4aSLai Jiangshan size = end - buf; 26914370aa4aSLai Jiangshan } 26924370aa4aSLai Jiangshan 2693fef20d9cSFrederic Weisbecker while (*fmt) { 2694fef20d9cSFrederic Weisbecker const char *old_fmt = fmt; 2695d4be151bSAndré Goddard Rosa int read = format_decode(fmt, &spec); 2696fef20d9cSFrederic Weisbecker 2697fef20d9cSFrederic Weisbecker fmt += read; 2698fef20d9cSFrederic Weisbecker 2699fef20d9cSFrederic Weisbecker switch (spec.type) { 2700fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NONE: { 2701fef20d9cSFrederic Weisbecker int copy = read; 2702fef20d9cSFrederic Weisbecker if (str < end) { 2703fef20d9cSFrederic Weisbecker if (copy > end - str) 2704fef20d9cSFrederic Weisbecker copy = end - str; 2705fef20d9cSFrederic Weisbecker memcpy(str, old_fmt, copy); 2706fef20d9cSFrederic Weisbecker } 2707fef20d9cSFrederic Weisbecker str += read; 2708fef20d9cSFrederic Weisbecker break; 27094370aa4aSLai Jiangshan } 27104370aa4aSLai Jiangshan 2711ed681a91SVegard Nossum case FORMAT_TYPE_WIDTH: 27124d72ba01SRasmus Villemoes set_field_width(&spec, get_arg(int)); 2713fef20d9cSFrederic Weisbecker break; 27144370aa4aSLai Jiangshan 2715fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PRECISION: 27164d72ba01SRasmus Villemoes set_precision(&spec, get_arg(int)); 2717fef20d9cSFrederic Weisbecker break; 27184370aa4aSLai Jiangshan 2719d4be151bSAndré Goddard Rosa case FORMAT_TYPE_CHAR: { 2720d4be151bSAndré Goddard Rosa char c; 2721d4be151bSAndré Goddard Rosa 2722fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 2723fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 27244370aa4aSLai Jiangshan if (str < end) 27254370aa4aSLai Jiangshan *str = ' '; 27264370aa4aSLai Jiangshan ++str; 27274370aa4aSLai Jiangshan } 27284370aa4aSLai Jiangshan } 27294370aa4aSLai Jiangshan c = (unsigned char) get_arg(char); 27304370aa4aSLai Jiangshan if (str < end) 27314370aa4aSLai Jiangshan *str = c; 27324370aa4aSLai Jiangshan ++str; 2733fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 27344370aa4aSLai Jiangshan if (str < end) 27354370aa4aSLai Jiangshan *str = ' '; 27364370aa4aSLai Jiangshan ++str; 27374370aa4aSLai Jiangshan } 2738fef20d9cSFrederic Weisbecker break; 2739d4be151bSAndré Goddard Rosa } 27404370aa4aSLai Jiangshan 2741fef20d9cSFrederic Weisbecker case FORMAT_TYPE_STR: { 27424370aa4aSLai Jiangshan const char *str_arg = args; 2743d4be151bSAndré Goddard Rosa args += strlen(str_arg) + 1; 2744fef20d9cSFrederic Weisbecker str = string(str, end, (char *)str_arg, spec); 2745fef20d9cSFrederic Weisbecker break; 27464370aa4aSLai Jiangshan } 27474370aa4aSLai Jiangshan 2748841a915dSSteven Rostedt (VMware) case FORMAT_TYPE_PTR: { 2749841a915dSSteven Rostedt (VMware) bool process = false; 2750841a915dSSteven Rostedt (VMware) int copy, len; 2751841a915dSSteven Rostedt (VMware) /* Non function dereferences were already done */ 2752841a915dSSteven Rostedt (VMware) switch (*fmt) { 2753841a915dSSteven Rostedt (VMware) case 'S': 2754841a915dSSteven Rostedt (VMware) case 's': 2755841a915dSSteven Rostedt (VMware) case 'F': 2756841a915dSSteven Rostedt (VMware) case 'f': 2757841a915dSSteven Rostedt (VMware) process = true; 2758841a915dSSteven Rostedt (VMware) break; 2759841a915dSSteven Rostedt (VMware) default: 2760841a915dSSteven Rostedt (VMware) if (!isalnum(*fmt)) { 2761841a915dSSteven Rostedt (VMware) process = true; 2762841a915dSSteven Rostedt (VMware) break; 2763841a915dSSteven Rostedt (VMware) } 2764841a915dSSteven Rostedt (VMware) /* Pointer dereference was already processed */ 2765841a915dSSteven Rostedt (VMware) if (str < end) { 2766841a915dSSteven Rostedt (VMware) len = copy = strlen(args); 2767841a915dSSteven Rostedt (VMware) if (copy > end - str) 2768841a915dSSteven Rostedt (VMware) copy = end - str; 2769841a915dSSteven Rostedt (VMware) memcpy(str, args, copy); 2770841a915dSSteven Rostedt (VMware) str += len; 2771841a915dSSteven Rostedt (VMware) args += len; 2772841a915dSSteven Rostedt (VMware) } 2773841a915dSSteven Rostedt (VMware) } 2774841a915dSSteven Rostedt (VMware) if (process) 2775ffbfed03SRasmus Villemoes str = pointer(fmt, str, end, get_arg(void *), spec); 2776841a915dSSteven Rostedt (VMware) 2777fef20d9cSFrederic Weisbecker while (isalnum(*fmt)) 27784370aa4aSLai Jiangshan fmt++; 2779fef20d9cSFrederic Weisbecker break; 2780841a915dSSteven Rostedt (VMware) } 27814370aa4aSLai Jiangshan 2782fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PERCENT_CHAR: 27834370aa4aSLai Jiangshan if (str < end) 27844370aa4aSLai Jiangshan *str = '%'; 27854370aa4aSLai Jiangshan ++str; 2786fef20d9cSFrederic Weisbecker break; 2787fef20d9cSFrederic Weisbecker 2788b006f19bSRasmus Villemoes case FORMAT_TYPE_INVALID: 2789b006f19bSRasmus Villemoes goto out; 2790b006f19bSRasmus Villemoes 2791d4be151bSAndré Goddard Rosa default: { 2792d4be151bSAndré Goddard Rosa unsigned long long num; 2793d4be151bSAndré Goddard Rosa 2794fef20d9cSFrederic Weisbecker switch (spec.type) { 2795fef20d9cSFrederic Weisbecker 2796fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG_LONG: 27974370aa4aSLai Jiangshan num = get_arg(long long); 2798fef20d9cSFrederic Weisbecker break; 2799fef20d9cSFrederic Weisbecker case FORMAT_TYPE_ULONG: 2800fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG: 2801fef20d9cSFrederic Weisbecker num = get_arg(unsigned long); 2802fef20d9cSFrederic Weisbecker break; 2803fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SIZE_T: 28044370aa4aSLai Jiangshan num = get_arg(size_t); 2805fef20d9cSFrederic Weisbecker break; 2806fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTRDIFF: 28074370aa4aSLai Jiangshan num = get_arg(ptrdiff_t); 2808fef20d9cSFrederic Weisbecker break; 2809a4e94ef0SZhaolei case FORMAT_TYPE_UBYTE: 2810a4e94ef0SZhaolei num = get_arg(unsigned char); 2811a4e94ef0SZhaolei break; 2812a4e94ef0SZhaolei case FORMAT_TYPE_BYTE: 2813a4e94ef0SZhaolei num = get_arg(signed char); 2814a4e94ef0SZhaolei break; 2815fef20d9cSFrederic Weisbecker case FORMAT_TYPE_USHORT: 2816fef20d9cSFrederic Weisbecker num = get_arg(unsigned short); 2817fef20d9cSFrederic Weisbecker break; 2818fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SHORT: 2819fef20d9cSFrederic Weisbecker num = get_arg(short); 2820fef20d9cSFrederic Weisbecker break; 2821fef20d9cSFrederic Weisbecker case FORMAT_TYPE_UINT: 28224370aa4aSLai Jiangshan num = get_arg(unsigned int); 2823fef20d9cSFrederic Weisbecker break; 2824fef20d9cSFrederic Weisbecker default: 2825fef20d9cSFrederic Weisbecker num = get_arg(int); 28264370aa4aSLai Jiangshan } 2827fef20d9cSFrederic Weisbecker 2828fef20d9cSFrederic Weisbecker str = number(str, end, num, spec); 2829d4be151bSAndré Goddard Rosa } /* default: */ 2830d4be151bSAndré Goddard Rosa } /* switch(spec.type) */ 2831d4be151bSAndré Goddard Rosa } /* while(*fmt) */ 2832fef20d9cSFrederic Weisbecker 2833b006f19bSRasmus Villemoes out: 28344370aa4aSLai Jiangshan if (size > 0) { 28354370aa4aSLai Jiangshan if (str < end) 28364370aa4aSLai Jiangshan *str = '\0'; 28374370aa4aSLai Jiangshan else 28384370aa4aSLai Jiangshan end[-1] = '\0'; 28394370aa4aSLai Jiangshan } 2840fef20d9cSFrederic Weisbecker 28414370aa4aSLai Jiangshan #undef get_arg 28424370aa4aSLai Jiangshan 28434370aa4aSLai Jiangshan /* the trailing null byte doesn't count towards the total */ 28444370aa4aSLai Jiangshan return str - buf; 28454370aa4aSLai Jiangshan } 28464370aa4aSLai Jiangshan EXPORT_SYMBOL_GPL(bstr_printf); 28474370aa4aSLai Jiangshan 28484370aa4aSLai Jiangshan /** 28494370aa4aSLai Jiangshan * bprintf - Parse a format string and place args' binary value in a buffer 28504370aa4aSLai Jiangshan * @bin_buf: The buffer to place args' binary value 28514370aa4aSLai Jiangshan * @size: The size of the buffer(by words(32bits), not characters) 28524370aa4aSLai Jiangshan * @fmt: The format string to use 28534370aa4aSLai Jiangshan * @...: Arguments for the format string 28544370aa4aSLai Jiangshan * 28554370aa4aSLai Jiangshan * The function returns the number of words(u32) written 28564370aa4aSLai Jiangshan * into @bin_buf. 28574370aa4aSLai Jiangshan */ 28584370aa4aSLai Jiangshan int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 28594370aa4aSLai Jiangshan { 28604370aa4aSLai Jiangshan va_list args; 28614370aa4aSLai Jiangshan int ret; 28624370aa4aSLai Jiangshan 28634370aa4aSLai Jiangshan va_start(args, fmt); 28644370aa4aSLai Jiangshan ret = vbin_printf(bin_buf, size, fmt, args); 28654370aa4aSLai Jiangshan va_end(args); 28667b9186f5SAndré Goddard Rosa 28674370aa4aSLai Jiangshan return ret; 28684370aa4aSLai Jiangshan } 28694370aa4aSLai Jiangshan EXPORT_SYMBOL_GPL(bprintf); 28704370aa4aSLai Jiangshan 28714370aa4aSLai Jiangshan #endif /* CONFIG_BINARY_PRINTF */ 28724370aa4aSLai Jiangshan 28731da177e4SLinus Torvalds /** 28741da177e4SLinus Torvalds * vsscanf - Unformat a buffer into a list of arguments 28751da177e4SLinus Torvalds * @buf: input buffer 28761da177e4SLinus Torvalds * @fmt: format of buffer 28771da177e4SLinus Torvalds * @args: arguments 28781da177e4SLinus Torvalds */ 28791da177e4SLinus Torvalds int vsscanf(const char *buf, const char *fmt, va_list args) 28801da177e4SLinus Torvalds { 28811da177e4SLinus Torvalds const char *str = buf; 28821da177e4SLinus Torvalds char *next; 28831da177e4SLinus Torvalds char digit; 28841da177e4SLinus Torvalds int num = 0; 2885ef0658f3SJoe Perches u8 qualifier; 288653809751SJan Beulich unsigned int base; 288753809751SJan Beulich union { 288853809751SJan Beulich long long s; 288953809751SJan Beulich unsigned long long u; 289053809751SJan Beulich } val; 2891ef0658f3SJoe Perches s16 field_width; 2892d4be151bSAndré Goddard Rosa bool is_sign; 28931da177e4SLinus Torvalds 2894da99075cSJan Beulich while (*fmt) { 28951da177e4SLinus Torvalds /* skip any white space in format */ 28961da177e4SLinus Torvalds /* white space in format matchs any amount of 28971da177e4SLinus Torvalds * white space, including none, in the input. 28981da177e4SLinus Torvalds */ 28991da177e4SLinus Torvalds if (isspace(*fmt)) { 2900e7d2860bSAndré Goddard Rosa fmt = skip_spaces(++fmt); 2901e7d2860bSAndré Goddard Rosa str = skip_spaces(str); 29021da177e4SLinus Torvalds } 29031da177e4SLinus Torvalds 29041da177e4SLinus Torvalds /* anything that is not a conversion must match exactly */ 29051da177e4SLinus Torvalds if (*fmt != '%' && *fmt) { 29061da177e4SLinus Torvalds if (*fmt++ != *str++) 29071da177e4SLinus Torvalds break; 29081da177e4SLinus Torvalds continue; 29091da177e4SLinus Torvalds } 29101da177e4SLinus Torvalds 29111da177e4SLinus Torvalds if (!*fmt) 29121da177e4SLinus Torvalds break; 29131da177e4SLinus Torvalds ++fmt; 29141da177e4SLinus Torvalds 29151da177e4SLinus Torvalds /* skip this conversion. 29161da177e4SLinus Torvalds * advance both strings to next white space 29171da177e4SLinus Torvalds */ 29181da177e4SLinus Torvalds if (*fmt == '*') { 2919da99075cSJan Beulich if (!*str) 2920da99075cSJan Beulich break; 2921f9310b2fSJessica Yu while (!isspace(*fmt) && *fmt != '%' && *fmt) { 2922f9310b2fSJessica Yu /* '%*[' not yet supported, invalid format */ 2923f9310b2fSJessica Yu if (*fmt == '[') 2924f9310b2fSJessica Yu return num; 29251da177e4SLinus Torvalds fmt++; 2926f9310b2fSJessica Yu } 29271da177e4SLinus Torvalds while (!isspace(*str) && *str) 29281da177e4SLinus Torvalds str++; 29291da177e4SLinus Torvalds continue; 29301da177e4SLinus Torvalds } 29311da177e4SLinus Torvalds 29321da177e4SLinus Torvalds /* get field width */ 29331da177e4SLinus Torvalds field_width = -1; 293453809751SJan Beulich if (isdigit(*fmt)) { 29351da177e4SLinus Torvalds field_width = skip_atoi(&fmt); 293653809751SJan Beulich if (field_width <= 0) 293753809751SJan Beulich break; 293853809751SJan Beulich } 29391da177e4SLinus Torvalds 29401da177e4SLinus Torvalds /* get conversion qualifier */ 29411da177e4SLinus Torvalds qualifier = -1; 294275fb8f26SAndy Shevchenko if (*fmt == 'h' || _tolower(*fmt) == 'l' || 29435b5e0928SAlexey Dobriyan *fmt == 'z') { 29441da177e4SLinus Torvalds qualifier = *fmt++; 29451da177e4SLinus Torvalds if (unlikely(qualifier == *fmt)) { 29461da177e4SLinus Torvalds if (qualifier == 'h') { 29471da177e4SLinus Torvalds qualifier = 'H'; 29481da177e4SLinus Torvalds fmt++; 29491da177e4SLinus Torvalds } else if (qualifier == 'l') { 29501da177e4SLinus Torvalds qualifier = 'L'; 29511da177e4SLinus Torvalds fmt++; 29521da177e4SLinus Torvalds } 29531da177e4SLinus Torvalds } 29541da177e4SLinus Torvalds } 29551da177e4SLinus Torvalds 2956da99075cSJan Beulich if (!*fmt) 2957da99075cSJan Beulich break; 2958da99075cSJan Beulich 2959da99075cSJan Beulich if (*fmt == 'n') { 2960da99075cSJan Beulich /* return number of characters read so far */ 2961da99075cSJan Beulich *va_arg(args, int *) = str - buf; 2962da99075cSJan Beulich ++fmt; 2963da99075cSJan Beulich continue; 2964da99075cSJan Beulich } 2965da99075cSJan Beulich 2966da99075cSJan Beulich if (!*str) 29671da177e4SLinus Torvalds break; 29681da177e4SLinus Torvalds 2969d4be151bSAndré Goddard Rosa base = 10; 29703f623ebaSFabian Frederick is_sign = false; 2971d4be151bSAndré Goddard Rosa 29721da177e4SLinus Torvalds switch (*fmt++) { 29731da177e4SLinus Torvalds case 'c': 29741da177e4SLinus Torvalds { 29751da177e4SLinus Torvalds char *s = (char *)va_arg(args, char*); 29761da177e4SLinus Torvalds if (field_width == -1) 29771da177e4SLinus Torvalds field_width = 1; 29781da177e4SLinus Torvalds do { 29791da177e4SLinus Torvalds *s++ = *str++; 29801da177e4SLinus Torvalds } while (--field_width > 0 && *str); 29811da177e4SLinus Torvalds num++; 29821da177e4SLinus Torvalds } 29831da177e4SLinus Torvalds continue; 29841da177e4SLinus Torvalds case 's': 29851da177e4SLinus Torvalds { 29861da177e4SLinus Torvalds char *s = (char *)va_arg(args, char *); 29871da177e4SLinus Torvalds if (field_width == -1) 29884be929beSAlexey Dobriyan field_width = SHRT_MAX; 29891da177e4SLinus Torvalds /* first, skip leading white space in buffer */ 2990e7d2860bSAndré Goddard Rosa str = skip_spaces(str); 29911da177e4SLinus Torvalds 29921da177e4SLinus Torvalds /* now copy until next white space */ 29937b9186f5SAndré Goddard Rosa while (*str && !isspace(*str) && field_width--) 29941da177e4SLinus Torvalds *s++ = *str++; 29951da177e4SLinus Torvalds *s = '\0'; 29961da177e4SLinus Torvalds num++; 29971da177e4SLinus Torvalds } 29981da177e4SLinus Torvalds continue; 2999f9310b2fSJessica Yu /* 3000f9310b2fSJessica Yu * Warning: This implementation of the '[' conversion specifier 3001f9310b2fSJessica Yu * deviates from its glibc counterpart in the following ways: 3002f9310b2fSJessica Yu * (1) It does NOT support ranges i.e. '-' is NOT a special 3003f9310b2fSJessica Yu * character 3004f9310b2fSJessica Yu * (2) It cannot match the closing bracket ']' itself 3005f9310b2fSJessica Yu * (3) A field width is required 3006f9310b2fSJessica Yu * (4) '%*[' (discard matching input) is currently not supported 3007f9310b2fSJessica Yu * 3008f9310b2fSJessica Yu * Example usage: 3009f9310b2fSJessica Yu * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]", 3010f9310b2fSJessica Yu * buf1, buf2, buf3); 3011f9310b2fSJessica Yu * if (ret < 3) 3012f9310b2fSJessica Yu * // etc.. 3013f9310b2fSJessica Yu */ 3014f9310b2fSJessica Yu case '[': 3015f9310b2fSJessica Yu { 3016f9310b2fSJessica Yu char *s = (char *)va_arg(args, char *); 3017f9310b2fSJessica Yu DECLARE_BITMAP(set, 256) = {0}; 3018f9310b2fSJessica Yu unsigned int len = 0; 3019f9310b2fSJessica Yu bool negate = (*fmt == '^'); 3020f9310b2fSJessica Yu 3021f9310b2fSJessica Yu /* field width is required */ 3022f9310b2fSJessica Yu if (field_width == -1) 3023f9310b2fSJessica Yu return num; 3024f9310b2fSJessica Yu 3025f9310b2fSJessica Yu if (negate) 3026f9310b2fSJessica Yu ++fmt; 3027f9310b2fSJessica Yu 3028f9310b2fSJessica Yu for ( ; *fmt && *fmt != ']'; ++fmt, ++len) 3029f9310b2fSJessica Yu set_bit((u8)*fmt, set); 3030f9310b2fSJessica Yu 3031f9310b2fSJessica Yu /* no ']' or no character set found */ 3032f9310b2fSJessica Yu if (!*fmt || !len) 3033f9310b2fSJessica Yu return num; 3034f9310b2fSJessica Yu ++fmt; 3035f9310b2fSJessica Yu 3036f9310b2fSJessica Yu if (negate) { 3037f9310b2fSJessica Yu bitmap_complement(set, set, 256); 3038f9310b2fSJessica Yu /* exclude null '\0' byte */ 3039f9310b2fSJessica Yu clear_bit(0, set); 3040f9310b2fSJessica Yu } 3041f9310b2fSJessica Yu 3042f9310b2fSJessica Yu /* match must be non-empty */ 3043f9310b2fSJessica Yu if (!test_bit((u8)*str, set)) 3044f9310b2fSJessica Yu return num; 3045f9310b2fSJessica Yu 3046f9310b2fSJessica Yu while (test_bit((u8)*str, set) && field_width--) 3047f9310b2fSJessica Yu *s++ = *str++; 3048f9310b2fSJessica Yu *s = '\0'; 3049f9310b2fSJessica Yu ++num; 3050f9310b2fSJessica Yu } 3051f9310b2fSJessica Yu continue; 30521da177e4SLinus Torvalds case 'o': 30531da177e4SLinus Torvalds base = 8; 30541da177e4SLinus Torvalds break; 30551da177e4SLinus Torvalds case 'x': 30561da177e4SLinus Torvalds case 'X': 30571da177e4SLinus Torvalds base = 16; 30581da177e4SLinus Torvalds break; 30591da177e4SLinus Torvalds case 'i': 30601da177e4SLinus Torvalds base = 0; 30611da177e4SLinus Torvalds case 'd': 30623f623ebaSFabian Frederick is_sign = true; 30631da177e4SLinus Torvalds case 'u': 30641da177e4SLinus Torvalds break; 30651da177e4SLinus Torvalds case '%': 30661da177e4SLinus Torvalds /* looking for '%' in str */ 30671da177e4SLinus Torvalds if (*str++ != '%') 30681da177e4SLinus Torvalds return num; 30691da177e4SLinus Torvalds continue; 30701da177e4SLinus Torvalds default: 30711da177e4SLinus Torvalds /* invalid format; stop here */ 30721da177e4SLinus Torvalds return num; 30731da177e4SLinus Torvalds } 30741da177e4SLinus Torvalds 30751da177e4SLinus Torvalds /* have some sort of integer conversion. 30761da177e4SLinus Torvalds * first, skip white space in buffer. 30771da177e4SLinus Torvalds */ 3078e7d2860bSAndré Goddard Rosa str = skip_spaces(str); 30791da177e4SLinus Torvalds 30801da177e4SLinus Torvalds digit = *str; 30811da177e4SLinus Torvalds if (is_sign && digit == '-') 30821da177e4SLinus Torvalds digit = *(str + 1); 30831da177e4SLinus Torvalds 30841da177e4SLinus Torvalds if (!digit 30851da177e4SLinus Torvalds || (base == 16 && !isxdigit(digit)) 30861da177e4SLinus Torvalds || (base == 10 && !isdigit(digit)) 30871da177e4SLinus Torvalds || (base == 8 && (!isdigit(digit) || digit > '7')) 30881da177e4SLinus Torvalds || (base == 0 && !isdigit(digit))) 30891da177e4SLinus Torvalds break; 30901da177e4SLinus Torvalds 309153809751SJan Beulich if (is_sign) 309253809751SJan Beulich val.s = qualifier != 'L' ? 309353809751SJan Beulich simple_strtol(str, &next, base) : 309453809751SJan Beulich simple_strtoll(str, &next, base); 309553809751SJan Beulich else 309653809751SJan Beulich val.u = qualifier != 'L' ? 309753809751SJan Beulich simple_strtoul(str, &next, base) : 309853809751SJan Beulich simple_strtoull(str, &next, base); 309953809751SJan Beulich 310053809751SJan Beulich if (field_width > 0 && next - str > field_width) { 310153809751SJan Beulich if (base == 0) 310253809751SJan Beulich _parse_integer_fixup_radix(str, &base); 310353809751SJan Beulich while (next - str > field_width) { 310453809751SJan Beulich if (is_sign) 310553809751SJan Beulich val.s = div_s64(val.s, base); 310653809751SJan Beulich else 310753809751SJan Beulich val.u = div_u64(val.u, base); 310853809751SJan Beulich --next; 310953809751SJan Beulich } 311053809751SJan Beulich } 311153809751SJan Beulich 31121da177e4SLinus Torvalds switch (qualifier) { 31131da177e4SLinus Torvalds case 'H': /* that's 'hh' in format */ 311453809751SJan Beulich if (is_sign) 311553809751SJan Beulich *va_arg(args, signed char *) = val.s; 311653809751SJan Beulich else 311753809751SJan Beulich *va_arg(args, unsigned char *) = val.u; 31181da177e4SLinus Torvalds break; 31191da177e4SLinus Torvalds case 'h': 312053809751SJan Beulich if (is_sign) 312153809751SJan Beulich *va_arg(args, short *) = val.s; 312253809751SJan Beulich else 312353809751SJan Beulich *va_arg(args, unsigned short *) = val.u; 31241da177e4SLinus Torvalds break; 31251da177e4SLinus Torvalds case 'l': 312653809751SJan Beulich if (is_sign) 312753809751SJan Beulich *va_arg(args, long *) = val.s; 312853809751SJan Beulich else 312953809751SJan Beulich *va_arg(args, unsigned long *) = val.u; 31301da177e4SLinus Torvalds break; 31311da177e4SLinus Torvalds case 'L': 313253809751SJan Beulich if (is_sign) 313353809751SJan Beulich *va_arg(args, long long *) = val.s; 313453809751SJan Beulich else 313553809751SJan Beulich *va_arg(args, unsigned long long *) = val.u; 31361da177e4SLinus Torvalds break; 31371da177e4SLinus Torvalds case 'z': 313853809751SJan Beulich *va_arg(args, size_t *) = val.u; 31391da177e4SLinus Torvalds break; 31401da177e4SLinus Torvalds default: 314153809751SJan Beulich if (is_sign) 314253809751SJan Beulich *va_arg(args, int *) = val.s; 314353809751SJan Beulich else 314453809751SJan Beulich *va_arg(args, unsigned int *) = val.u; 31451da177e4SLinus Torvalds break; 31461da177e4SLinus Torvalds } 31471da177e4SLinus Torvalds num++; 31481da177e4SLinus Torvalds 31491da177e4SLinus Torvalds if (!next) 31501da177e4SLinus Torvalds break; 31511da177e4SLinus Torvalds str = next; 31521da177e4SLinus Torvalds } 3153c6b40d16SJohannes Berg 31541da177e4SLinus Torvalds return num; 31551da177e4SLinus Torvalds } 31561da177e4SLinus Torvalds EXPORT_SYMBOL(vsscanf); 31571da177e4SLinus Torvalds 31581da177e4SLinus Torvalds /** 31591da177e4SLinus Torvalds * sscanf - Unformat a buffer into a list of arguments 31601da177e4SLinus Torvalds * @buf: input buffer 31611da177e4SLinus Torvalds * @fmt: formatting of buffer 31621da177e4SLinus Torvalds * @...: resulting arguments 31631da177e4SLinus Torvalds */ 31641da177e4SLinus Torvalds int sscanf(const char *buf, const char *fmt, ...) 31651da177e4SLinus Torvalds { 31661da177e4SLinus Torvalds va_list args; 31671da177e4SLinus Torvalds int i; 31681da177e4SLinus Torvalds 31691da177e4SLinus Torvalds va_start(args, fmt); 31701da177e4SLinus Torvalds i = vsscanf(buf, fmt, args); 31711da177e4SLinus Torvalds va_end(args); 31727b9186f5SAndré Goddard Rosa 31731da177e4SLinus Torvalds return i; 31741da177e4SLinus Torvalds } 31751da177e4SLinus Torvalds EXPORT_SYMBOL(sscanf); 3176