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> 201da177e4SLinus Torvalds #include <linux/module.h> 211da177e4SLinus Torvalds #include <linux/types.h> 221da177e4SLinus Torvalds #include <linux/string.h> 231da177e4SLinus Torvalds #include <linux/ctype.h> 241da177e4SLinus Torvalds #include <linux/kernel.h> 250fe1ef24SLinus Torvalds #include <linux/kallsyms.h> 260fe1ef24SLinus Torvalds #include <linux/uaccess.h> 27332d2e78SLinus Torvalds #include <linux/ioport.h> 288a27f7c9SJoe Perches #include <net/addrconf.h> 291da177e4SLinus Torvalds 304e57b681STim Schmielau #include <asm/page.h> /* for PAGE_SIZE */ 311da177e4SLinus Torvalds #include <asm/div64.h> 32deac93dfSJames Bottomley #include <asm/sections.h> /* for dereference_function_descriptor() */ 331da177e4SLinus Torvalds 349b706aeeSDenys Vlasenko /* Works only for digits and letters, but small and fast */ 359b706aeeSDenys Vlasenko #define TOLOWER(x) ((x) | 0x20) 369b706aeeSDenys Vlasenko 37aa46a63eSHarvey Harrison static unsigned int simple_guess_base(const char *cp) 38aa46a63eSHarvey Harrison { 39aa46a63eSHarvey Harrison if (cp[0] == '0') { 40aa46a63eSHarvey Harrison if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2])) 41aa46a63eSHarvey Harrison return 16; 42aa46a63eSHarvey Harrison else 43aa46a63eSHarvey Harrison return 8; 44aa46a63eSHarvey Harrison } else { 45aa46a63eSHarvey Harrison return 10; 46aa46a63eSHarvey Harrison } 47aa46a63eSHarvey Harrison } 48aa46a63eSHarvey Harrison 491da177e4SLinus Torvalds /** 501da177e4SLinus Torvalds * simple_strtoull - convert a string to an unsigned long long 511da177e4SLinus Torvalds * @cp: The start of the string 521da177e4SLinus Torvalds * @endp: A pointer to the end of the parsed string will be placed here 531da177e4SLinus Torvalds * @base: The number base to use 541da177e4SLinus Torvalds */ 551da177e4SLinus Torvalds unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base) 561da177e4SLinus Torvalds { 57aa46a63eSHarvey Harrison unsigned long long result = 0; 581da177e4SLinus Torvalds 59aa46a63eSHarvey Harrison if (!base) 60aa46a63eSHarvey Harrison base = simple_guess_base(cp); 61aa46a63eSHarvey Harrison 62aa46a63eSHarvey Harrison if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x') 631da177e4SLinus Torvalds cp += 2; 64aa46a63eSHarvey Harrison 65aa46a63eSHarvey Harrison while (isxdigit(*cp)) { 66aa46a63eSHarvey Harrison unsigned int value; 67aa46a63eSHarvey Harrison 68aa46a63eSHarvey Harrison value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10; 69aa46a63eSHarvey Harrison if (value >= base) 70aa46a63eSHarvey Harrison break; 711da177e4SLinus Torvalds result = result * base + value; 721da177e4SLinus Torvalds cp++; 731da177e4SLinus Torvalds } 741da177e4SLinus Torvalds if (endp) 751da177e4SLinus Torvalds *endp = (char *)cp; 767b9186f5SAndré Goddard Rosa 771da177e4SLinus Torvalds return result; 781da177e4SLinus Torvalds } 791da177e4SLinus Torvalds EXPORT_SYMBOL(simple_strtoull); 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds /** 82922ac25cSAndré Goddard Rosa * simple_strtoul - convert a string to an unsigned long 83922ac25cSAndré Goddard Rosa * @cp: The start of the string 84922ac25cSAndré Goddard Rosa * @endp: A pointer to the end of the parsed string will be placed here 85922ac25cSAndré Goddard Rosa * @base: The number base to use 86922ac25cSAndré Goddard Rosa */ 87922ac25cSAndré Goddard Rosa unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base) 88922ac25cSAndré Goddard Rosa { 89922ac25cSAndré Goddard Rosa return simple_strtoull(cp, endp, base); 90922ac25cSAndré Goddard Rosa } 91922ac25cSAndré Goddard Rosa EXPORT_SYMBOL(simple_strtoul); 92922ac25cSAndré Goddard Rosa 93922ac25cSAndré Goddard Rosa /** 94922ac25cSAndré Goddard Rosa * simple_strtol - convert a string to a signed long 95922ac25cSAndré Goddard Rosa * @cp: The start of the string 96922ac25cSAndré Goddard Rosa * @endp: A pointer to the end of the parsed string will be placed here 97922ac25cSAndré Goddard Rosa * @base: The number base to use 98922ac25cSAndré Goddard Rosa */ 99922ac25cSAndré Goddard Rosa long simple_strtol(const char *cp, char **endp, unsigned int base) 100922ac25cSAndré Goddard Rosa { 101922ac25cSAndré Goddard Rosa if (*cp == '-') 102922ac25cSAndré Goddard Rosa return -simple_strtoul(cp + 1, endp, base); 103922ac25cSAndré Goddard Rosa 104922ac25cSAndré Goddard Rosa return simple_strtoul(cp, endp, base); 105922ac25cSAndré Goddard Rosa } 106922ac25cSAndré Goddard Rosa EXPORT_SYMBOL(simple_strtol); 107922ac25cSAndré Goddard Rosa 108922ac25cSAndré Goddard Rosa /** 1091da177e4SLinus Torvalds * simple_strtoll - convert a string to a signed long long 1101da177e4SLinus Torvalds * @cp: The start of the string 1111da177e4SLinus Torvalds * @endp: A pointer to the end of the parsed string will be placed here 1121da177e4SLinus Torvalds * @base: The number base to use 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 } 1211da177e4SLinus Torvalds 12206b2a76dSYi Yang /** 12306b2a76dSYi Yang * strict_strtoul - convert a string to an unsigned long strictly 12406b2a76dSYi Yang * @cp: The string to be converted 12506b2a76dSYi Yang * @base: The number base to use 12606b2a76dSYi Yang * @res: The converted result value 12706b2a76dSYi Yang * 12806b2a76dSYi Yang * strict_strtoul converts a string to an unsigned long only if the 12906b2a76dSYi Yang * string is really an unsigned long string, any string containing 13006b2a76dSYi Yang * any invalid char at the tail will be rejected and -EINVAL is returned, 13106b2a76dSYi Yang * only a newline char at the tail is acceptible because people generally 13206b2a76dSYi Yang * change a module parameter in the following way: 13306b2a76dSYi Yang * 13406b2a76dSYi Yang * echo 1024 > /sys/module/e1000/parameters/copybreak 13506b2a76dSYi Yang * 13606b2a76dSYi Yang * echo will append a newline to the tail. 13706b2a76dSYi Yang * 13806b2a76dSYi Yang * It returns 0 if conversion is successful and *res is set to the converted 13906b2a76dSYi Yang * value, otherwise it returns -EINVAL and *res is set to 0. 14006b2a76dSYi Yang * 14106b2a76dSYi Yang * simple_strtoul just ignores the successive invalid characters and 14206b2a76dSYi Yang * return the converted value of prefix part of the string. 14306b2a76dSYi Yang */ 1449d85db22SHarvey Harrison int strict_strtoul(const char *cp, unsigned int base, unsigned long *res) 1459d85db22SHarvey Harrison { 1469d85db22SHarvey Harrison char *tail; 1479d85db22SHarvey Harrison unsigned long val; 1489d85db22SHarvey Harrison size_t len; 1499d85db22SHarvey Harrison 1509d85db22SHarvey Harrison *res = 0; 1519d85db22SHarvey Harrison len = strlen(cp); 1529d85db22SHarvey Harrison if (len == 0) 1539d85db22SHarvey Harrison return -EINVAL; 1549d85db22SHarvey Harrison 1559d85db22SHarvey Harrison val = simple_strtoul(cp, &tail, base); 156e899aa82SPavel Machek if (tail == cp) 157e899aa82SPavel Machek return -EINVAL; 1587b9186f5SAndré Goddard Rosa 1599d85db22SHarvey Harrison if ((*tail == '\0') || 1609d85db22SHarvey Harrison ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 1619d85db22SHarvey Harrison *res = val; 1629d85db22SHarvey Harrison return 0; 1639d85db22SHarvey Harrison } 1649d85db22SHarvey Harrison 1659d85db22SHarvey Harrison return -EINVAL; 1669d85db22SHarvey Harrison } 1679d85db22SHarvey Harrison EXPORT_SYMBOL(strict_strtoul); 16806b2a76dSYi Yang 16906b2a76dSYi Yang /** 17006b2a76dSYi Yang * strict_strtol - convert a string to a long strictly 17106b2a76dSYi Yang * @cp: The string to be converted 17206b2a76dSYi Yang * @base: The number base to use 17306b2a76dSYi Yang * @res: The converted result value 17406b2a76dSYi Yang * 17506b2a76dSYi Yang * strict_strtol is similiar to strict_strtoul, but it allows the first 17606b2a76dSYi Yang * character of a string is '-'. 17706b2a76dSYi Yang * 17806b2a76dSYi Yang * It returns 0 if conversion is successful and *res is set to the converted 17906b2a76dSYi Yang * value, otherwise it returns -EINVAL and *res is set to 0. 18006b2a76dSYi Yang */ 1819d85db22SHarvey Harrison int strict_strtol(const char *cp, unsigned int base, long *res) 1829d85db22SHarvey Harrison { 1839d85db22SHarvey Harrison int ret; 1849d85db22SHarvey Harrison if (*cp == '-') { 1859d85db22SHarvey Harrison ret = strict_strtoul(cp + 1, base, (unsigned long *)res); 1869d85db22SHarvey Harrison if (!ret) 1879d85db22SHarvey Harrison *res = -(*res); 1889d85db22SHarvey Harrison } else { 1899d85db22SHarvey Harrison ret = strict_strtoul(cp, base, (unsigned long *)res); 1909d85db22SHarvey Harrison } 1919d85db22SHarvey Harrison 1929d85db22SHarvey Harrison return ret; 1939d85db22SHarvey Harrison } 1949d85db22SHarvey Harrison EXPORT_SYMBOL(strict_strtol); 19506b2a76dSYi Yang 19606b2a76dSYi Yang /** 19706b2a76dSYi Yang * strict_strtoull - convert a string to an unsigned long long strictly 19806b2a76dSYi Yang * @cp: The string to be converted 19906b2a76dSYi Yang * @base: The number base to use 20006b2a76dSYi Yang * @res: The converted result value 20106b2a76dSYi Yang * 20206b2a76dSYi Yang * strict_strtoull converts a string to an unsigned long long only if the 20306b2a76dSYi Yang * string is really an unsigned long long string, any string containing 20406b2a76dSYi Yang * any invalid char at the tail will be rejected and -EINVAL is returned, 20506b2a76dSYi Yang * only a newline char at the tail is acceptible because people generally 20606b2a76dSYi Yang * change a module parameter in the following way: 20706b2a76dSYi Yang * 20806b2a76dSYi Yang * echo 1024 > /sys/module/e1000/parameters/copybreak 20906b2a76dSYi Yang * 21006b2a76dSYi Yang * echo will append a newline to the tail of the string. 21106b2a76dSYi Yang * 21206b2a76dSYi Yang * It returns 0 if conversion is successful and *res is set to the converted 21306b2a76dSYi Yang * value, otherwise it returns -EINVAL and *res is set to 0. 21406b2a76dSYi Yang * 21506b2a76dSYi Yang * simple_strtoull just ignores the successive invalid characters and 21606b2a76dSYi Yang * return the converted value of prefix part of the string. 21706b2a76dSYi Yang */ 2189d85db22SHarvey Harrison int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res) 2199d85db22SHarvey Harrison { 2209d85db22SHarvey Harrison char *tail; 2219d85db22SHarvey Harrison unsigned long long val; 2229d85db22SHarvey Harrison size_t len; 2239d85db22SHarvey Harrison 2249d85db22SHarvey Harrison *res = 0; 2259d85db22SHarvey Harrison len = strlen(cp); 2269d85db22SHarvey Harrison if (len == 0) 2279d85db22SHarvey Harrison return -EINVAL; 2289d85db22SHarvey Harrison 2299d85db22SHarvey Harrison val = simple_strtoull(cp, &tail, base); 230e899aa82SPavel Machek if (tail == cp) 231e899aa82SPavel Machek return -EINVAL; 2329d85db22SHarvey Harrison if ((*tail == '\0') || 2339d85db22SHarvey Harrison ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 2349d85db22SHarvey Harrison *res = val; 2359d85db22SHarvey Harrison return 0; 2369d85db22SHarvey Harrison } 2379d85db22SHarvey Harrison 2389d85db22SHarvey Harrison return -EINVAL; 2399d85db22SHarvey Harrison } 2409d85db22SHarvey Harrison EXPORT_SYMBOL(strict_strtoull); 24106b2a76dSYi Yang 24206b2a76dSYi Yang /** 24306b2a76dSYi Yang * strict_strtoll - convert a string to a long long strictly 24406b2a76dSYi Yang * @cp: The string to be converted 24506b2a76dSYi Yang * @base: The number base to use 24606b2a76dSYi Yang * @res: The converted result value 24706b2a76dSYi Yang * 24806b2a76dSYi Yang * strict_strtoll is similiar to strict_strtoull, but it allows the first 24906b2a76dSYi Yang * character of a string is '-'. 25006b2a76dSYi Yang * 25106b2a76dSYi Yang * It returns 0 if conversion is successful and *res is set to the converted 25206b2a76dSYi Yang * value, otherwise it returns -EINVAL and *res is set to 0. 25306b2a76dSYi Yang */ 2549d85db22SHarvey Harrison int strict_strtoll(const char *cp, unsigned int base, long long *res) 2559d85db22SHarvey Harrison { 2569d85db22SHarvey Harrison int ret; 2579d85db22SHarvey Harrison if (*cp == '-') { 2589d85db22SHarvey Harrison ret = strict_strtoull(cp + 1, base, (unsigned long long *)res); 2599d85db22SHarvey Harrison if (!ret) 2609d85db22SHarvey Harrison *res = -(*res); 2619d85db22SHarvey Harrison } else { 2629d85db22SHarvey Harrison ret = strict_strtoull(cp, base, (unsigned long long *)res); 2639d85db22SHarvey Harrison } 26406b2a76dSYi Yang 2659d85db22SHarvey Harrison return ret; 2669d85db22SHarvey Harrison } 26706b2a76dSYi Yang EXPORT_SYMBOL(strict_strtoll); 26806b2a76dSYi Yang 2691da177e4SLinus Torvalds static int skip_atoi(const char **s) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds int i = 0; 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds while (isdigit(**s)) 2741da177e4SLinus Torvalds i = i*10 + *((*s)++) - '0'; 2757b9186f5SAndré Goddard Rosa 2761da177e4SLinus Torvalds return i; 2771da177e4SLinus Torvalds } 2781da177e4SLinus Torvalds 2794277eeddSDenis Vlasenko /* Decimal conversion is by far the most typical, and is used 2804277eeddSDenis Vlasenko * for /proc and /sys data. This directly impacts e.g. top performance 2814277eeddSDenis Vlasenko * with many processes running. We optimize it for speed 2824277eeddSDenis Vlasenko * using code from 2834277eeddSDenis Vlasenko * http://www.cs.uiowa.edu/~jones/bcd/decimal.html 2844277eeddSDenis Vlasenko * (with permission from the author, Douglas W. Jones). */ 2854277eeddSDenis Vlasenko 2864277eeddSDenis Vlasenko /* Formats correctly any integer in [0,99999]. 2874277eeddSDenis Vlasenko * Outputs from one to five digits depending on input. 2884277eeddSDenis Vlasenko * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */ 2894277eeddSDenis Vlasenko static char *put_dec_trunc(char *buf, unsigned q) 2904277eeddSDenis Vlasenko { 2914277eeddSDenis Vlasenko unsigned d3, d2, d1, d0; 2924277eeddSDenis Vlasenko d1 = (q>>4) & 0xf; 2934277eeddSDenis Vlasenko d2 = (q>>8) & 0xf; 2944277eeddSDenis Vlasenko d3 = (q>>12); 2954277eeddSDenis Vlasenko 2964277eeddSDenis Vlasenko d0 = 6*(d3 + d2 + d1) + (q & 0xf); 2974277eeddSDenis Vlasenko q = (d0 * 0xcd) >> 11; 2984277eeddSDenis Vlasenko d0 = d0 - 10*q; 2994277eeddSDenis Vlasenko *buf++ = d0 + '0'; /* least significant digit */ 3004277eeddSDenis Vlasenko d1 = q + 9*d3 + 5*d2 + d1; 3014277eeddSDenis Vlasenko if (d1 != 0) { 3024277eeddSDenis Vlasenko q = (d1 * 0xcd) >> 11; 3034277eeddSDenis Vlasenko d1 = d1 - 10*q; 3044277eeddSDenis Vlasenko *buf++ = d1 + '0'; /* next digit */ 3054277eeddSDenis Vlasenko 3064277eeddSDenis Vlasenko d2 = q + 2*d2; 3074277eeddSDenis Vlasenko if ((d2 != 0) || (d3 != 0)) { 3084277eeddSDenis Vlasenko q = (d2 * 0xd) >> 7; 3094277eeddSDenis Vlasenko d2 = d2 - 10*q; 3104277eeddSDenis Vlasenko *buf++ = d2 + '0'; /* next digit */ 3114277eeddSDenis Vlasenko 3124277eeddSDenis Vlasenko d3 = q + 4*d3; 3134277eeddSDenis Vlasenko if (d3 != 0) { 3144277eeddSDenis Vlasenko q = (d3 * 0xcd) >> 11; 3154277eeddSDenis Vlasenko d3 = d3 - 10*q; 3164277eeddSDenis Vlasenko *buf++ = d3 + '0'; /* next digit */ 3174277eeddSDenis Vlasenko if (q != 0) 3184277eeddSDenis Vlasenko *buf++ = q + '0'; /* most sign. digit */ 3194277eeddSDenis Vlasenko } 3204277eeddSDenis Vlasenko } 3214277eeddSDenis Vlasenko } 3227b9186f5SAndré Goddard Rosa 3234277eeddSDenis Vlasenko return buf; 3244277eeddSDenis Vlasenko } 3254277eeddSDenis Vlasenko /* Same with if's removed. Always emits five digits */ 3264277eeddSDenis Vlasenko static char *put_dec_full(char *buf, unsigned q) 3274277eeddSDenis Vlasenko { 3284277eeddSDenis Vlasenko /* BTW, if q is in [0,9999], 8-bit ints will be enough, */ 3294277eeddSDenis Vlasenko /* but anyway, gcc produces better code with full-sized ints */ 3304277eeddSDenis Vlasenko unsigned d3, d2, d1, d0; 3314277eeddSDenis Vlasenko d1 = (q>>4) & 0xf; 3324277eeddSDenis Vlasenko d2 = (q>>8) & 0xf; 3334277eeddSDenis Vlasenko d3 = (q>>12); 3344277eeddSDenis Vlasenko 3357b9186f5SAndré Goddard Rosa /* 3367b9186f5SAndré Goddard Rosa * Possible ways to approx. divide by 10 3377b9186f5SAndré Goddard Rosa * gcc -O2 replaces multiply with shifts and adds 3387b9186f5SAndré Goddard Rosa * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386) 3397b9186f5SAndré Goddard Rosa * (x * 0x67) >> 10: 1100111 3407b9186f5SAndré Goddard Rosa * (x * 0x34) >> 9: 110100 - same 3417b9186f5SAndré Goddard Rosa * (x * 0x1a) >> 8: 11010 - same 3427b9186f5SAndré Goddard Rosa * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386) 3437b9186f5SAndré Goddard Rosa */ 3444277eeddSDenis Vlasenko d0 = 6*(d3 + d2 + d1) + (q & 0xf); 3454277eeddSDenis Vlasenko q = (d0 * 0xcd) >> 11; 3464277eeddSDenis Vlasenko d0 = d0 - 10*q; 3474277eeddSDenis Vlasenko *buf++ = d0 + '0'; 3484277eeddSDenis Vlasenko d1 = q + 9*d3 + 5*d2 + d1; 3494277eeddSDenis Vlasenko q = (d1 * 0xcd) >> 11; 3504277eeddSDenis Vlasenko d1 = d1 - 10*q; 3514277eeddSDenis Vlasenko *buf++ = d1 + '0'; 3524277eeddSDenis Vlasenko 3534277eeddSDenis Vlasenko d2 = q + 2*d2; 3544277eeddSDenis Vlasenko q = (d2 * 0xd) >> 7; 3554277eeddSDenis Vlasenko d2 = d2 - 10*q; 3564277eeddSDenis Vlasenko *buf++ = d2 + '0'; 3574277eeddSDenis Vlasenko 3584277eeddSDenis Vlasenko d3 = q + 4*d3; 3594277eeddSDenis Vlasenko q = (d3 * 0xcd) >> 11; /* - shorter code */ 3604277eeddSDenis Vlasenko /* q = (d3 * 0x67) >> 10; - would also work */ 3614277eeddSDenis Vlasenko d3 = d3 - 10*q; 3624277eeddSDenis Vlasenko *buf++ = d3 + '0'; 3634277eeddSDenis Vlasenko *buf++ = q + '0'; 3647b9186f5SAndré Goddard Rosa 3654277eeddSDenis Vlasenko return buf; 3664277eeddSDenis Vlasenko } 3674277eeddSDenis Vlasenko /* No inlining helps gcc to use registers better */ 3684277eeddSDenis Vlasenko static noinline char *put_dec(char *buf, unsigned long long num) 3694277eeddSDenis Vlasenko { 3704277eeddSDenis Vlasenko while (1) { 3714277eeddSDenis Vlasenko unsigned rem; 3724277eeddSDenis Vlasenko if (num < 100000) 3734277eeddSDenis Vlasenko return put_dec_trunc(buf, num); 3744277eeddSDenis Vlasenko rem = do_div(num, 100000); 3754277eeddSDenis Vlasenko buf = put_dec_full(buf, rem); 3764277eeddSDenis Vlasenko } 3774277eeddSDenis Vlasenko } 3784277eeddSDenis Vlasenko 3791da177e4SLinus Torvalds #define ZEROPAD 1 /* pad with zero */ 3801da177e4SLinus Torvalds #define SIGN 2 /* unsigned/signed long */ 3811da177e4SLinus Torvalds #define PLUS 4 /* show plus */ 3821da177e4SLinus Torvalds #define SPACE 8 /* space if plus */ 3831da177e4SLinus Torvalds #define LEFT 16 /* left justified */ 3849b706aeeSDenys Vlasenko #define SMALL 32 /* Must be 32 == 0x20 */ 3859b706aeeSDenys Vlasenko #define SPECIAL 64 /* 0x */ 3861da177e4SLinus Torvalds 387fef20d9cSFrederic Weisbecker enum format_type { 388fef20d9cSFrederic Weisbecker FORMAT_TYPE_NONE, /* Just a string part */ 389ed681a91SVegard Nossum FORMAT_TYPE_WIDTH, 390fef20d9cSFrederic Weisbecker FORMAT_TYPE_PRECISION, 391fef20d9cSFrederic Weisbecker FORMAT_TYPE_CHAR, 392fef20d9cSFrederic Weisbecker FORMAT_TYPE_STR, 393fef20d9cSFrederic Weisbecker FORMAT_TYPE_PTR, 394fef20d9cSFrederic Weisbecker FORMAT_TYPE_PERCENT_CHAR, 395fef20d9cSFrederic Weisbecker FORMAT_TYPE_INVALID, 396fef20d9cSFrederic Weisbecker FORMAT_TYPE_LONG_LONG, 397fef20d9cSFrederic Weisbecker FORMAT_TYPE_ULONG, 398fef20d9cSFrederic Weisbecker FORMAT_TYPE_LONG, 399a4e94ef0SZhaolei FORMAT_TYPE_UBYTE, 400a4e94ef0SZhaolei FORMAT_TYPE_BYTE, 401fef20d9cSFrederic Weisbecker FORMAT_TYPE_USHORT, 402fef20d9cSFrederic Weisbecker FORMAT_TYPE_SHORT, 403fef20d9cSFrederic Weisbecker FORMAT_TYPE_UINT, 404fef20d9cSFrederic Weisbecker FORMAT_TYPE_INT, 405fef20d9cSFrederic Weisbecker FORMAT_TYPE_NRCHARS, 406fef20d9cSFrederic Weisbecker FORMAT_TYPE_SIZE_T, 407fef20d9cSFrederic Weisbecker FORMAT_TYPE_PTRDIFF 408fef20d9cSFrederic Weisbecker }; 409fef20d9cSFrederic Weisbecker 410fef20d9cSFrederic Weisbecker struct printf_spec { 411fef20d9cSFrederic Weisbecker enum format_type type; 412fef20d9cSFrederic Weisbecker int flags; /* flags to number() */ 413fef20d9cSFrederic Weisbecker int field_width; /* width of output field */ 414fef20d9cSFrederic Weisbecker int base; 415fef20d9cSFrederic Weisbecker int precision; /* # of digits/chars */ 416fef20d9cSFrederic Weisbecker int qualifier; 417fef20d9cSFrederic Weisbecker }; 418fef20d9cSFrederic Weisbecker 419fef20d9cSFrederic Weisbecker static char *number(char *buf, char *end, unsigned long long num, 420fef20d9cSFrederic Weisbecker struct printf_spec spec) 4211da177e4SLinus Torvalds { 4229b706aeeSDenys Vlasenko /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ 4239b706aeeSDenys Vlasenko static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ 4249b706aeeSDenys Vlasenko 4259b706aeeSDenys Vlasenko char tmp[66]; 4269b706aeeSDenys Vlasenko char sign; 4279b706aeeSDenys Vlasenko char locase; 428fef20d9cSFrederic Weisbecker int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10); 4291da177e4SLinus Torvalds int i; 4301da177e4SLinus Torvalds 4319b706aeeSDenys Vlasenko /* locase = 0 or 0x20. ORing digits or letters with 'locase' 4329b706aeeSDenys Vlasenko * produces same digits or (maybe lowercased) letters */ 433fef20d9cSFrederic Weisbecker locase = (spec.flags & SMALL); 434fef20d9cSFrederic Weisbecker if (spec.flags & LEFT) 435fef20d9cSFrederic Weisbecker spec.flags &= ~ZEROPAD; 4361da177e4SLinus Torvalds sign = 0; 437fef20d9cSFrederic Weisbecker if (spec.flags & SIGN) { 4381da177e4SLinus Torvalds if ((signed long long)num < 0) { 4391da177e4SLinus Torvalds sign = '-'; 4401da177e4SLinus Torvalds num = -(signed long long)num; 441fef20d9cSFrederic Weisbecker spec.field_width--; 442fef20d9cSFrederic Weisbecker } else if (spec.flags & PLUS) { 4431da177e4SLinus Torvalds sign = '+'; 444fef20d9cSFrederic Weisbecker spec.field_width--; 445fef20d9cSFrederic Weisbecker } else if (spec.flags & SPACE) { 4461da177e4SLinus Torvalds sign = ' '; 447fef20d9cSFrederic Weisbecker spec.field_width--; 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds } 450b39a7340SDenis Vlasenko if (need_pfx) { 451fef20d9cSFrederic Weisbecker spec.field_width--; 452fef20d9cSFrederic Weisbecker if (spec.base == 16) 453fef20d9cSFrederic Weisbecker spec.field_width--; 4541da177e4SLinus Torvalds } 455b39a7340SDenis Vlasenko 456b39a7340SDenis Vlasenko /* generate full string in tmp[], in reverse order */ 4571da177e4SLinus Torvalds i = 0; 4581da177e4SLinus Torvalds if (num == 0) 4591da177e4SLinus Torvalds tmp[i++] = '0'; 4604277eeddSDenis Vlasenko /* Generic code, for any base: 4614277eeddSDenis Vlasenko else do { 4629b706aeeSDenys Vlasenko tmp[i++] = (digits[do_div(num,base)] | locase); 4634277eeddSDenis Vlasenko } while (num != 0); 4644277eeddSDenis Vlasenko */ 465fef20d9cSFrederic Weisbecker else if (spec.base != 10) { /* 8 or 16 */ 466fef20d9cSFrederic Weisbecker int mask = spec.base - 1; 467b39a7340SDenis Vlasenko int shift = 3; 4687b9186f5SAndré Goddard Rosa 4697b9186f5SAndré Goddard Rosa if (spec.base == 16) 4707b9186f5SAndré Goddard Rosa shift = 4; 471b39a7340SDenis Vlasenko do { 4729b706aeeSDenys Vlasenko tmp[i++] = (digits[((unsigned char)num) & mask] | locase); 473b39a7340SDenis Vlasenko num >>= shift; 474b39a7340SDenis Vlasenko } while (num); 4754277eeddSDenis Vlasenko } else { /* base 10 */ 4764277eeddSDenis Vlasenko i = put_dec(tmp, num) - tmp; 4774277eeddSDenis Vlasenko } 478b39a7340SDenis Vlasenko 479b39a7340SDenis Vlasenko /* printing 100 using %2d gives "100", not "00" */ 480fef20d9cSFrederic Weisbecker if (i > spec.precision) 481fef20d9cSFrederic Weisbecker spec.precision = i; 482b39a7340SDenis Vlasenko /* leading space padding */ 483fef20d9cSFrederic Weisbecker spec.field_width -= spec.precision; 484fef20d9cSFrederic Weisbecker if (!(spec.flags & (ZEROPAD+LEFT))) { 485fef20d9cSFrederic Weisbecker while (--spec.field_width >= 0) { 486f796937aSJeremy Fitzhardinge if (buf < end) 4871da177e4SLinus Torvalds *buf = ' '; 4881da177e4SLinus Torvalds ++buf; 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds } 491b39a7340SDenis Vlasenko /* sign */ 4921da177e4SLinus Torvalds if (sign) { 493f796937aSJeremy Fitzhardinge if (buf < end) 4941da177e4SLinus Torvalds *buf = sign; 4951da177e4SLinus Torvalds ++buf; 4961da177e4SLinus Torvalds } 497b39a7340SDenis Vlasenko /* "0x" / "0" prefix */ 498b39a7340SDenis Vlasenko if (need_pfx) { 499f796937aSJeremy Fitzhardinge if (buf < end) 5001da177e4SLinus Torvalds *buf = '0'; 5011da177e4SLinus Torvalds ++buf; 502fef20d9cSFrederic Weisbecker if (spec.base == 16) { 503f796937aSJeremy Fitzhardinge if (buf < end) 5049b706aeeSDenys Vlasenko *buf = ('X' | locase); 5051da177e4SLinus Torvalds ++buf; 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds } 508b39a7340SDenis Vlasenko /* zero or space padding */ 509fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 510fef20d9cSFrederic Weisbecker char c = (spec.flags & ZEROPAD) ? '0' : ' '; 511fef20d9cSFrederic Weisbecker while (--spec.field_width >= 0) { 512f796937aSJeremy Fitzhardinge if (buf < end) 5131da177e4SLinus Torvalds *buf = c; 5141da177e4SLinus Torvalds ++buf; 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds } 517b39a7340SDenis Vlasenko /* hmm even more zero padding? */ 518fef20d9cSFrederic Weisbecker while (i <= --spec.precision) { 519f796937aSJeremy Fitzhardinge if (buf < end) 5201da177e4SLinus Torvalds *buf = '0'; 5211da177e4SLinus Torvalds ++buf; 5221da177e4SLinus Torvalds } 523b39a7340SDenis Vlasenko /* actual digits of result */ 524b39a7340SDenis Vlasenko while (--i >= 0) { 525f796937aSJeremy Fitzhardinge if (buf < end) 5261da177e4SLinus Torvalds *buf = tmp[i]; 5271da177e4SLinus Torvalds ++buf; 5281da177e4SLinus Torvalds } 529b39a7340SDenis Vlasenko /* trailing space padding */ 530fef20d9cSFrederic Weisbecker while (--spec.field_width >= 0) { 531f796937aSJeremy Fitzhardinge if (buf < end) 5321da177e4SLinus Torvalds *buf = ' '; 5331da177e4SLinus Torvalds ++buf; 5341da177e4SLinus Torvalds } 5357b9186f5SAndré Goddard Rosa 5361da177e4SLinus Torvalds return buf; 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds 5390f4f81dcSAndré Goddard Rosa static char *string(char *buf, char *end, const char *s, struct printf_spec spec) 5400f9bfa56SLinus Torvalds { 5410f9bfa56SLinus Torvalds int len, i; 5420f9bfa56SLinus Torvalds 5430f9bfa56SLinus Torvalds if ((unsigned long)s < PAGE_SIZE) 5440f4f81dcSAndré Goddard Rosa s = "(null)"; 5450f9bfa56SLinus Torvalds 546fef20d9cSFrederic Weisbecker len = strnlen(s, spec.precision); 5470f9bfa56SLinus Torvalds 548fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 549fef20d9cSFrederic Weisbecker while (len < spec.field_width--) { 5500f9bfa56SLinus Torvalds if (buf < end) 5510f9bfa56SLinus Torvalds *buf = ' '; 5520f9bfa56SLinus Torvalds ++buf; 5530f9bfa56SLinus Torvalds } 5540f9bfa56SLinus Torvalds } 5550f9bfa56SLinus Torvalds for (i = 0; i < len; ++i) { 5560f9bfa56SLinus Torvalds if (buf < end) 5570f9bfa56SLinus Torvalds *buf = *s; 5580f9bfa56SLinus Torvalds ++buf; ++s; 5590f9bfa56SLinus Torvalds } 560fef20d9cSFrederic Weisbecker while (len < spec.field_width--) { 5610f9bfa56SLinus Torvalds if (buf < end) 5620f9bfa56SLinus Torvalds *buf = ' '; 5630f9bfa56SLinus Torvalds ++buf; 5640f9bfa56SLinus Torvalds } 5657b9186f5SAndré Goddard Rosa 5660f9bfa56SLinus Torvalds return buf; 5670f9bfa56SLinus Torvalds } 5680f9bfa56SLinus Torvalds 569fef20d9cSFrederic Weisbecker static char *symbol_string(char *buf, char *end, void *ptr, 5700c8b946eSFrederic Weisbecker struct printf_spec spec, char ext) 5710fe1ef24SLinus Torvalds { 5720fe1ef24SLinus Torvalds unsigned long value = (unsigned long) ptr; 5730fe1ef24SLinus Torvalds #ifdef CONFIG_KALLSYMS 5740fe1ef24SLinus Torvalds char sym[KSYM_SYMBOL_LEN]; 57591adcd2cSSteven Rostedt if (ext != 'f' && ext != 's') 5760fe1ef24SLinus Torvalds sprint_symbol(sym, value); 5770c8b946eSFrederic Weisbecker else 5780c8b946eSFrederic Weisbecker kallsyms_lookup(value, NULL, NULL, NULL, sym); 5797b9186f5SAndré Goddard Rosa 580fef20d9cSFrederic Weisbecker return string(buf, end, sym, spec); 5810fe1ef24SLinus Torvalds #else 582fef20d9cSFrederic Weisbecker spec.field_width = 2 * sizeof(void *); 583fef20d9cSFrederic Weisbecker spec.flags |= SPECIAL | SMALL | ZEROPAD; 584fef20d9cSFrederic Weisbecker spec.base = 16; 5857b9186f5SAndré Goddard Rosa 586fef20d9cSFrederic Weisbecker return number(buf, end, value, spec); 5870fe1ef24SLinus Torvalds #endif 5880fe1ef24SLinus Torvalds } 5890fe1ef24SLinus Torvalds 590fef20d9cSFrederic Weisbecker static char *resource_string(char *buf, char *end, struct resource *res, 591fd95541eSBjorn Helgaas struct printf_spec spec, const char *fmt) 592332d2e78SLinus Torvalds { 593332d2e78SLinus Torvalds #ifndef IO_RSRC_PRINTK_SIZE 59428405372SBjorn Helgaas #define IO_RSRC_PRINTK_SIZE 6 595332d2e78SLinus Torvalds #endif 596332d2e78SLinus Torvalds 597332d2e78SLinus Torvalds #ifndef MEM_RSRC_PRINTK_SIZE 59828405372SBjorn Helgaas #define MEM_RSRC_PRINTK_SIZE 10 599332d2e78SLinus Torvalds #endif 600c91d3376SBjorn Helgaas struct printf_spec hex_spec = { 601fef20d9cSFrederic Weisbecker .base = 16, 602fef20d9cSFrederic Weisbecker .precision = -1, 603fef20d9cSFrederic Weisbecker .flags = SPECIAL | SMALL | ZEROPAD, 604fef20d9cSFrederic Weisbecker }; 605c91d3376SBjorn Helgaas struct printf_spec dec_spec = { 606c91d3376SBjorn Helgaas .base = 10, 607c91d3376SBjorn Helgaas .precision = -1, 608c91d3376SBjorn Helgaas .flags = 0, 609c91d3376SBjorn Helgaas }; 610fd95541eSBjorn Helgaas struct printf_spec str_spec = { 611fd95541eSBjorn Helgaas .field_width = -1, 612fd95541eSBjorn Helgaas .precision = 10, 613fd95541eSBjorn Helgaas .flags = LEFT, 614fd95541eSBjorn Helgaas }; 615fd95541eSBjorn Helgaas struct printf_spec flag_spec = { 616fd95541eSBjorn Helgaas .base = 16, 617fd95541eSBjorn Helgaas .precision = -1, 618fd95541eSBjorn Helgaas .flags = SPECIAL | SMALL, 619fd95541eSBjorn Helgaas }; 620c7dabef8SBjorn Helgaas 621c7dabef8SBjorn Helgaas /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8) 622c7dabef8SBjorn Helgaas * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */ 623c7dabef8SBjorn Helgaas #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4) 624c7dabef8SBjorn Helgaas #define FLAG_BUF_SIZE (2 * sizeof(res->flags)) 625c7dabef8SBjorn Helgaas #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref disabled]") 626c7dabef8SBjorn Helgaas #define RAW_BUF_SIZE sizeof("[mem - flags 0x]") 627c7dabef8SBjorn Helgaas char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, 628c7dabef8SBjorn Helgaas 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)]; 629c7dabef8SBjorn Helgaas 630332d2e78SLinus Torvalds char *p = sym, *pend = sym + sizeof(sym); 631c91d3376SBjorn Helgaas int size = -1, addr = 0; 632c7dabef8SBjorn Helgaas int decode = (fmt[0] == 'R') ? 1 : 0; 633332d2e78SLinus Torvalds 634c91d3376SBjorn Helgaas if (res->flags & IORESOURCE_IO) { 635332d2e78SLinus Torvalds size = IO_RSRC_PRINTK_SIZE; 636c91d3376SBjorn Helgaas addr = 1; 637c91d3376SBjorn Helgaas } else if (res->flags & IORESOURCE_MEM) { 638332d2e78SLinus Torvalds size = MEM_RSRC_PRINTK_SIZE; 639c91d3376SBjorn Helgaas addr = 1; 640c91d3376SBjorn Helgaas } 641332d2e78SLinus Torvalds 642332d2e78SLinus Torvalds *p++ = '['; 643fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_IO) 644fd95541eSBjorn Helgaas p = string(p, pend, "io ", str_spec); 645fd95541eSBjorn Helgaas else if (res->flags & IORESOURCE_MEM) 646fd95541eSBjorn Helgaas p = string(p, pend, "mem ", str_spec); 647fd95541eSBjorn Helgaas else if (res->flags & IORESOURCE_IRQ) 648fd95541eSBjorn Helgaas p = string(p, pend, "irq ", str_spec); 649fd95541eSBjorn Helgaas else if (res->flags & IORESOURCE_DMA) 650fd95541eSBjorn Helgaas p = string(p, pend, "dma ", str_spec); 651c7dabef8SBjorn Helgaas else { 652c7dabef8SBjorn Helgaas p = string(p, pend, "??? ", str_spec); 653c7dabef8SBjorn Helgaas decode = 0; 654fd95541eSBjorn Helgaas } 655c91d3376SBjorn Helgaas hex_spec.field_width = size; 656c91d3376SBjorn Helgaas p = number(p, pend, res->start, addr ? hex_spec : dec_spec); 657c91d3376SBjorn Helgaas if (res->start != res->end) { 658332d2e78SLinus Torvalds *p++ = '-'; 659c91d3376SBjorn Helgaas p = number(p, pend, res->end, addr ? hex_spec : dec_spec); 660c91d3376SBjorn Helgaas } 661c7dabef8SBjorn Helgaas if (decode) { 662fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_MEM_64) 663fd95541eSBjorn Helgaas p = string(p, pend, " 64bit", str_spec); 664fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_PREFETCH) 665fd95541eSBjorn Helgaas p = string(p, pend, " pref", str_spec); 666fd95541eSBjorn Helgaas if (res->flags & IORESOURCE_DISABLED) 667fd95541eSBjorn Helgaas p = string(p, pend, " disabled", str_spec); 668c7dabef8SBjorn Helgaas } else { 669fd95541eSBjorn Helgaas p = string(p, pend, " flags ", str_spec); 670c7dabef8SBjorn Helgaas p = number(p, pend, res->flags, flag_spec); 671fd95541eSBjorn Helgaas } 672332d2e78SLinus Torvalds *p++ = ']'; 673c7dabef8SBjorn Helgaas *p = '\0'; 674332d2e78SLinus Torvalds 675fef20d9cSFrederic Weisbecker return string(buf, end, sym, spec); 676332d2e78SLinus Torvalds } 677332d2e78SLinus Torvalds 678fef20d9cSFrederic Weisbecker static char *mac_address_string(char *buf, char *end, u8 *addr, 6798a27f7c9SJoe Perches struct printf_spec spec, const char *fmt) 680dd45c9cfSHarvey Harrison { 6818a27f7c9SJoe Perches char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")]; 682dd45c9cfSHarvey Harrison char *p = mac_addr; 683dd45c9cfSHarvey Harrison int i; 684bc7259a2SJoe Perches char separator; 685bc7259a2SJoe Perches 686bc7259a2SJoe Perches if (fmt[1] == 'F') { /* FDDI canonical format */ 687bc7259a2SJoe Perches separator = '-'; 688bc7259a2SJoe Perches } else { 689bc7259a2SJoe Perches separator = ':'; 690bc7259a2SJoe Perches } 691dd45c9cfSHarvey Harrison 692dd45c9cfSHarvey Harrison for (i = 0; i < 6; i++) { 693*c8e00060SJoe Perches p = pack_hex_byte(p, addr[i]); 6948a27f7c9SJoe Perches if (fmt[0] == 'M' && i != 5) 695bc7259a2SJoe Perches *p++ = separator; 696dd45c9cfSHarvey Harrison } 697dd45c9cfSHarvey Harrison *p = '\0'; 698dd45c9cfSHarvey Harrison 699fef20d9cSFrederic Weisbecker return string(buf, end, mac_addr, spec); 700dd45c9cfSHarvey Harrison } 701dd45c9cfSHarvey Harrison 7028a27f7c9SJoe Perches static char *ip4_string(char *p, const u8 *addr, bool leading_zeros) 703689afa7dSHarvey Harrison { 704689afa7dSHarvey Harrison int i; 705689afa7dSHarvey Harrison 7068a27f7c9SJoe Perches for (i = 0; i < 4; i++) { 7078a27f7c9SJoe Perches char temp[3]; /* hold each IP quad in reverse order */ 7088a27f7c9SJoe Perches int digits = put_dec_trunc(temp, addr[i]) - temp; 7098a27f7c9SJoe Perches if (leading_zeros) { 7108a27f7c9SJoe Perches if (digits < 3) 7118a27f7c9SJoe Perches *p++ = '0'; 7128a27f7c9SJoe Perches if (digits < 2) 7138a27f7c9SJoe Perches *p++ = '0'; 7148a27f7c9SJoe Perches } 7158a27f7c9SJoe Perches /* reverse the digits in the quad */ 7168a27f7c9SJoe Perches while (digits--) 7178a27f7c9SJoe Perches *p++ = temp[digits]; 7188a27f7c9SJoe Perches if (i < 3) 7198a27f7c9SJoe Perches *p++ = '.'; 7208a27f7c9SJoe Perches } 7218a27f7c9SJoe Perches *p = '\0'; 7227b9186f5SAndré Goddard Rosa 7238a27f7c9SJoe Perches return p; 7248a27f7c9SJoe Perches } 7258a27f7c9SJoe Perches 726eb78cd26SJoe Perches static char *ip6_compressed_string(char *p, const char *addr) 7278a27f7c9SJoe Perches { 7287b9186f5SAndré Goddard Rosa int i, j, range; 7298a27f7c9SJoe Perches unsigned char zerolength[8]; 7308a27f7c9SJoe Perches int longest = 1; 7318a27f7c9SJoe Perches int colonpos = -1; 7328a27f7c9SJoe Perches u16 word; 7337b9186f5SAndré Goddard Rosa u8 hi, lo; 7348a27f7c9SJoe Perches bool needcolon = false; 735eb78cd26SJoe Perches bool useIPv4; 736eb78cd26SJoe Perches struct in6_addr in6; 737eb78cd26SJoe Perches 738eb78cd26SJoe Perches memcpy(&in6, addr, sizeof(struct in6_addr)); 739eb78cd26SJoe Perches 740eb78cd26SJoe Perches useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 7418a27f7c9SJoe Perches 7428a27f7c9SJoe Perches memset(zerolength, 0, sizeof(zerolength)); 7438a27f7c9SJoe Perches 7448a27f7c9SJoe Perches if (useIPv4) 7458a27f7c9SJoe Perches range = 6; 7468a27f7c9SJoe Perches else 7478a27f7c9SJoe Perches range = 8; 7488a27f7c9SJoe Perches 7498a27f7c9SJoe Perches /* find position of longest 0 run */ 7508a27f7c9SJoe Perches for (i = 0; i < range; i++) { 7518a27f7c9SJoe Perches for (j = i; j < range; j++) { 752eb78cd26SJoe Perches if (in6.s6_addr16[j] != 0) 7538a27f7c9SJoe Perches break; 7548a27f7c9SJoe Perches zerolength[i]++; 7558a27f7c9SJoe Perches } 7568a27f7c9SJoe Perches } 7578a27f7c9SJoe Perches for (i = 0; i < range; i++) { 7588a27f7c9SJoe Perches if (zerolength[i] > longest) { 7598a27f7c9SJoe Perches longest = zerolength[i]; 7608a27f7c9SJoe Perches colonpos = i; 7618a27f7c9SJoe Perches } 7628a27f7c9SJoe Perches } 7638a27f7c9SJoe Perches 7648a27f7c9SJoe Perches /* emit address */ 7658a27f7c9SJoe Perches for (i = 0; i < range; i++) { 7668a27f7c9SJoe Perches if (i == colonpos) { 7678a27f7c9SJoe Perches if (needcolon || i == 0) 7688a27f7c9SJoe Perches *p++ = ':'; 7698a27f7c9SJoe Perches *p++ = ':'; 7708a27f7c9SJoe Perches needcolon = false; 7718a27f7c9SJoe Perches i += longest - 1; 7728a27f7c9SJoe Perches continue; 7738a27f7c9SJoe Perches } 7748a27f7c9SJoe Perches if (needcolon) { 7758a27f7c9SJoe Perches *p++ = ':'; 7768a27f7c9SJoe Perches needcolon = false; 7778a27f7c9SJoe Perches } 7788a27f7c9SJoe Perches /* hex u16 without leading 0s */ 779eb78cd26SJoe Perches word = ntohs(in6.s6_addr16[i]); 7808a27f7c9SJoe Perches hi = word >> 8; 7818a27f7c9SJoe Perches lo = word & 0xff; 7828a27f7c9SJoe Perches if (hi) { 7838a27f7c9SJoe Perches if (hi > 0x0f) 7848a27f7c9SJoe Perches p = pack_hex_byte(p, hi); 7858a27f7c9SJoe Perches else 7868a27f7c9SJoe Perches *p++ = hex_asc_lo(hi); 787b5ff992bSAndré Goddard Rosa p = pack_hex_byte(p, lo); 7888a27f7c9SJoe Perches } 789b5ff992bSAndré Goddard Rosa else if (lo > 0x0f) 7908a27f7c9SJoe Perches p = pack_hex_byte(p, lo); 7918a27f7c9SJoe Perches else 7928a27f7c9SJoe Perches *p++ = hex_asc_lo(lo); 7938a27f7c9SJoe Perches needcolon = true; 7948a27f7c9SJoe Perches } 7958a27f7c9SJoe Perches 7968a27f7c9SJoe Perches if (useIPv4) { 7978a27f7c9SJoe Perches if (needcolon) 7988a27f7c9SJoe Perches *p++ = ':'; 799eb78cd26SJoe Perches p = ip4_string(p, &in6.s6_addr[12], false); 8008a27f7c9SJoe Perches } 8018a27f7c9SJoe Perches *p = '\0'; 8027b9186f5SAndré Goddard Rosa 8038a27f7c9SJoe Perches return p; 8048a27f7c9SJoe Perches } 8058a27f7c9SJoe Perches 806eb78cd26SJoe Perches static char *ip6_string(char *p, const char *addr, const char *fmt) 8078a27f7c9SJoe Perches { 8088a27f7c9SJoe Perches int i; 8097b9186f5SAndré Goddard Rosa 810689afa7dSHarvey Harrison for (i = 0; i < 8; i++) { 811eb78cd26SJoe Perches p = pack_hex_byte(p, *addr++); 812eb78cd26SJoe Perches p = pack_hex_byte(p, *addr++); 8138a27f7c9SJoe Perches if (fmt[0] == 'I' && i != 7) 814689afa7dSHarvey Harrison *p++ = ':'; 815689afa7dSHarvey Harrison } 816689afa7dSHarvey Harrison *p = '\0'; 8177b9186f5SAndré Goddard Rosa 8188a27f7c9SJoe Perches return p; 8198a27f7c9SJoe Perches } 8208a27f7c9SJoe Perches 8218a27f7c9SJoe Perches static char *ip6_addr_string(char *buf, char *end, const u8 *addr, 8228a27f7c9SJoe Perches struct printf_spec spec, const char *fmt) 8238a27f7c9SJoe Perches { 8248a27f7c9SJoe Perches char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 8258a27f7c9SJoe Perches 8268a27f7c9SJoe Perches if (fmt[0] == 'I' && fmt[2] == 'c') 827eb78cd26SJoe Perches ip6_compressed_string(ip6_addr, addr); 8288a27f7c9SJoe Perches else 829eb78cd26SJoe Perches ip6_string(ip6_addr, addr, fmt); 830689afa7dSHarvey Harrison 831fef20d9cSFrederic Weisbecker return string(buf, end, ip6_addr, spec); 832689afa7dSHarvey Harrison } 833689afa7dSHarvey Harrison 8348a27f7c9SJoe Perches static char *ip4_addr_string(char *buf, char *end, const u8 *addr, 8358a27f7c9SJoe Perches struct printf_spec spec, const char *fmt) 8364aa99606SHarvey Harrison { 8378a27f7c9SJoe Perches char ip4_addr[sizeof("255.255.255.255")]; 8384aa99606SHarvey Harrison 8398a27f7c9SJoe Perches ip4_string(ip4_addr, addr, fmt[0] == 'i'); 8404aa99606SHarvey Harrison 841fef20d9cSFrederic Weisbecker return string(buf, end, ip4_addr, spec); 8424aa99606SHarvey Harrison } 8434aa99606SHarvey Harrison 8449ac6e44eSJoe Perches static char *uuid_string(char *buf, char *end, const u8 *addr, 8459ac6e44eSJoe Perches struct printf_spec spec, const char *fmt) 8469ac6e44eSJoe Perches { 8479ac6e44eSJoe Perches char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")]; 8489ac6e44eSJoe Perches char *p = uuid; 8499ac6e44eSJoe Perches int i; 8509ac6e44eSJoe Perches static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; 8519ac6e44eSJoe Perches static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15}; 8529ac6e44eSJoe Perches const u8 *index = be; 8539ac6e44eSJoe Perches bool uc = false; 8549ac6e44eSJoe Perches 8559ac6e44eSJoe Perches switch (*(++fmt)) { 8569ac6e44eSJoe Perches case 'L': 8579ac6e44eSJoe Perches uc = true; /* fall-through */ 8589ac6e44eSJoe Perches case 'l': 8599ac6e44eSJoe Perches index = le; 8609ac6e44eSJoe Perches break; 8619ac6e44eSJoe Perches case 'B': 8629ac6e44eSJoe Perches uc = true; 8639ac6e44eSJoe Perches break; 8649ac6e44eSJoe Perches } 8659ac6e44eSJoe Perches 8669ac6e44eSJoe Perches for (i = 0; i < 16; i++) { 8679ac6e44eSJoe Perches p = pack_hex_byte(p, addr[index[i]]); 8689ac6e44eSJoe Perches switch (i) { 8699ac6e44eSJoe Perches case 3: 8709ac6e44eSJoe Perches case 5: 8719ac6e44eSJoe Perches case 7: 8729ac6e44eSJoe Perches case 9: 8739ac6e44eSJoe Perches *p++ = '-'; 8749ac6e44eSJoe Perches break; 8759ac6e44eSJoe Perches } 8769ac6e44eSJoe Perches } 8779ac6e44eSJoe Perches 8789ac6e44eSJoe Perches *p = 0; 8799ac6e44eSJoe Perches 8809ac6e44eSJoe Perches if (uc) { 8819ac6e44eSJoe Perches p = uuid; 8829ac6e44eSJoe Perches do { 8839ac6e44eSJoe Perches *p = toupper(*p); 8849ac6e44eSJoe Perches } while (*(++p)); 8859ac6e44eSJoe Perches } 8869ac6e44eSJoe Perches 8879ac6e44eSJoe Perches return string(buf, end, uuid, spec); 8889ac6e44eSJoe Perches } 8899ac6e44eSJoe Perches 8904d8a743cSLinus Torvalds /* 8914d8a743cSLinus Torvalds * Show a '%p' thing. A kernel extension is that the '%p' is followed 8924d8a743cSLinus Torvalds * by an extra set of alphanumeric characters that are extended format 8934d8a743cSLinus Torvalds * specifiers. 8944d8a743cSLinus Torvalds * 895332d2e78SLinus Torvalds * Right now we handle: 8960fe1ef24SLinus Torvalds * 8970c8b946eSFrederic Weisbecker * - 'F' For symbolic function descriptor pointers with offset 8980c8b946eSFrederic Weisbecker * - 'f' For simple symbolic function names without offset 8990efb4d20SSteven Rostedt * - 'S' For symbolic direct pointers with offset 9000efb4d20SSteven Rostedt * - 's' For symbolic direct pointers without offset 901c7dabef8SBjorn Helgaas * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 902c7dabef8SBjorn Helgaas * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 903dd45c9cfSHarvey Harrison * - 'M' For a 6-byte MAC address, it prints the address in the 904dd45c9cfSHarvey Harrison * usual colon-separated hex notation 9058a27f7c9SJoe Perches * - 'm' For a 6-byte MAC address, it prints the hex address without colons 906bc7259a2SJoe Perches * - 'MF' For a 6-byte MAC FDDI address, it prints the address 907*c8e00060SJoe Perches * with a dash-separated hex notation 9088a27f7c9SJoe Perches * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 9098a27f7c9SJoe Perches * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 9108a27f7c9SJoe Perches * IPv6 uses colon separated network-order 16 bit hex with leading 0's 9118a27f7c9SJoe Perches * - 'i' [46] for 'raw' IPv4/IPv6 addresses 9128a27f7c9SJoe Perches * IPv6 omits the colons (01020304...0f) 9138a27f7c9SJoe Perches * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 9148a27f7c9SJoe Perches * - 'I6c' for IPv6 addresses printed as specified by 9158a27f7c9SJoe Perches * http://www.ietf.org/id/draft-kawamura-ipv6-text-representation-03.txt 9169ac6e44eSJoe Perches * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 9179ac6e44eSJoe Perches * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 9189ac6e44eSJoe Perches * Options for %pU are: 9199ac6e44eSJoe Perches * b big endian lower case hex (default) 9209ac6e44eSJoe Perches * B big endian UPPER case hex 9219ac6e44eSJoe Perches * l little endian lower case hex 9229ac6e44eSJoe Perches * L little endian UPPER case hex 9239ac6e44eSJoe Perches * big endian output byte order is: 9249ac6e44eSJoe Perches * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 9259ac6e44eSJoe Perches * little endian output byte order is: 9269ac6e44eSJoe Perches * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 9279ac6e44eSJoe Perches * 928332d2e78SLinus Torvalds * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 929332d2e78SLinus Torvalds * function pointers are really function descriptors, which contain a 930332d2e78SLinus Torvalds * pointer to the real address. 9314d8a743cSLinus Torvalds */ 932fef20d9cSFrederic Weisbecker static char *pointer(const char *fmt, char *buf, char *end, void *ptr, 933fef20d9cSFrederic Weisbecker struct printf_spec spec) 93478a8bf69SLinus Torvalds { 935d97106abSLinus Torvalds if (!ptr) 936fef20d9cSFrederic Weisbecker return string(buf, end, "(null)", spec); 937d97106abSLinus Torvalds 9380fe1ef24SLinus Torvalds switch (*fmt) { 9390fe1ef24SLinus Torvalds case 'F': 9400c8b946eSFrederic Weisbecker case 'f': 9410fe1ef24SLinus Torvalds ptr = dereference_function_descriptor(ptr); 9420fe1ef24SLinus Torvalds /* Fallthrough */ 9430fe1ef24SLinus Torvalds case 'S': 9449ac6e44eSJoe Perches case 's': 9450c8b946eSFrederic Weisbecker return symbol_string(buf, end, ptr, spec, *fmt); 946332d2e78SLinus Torvalds case 'R': 947c7dabef8SBjorn Helgaas case 'r': 948fd95541eSBjorn Helgaas return resource_string(buf, end, ptr, spec, fmt); 9498a27f7c9SJoe Perches case 'M': /* Colon separated: 00:01:02:03:04:05 */ 9508a27f7c9SJoe Perches case 'm': /* Contiguous: 000102030405 */ 951bc7259a2SJoe Perches /* [mM]F (FDDI, bit reversed) */ 9528a27f7c9SJoe Perches return mac_address_string(buf, end, ptr, spec, fmt); 9538a27f7c9SJoe Perches case 'I': /* Formatted IP supported 9548a27f7c9SJoe Perches * 4: 1.2.3.4 9558a27f7c9SJoe Perches * 6: 0001:0203:...:0708 9568a27f7c9SJoe Perches * 6c: 1::708 or 1::1.2.3.4 9578a27f7c9SJoe Perches */ 9588a27f7c9SJoe Perches case 'i': /* Contiguous: 9598a27f7c9SJoe Perches * 4: 001.002.003.004 9608a27f7c9SJoe Perches * 6: 000102...0f 9618a27f7c9SJoe Perches */ 9628a27f7c9SJoe Perches switch (fmt[1]) { 9638a27f7c9SJoe Perches case '6': 9648a27f7c9SJoe Perches return ip6_addr_string(buf, end, ptr, spec, fmt); 9658a27f7c9SJoe Perches case '4': 9668a27f7c9SJoe Perches return ip4_addr_string(buf, end, ptr, spec, fmt); 9678a27f7c9SJoe Perches } 9684aa99606SHarvey Harrison break; 9699ac6e44eSJoe Perches case 'U': 9709ac6e44eSJoe Perches return uuid_string(buf, end, ptr, spec, fmt); 9710fe1ef24SLinus Torvalds } 972fef20d9cSFrederic Weisbecker spec.flags |= SMALL; 973fef20d9cSFrederic Weisbecker if (spec.field_width == -1) { 974fef20d9cSFrederic Weisbecker spec.field_width = 2*sizeof(void *); 975fef20d9cSFrederic Weisbecker spec.flags |= ZEROPAD; 97678a8bf69SLinus Torvalds } 977fef20d9cSFrederic Weisbecker spec.base = 16; 978fef20d9cSFrederic Weisbecker 979fef20d9cSFrederic Weisbecker return number(buf, end, (unsigned long) ptr, spec); 980fef20d9cSFrederic Weisbecker } 981fef20d9cSFrederic Weisbecker 982fef20d9cSFrederic Weisbecker /* 983fef20d9cSFrederic Weisbecker * Helper function to decode printf style format. 984fef20d9cSFrederic Weisbecker * Each call decode a token from the format and return the 985fef20d9cSFrederic Weisbecker * number of characters read (or likely the delta where it wants 986fef20d9cSFrederic Weisbecker * to go on the next call). 987fef20d9cSFrederic Weisbecker * The decoded token is returned through the parameters 988fef20d9cSFrederic Weisbecker * 989fef20d9cSFrederic Weisbecker * 'h', 'l', or 'L' for integer fields 990fef20d9cSFrederic Weisbecker * 'z' support added 23/7/1999 S.H. 991fef20d9cSFrederic Weisbecker * 'z' changed to 'Z' --davidm 1/25/99 992fef20d9cSFrederic Weisbecker * 't' added for ptrdiff_t 993fef20d9cSFrederic Weisbecker * 994fef20d9cSFrederic Weisbecker * @fmt: the format string 995fef20d9cSFrederic Weisbecker * @type of the token returned 996fef20d9cSFrederic Weisbecker * @flags: various flags such as +, -, # tokens.. 997fef20d9cSFrederic Weisbecker * @field_width: overwritten width 998fef20d9cSFrederic Weisbecker * @base: base of the number (octal, hex, ...) 999fef20d9cSFrederic Weisbecker * @precision: precision of a number 1000fef20d9cSFrederic Weisbecker * @qualifier: qualifier of a number (long, size_t, ...) 1001fef20d9cSFrederic Weisbecker */ 1002fef20d9cSFrederic Weisbecker static int format_decode(const char *fmt, struct printf_spec *spec) 1003fef20d9cSFrederic Weisbecker { 1004fef20d9cSFrederic Weisbecker const char *start = fmt; 1005fef20d9cSFrederic Weisbecker 1006fef20d9cSFrederic Weisbecker /* we finished early by reading the field width */ 1007ed681a91SVegard Nossum if (spec->type == FORMAT_TYPE_WIDTH) { 1008fef20d9cSFrederic Weisbecker if (spec->field_width < 0) { 1009fef20d9cSFrederic Weisbecker spec->field_width = -spec->field_width; 1010fef20d9cSFrederic Weisbecker spec->flags |= LEFT; 1011fef20d9cSFrederic Weisbecker } 1012fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NONE; 1013fef20d9cSFrederic Weisbecker goto precision; 1014fef20d9cSFrederic Weisbecker } 1015fef20d9cSFrederic Weisbecker 1016fef20d9cSFrederic Weisbecker /* we finished early by reading the precision */ 1017fef20d9cSFrederic Weisbecker if (spec->type == FORMAT_TYPE_PRECISION) { 1018fef20d9cSFrederic Weisbecker if (spec->precision < 0) 1019fef20d9cSFrederic Weisbecker spec->precision = 0; 1020fef20d9cSFrederic Weisbecker 1021fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NONE; 1022fef20d9cSFrederic Weisbecker goto qualifier; 1023fef20d9cSFrederic Weisbecker } 1024fef20d9cSFrederic Weisbecker 1025fef20d9cSFrederic Weisbecker /* By default */ 1026fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NONE; 1027fef20d9cSFrederic Weisbecker 1028fef20d9cSFrederic Weisbecker for (; *fmt ; ++fmt) { 1029fef20d9cSFrederic Weisbecker if (*fmt == '%') 1030fef20d9cSFrederic Weisbecker break; 1031fef20d9cSFrederic Weisbecker } 1032fef20d9cSFrederic Weisbecker 1033fef20d9cSFrederic Weisbecker /* Return the current non-format string */ 1034fef20d9cSFrederic Weisbecker if (fmt != start || !*fmt) 1035fef20d9cSFrederic Weisbecker return fmt - start; 1036fef20d9cSFrederic Weisbecker 1037fef20d9cSFrederic Weisbecker /* Process flags */ 1038fef20d9cSFrederic Weisbecker spec->flags = 0; 1039fef20d9cSFrederic Weisbecker 1040fef20d9cSFrederic Weisbecker while (1) { /* this also skips first '%' */ 1041fef20d9cSFrederic Weisbecker bool found = true; 1042fef20d9cSFrederic Weisbecker 1043fef20d9cSFrederic Weisbecker ++fmt; 1044fef20d9cSFrederic Weisbecker 1045fef20d9cSFrederic Weisbecker switch (*fmt) { 1046fef20d9cSFrederic Weisbecker case '-': spec->flags |= LEFT; break; 1047fef20d9cSFrederic Weisbecker case '+': spec->flags |= PLUS; break; 1048fef20d9cSFrederic Weisbecker case ' ': spec->flags |= SPACE; break; 1049fef20d9cSFrederic Weisbecker case '#': spec->flags |= SPECIAL; break; 1050fef20d9cSFrederic Weisbecker case '0': spec->flags |= ZEROPAD; break; 1051fef20d9cSFrederic Weisbecker default: found = false; 1052fef20d9cSFrederic Weisbecker } 1053fef20d9cSFrederic Weisbecker 1054fef20d9cSFrederic Weisbecker if (!found) 1055fef20d9cSFrederic Weisbecker break; 1056fef20d9cSFrederic Weisbecker } 1057fef20d9cSFrederic Weisbecker 1058fef20d9cSFrederic Weisbecker /* get field width */ 1059fef20d9cSFrederic Weisbecker spec->field_width = -1; 1060fef20d9cSFrederic Weisbecker 1061fef20d9cSFrederic Weisbecker if (isdigit(*fmt)) 1062fef20d9cSFrederic Weisbecker spec->field_width = skip_atoi(&fmt); 1063fef20d9cSFrederic Weisbecker else if (*fmt == '*') { 1064fef20d9cSFrederic Weisbecker /* it's the next argument */ 1065ed681a91SVegard Nossum spec->type = FORMAT_TYPE_WIDTH; 1066fef20d9cSFrederic Weisbecker return ++fmt - start; 1067fef20d9cSFrederic Weisbecker } 1068fef20d9cSFrederic Weisbecker 1069fef20d9cSFrederic Weisbecker precision: 1070fef20d9cSFrederic Weisbecker /* get the precision */ 1071fef20d9cSFrederic Weisbecker spec->precision = -1; 1072fef20d9cSFrederic Weisbecker if (*fmt == '.') { 1073fef20d9cSFrederic Weisbecker ++fmt; 1074fef20d9cSFrederic Weisbecker if (isdigit(*fmt)) { 1075fef20d9cSFrederic Weisbecker spec->precision = skip_atoi(&fmt); 1076fef20d9cSFrederic Weisbecker if (spec->precision < 0) 1077fef20d9cSFrederic Weisbecker spec->precision = 0; 1078fef20d9cSFrederic Weisbecker } else if (*fmt == '*') { 1079fef20d9cSFrederic Weisbecker /* it's the next argument */ 1080adf26f84SVegard Nossum spec->type = FORMAT_TYPE_PRECISION; 1081fef20d9cSFrederic Weisbecker return ++fmt - start; 1082fef20d9cSFrederic Weisbecker } 1083fef20d9cSFrederic Weisbecker } 1084fef20d9cSFrederic Weisbecker 1085fef20d9cSFrederic Weisbecker qualifier: 1086fef20d9cSFrederic Weisbecker /* get the conversion qualifier */ 1087fef20d9cSFrederic Weisbecker spec->qualifier = -1; 108808562cb2SAndré Goddard Rosa if (*fmt == 'h' || TOLOWER(*fmt) == 'l' || 108908562cb2SAndré Goddard Rosa TOLOWER(*fmt) == 'z' || *fmt == 't') { 1090a4e94ef0SZhaolei spec->qualifier = *fmt++; 1091a4e94ef0SZhaolei if (unlikely(spec->qualifier == *fmt)) { 1092a4e94ef0SZhaolei if (spec->qualifier == 'l') { 1093fef20d9cSFrederic Weisbecker spec->qualifier = 'L'; 1094fef20d9cSFrederic Weisbecker ++fmt; 1095a4e94ef0SZhaolei } else if (spec->qualifier == 'h') { 1096a4e94ef0SZhaolei spec->qualifier = 'H'; 1097a4e94ef0SZhaolei ++fmt; 1098a4e94ef0SZhaolei } 1099fef20d9cSFrederic Weisbecker } 1100fef20d9cSFrederic Weisbecker } 1101fef20d9cSFrederic Weisbecker 1102fef20d9cSFrederic Weisbecker /* default base */ 1103fef20d9cSFrederic Weisbecker spec->base = 10; 1104fef20d9cSFrederic Weisbecker switch (*fmt) { 1105fef20d9cSFrederic Weisbecker case 'c': 1106fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_CHAR; 1107fef20d9cSFrederic Weisbecker return ++fmt - start; 1108fef20d9cSFrederic Weisbecker 1109fef20d9cSFrederic Weisbecker case 's': 1110fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_STR; 1111fef20d9cSFrederic Weisbecker return ++fmt - start; 1112fef20d9cSFrederic Weisbecker 1113fef20d9cSFrederic Weisbecker case 'p': 1114fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_PTR; 1115fef20d9cSFrederic Weisbecker return fmt - start; 1116fef20d9cSFrederic Weisbecker /* skip alnum */ 1117fef20d9cSFrederic Weisbecker 1118fef20d9cSFrederic Weisbecker case 'n': 1119fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_NRCHARS; 1120fef20d9cSFrederic Weisbecker return ++fmt - start; 1121fef20d9cSFrederic Weisbecker 1122fef20d9cSFrederic Weisbecker case '%': 1123fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_PERCENT_CHAR; 1124fef20d9cSFrederic Weisbecker return ++fmt - start; 1125fef20d9cSFrederic Weisbecker 1126fef20d9cSFrederic Weisbecker /* integer number formats - set up the flags and "break" */ 1127fef20d9cSFrederic Weisbecker case 'o': 1128fef20d9cSFrederic Weisbecker spec->base = 8; 1129fef20d9cSFrederic Weisbecker break; 1130fef20d9cSFrederic Weisbecker 1131fef20d9cSFrederic Weisbecker case 'x': 1132fef20d9cSFrederic Weisbecker spec->flags |= SMALL; 1133fef20d9cSFrederic Weisbecker 1134fef20d9cSFrederic Weisbecker case 'X': 1135fef20d9cSFrederic Weisbecker spec->base = 16; 1136fef20d9cSFrederic Weisbecker break; 1137fef20d9cSFrederic Weisbecker 1138fef20d9cSFrederic Weisbecker case 'd': 1139fef20d9cSFrederic Weisbecker case 'i': 114039e874f8SFrederic Weisbecker spec->flags |= SIGN; 1141fef20d9cSFrederic Weisbecker case 'u': 1142fef20d9cSFrederic Weisbecker break; 1143fef20d9cSFrederic Weisbecker 1144fef20d9cSFrederic Weisbecker default: 1145fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_INVALID; 1146fef20d9cSFrederic Weisbecker return fmt - start; 1147fef20d9cSFrederic Weisbecker } 1148fef20d9cSFrederic Weisbecker 1149fef20d9cSFrederic Weisbecker if (spec->qualifier == 'L') 1150fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_LONG_LONG; 1151fef20d9cSFrederic Weisbecker else if (spec->qualifier == 'l') { 115239e874f8SFrederic Weisbecker if (spec->flags & SIGN) 1153fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_LONG; 1154fef20d9cSFrederic Weisbecker else 1155fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_ULONG; 115608562cb2SAndré Goddard Rosa } else if (TOLOWER(spec->qualifier) == 'z') { 1157fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_SIZE_T; 1158fef20d9cSFrederic Weisbecker } else if (spec->qualifier == 't') { 1159fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_PTRDIFF; 1160a4e94ef0SZhaolei } else if (spec->qualifier == 'H') { 1161a4e94ef0SZhaolei if (spec->flags & SIGN) 1162a4e94ef0SZhaolei spec->type = FORMAT_TYPE_BYTE; 1163a4e94ef0SZhaolei else 1164a4e94ef0SZhaolei spec->type = FORMAT_TYPE_UBYTE; 1165fef20d9cSFrederic Weisbecker } else if (spec->qualifier == 'h') { 116639e874f8SFrederic Weisbecker if (spec->flags & SIGN) 1167fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_SHORT; 1168fef20d9cSFrederic Weisbecker else 1169fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_USHORT; 1170fef20d9cSFrederic Weisbecker } else { 117139e874f8SFrederic Weisbecker if (spec->flags & SIGN) 1172fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_INT; 1173fef20d9cSFrederic Weisbecker else 1174fef20d9cSFrederic Weisbecker spec->type = FORMAT_TYPE_UINT; 1175fef20d9cSFrederic Weisbecker } 1176fef20d9cSFrederic Weisbecker 1177fef20d9cSFrederic Weisbecker return ++fmt - start; 117878a8bf69SLinus Torvalds } 117978a8bf69SLinus Torvalds 11801da177e4SLinus Torvalds /** 11811da177e4SLinus Torvalds * vsnprintf - Format a string and place it in a buffer 11821da177e4SLinus Torvalds * @buf: The buffer to place the result into 11831da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 11841da177e4SLinus Torvalds * @fmt: The format string to use 11851da177e4SLinus Torvalds * @args: Arguments for the format string 11861da177e4SLinus Torvalds * 118720036fdcSAndi Kleen * This function follows C99 vsnprintf, but has some extensions: 118891adcd2cSSteven Rostedt * %pS output the name of a text symbol with offset 118991adcd2cSSteven Rostedt * %ps output the name of a text symbol without offset 11900c8b946eSFrederic Weisbecker * %pF output the name of a function pointer with its offset 11910c8b946eSFrederic Weisbecker * %pf output the name of a function pointer without its offset 11928a79503aSUwe Kleine-König * %pR output the address range in a struct resource with decoded flags 11938a79503aSUwe Kleine-König * %pr output the address range in a struct resource with raw flags 11948a79503aSUwe Kleine-König * %pM output a 6-byte MAC address with colons 11958a79503aSUwe Kleine-König * %pm output a 6-byte MAC address without colons 11968a79503aSUwe Kleine-König * %pI4 print an IPv4 address without leading zeros 11978a79503aSUwe Kleine-König * %pi4 print an IPv4 address with leading zeros 11988a79503aSUwe Kleine-König * %pI6 print an IPv6 address with colons 11998a79503aSUwe Kleine-König * %pi6 print an IPv6 address without colons 12008a79503aSUwe Kleine-König * %pI6c print an IPv6 address as specified by 12018a79503aSUwe Kleine-König * http://www.ietf.org/id/draft-kawamura-ipv6-text-representation-03.txt 12028a79503aSUwe Kleine-König * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper 12038a79503aSUwe Kleine-König * case. 12040efb4d20SSteven Rostedt * %n is ignored 120520036fdcSAndi Kleen * 12061da177e4SLinus Torvalds * The return value is the number of characters which would 12071da177e4SLinus Torvalds * be generated for the given input, excluding the trailing 12081da177e4SLinus Torvalds * '\0', as per ISO C99. If you want to have the exact 12091da177e4SLinus Torvalds * number of characters written into @buf as return value 121072fd4a35SRobert P. J. Day * (not including the trailing '\0'), use vscnprintf(). If the 12111da177e4SLinus Torvalds * return is greater than or equal to @size, the resulting 12121da177e4SLinus Torvalds * string is truncated. 12131da177e4SLinus Torvalds * 12141da177e4SLinus Torvalds * Call this function if you are already dealing with a va_list. 121572fd4a35SRobert P. J. Day * You probably want snprintf() instead. 12161da177e4SLinus Torvalds */ 12171da177e4SLinus Torvalds int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 12181da177e4SLinus Torvalds { 12191da177e4SLinus Torvalds unsigned long long num; 1220d4be151bSAndré Goddard Rosa char *str, *end; 1221fef20d9cSFrederic Weisbecker struct printf_spec spec = {0}; 12221da177e4SLinus Torvalds 1223f796937aSJeremy Fitzhardinge /* Reject out-of-range values early. Large positive sizes are 1224f796937aSJeremy Fitzhardinge used for unknown buffer sizes. */ 12252f30b1f9SMarcin Slusarz if (WARN_ON_ONCE((int) size < 0)) 12261da177e4SLinus Torvalds return 0; 12271da177e4SLinus Torvalds 12281da177e4SLinus Torvalds str = buf; 1229f796937aSJeremy Fitzhardinge end = buf + size; 12301da177e4SLinus Torvalds 1231f796937aSJeremy Fitzhardinge /* Make sure end is always >= buf */ 1232f796937aSJeremy Fitzhardinge if (end < buf) { 12331da177e4SLinus Torvalds end = ((void *)-1); 1234f796937aSJeremy Fitzhardinge size = end - buf; 12351da177e4SLinus Torvalds } 12361da177e4SLinus Torvalds 1237fef20d9cSFrederic Weisbecker while (*fmt) { 1238fef20d9cSFrederic Weisbecker const char *old_fmt = fmt; 1239d4be151bSAndré Goddard Rosa int read = format_decode(fmt, &spec); 1240fef20d9cSFrederic Weisbecker 1241fef20d9cSFrederic Weisbecker fmt += read; 1242fef20d9cSFrederic Weisbecker 1243fef20d9cSFrederic Weisbecker switch (spec.type) { 1244fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NONE: { 1245fef20d9cSFrederic Weisbecker int copy = read; 1246fef20d9cSFrederic Weisbecker if (str < end) { 1247fef20d9cSFrederic Weisbecker if (copy > end - str) 1248fef20d9cSFrederic Weisbecker copy = end - str; 1249fef20d9cSFrederic Weisbecker memcpy(str, old_fmt, copy); 1250fef20d9cSFrederic Weisbecker } 1251fef20d9cSFrederic Weisbecker str += read; 1252fef20d9cSFrederic Weisbecker break; 12531da177e4SLinus Torvalds } 12541da177e4SLinus Torvalds 1255ed681a91SVegard Nossum case FORMAT_TYPE_WIDTH: 1256fef20d9cSFrederic Weisbecker spec.field_width = va_arg(args, int); 1257fef20d9cSFrederic Weisbecker break; 12581da177e4SLinus Torvalds 1259fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PRECISION: 1260fef20d9cSFrederic Weisbecker spec.precision = va_arg(args, int); 1261fef20d9cSFrederic Weisbecker break; 12621da177e4SLinus Torvalds 1263d4be151bSAndré Goddard Rosa case FORMAT_TYPE_CHAR: { 1264d4be151bSAndré Goddard Rosa char c; 1265d4be151bSAndré Goddard Rosa 1266fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 1267fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 1268f796937aSJeremy Fitzhardinge if (str < end) 12691da177e4SLinus Torvalds *str = ' '; 12701da177e4SLinus Torvalds ++str; 1271fef20d9cSFrederic Weisbecker 12721da177e4SLinus Torvalds } 12731da177e4SLinus Torvalds } 12741da177e4SLinus Torvalds c = (unsigned char) va_arg(args, int); 1275f796937aSJeremy Fitzhardinge if (str < end) 12761da177e4SLinus Torvalds *str = c; 12771da177e4SLinus Torvalds ++str; 1278fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 1279f796937aSJeremy Fitzhardinge if (str < end) 12801da177e4SLinus Torvalds *str = ' '; 12811da177e4SLinus Torvalds ++str; 12821da177e4SLinus Torvalds } 1283fef20d9cSFrederic Weisbecker break; 1284d4be151bSAndré Goddard Rosa } 12851da177e4SLinus Torvalds 1286fef20d9cSFrederic Weisbecker case FORMAT_TYPE_STR: 1287fef20d9cSFrederic Weisbecker str = string(str, end, va_arg(args, char *), spec); 1288fef20d9cSFrederic Weisbecker break; 12891da177e4SLinus Torvalds 1290fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTR: 1291fef20d9cSFrederic Weisbecker str = pointer(fmt+1, str, end, va_arg(args, void *), 1292fef20d9cSFrederic Weisbecker spec); 1293fef20d9cSFrederic Weisbecker while (isalnum(*fmt)) 12944d8a743cSLinus Torvalds fmt++; 1295fef20d9cSFrederic Weisbecker break; 12961da177e4SLinus Torvalds 1297fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PERCENT_CHAR: 1298f796937aSJeremy Fitzhardinge if (str < end) 12991da177e4SLinus Torvalds *str = '%'; 13001da177e4SLinus Torvalds ++str; 13011da177e4SLinus Torvalds break; 13021da177e4SLinus Torvalds 1303fef20d9cSFrederic Weisbecker case FORMAT_TYPE_INVALID: 1304f796937aSJeremy Fitzhardinge if (str < end) 13051da177e4SLinus Torvalds *str = '%'; 13061da177e4SLinus Torvalds ++str; 1307fef20d9cSFrederic Weisbecker break; 1308fef20d9cSFrederic Weisbecker 1309fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NRCHARS: { 1310fef20d9cSFrederic Weisbecker int qualifier = spec.qualifier; 1311fef20d9cSFrederic Weisbecker 1312fef20d9cSFrederic Weisbecker if (qualifier == 'l') { 1313fef20d9cSFrederic Weisbecker long *ip = va_arg(args, long *); 1314fef20d9cSFrederic Weisbecker *ip = (str - buf); 131508562cb2SAndré Goddard Rosa } else if (TOLOWER(qualifier) == 'z') { 1316fef20d9cSFrederic Weisbecker size_t *ip = va_arg(args, size_t *); 1317fef20d9cSFrederic Weisbecker *ip = (str - buf); 13181da177e4SLinus Torvalds } else { 1319fef20d9cSFrederic Weisbecker int *ip = va_arg(args, int *); 1320fef20d9cSFrederic Weisbecker *ip = (str - buf); 1321fef20d9cSFrederic Weisbecker } 1322fef20d9cSFrederic Weisbecker break; 1323fef20d9cSFrederic Weisbecker } 1324fef20d9cSFrederic Weisbecker 1325fef20d9cSFrederic Weisbecker default: 1326fef20d9cSFrederic Weisbecker switch (spec.type) { 1327fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG_LONG: 1328fef20d9cSFrederic Weisbecker num = va_arg(args, long long); 1329fef20d9cSFrederic Weisbecker break; 1330fef20d9cSFrederic Weisbecker case FORMAT_TYPE_ULONG: 1331fef20d9cSFrederic Weisbecker num = va_arg(args, unsigned long); 1332fef20d9cSFrederic Weisbecker break; 1333fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG: 1334fef20d9cSFrederic Weisbecker num = va_arg(args, long); 1335fef20d9cSFrederic Weisbecker break; 1336fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SIZE_T: 1337fef20d9cSFrederic Weisbecker num = va_arg(args, size_t); 1338fef20d9cSFrederic Weisbecker break; 1339fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTRDIFF: 1340fef20d9cSFrederic Weisbecker num = va_arg(args, ptrdiff_t); 1341fef20d9cSFrederic Weisbecker break; 1342a4e94ef0SZhaolei case FORMAT_TYPE_UBYTE: 1343a4e94ef0SZhaolei num = (unsigned char) va_arg(args, int); 1344a4e94ef0SZhaolei break; 1345a4e94ef0SZhaolei case FORMAT_TYPE_BYTE: 1346a4e94ef0SZhaolei num = (signed char) va_arg(args, int); 1347a4e94ef0SZhaolei break; 1348fef20d9cSFrederic Weisbecker case FORMAT_TYPE_USHORT: 1349fef20d9cSFrederic Weisbecker num = (unsigned short) va_arg(args, int); 1350fef20d9cSFrederic Weisbecker break; 1351fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SHORT: 1352fef20d9cSFrederic Weisbecker num = (short) va_arg(args, int); 1353fef20d9cSFrederic Weisbecker break; 135439e874f8SFrederic Weisbecker case FORMAT_TYPE_INT: 135539e874f8SFrederic Weisbecker num = (int) va_arg(args, int); 1356fef20d9cSFrederic Weisbecker break; 1357fef20d9cSFrederic Weisbecker default: 1358fef20d9cSFrederic Weisbecker num = va_arg(args, unsigned int); 13591da177e4SLinus Torvalds } 1360fef20d9cSFrederic Weisbecker 1361fef20d9cSFrederic Weisbecker str = number(str, end, num, spec); 13621da177e4SLinus Torvalds } 1363fef20d9cSFrederic Weisbecker } 1364fef20d9cSFrederic Weisbecker 1365f796937aSJeremy Fitzhardinge if (size > 0) { 1366f796937aSJeremy Fitzhardinge if (str < end) 13671da177e4SLinus Torvalds *str = '\0'; 1368f796937aSJeremy Fitzhardinge else 13690a6047eeSLinus Torvalds end[-1] = '\0'; 1370f796937aSJeremy Fitzhardinge } 1371fef20d9cSFrederic Weisbecker 1372f796937aSJeremy Fitzhardinge /* the trailing null byte doesn't count towards the total */ 13731da177e4SLinus Torvalds return str-buf; 1374fef20d9cSFrederic Weisbecker 13751da177e4SLinus Torvalds } 13761da177e4SLinus Torvalds EXPORT_SYMBOL(vsnprintf); 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds /** 13791da177e4SLinus Torvalds * vscnprintf - Format a string and place it in a buffer 13801da177e4SLinus Torvalds * @buf: The buffer to place the result into 13811da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 13821da177e4SLinus Torvalds * @fmt: The format string to use 13831da177e4SLinus Torvalds * @args: Arguments for the format string 13841da177e4SLinus Torvalds * 13851da177e4SLinus Torvalds * The return value is the number of characters which have been written into 13861da177e4SLinus Torvalds * the @buf not including the trailing '\0'. If @size is <= 0 the function 13871da177e4SLinus Torvalds * returns 0. 13881da177e4SLinus Torvalds * 13891da177e4SLinus Torvalds * Call this function if you are already dealing with a va_list. 139072fd4a35SRobert P. J. Day * You probably want scnprintf() instead. 139120036fdcSAndi Kleen * 139220036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 13931da177e4SLinus Torvalds */ 13941da177e4SLinus Torvalds int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 13951da177e4SLinus Torvalds { 13961da177e4SLinus Torvalds int i; 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds i = vsnprintf(buf, size, fmt, args); 13997b9186f5SAndré Goddard Rosa 14001da177e4SLinus Torvalds return (i >= size) ? (size - 1) : i; 14011da177e4SLinus Torvalds } 14021da177e4SLinus Torvalds EXPORT_SYMBOL(vscnprintf); 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds /** 14051da177e4SLinus Torvalds * snprintf - Format a string and place it in a buffer 14061da177e4SLinus Torvalds * @buf: The buffer to place the result into 14071da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 14081da177e4SLinus Torvalds * @fmt: The format string to use 14091da177e4SLinus Torvalds * @...: Arguments for the format string 14101da177e4SLinus Torvalds * 14111da177e4SLinus Torvalds * The return value is the number of characters which would be 14121da177e4SLinus Torvalds * generated for the given input, excluding the trailing null, 14131da177e4SLinus Torvalds * as per ISO C99. If the return is greater than or equal to 14141da177e4SLinus Torvalds * @size, the resulting string is truncated. 141520036fdcSAndi Kleen * 141620036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 14171da177e4SLinus Torvalds */ 14181da177e4SLinus Torvalds int snprintf(char *buf, size_t size, const char *fmt, ...) 14191da177e4SLinus Torvalds { 14201da177e4SLinus Torvalds va_list args; 14211da177e4SLinus Torvalds int i; 14221da177e4SLinus Torvalds 14231da177e4SLinus Torvalds va_start(args, fmt); 14241da177e4SLinus Torvalds i = vsnprintf(buf, size, fmt, args); 14251da177e4SLinus Torvalds va_end(args); 14267b9186f5SAndré Goddard Rosa 14271da177e4SLinus Torvalds return i; 14281da177e4SLinus Torvalds } 14291da177e4SLinus Torvalds EXPORT_SYMBOL(snprintf); 14301da177e4SLinus Torvalds 14311da177e4SLinus Torvalds /** 14321da177e4SLinus Torvalds * scnprintf - Format a string and place it in a buffer 14331da177e4SLinus Torvalds * @buf: The buffer to place the result into 14341da177e4SLinus Torvalds * @size: The size of the buffer, including the trailing null space 14351da177e4SLinus Torvalds * @fmt: The format string to use 14361da177e4SLinus Torvalds * @...: Arguments for the format string 14371da177e4SLinus Torvalds * 14381da177e4SLinus Torvalds * The return value is the number of characters written into @buf not including 1439ea6f3281SMartin Peschke * the trailing '\0'. If @size is <= 0 the function returns 0. 14401da177e4SLinus Torvalds */ 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds int scnprintf(char *buf, size_t size, const char *fmt, ...) 14431da177e4SLinus Torvalds { 14441da177e4SLinus Torvalds va_list args; 14451da177e4SLinus Torvalds int i; 14461da177e4SLinus Torvalds 14471da177e4SLinus Torvalds va_start(args, fmt); 14481da177e4SLinus Torvalds i = vsnprintf(buf, size, fmt, args); 14491da177e4SLinus Torvalds va_end(args); 14507b9186f5SAndré Goddard Rosa 14511da177e4SLinus Torvalds return (i >= size) ? (size - 1) : i; 14521da177e4SLinus Torvalds } 14531da177e4SLinus Torvalds EXPORT_SYMBOL(scnprintf); 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds /** 14561da177e4SLinus Torvalds * vsprintf - Format a string and place it in a buffer 14571da177e4SLinus Torvalds * @buf: The buffer to place the result into 14581da177e4SLinus Torvalds * @fmt: The format string to use 14591da177e4SLinus Torvalds * @args: Arguments for the format string 14601da177e4SLinus Torvalds * 14611da177e4SLinus Torvalds * The function returns the number of characters written 146272fd4a35SRobert P. J. Day * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 14631da177e4SLinus Torvalds * buffer overflows. 14641da177e4SLinus Torvalds * 14651da177e4SLinus Torvalds * Call this function if you are already dealing with a va_list. 146672fd4a35SRobert P. J. Day * You probably want sprintf() instead. 146720036fdcSAndi Kleen * 146820036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 14691da177e4SLinus Torvalds */ 14701da177e4SLinus Torvalds int vsprintf(char *buf, const char *fmt, va_list args) 14711da177e4SLinus Torvalds { 14721da177e4SLinus Torvalds return vsnprintf(buf, INT_MAX, fmt, args); 14731da177e4SLinus Torvalds } 14741da177e4SLinus Torvalds EXPORT_SYMBOL(vsprintf); 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds /** 14771da177e4SLinus Torvalds * sprintf - Format a string and place it in a buffer 14781da177e4SLinus Torvalds * @buf: The buffer to place the result into 14791da177e4SLinus Torvalds * @fmt: The format string to use 14801da177e4SLinus Torvalds * @...: Arguments for the format string 14811da177e4SLinus Torvalds * 14821da177e4SLinus Torvalds * The function returns the number of characters written 148372fd4a35SRobert P. J. Day * into @buf. Use snprintf() or scnprintf() in order to avoid 14841da177e4SLinus Torvalds * buffer overflows. 148520036fdcSAndi Kleen * 148620036fdcSAndi Kleen * See the vsnprintf() documentation for format string extensions over C99. 14871da177e4SLinus Torvalds */ 14881da177e4SLinus Torvalds int sprintf(char *buf, const char *fmt, ...) 14891da177e4SLinus Torvalds { 14901da177e4SLinus Torvalds va_list args; 14911da177e4SLinus Torvalds int i; 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds va_start(args, fmt); 14941da177e4SLinus Torvalds i = vsnprintf(buf, INT_MAX, fmt, args); 14951da177e4SLinus Torvalds va_end(args); 14967b9186f5SAndré Goddard Rosa 14971da177e4SLinus Torvalds return i; 14981da177e4SLinus Torvalds } 14991da177e4SLinus Torvalds EXPORT_SYMBOL(sprintf); 15001da177e4SLinus Torvalds 15014370aa4aSLai Jiangshan #ifdef CONFIG_BINARY_PRINTF 15024370aa4aSLai Jiangshan /* 15034370aa4aSLai Jiangshan * bprintf service: 15044370aa4aSLai Jiangshan * vbin_printf() - VA arguments to binary data 15054370aa4aSLai Jiangshan * bstr_printf() - Binary data to text string 15064370aa4aSLai Jiangshan */ 15074370aa4aSLai Jiangshan 15084370aa4aSLai Jiangshan /** 15094370aa4aSLai Jiangshan * vbin_printf - Parse a format string and place args' binary value in a buffer 15104370aa4aSLai Jiangshan * @bin_buf: The buffer to place args' binary value 15114370aa4aSLai Jiangshan * @size: The size of the buffer(by words(32bits), not characters) 15124370aa4aSLai Jiangshan * @fmt: The format string to use 15134370aa4aSLai Jiangshan * @args: Arguments for the format string 15144370aa4aSLai Jiangshan * 15154370aa4aSLai Jiangshan * The format follows C99 vsnprintf, except %n is ignored, and its argument 15164370aa4aSLai Jiangshan * is skiped. 15174370aa4aSLai Jiangshan * 15184370aa4aSLai Jiangshan * The return value is the number of words(32bits) which would be generated for 15194370aa4aSLai Jiangshan * the given input. 15204370aa4aSLai Jiangshan * 15214370aa4aSLai Jiangshan * NOTE: 15224370aa4aSLai Jiangshan * If the return value is greater than @size, the resulting bin_buf is NOT 15234370aa4aSLai Jiangshan * valid for bstr_printf(). 15244370aa4aSLai Jiangshan */ 15254370aa4aSLai Jiangshan int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 15264370aa4aSLai Jiangshan { 1527fef20d9cSFrederic Weisbecker struct printf_spec spec = {0}; 15284370aa4aSLai Jiangshan char *str, *end; 15294370aa4aSLai Jiangshan 15304370aa4aSLai Jiangshan str = (char *)bin_buf; 15314370aa4aSLai Jiangshan end = (char *)(bin_buf + size); 15324370aa4aSLai Jiangshan 15334370aa4aSLai Jiangshan #define save_arg(type) \ 15344370aa4aSLai Jiangshan do { \ 15354370aa4aSLai Jiangshan if (sizeof(type) == 8) { \ 15364370aa4aSLai Jiangshan unsigned long long value; \ 15374370aa4aSLai Jiangshan str = PTR_ALIGN(str, sizeof(u32)); \ 15384370aa4aSLai Jiangshan value = va_arg(args, unsigned long long); \ 15394370aa4aSLai Jiangshan if (str + sizeof(type) <= end) { \ 15404370aa4aSLai Jiangshan *(u32 *)str = *(u32 *)&value; \ 15414370aa4aSLai Jiangshan *(u32 *)(str + 4) = *((u32 *)&value + 1); \ 15424370aa4aSLai Jiangshan } \ 15434370aa4aSLai Jiangshan } else { \ 15444370aa4aSLai Jiangshan unsigned long value; \ 15454370aa4aSLai Jiangshan str = PTR_ALIGN(str, sizeof(type)); \ 15464370aa4aSLai Jiangshan value = va_arg(args, int); \ 15474370aa4aSLai Jiangshan if (str + sizeof(type) <= end) \ 15484370aa4aSLai Jiangshan *(typeof(type) *)str = (type)value; \ 15494370aa4aSLai Jiangshan } \ 15504370aa4aSLai Jiangshan str += sizeof(type); \ 15514370aa4aSLai Jiangshan } while (0) 15524370aa4aSLai Jiangshan 1553fef20d9cSFrederic Weisbecker while (*fmt) { 1554d4be151bSAndré Goddard Rosa int read = format_decode(fmt, &spec); 15554370aa4aSLai Jiangshan 1556fef20d9cSFrederic Weisbecker fmt += read; 1557fef20d9cSFrederic Weisbecker 1558fef20d9cSFrederic Weisbecker switch (spec.type) { 1559fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NONE: 1560d4be151bSAndré Goddard Rosa case FORMAT_TYPE_INVALID: 1561d4be151bSAndré Goddard Rosa case FORMAT_TYPE_PERCENT_CHAR: 1562fef20d9cSFrederic Weisbecker break; 1563fef20d9cSFrederic Weisbecker 1564ed681a91SVegard Nossum case FORMAT_TYPE_WIDTH: 1565fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PRECISION: 15664370aa4aSLai Jiangshan save_arg(int); 1567fef20d9cSFrederic Weisbecker break; 15684370aa4aSLai Jiangshan 1569fef20d9cSFrederic Weisbecker case FORMAT_TYPE_CHAR: 15704370aa4aSLai Jiangshan save_arg(char); 1571fef20d9cSFrederic Weisbecker break; 1572fef20d9cSFrederic Weisbecker 1573fef20d9cSFrederic Weisbecker case FORMAT_TYPE_STR: { 15744370aa4aSLai Jiangshan const char *save_str = va_arg(args, char *); 15754370aa4aSLai Jiangshan size_t len; 15766c356634SAndré Goddard Rosa 15774370aa4aSLai Jiangshan if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 15784370aa4aSLai Jiangshan || (unsigned long)save_str < PAGE_SIZE) 15790f4f81dcSAndré Goddard Rosa save_str = "(null)"; 15806c356634SAndré Goddard Rosa len = strlen(save_str) + 1; 15816c356634SAndré Goddard Rosa if (str + len < end) 15826c356634SAndré Goddard Rosa memcpy(str, save_str, len); 15836c356634SAndré Goddard Rosa str += len; 1584fef20d9cSFrederic Weisbecker break; 15854370aa4aSLai Jiangshan } 1586fef20d9cSFrederic Weisbecker 1587fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTR: 15884370aa4aSLai Jiangshan save_arg(void *); 15894370aa4aSLai Jiangshan /* skip all alphanumeric pointer suffixes */ 1590fef20d9cSFrederic Weisbecker while (isalnum(*fmt)) 15914370aa4aSLai Jiangshan fmt++; 1592fef20d9cSFrederic Weisbecker break; 1593fef20d9cSFrederic Weisbecker 1594fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NRCHARS: { 15954370aa4aSLai Jiangshan /* skip %n 's argument */ 1596fef20d9cSFrederic Weisbecker int qualifier = spec.qualifier; 15974370aa4aSLai Jiangshan void *skip_arg; 15984370aa4aSLai Jiangshan if (qualifier == 'l') 15994370aa4aSLai Jiangshan skip_arg = va_arg(args, long *); 160008562cb2SAndré Goddard Rosa else if (TOLOWER(qualifier) == 'z') 16014370aa4aSLai Jiangshan skip_arg = va_arg(args, size_t *); 16024370aa4aSLai Jiangshan else 16034370aa4aSLai Jiangshan skip_arg = va_arg(args, int *); 1604fef20d9cSFrederic Weisbecker break; 16054370aa4aSLai Jiangshan } 16064370aa4aSLai Jiangshan 1607fef20d9cSFrederic Weisbecker default: 1608fef20d9cSFrederic Weisbecker switch (spec.type) { 1609fef20d9cSFrederic Weisbecker 1610fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG_LONG: 1611fef20d9cSFrederic Weisbecker save_arg(long long); 1612fef20d9cSFrederic Weisbecker break; 1613fef20d9cSFrederic Weisbecker case FORMAT_TYPE_ULONG: 1614fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG: 1615fef20d9cSFrederic Weisbecker save_arg(unsigned long); 1616fef20d9cSFrederic Weisbecker break; 1617fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SIZE_T: 1618fef20d9cSFrederic Weisbecker save_arg(size_t); 1619fef20d9cSFrederic Weisbecker break; 1620fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTRDIFF: 1621fef20d9cSFrederic Weisbecker save_arg(ptrdiff_t); 1622fef20d9cSFrederic Weisbecker break; 1623a4e94ef0SZhaolei case FORMAT_TYPE_UBYTE: 1624a4e94ef0SZhaolei case FORMAT_TYPE_BYTE: 1625a4e94ef0SZhaolei save_arg(char); 1626a4e94ef0SZhaolei break; 1627fef20d9cSFrederic Weisbecker case FORMAT_TYPE_USHORT: 1628fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SHORT: 1629fef20d9cSFrederic Weisbecker save_arg(short); 1630fef20d9cSFrederic Weisbecker break; 1631fef20d9cSFrederic Weisbecker default: 1632fef20d9cSFrederic Weisbecker save_arg(int); 1633fef20d9cSFrederic Weisbecker } 1634fef20d9cSFrederic Weisbecker } 1635fef20d9cSFrederic Weisbecker } 1636fef20d9cSFrederic Weisbecker 16377b9186f5SAndré Goddard Rosa return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 1638fef20d9cSFrederic Weisbecker #undef save_arg 16394370aa4aSLai Jiangshan } 16404370aa4aSLai Jiangshan EXPORT_SYMBOL_GPL(vbin_printf); 16414370aa4aSLai Jiangshan 16424370aa4aSLai Jiangshan /** 16434370aa4aSLai Jiangshan * bstr_printf - Format a string from binary arguments and place it in a buffer 16444370aa4aSLai Jiangshan * @buf: The buffer to place the result into 16454370aa4aSLai Jiangshan * @size: The size of the buffer, including the trailing null space 16464370aa4aSLai Jiangshan * @fmt: The format string to use 16474370aa4aSLai Jiangshan * @bin_buf: Binary arguments for the format string 16484370aa4aSLai Jiangshan * 16494370aa4aSLai Jiangshan * This function like C99 vsnprintf, but the difference is that vsnprintf gets 16504370aa4aSLai Jiangshan * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 16514370aa4aSLai Jiangshan * a binary buffer that generated by vbin_printf. 16524370aa4aSLai Jiangshan * 16534370aa4aSLai Jiangshan * The format follows C99 vsnprintf, but has some extensions: 16540efb4d20SSteven Rostedt * see vsnprintf comment for details. 16554370aa4aSLai Jiangshan * 16564370aa4aSLai Jiangshan * The return value is the number of characters which would 16574370aa4aSLai Jiangshan * be generated for the given input, excluding the trailing 16584370aa4aSLai Jiangshan * '\0', as per ISO C99. If you want to have the exact 16594370aa4aSLai Jiangshan * number of characters written into @buf as return value 16604370aa4aSLai Jiangshan * (not including the trailing '\0'), use vscnprintf(). If the 16614370aa4aSLai Jiangshan * return is greater than or equal to @size, the resulting 16624370aa4aSLai Jiangshan * string is truncated. 16634370aa4aSLai Jiangshan */ 16644370aa4aSLai Jiangshan int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 16654370aa4aSLai Jiangshan { 1666fef20d9cSFrederic Weisbecker struct printf_spec spec = {0}; 1667d4be151bSAndré Goddard Rosa char *str, *end; 1668d4be151bSAndré Goddard Rosa const char *args = (const char *)bin_buf; 16694370aa4aSLai Jiangshan 16702f30b1f9SMarcin Slusarz if (WARN_ON_ONCE((int) size < 0)) 16714370aa4aSLai Jiangshan return 0; 16724370aa4aSLai Jiangshan 16734370aa4aSLai Jiangshan str = buf; 16744370aa4aSLai Jiangshan end = buf + size; 16754370aa4aSLai Jiangshan 16764370aa4aSLai Jiangshan #define get_arg(type) \ 16774370aa4aSLai Jiangshan ({ \ 16784370aa4aSLai Jiangshan typeof(type) value; \ 16794370aa4aSLai Jiangshan if (sizeof(type) == 8) { \ 16804370aa4aSLai Jiangshan args = PTR_ALIGN(args, sizeof(u32)); \ 16814370aa4aSLai Jiangshan *(u32 *)&value = *(u32 *)args; \ 16824370aa4aSLai Jiangshan *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 16834370aa4aSLai Jiangshan } else { \ 16844370aa4aSLai Jiangshan args = PTR_ALIGN(args, sizeof(type)); \ 16854370aa4aSLai Jiangshan value = *(typeof(type) *)args; \ 16864370aa4aSLai Jiangshan } \ 16874370aa4aSLai Jiangshan args += sizeof(type); \ 16884370aa4aSLai Jiangshan value; \ 16894370aa4aSLai Jiangshan }) 16904370aa4aSLai Jiangshan 16914370aa4aSLai Jiangshan /* Make sure end is always >= buf */ 16924370aa4aSLai Jiangshan if (end < buf) { 16934370aa4aSLai Jiangshan end = ((void *)-1); 16944370aa4aSLai Jiangshan size = end - buf; 16954370aa4aSLai Jiangshan } 16964370aa4aSLai Jiangshan 1697fef20d9cSFrederic Weisbecker while (*fmt) { 1698fef20d9cSFrederic Weisbecker const char *old_fmt = fmt; 1699d4be151bSAndré Goddard Rosa int read = format_decode(fmt, &spec); 1700fef20d9cSFrederic Weisbecker 1701fef20d9cSFrederic Weisbecker fmt += read; 1702fef20d9cSFrederic Weisbecker 1703fef20d9cSFrederic Weisbecker switch (spec.type) { 1704fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NONE: { 1705fef20d9cSFrederic Weisbecker int copy = read; 1706fef20d9cSFrederic Weisbecker if (str < end) { 1707fef20d9cSFrederic Weisbecker if (copy > end - str) 1708fef20d9cSFrederic Weisbecker copy = end - str; 1709fef20d9cSFrederic Weisbecker memcpy(str, old_fmt, copy); 1710fef20d9cSFrederic Weisbecker } 1711fef20d9cSFrederic Weisbecker str += read; 1712fef20d9cSFrederic Weisbecker break; 17134370aa4aSLai Jiangshan } 17144370aa4aSLai Jiangshan 1715ed681a91SVegard Nossum case FORMAT_TYPE_WIDTH: 1716fef20d9cSFrederic Weisbecker spec.field_width = get_arg(int); 1717fef20d9cSFrederic Weisbecker break; 17184370aa4aSLai Jiangshan 1719fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PRECISION: 1720fef20d9cSFrederic Weisbecker spec.precision = get_arg(int); 1721fef20d9cSFrederic Weisbecker break; 17224370aa4aSLai Jiangshan 1723d4be151bSAndré Goddard Rosa case FORMAT_TYPE_CHAR: { 1724d4be151bSAndré Goddard Rosa char c; 1725d4be151bSAndré Goddard Rosa 1726fef20d9cSFrederic Weisbecker if (!(spec.flags & LEFT)) { 1727fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 17284370aa4aSLai Jiangshan if (str < end) 17294370aa4aSLai Jiangshan *str = ' '; 17304370aa4aSLai Jiangshan ++str; 17314370aa4aSLai Jiangshan } 17324370aa4aSLai Jiangshan } 17334370aa4aSLai Jiangshan c = (unsigned char) get_arg(char); 17344370aa4aSLai Jiangshan if (str < end) 17354370aa4aSLai Jiangshan *str = c; 17364370aa4aSLai Jiangshan ++str; 1737fef20d9cSFrederic Weisbecker while (--spec.field_width > 0) { 17384370aa4aSLai Jiangshan if (str < end) 17394370aa4aSLai Jiangshan *str = ' '; 17404370aa4aSLai Jiangshan ++str; 17414370aa4aSLai Jiangshan } 1742fef20d9cSFrederic Weisbecker break; 1743d4be151bSAndré Goddard Rosa } 17444370aa4aSLai Jiangshan 1745fef20d9cSFrederic Weisbecker case FORMAT_TYPE_STR: { 17464370aa4aSLai Jiangshan const char *str_arg = args; 1747d4be151bSAndré Goddard Rosa args += strlen(str_arg) + 1; 1748fef20d9cSFrederic Weisbecker str = string(str, end, (char *)str_arg, spec); 1749fef20d9cSFrederic Weisbecker break; 17504370aa4aSLai Jiangshan } 17514370aa4aSLai Jiangshan 1752fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTR: 1753fef20d9cSFrederic Weisbecker str = pointer(fmt+1, str, end, get_arg(void *), spec); 1754fef20d9cSFrederic Weisbecker while (isalnum(*fmt)) 17554370aa4aSLai Jiangshan fmt++; 1756fef20d9cSFrederic Weisbecker break; 17574370aa4aSLai Jiangshan 1758fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PERCENT_CHAR: 1759fef20d9cSFrederic Weisbecker case FORMAT_TYPE_INVALID: 17604370aa4aSLai Jiangshan if (str < end) 17614370aa4aSLai Jiangshan *str = '%'; 17624370aa4aSLai Jiangshan ++str; 1763fef20d9cSFrederic Weisbecker break; 1764fef20d9cSFrederic Weisbecker 1765fef20d9cSFrederic Weisbecker case FORMAT_TYPE_NRCHARS: 1766fef20d9cSFrederic Weisbecker /* skip */ 1767fef20d9cSFrederic Weisbecker break; 1768fef20d9cSFrederic Weisbecker 1769d4be151bSAndré Goddard Rosa default: { 1770d4be151bSAndré Goddard Rosa unsigned long long num; 1771d4be151bSAndré Goddard Rosa 1772fef20d9cSFrederic Weisbecker switch (spec.type) { 1773fef20d9cSFrederic Weisbecker 1774fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG_LONG: 17754370aa4aSLai Jiangshan num = get_arg(long long); 1776fef20d9cSFrederic Weisbecker break; 1777fef20d9cSFrederic Weisbecker case FORMAT_TYPE_ULONG: 1778fef20d9cSFrederic Weisbecker case FORMAT_TYPE_LONG: 1779fef20d9cSFrederic Weisbecker num = get_arg(unsigned long); 1780fef20d9cSFrederic Weisbecker break; 1781fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SIZE_T: 17824370aa4aSLai Jiangshan num = get_arg(size_t); 1783fef20d9cSFrederic Weisbecker break; 1784fef20d9cSFrederic Weisbecker case FORMAT_TYPE_PTRDIFF: 17854370aa4aSLai Jiangshan num = get_arg(ptrdiff_t); 1786fef20d9cSFrederic Weisbecker break; 1787a4e94ef0SZhaolei case FORMAT_TYPE_UBYTE: 1788a4e94ef0SZhaolei num = get_arg(unsigned char); 1789a4e94ef0SZhaolei break; 1790a4e94ef0SZhaolei case FORMAT_TYPE_BYTE: 1791a4e94ef0SZhaolei num = get_arg(signed char); 1792a4e94ef0SZhaolei break; 1793fef20d9cSFrederic Weisbecker case FORMAT_TYPE_USHORT: 1794fef20d9cSFrederic Weisbecker num = get_arg(unsigned short); 1795fef20d9cSFrederic Weisbecker break; 1796fef20d9cSFrederic Weisbecker case FORMAT_TYPE_SHORT: 1797fef20d9cSFrederic Weisbecker num = get_arg(short); 1798fef20d9cSFrederic Weisbecker break; 1799fef20d9cSFrederic Weisbecker case FORMAT_TYPE_UINT: 18004370aa4aSLai Jiangshan num = get_arg(unsigned int); 1801fef20d9cSFrederic Weisbecker break; 1802fef20d9cSFrederic Weisbecker default: 1803fef20d9cSFrederic Weisbecker num = get_arg(int); 18044370aa4aSLai Jiangshan } 1805fef20d9cSFrederic Weisbecker 1806fef20d9cSFrederic Weisbecker str = number(str, end, num, spec); 1807d4be151bSAndré Goddard Rosa } /* default: */ 1808d4be151bSAndré Goddard Rosa } /* switch(spec.type) */ 1809d4be151bSAndré Goddard Rosa } /* while(*fmt) */ 1810fef20d9cSFrederic Weisbecker 18114370aa4aSLai Jiangshan if (size > 0) { 18124370aa4aSLai Jiangshan if (str < end) 18134370aa4aSLai Jiangshan *str = '\0'; 18144370aa4aSLai Jiangshan else 18154370aa4aSLai Jiangshan end[-1] = '\0'; 18164370aa4aSLai Jiangshan } 1817fef20d9cSFrederic Weisbecker 18184370aa4aSLai Jiangshan #undef get_arg 18194370aa4aSLai Jiangshan 18204370aa4aSLai Jiangshan /* the trailing null byte doesn't count towards the total */ 18214370aa4aSLai Jiangshan return str - buf; 18224370aa4aSLai Jiangshan } 18234370aa4aSLai Jiangshan EXPORT_SYMBOL_GPL(bstr_printf); 18244370aa4aSLai Jiangshan 18254370aa4aSLai Jiangshan /** 18264370aa4aSLai Jiangshan * bprintf - Parse a format string and place args' binary value in a buffer 18274370aa4aSLai Jiangshan * @bin_buf: The buffer to place args' binary value 18284370aa4aSLai Jiangshan * @size: The size of the buffer(by words(32bits), not characters) 18294370aa4aSLai Jiangshan * @fmt: The format string to use 18304370aa4aSLai Jiangshan * @...: Arguments for the format string 18314370aa4aSLai Jiangshan * 18324370aa4aSLai Jiangshan * The function returns the number of words(u32) written 18334370aa4aSLai Jiangshan * into @bin_buf. 18344370aa4aSLai Jiangshan */ 18354370aa4aSLai Jiangshan int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 18364370aa4aSLai Jiangshan { 18374370aa4aSLai Jiangshan va_list args; 18384370aa4aSLai Jiangshan int ret; 18394370aa4aSLai Jiangshan 18404370aa4aSLai Jiangshan va_start(args, fmt); 18414370aa4aSLai Jiangshan ret = vbin_printf(bin_buf, size, fmt, args); 18424370aa4aSLai Jiangshan va_end(args); 18437b9186f5SAndré Goddard Rosa 18444370aa4aSLai Jiangshan return ret; 18454370aa4aSLai Jiangshan } 18464370aa4aSLai Jiangshan EXPORT_SYMBOL_GPL(bprintf); 18474370aa4aSLai Jiangshan 18484370aa4aSLai Jiangshan #endif /* CONFIG_BINARY_PRINTF */ 18494370aa4aSLai Jiangshan 18501da177e4SLinus Torvalds /** 18511da177e4SLinus Torvalds * vsscanf - Unformat a buffer into a list of arguments 18521da177e4SLinus Torvalds * @buf: input buffer 18531da177e4SLinus Torvalds * @fmt: format of buffer 18541da177e4SLinus Torvalds * @args: arguments 18551da177e4SLinus Torvalds */ 18561da177e4SLinus Torvalds int vsscanf(const char *buf, const char *fmt, va_list args) 18571da177e4SLinus Torvalds { 18581da177e4SLinus Torvalds const char *str = buf; 18591da177e4SLinus Torvalds char *next; 18601da177e4SLinus Torvalds char digit; 18611da177e4SLinus Torvalds int num = 0; 18627b9186f5SAndré Goddard Rosa int qualifier, base, field_width; 1863d4be151bSAndré Goddard Rosa bool is_sign; 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds while (*fmt && *str) { 18661da177e4SLinus Torvalds /* skip any white space in format */ 18671da177e4SLinus Torvalds /* white space in format matchs any amount of 18681da177e4SLinus Torvalds * white space, including none, in the input. 18691da177e4SLinus Torvalds */ 18701da177e4SLinus Torvalds if (isspace(*fmt)) { 1871e7d2860bSAndré Goddard Rosa fmt = skip_spaces(++fmt); 1872e7d2860bSAndré Goddard Rosa str = skip_spaces(str); 18731da177e4SLinus Torvalds } 18741da177e4SLinus Torvalds 18751da177e4SLinus Torvalds /* anything that is not a conversion must match exactly */ 18761da177e4SLinus Torvalds if (*fmt != '%' && *fmt) { 18771da177e4SLinus Torvalds if (*fmt++ != *str++) 18781da177e4SLinus Torvalds break; 18791da177e4SLinus Torvalds continue; 18801da177e4SLinus Torvalds } 18811da177e4SLinus Torvalds 18821da177e4SLinus Torvalds if (!*fmt) 18831da177e4SLinus Torvalds break; 18841da177e4SLinus Torvalds ++fmt; 18851da177e4SLinus Torvalds 18861da177e4SLinus Torvalds /* skip this conversion. 18871da177e4SLinus Torvalds * advance both strings to next white space 18881da177e4SLinus Torvalds */ 18891da177e4SLinus Torvalds if (*fmt == '*') { 18908fccae2cSAndy Spencer while (!isspace(*fmt) && *fmt != '%' && *fmt) 18911da177e4SLinus Torvalds fmt++; 18921da177e4SLinus Torvalds while (!isspace(*str) && *str) 18931da177e4SLinus Torvalds str++; 18941da177e4SLinus Torvalds continue; 18951da177e4SLinus Torvalds } 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds /* get field width */ 18981da177e4SLinus Torvalds field_width = -1; 18991da177e4SLinus Torvalds if (isdigit(*fmt)) 19001da177e4SLinus Torvalds field_width = skip_atoi(&fmt); 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds /* get conversion qualifier */ 19031da177e4SLinus Torvalds qualifier = -1; 190408562cb2SAndré Goddard Rosa if (*fmt == 'h' || TOLOWER(*fmt) == 'l' || 190508562cb2SAndré Goddard Rosa TOLOWER(*fmt) == 'z') { 19061da177e4SLinus Torvalds qualifier = *fmt++; 19071da177e4SLinus Torvalds if (unlikely(qualifier == *fmt)) { 19081da177e4SLinus Torvalds if (qualifier == 'h') { 19091da177e4SLinus Torvalds qualifier = 'H'; 19101da177e4SLinus Torvalds fmt++; 19111da177e4SLinus Torvalds } else if (qualifier == 'l') { 19121da177e4SLinus Torvalds qualifier = 'L'; 19131da177e4SLinus Torvalds fmt++; 19141da177e4SLinus Torvalds } 19151da177e4SLinus Torvalds } 19161da177e4SLinus Torvalds } 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds if (!*fmt || !*str) 19191da177e4SLinus Torvalds break; 19201da177e4SLinus Torvalds 1921d4be151bSAndré Goddard Rosa base = 10; 1922d4be151bSAndré Goddard Rosa is_sign = 0; 1923d4be151bSAndré Goddard Rosa 19241da177e4SLinus Torvalds switch (*fmt++) { 19251da177e4SLinus Torvalds case 'c': 19261da177e4SLinus Torvalds { 19271da177e4SLinus Torvalds char *s = (char *)va_arg(args, char*); 19281da177e4SLinus Torvalds if (field_width == -1) 19291da177e4SLinus Torvalds field_width = 1; 19301da177e4SLinus Torvalds do { 19311da177e4SLinus Torvalds *s++ = *str++; 19321da177e4SLinus Torvalds } while (--field_width > 0 && *str); 19331da177e4SLinus Torvalds num++; 19341da177e4SLinus Torvalds } 19351da177e4SLinus Torvalds continue; 19361da177e4SLinus Torvalds case 's': 19371da177e4SLinus Torvalds { 19381da177e4SLinus Torvalds char *s = (char *)va_arg(args, char *); 19391da177e4SLinus Torvalds if (field_width == -1) 19401da177e4SLinus Torvalds field_width = INT_MAX; 19411da177e4SLinus Torvalds /* first, skip leading white space in buffer */ 1942e7d2860bSAndré Goddard Rosa str = skip_spaces(str); 19431da177e4SLinus Torvalds 19441da177e4SLinus Torvalds /* now copy until next white space */ 19457b9186f5SAndré Goddard Rosa while (*str && !isspace(*str) && field_width--) 19461da177e4SLinus Torvalds *s++ = *str++; 19471da177e4SLinus Torvalds *s = '\0'; 19481da177e4SLinus Torvalds num++; 19491da177e4SLinus Torvalds } 19501da177e4SLinus Torvalds continue; 19511da177e4SLinus Torvalds case 'n': 19521da177e4SLinus Torvalds /* return number of characters read so far */ 19531da177e4SLinus Torvalds { 19541da177e4SLinus Torvalds int *i = (int *)va_arg(args, int*); 19551da177e4SLinus Torvalds *i = str - buf; 19561da177e4SLinus Torvalds } 19571da177e4SLinus Torvalds continue; 19581da177e4SLinus Torvalds case 'o': 19591da177e4SLinus Torvalds base = 8; 19601da177e4SLinus Torvalds break; 19611da177e4SLinus Torvalds case 'x': 19621da177e4SLinus Torvalds case 'X': 19631da177e4SLinus Torvalds base = 16; 19641da177e4SLinus Torvalds break; 19651da177e4SLinus Torvalds case 'i': 19661da177e4SLinus Torvalds base = 0; 19671da177e4SLinus Torvalds case 'd': 19681da177e4SLinus Torvalds is_sign = 1; 19691da177e4SLinus Torvalds case 'u': 19701da177e4SLinus Torvalds break; 19711da177e4SLinus Torvalds case '%': 19721da177e4SLinus Torvalds /* looking for '%' in str */ 19731da177e4SLinus Torvalds if (*str++ != '%') 19741da177e4SLinus Torvalds return num; 19751da177e4SLinus Torvalds continue; 19761da177e4SLinus Torvalds default: 19771da177e4SLinus Torvalds /* invalid format; stop here */ 19781da177e4SLinus Torvalds return num; 19791da177e4SLinus Torvalds } 19801da177e4SLinus Torvalds 19811da177e4SLinus Torvalds /* have some sort of integer conversion. 19821da177e4SLinus Torvalds * first, skip white space in buffer. 19831da177e4SLinus Torvalds */ 1984e7d2860bSAndré Goddard Rosa str = skip_spaces(str); 19851da177e4SLinus Torvalds 19861da177e4SLinus Torvalds digit = *str; 19871da177e4SLinus Torvalds if (is_sign && digit == '-') 19881da177e4SLinus Torvalds digit = *(str + 1); 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds if (!digit 19911da177e4SLinus Torvalds || (base == 16 && !isxdigit(digit)) 19921da177e4SLinus Torvalds || (base == 10 && !isdigit(digit)) 19931da177e4SLinus Torvalds || (base == 8 && (!isdigit(digit) || digit > '7')) 19941da177e4SLinus Torvalds || (base == 0 && !isdigit(digit))) 19951da177e4SLinus Torvalds break; 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds switch (qualifier) { 19981da177e4SLinus Torvalds case 'H': /* that's 'hh' in format */ 19991da177e4SLinus Torvalds if (is_sign) { 20001da177e4SLinus Torvalds signed char *s = (signed char *)va_arg(args, signed char *); 20011da177e4SLinus Torvalds *s = (signed char)simple_strtol(str, &next, base); 20021da177e4SLinus Torvalds } else { 20031da177e4SLinus Torvalds unsigned char *s = (unsigned char *)va_arg(args, unsigned char *); 20041da177e4SLinus Torvalds *s = (unsigned char)simple_strtoul(str, &next, base); 20051da177e4SLinus Torvalds } 20061da177e4SLinus Torvalds break; 20071da177e4SLinus Torvalds case 'h': 20081da177e4SLinus Torvalds if (is_sign) { 20091da177e4SLinus Torvalds short *s = (short *)va_arg(args, short *); 20101da177e4SLinus Torvalds *s = (short)simple_strtol(str, &next, base); 20111da177e4SLinus Torvalds } else { 20121da177e4SLinus Torvalds unsigned short *s = (unsigned short *)va_arg(args, unsigned short *); 20131da177e4SLinus Torvalds *s = (unsigned short)simple_strtoul(str, &next, base); 20141da177e4SLinus Torvalds } 20151da177e4SLinus Torvalds break; 20161da177e4SLinus Torvalds case 'l': 20171da177e4SLinus Torvalds if (is_sign) { 20181da177e4SLinus Torvalds long *l = (long *)va_arg(args, long *); 20191da177e4SLinus Torvalds *l = simple_strtol(str, &next, base); 20201da177e4SLinus Torvalds } else { 20211da177e4SLinus Torvalds unsigned long *l = (unsigned long *)va_arg(args, unsigned long *); 20221da177e4SLinus Torvalds *l = simple_strtoul(str, &next, base); 20231da177e4SLinus Torvalds } 20241da177e4SLinus Torvalds break; 20251da177e4SLinus Torvalds case 'L': 20261da177e4SLinus Torvalds if (is_sign) { 20271da177e4SLinus Torvalds long long *l = (long long *)va_arg(args, long long *); 20281da177e4SLinus Torvalds *l = simple_strtoll(str, &next, base); 20291da177e4SLinus Torvalds } else { 20301da177e4SLinus Torvalds unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *); 20311da177e4SLinus Torvalds *l = simple_strtoull(str, &next, base); 20321da177e4SLinus Torvalds } 20331da177e4SLinus Torvalds break; 20341da177e4SLinus Torvalds case 'Z': 20351da177e4SLinus Torvalds case 'z': 20361da177e4SLinus Torvalds { 20371da177e4SLinus Torvalds size_t *s = (size_t *)va_arg(args, size_t *); 20381da177e4SLinus Torvalds *s = (size_t)simple_strtoul(str, &next, base); 20391da177e4SLinus Torvalds } 20401da177e4SLinus Torvalds break; 20411da177e4SLinus Torvalds default: 20421da177e4SLinus Torvalds if (is_sign) { 20431da177e4SLinus Torvalds int *i = (int *)va_arg(args, int *); 20441da177e4SLinus Torvalds *i = (int)simple_strtol(str, &next, base); 20451da177e4SLinus Torvalds } else { 20461da177e4SLinus Torvalds unsigned int *i = (unsigned int *)va_arg(args, unsigned int*); 20471da177e4SLinus Torvalds *i = (unsigned int)simple_strtoul(str, &next, base); 20481da177e4SLinus Torvalds } 20491da177e4SLinus Torvalds break; 20501da177e4SLinus Torvalds } 20511da177e4SLinus Torvalds num++; 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds if (!next) 20541da177e4SLinus Torvalds break; 20551da177e4SLinus Torvalds str = next; 20561da177e4SLinus Torvalds } 2057c6b40d16SJohannes Berg 2058c6b40d16SJohannes Berg /* 2059c6b40d16SJohannes Berg * Now we've come all the way through so either the input string or the 2060c6b40d16SJohannes Berg * format ended. In the former case, there can be a %n at the current 2061c6b40d16SJohannes Berg * position in the format that needs to be filled. 2062c6b40d16SJohannes Berg */ 2063c6b40d16SJohannes Berg if (*fmt == '%' && *(fmt + 1) == 'n') { 2064c6b40d16SJohannes Berg int *p = (int *)va_arg(args, int *); 2065c6b40d16SJohannes Berg *p = str - buf; 2066c6b40d16SJohannes Berg } 2067c6b40d16SJohannes Berg 20681da177e4SLinus Torvalds return num; 20691da177e4SLinus Torvalds } 20701da177e4SLinus Torvalds EXPORT_SYMBOL(vsscanf); 20711da177e4SLinus Torvalds 20721da177e4SLinus Torvalds /** 20731da177e4SLinus Torvalds * sscanf - Unformat a buffer into a list of arguments 20741da177e4SLinus Torvalds * @buf: input buffer 20751da177e4SLinus Torvalds * @fmt: formatting of buffer 20761da177e4SLinus Torvalds * @...: resulting arguments 20771da177e4SLinus Torvalds */ 20781da177e4SLinus Torvalds int sscanf(const char *buf, const char *fmt, ...) 20791da177e4SLinus Torvalds { 20801da177e4SLinus Torvalds va_list args; 20811da177e4SLinus Torvalds int i; 20821da177e4SLinus Torvalds 20831da177e4SLinus Torvalds va_start(args, fmt); 20841da177e4SLinus Torvalds i = vsscanf(buf, fmt, args); 20851da177e4SLinus Torvalds va_end(args); 20867b9186f5SAndré Goddard Rosa 20871da177e4SLinus Torvalds return i; 20881da177e4SLinus Torvalds } 20891da177e4SLinus Torvalds EXPORT_SYMBOL(sscanf); 2090