3706 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * linux/lib/vsprintf.c4 *5 * Copyright (C) 1991, 1992 Linus Torvalds6 */7 8/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */9/*10 * Wirzenius wrote this portably, Torvalds fucked it up :-)11 */12 13/*14 * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>15 * - changed to provide snprintf and vsnprintf functions16 * So Feb 1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>17 * - scnprintf and vscnprintf18 */19 20#include <linux/stdarg.h>21#include <linux/build_bug.h>22#include <linux/clk.h>23#include <linux/clk-provider.h>24#include <linux/errname.h>25#include <linux/module.h> /* for KSYM_SYMBOL_LEN */26#include <linux/types.h>27#include <linux/string.h>28#include <linux/ctype.h>29#include <linux/kernel.h>30#include <linux/kallsyms.h>31#include <linux/math64.h>32#include <linux/uaccess.h>33#include <linux/ioport.h>34#include <linux/dcache.h>35#include <linux/cred.h>36#include <linux/rtc.h>37#include <linux/sprintf.h>38#include <linux/time.h>39#include <linux/uuid.h>40#include <linux/of.h>41#include <net/addrconf.h>42#include <linux/siphash.h>43#include <linux/compiler.h>44#include <linux/property.h>45#include <linux/notifier.h>46#ifdef CONFIG_BLOCK47#include <linux/blkdev.h>48#endif49 50#include "../mm/internal.h" /* For the trace_print_flags arrays */51 52#include <asm/page.h> /* for PAGE_SIZE */53#include <asm/byteorder.h> /* cpu_to_le16 */54#include <linux/unaligned.h>55 56#include <linux/string_helpers.h>57#include "kstrtox.h"58 59/* Disable pointer hashing if requested */60bool no_hash_pointers __ro_after_init;61EXPORT_SYMBOL_GPL(no_hash_pointers);62 63noinline64static unsigned long long simple_strntoull(const char *startp, char **endp, unsigned int base, size_t max_chars)65{66 const char *cp;67 unsigned long long result = 0ULL;68 size_t prefix_chars;69 unsigned int rv;70 71 cp = _parse_integer_fixup_radix(startp, &base);72 prefix_chars = cp - startp;73 if (prefix_chars < max_chars) {74 rv = _parse_integer_limit(cp, base, &result, max_chars - prefix_chars);75 /* FIXME */76 cp += (rv & ~KSTRTOX_OVERFLOW);77 } else {78 /* Field too short for prefix + digit, skip over without converting */79 cp = startp + max_chars;80 }81 82 if (endp)83 *endp = (char *)cp;84 85 return result;86}87 88/**89 * simple_strtoull - convert a string to an unsigned long long90 * @cp: The start of the string91 * @endp: A pointer to the end of the parsed string will be placed here92 * @base: The number base to use93 *94 * This function has caveats. Please use kstrtoull instead.95 */96noinline97unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)98{99 return simple_strntoull(cp, endp, base, INT_MAX);100}101EXPORT_SYMBOL(simple_strtoull);102 103/**104 * simple_strtoul - convert a string to an unsigned long105 * @cp: The start of the string106 * @endp: A pointer to the end of the parsed string will be placed here107 * @base: The number base to use108 *109 * This function has caveats. Please use kstrtoul instead.110 */111unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)112{113 return simple_strtoull(cp, endp, base);114}115EXPORT_SYMBOL(simple_strtoul);116 117/**118 * simple_strtol - convert a string to a signed long119 * @cp: The start of the string120 * @endp: A pointer to the end of the parsed string will be placed here121 * @base: The number base to use122 *123 * This function has caveats. Please use kstrtol instead.124 */125long simple_strtol(const char *cp, char **endp, unsigned int base)126{127 if (*cp == '-')128 return -simple_strtoul(cp + 1, endp, base);129 130 return simple_strtoul(cp, endp, base);131}132EXPORT_SYMBOL(simple_strtol);133 134noinline135static long long simple_strntoll(const char *cp, char **endp, unsigned int base, size_t max_chars)136{137 /*138 * simple_strntoull() safely handles receiving max_chars==0 in the139 * case cp[0] == '-' && max_chars == 1.140 * If max_chars == 0 we can drop through and pass it to simple_strntoull()141 * and the content of *cp is irrelevant.142 */143 if (*cp == '-' && max_chars > 0)144 return -simple_strntoull(cp + 1, endp, base, max_chars - 1);145 146 return simple_strntoull(cp, endp, base, max_chars);147}148 149/**150 * simple_strtoll - convert a string to a signed long long151 * @cp: The start of the string152 * @endp: A pointer to the end of the parsed string will be placed here153 * @base: The number base to use154 *155 * This function has caveats. Please use kstrtoll instead.156 */157long long simple_strtoll(const char *cp, char **endp, unsigned int base)158{159 return simple_strntoll(cp, endp, base, INT_MAX);160}161EXPORT_SYMBOL(simple_strtoll);162 163static noinline_for_stack164int skip_atoi(const char **s)165{166 int i = 0;167 168 do {169 i = i*10 + *((*s)++) - '0';170 } while (isdigit(**s));171 172 return i;173}174 175/*176 * Decimal conversion is by far the most typical, and is used for177 * /proc and /sys data. This directly impacts e.g. top performance178 * with many processes running. We optimize it for speed by emitting179 * two characters at a time, using a 200 byte lookup table. This180 * roughly halves the number of multiplications compared to computing181 * the digits one at a time. Implementation strongly inspired by the182 * previous version, which in turn used ideas described at183 * <http://www.cs.uiowa.edu/~jones/bcd/divide.html> (with permission184 * from the author, Douglas W. Jones).185 *186 * It turns out there is precisely one 26 bit fixed-point187 * approximation a of 64/100 for which x/100 == (x * (u64)a) >> 32188 * holds for all x in [0, 10^8-1], namely a = 0x28f5c29. The actual189 * range happens to be somewhat larger (x <= 1073741898), but that's190 * irrelevant for our purpose.191 *192 * For dividing a number in the range [10^4, 10^6-1] by 100, we still193 * need a 32x32->64 bit multiply, so we simply use the same constant.194 *195 * For dividing a number in the range [100, 10^4-1] by 100, there are196 * several options. The simplest is (x * 0x147b) >> 19, which is valid197 * for all x <= 43698.198 */199 200static const u16 decpair[100] = {201#define _(x) (__force u16) cpu_to_le16(((x % 10) | ((x / 10) << 8)) + 0x3030)202 _( 0), _( 1), _( 2), _( 3), _( 4), _( 5), _( 6), _( 7), _( 8), _( 9),203 _(10), _(11), _(12), _(13), _(14), _(15), _(16), _(17), _(18), _(19),204 _(20), _(21), _(22), _(23), _(24), _(25), _(26), _(27), _(28), _(29),205 _(30), _(31), _(32), _(33), _(34), _(35), _(36), _(37), _(38), _(39),206 _(40), _(41), _(42), _(43), _(44), _(45), _(46), _(47), _(48), _(49),207 _(50), _(51), _(52), _(53), _(54), _(55), _(56), _(57), _(58), _(59),208 _(60), _(61), _(62), _(63), _(64), _(65), _(66), _(67), _(68), _(69),209 _(70), _(71), _(72), _(73), _(74), _(75), _(76), _(77), _(78), _(79),210 _(80), _(81), _(82), _(83), _(84), _(85), _(86), _(87), _(88), _(89),211 _(90), _(91), _(92), _(93), _(94), _(95), _(96), _(97), _(98), _(99),212#undef _213};214 215/*216 * This will print a single '0' even if r == 0, since we would217 * immediately jump to out_r where two 0s would be written but only218 * one of them accounted for in buf. This is needed by ip4_string219 * below. All other callers pass a non-zero value of r.220*/221static noinline_for_stack222char *put_dec_trunc8(char *buf, unsigned r)223{224 unsigned q;225 226 /* 1 <= r < 10^8 */227 if (r < 100)228 goto out_r;229 230 /* 100 <= r < 10^8 */231 q = (r * (u64)0x28f5c29) >> 32;232 *((u16 *)buf) = decpair[r - 100*q];233 buf += 2;234 235 /* 1 <= q < 10^6 */236 if (q < 100)237 goto out_q;238 239 /* 100 <= q < 10^6 */240 r = (q * (u64)0x28f5c29) >> 32;241 *((u16 *)buf) = decpair[q - 100*r];242 buf += 2;243 244 /* 1 <= r < 10^4 */245 if (r < 100)246 goto out_r;247 248 /* 100 <= r < 10^4 */249 q = (r * 0x147b) >> 19;250 *((u16 *)buf) = decpair[r - 100*q];251 buf += 2;252out_q:253 /* 1 <= q < 100 */254 r = q;255out_r:256 /* 1 <= r < 100 */257 *((u16 *)buf) = decpair[r];258 buf += r < 10 ? 1 : 2;259 return buf;260}261 262#if BITS_PER_LONG == 64 && BITS_PER_LONG_LONG == 64263static noinline_for_stack264char *put_dec_full8(char *buf, unsigned r)265{266 unsigned q;267 268 /* 0 <= r < 10^8 */269 q = (r * (u64)0x28f5c29) >> 32;270 *((u16 *)buf) = decpair[r - 100*q];271 buf += 2;272 273 /* 0 <= q < 10^6 */274 r = (q * (u64)0x28f5c29) >> 32;275 *((u16 *)buf) = decpair[q - 100*r];276 buf += 2;277 278 /* 0 <= r < 10^4 */279 q = (r * 0x147b) >> 19;280 *((u16 *)buf) = decpair[r - 100*q];281 buf += 2;282 283 /* 0 <= q < 100 */284 *((u16 *)buf) = decpair[q];285 buf += 2;286 return buf;287}288 289static noinline_for_stack290char *put_dec(char *buf, unsigned long long n)291{292 if (n >= 100*1000*1000)293 buf = put_dec_full8(buf, do_div(n, 100*1000*1000));294 /* 1 <= n <= 1.6e11 */295 if (n >= 100*1000*1000)296 buf = put_dec_full8(buf, do_div(n, 100*1000*1000));297 /* 1 <= n < 1e8 */298 return put_dec_trunc8(buf, n);299}300 301#elif BITS_PER_LONG == 32 && BITS_PER_LONG_LONG == 64302 303static void304put_dec_full4(char *buf, unsigned r)305{306 unsigned q;307 308 /* 0 <= r < 10^4 */309 q = (r * 0x147b) >> 19;310 *((u16 *)buf) = decpair[r - 100*q];311 buf += 2;312 /* 0 <= q < 100 */313 *((u16 *)buf) = decpair[q];314}315 316/*317 * Call put_dec_full4 on x % 10000, return x / 10000.318 * The approximation x/10000 == (x * 0x346DC5D7) >> 43319 * holds for all x < 1,128,869,999. The largest value this320 * helper will ever be asked to convert is 1,125,520,955.321 * (second call in the put_dec code, assuming n is all-ones).322 */323static noinline_for_stack324unsigned put_dec_helper4(char *buf, unsigned x)325{326 uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;327 328 put_dec_full4(buf, x - q * 10000);329 return q;330}331 332/* Based on code by Douglas W. Jones found at333 * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>334 * (with permission from the author).335 * Performs no 64-bit division and hence should be fast on 32-bit machines.336 */337static338char *put_dec(char *buf, unsigned long long n)339{340 uint32_t d3, d2, d1, q, h;341 342 if (n < 100*1000*1000)343 return put_dec_trunc8(buf, n);344 345 d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */346 h = (n >> 32);347 d2 = (h ) & 0xffff;348 d3 = (h >> 16); /* implicit "& 0xffff" */349 350 /* n = 2^48 d3 + 2^32 d2 + 2^16 d1 + d0351 = 281_4749_7671_0656 d3 + 42_9496_7296 d2 + 6_5536 d1 + d0 */352 q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);353 q = put_dec_helper4(buf, q);354 355 q += 7671 * d3 + 9496 * d2 + 6 * d1;356 q = put_dec_helper4(buf+4, q);357 358 q += 4749 * d3 + 42 * d2;359 q = put_dec_helper4(buf+8, q);360 361 q += 281 * d3;362 buf += 12;363 if (q)364 buf = put_dec_trunc8(buf, q);365 else while (buf[-1] == '0')366 --buf;367 368 return buf;369}370 371#endif372 373/*374 * Convert passed number to decimal string.375 * Returns the length of string. On buffer overflow, returns 0.376 *377 * If speed is not important, use snprintf(). It's easy to read the code.378 */379int num_to_str(char *buf, int size, unsigned long long num, unsigned int width)380{381 /* put_dec requires 2-byte alignment of the buffer. */382 char tmp[sizeof(num) * 3] __aligned(2);383 int idx, len;384 385 /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */386 if (num <= 9) {387 tmp[0] = '0' + num;388 len = 1;389 } else {390 len = put_dec(tmp, num) - tmp;391 }392 393 if (len > size || width > size)394 return 0;395 396 if (width > len) {397 width = width - len;398 for (idx = 0; idx < width; idx++)399 buf[idx] = ' ';400 } else {401 width = 0;402 }403 404 for (idx = 0; idx < len; ++idx)405 buf[idx + width] = tmp[len - idx - 1];406 407 return len + width;408}409 410#define SIGN 1 /* unsigned/signed, must be 1 */411#define LEFT 2 /* left justified */412#define PLUS 4 /* show plus */413#define SPACE 8 /* space if plus */414#define ZEROPAD 16 /* pad with zero, must be 16 == '0' - ' ' */415#define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */416#define SPECIAL 64 /* prefix hex with "0x", octal with "0" */417 418static_assert(SIGN == 1);419static_assert(ZEROPAD == ('0' - ' '));420static_assert(SMALL == ('a' ^ 'A'));421 422enum format_type {423 FORMAT_TYPE_NONE, /* Just a string part */424 FORMAT_TYPE_WIDTH,425 FORMAT_TYPE_PRECISION,426 FORMAT_TYPE_CHAR,427 FORMAT_TYPE_STR,428 FORMAT_TYPE_PTR,429 FORMAT_TYPE_PERCENT_CHAR,430 FORMAT_TYPE_INVALID,431 FORMAT_TYPE_LONG_LONG,432 FORMAT_TYPE_ULONG,433 FORMAT_TYPE_LONG,434 FORMAT_TYPE_UBYTE,435 FORMAT_TYPE_BYTE,436 FORMAT_TYPE_USHORT,437 FORMAT_TYPE_SHORT,438 FORMAT_TYPE_UINT,439 FORMAT_TYPE_INT,440 FORMAT_TYPE_SIZE_T,441 FORMAT_TYPE_PTRDIFF442};443 444struct printf_spec {445 unsigned int type:8; /* format_type enum */446 signed int field_width:24; /* width of output field */447 unsigned int flags:8; /* flags to number() */448 unsigned int base:8; /* number base, 8, 10 or 16 only */449 signed int precision:16; /* # of digits/chars */450} __packed;451static_assert(sizeof(struct printf_spec) == 8);452 453#define FIELD_WIDTH_MAX ((1 << 23) - 1)454#define PRECISION_MAX ((1 << 15) - 1)455 456static noinline_for_stack457char *number(char *buf, char *end, unsigned long long num,458 struct printf_spec spec)459{460 /* put_dec requires 2-byte alignment of the buffer. */461 char tmp[3 * sizeof(num)] __aligned(2);462 char sign;463 char locase;464 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);465 int i;466 bool is_zero = num == 0LL;467 int field_width = spec.field_width;468 int precision = spec.precision;469 470 /* locase = 0 or 0x20. ORing digits or letters with 'locase'471 * produces same digits or (maybe lowercased) letters */472 locase = (spec.flags & SMALL);473 if (spec.flags & LEFT)474 spec.flags &= ~ZEROPAD;475 sign = 0;476 if (spec.flags & SIGN) {477 if ((signed long long)num < 0) {478 sign = '-';479 num = -(signed long long)num;480 field_width--;481 } else if (spec.flags & PLUS) {482 sign = '+';483 field_width--;484 } else if (spec.flags & SPACE) {485 sign = ' ';486 field_width--;487 }488 }489 if (need_pfx) {490 if (spec.base == 16)491 field_width -= 2;492 else if (!is_zero)493 field_width--;494 }495 496 /* generate full string in tmp[], in reverse order */497 i = 0;498 if (num < spec.base)499 tmp[i++] = hex_asc_upper[num] | locase;500 else if (spec.base != 10) { /* 8 or 16 */501 int mask = spec.base - 1;502 int shift = 3;503 504 if (spec.base == 16)505 shift = 4;506 do {507 tmp[i++] = (hex_asc_upper[((unsigned char)num) & mask] | locase);508 num >>= shift;509 } while (num);510 } else { /* base 10 */511 i = put_dec(tmp, num) - tmp;512 }513 514 /* printing 100 using %2d gives "100", not "00" */515 if (i > precision)516 precision = i;517 /* leading space padding */518 field_width -= precision;519 if (!(spec.flags & (ZEROPAD | LEFT))) {520 while (--field_width >= 0) {521 if (buf < end)522 *buf = ' ';523 ++buf;524 }525 }526 /* sign */527 if (sign) {528 if (buf < end)529 *buf = sign;530 ++buf;531 }532 /* "0x" / "0" prefix */533 if (need_pfx) {534 if (spec.base == 16 || !is_zero) {535 if (buf < end)536 *buf = '0';537 ++buf;538 }539 if (spec.base == 16) {540 if (buf < end)541 *buf = ('X' | locase);542 ++buf;543 }544 }545 /* zero or space padding */546 if (!(spec.flags & LEFT)) {547 char c = ' ' + (spec.flags & ZEROPAD);548 549 while (--field_width >= 0) {550 if (buf < end)551 *buf = c;552 ++buf;553 }554 }555 /* hmm even more zero padding? */556 while (i <= --precision) {557 if (buf < end)558 *buf = '0';559 ++buf;560 }561 /* actual digits of result */562 while (--i >= 0) {563 if (buf < end)564 *buf = tmp[i];565 ++buf;566 }567 /* trailing space padding */568 while (--field_width >= 0) {569 if (buf < end)570 *buf = ' ';571 ++buf;572 }573 574 return buf;575}576 577static noinline_for_stack578char *special_hex_number(char *buf, char *end, unsigned long long num, int size)579{580 struct printf_spec spec;581 582 spec.type = FORMAT_TYPE_PTR;583 spec.field_width = 2 + 2 * size; /* 0x + hex */584 spec.flags = SPECIAL | SMALL | ZEROPAD;585 spec.base = 16;586 spec.precision = -1;587 588 return number(buf, end, num, spec);589}590 591static void move_right(char *buf, char *end, unsigned len, unsigned spaces)592{593 size_t size;594 if (buf >= end) /* nowhere to put anything */595 return;596 size = end - buf;597 if (size <= spaces) {598 memset(buf, ' ', size);599 return;600 }601 if (len) {602 if (len > size - spaces)603 len = size - spaces;604 memmove(buf + spaces, buf, len);605 }606 memset(buf, ' ', spaces);607}608 609/*610 * Handle field width padding for a string.611 * @buf: current buffer position612 * @n: length of string613 * @end: end of output buffer614 * @spec: for field width and flags615 * Returns: new buffer position after padding.616 */617static noinline_for_stack618char *widen_string(char *buf, int n, char *end, struct printf_spec spec)619{620 unsigned spaces;621 622 if (likely(n >= spec.field_width))623 return buf;624 /* we want to pad the sucker */625 spaces = spec.field_width - n;626 if (!(spec.flags & LEFT)) {627 move_right(buf - n, end, n, spaces);628 return buf + spaces;629 }630 while (spaces--) {631 if (buf < end)632 *buf = ' ';633 ++buf;634 }635 return buf;636}637 638/* Handle string from a well known address. */639static char *string_nocheck(char *buf, char *end, const char *s,640 struct printf_spec spec)641{642 int len = 0;643 int lim = spec.precision;644 645 while (lim--) {646 char c = *s++;647 if (!c)648 break;649 if (buf < end)650 *buf = c;651 ++buf;652 ++len;653 }654 return widen_string(buf, len, end, spec);655}656 657static char *err_ptr(char *buf, char *end, void *ptr,658 struct printf_spec spec)659{660 int err = PTR_ERR(ptr);661 const char *sym = errname(err);662 663 if (sym)664 return string_nocheck(buf, end, sym, spec);665 666 /*667 * Somebody passed ERR_PTR(-1234) or some other non-existing668 * Efoo - or perhaps CONFIG_SYMBOLIC_ERRNAME=n. Fall back to669 * printing it as its decimal representation.670 */671 spec.flags |= SIGN;672 spec.base = 10;673 return number(buf, end, err, spec);674}675 676/* Be careful: error messages must fit into the given buffer. */677static char *error_string(char *buf, char *end, const char *s,678 struct printf_spec spec)679{680 /*681 * Hard limit to avoid a completely insane messages. It actually682 * works pretty well because most error messages are in683 * the many pointer format modifiers.684 */685 if (spec.precision == -1)686 spec.precision = 2 * sizeof(void *);687 688 return string_nocheck(buf, end, s, spec);689}690 691/*692 * Do not call any complex external code here. Nested printk()/vsprintf()693 * might cause infinite loops. Failures might break printk() and would694 * be hard to debug.695 */696static const char *check_pointer_msg(const void *ptr)697{698 if (!ptr)699 return "(null)";700 701 if ((unsigned long)ptr < PAGE_SIZE || IS_ERR_VALUE(ptr))702 return "(efault)";703 704 return NULL;705}706 707static int check_pointer(char **buf, char *end, const void *ptr,708 struct printf_spec spec)709{710 const char *err_msg;711 712 err_msg = check_pointer_msg(ptr);713 if (err_msg) {714 *buf = error_string(*buf, end, err_msg, spec);715 return -EFAULT;716 }717 718 return 0;719}720 721static noinline_for_stack722char *string(char *buf, char *end, const char *s,723 struct printf_spec spec)724{725 if (check_pointer(&buf, end, s, spec))726 return buf;727 728 return string_nocheck(buf, end, s, spec);729}730 731static char *pointer_string(char *buf, char *end,732 const void *ptr,733 struct printf_spec spec)734{735 spec.base = 16;736 spec.flags |= SMALL;737 if (spec.field_width == -1) {738 spec.field_width = 2 * sizeof(ptr);739 spec.flags |= ZEROPAD;740 }741 742 return number(buf, end, (unsigned long int)ptr, spec);743}744 745/* Make pointers available for printing early in the boot sequence. */746static int debug_boot_weak_hash __ro_after_init;747 748static int __init debug_boot_weak_hash_enable(char *str)749{750 debug_boot_weak_hash = 1;751 pr_info("debug_boot_weak_hash enabled\n");752 return 0;753}754early_param("debug_boot_weak_hash", debug_boot_weak_hash_enable);755 756static bool filled_random_ptr_key __read_mostly;757static siphash_key_t ptr_key __read_mostly;758 759static int fill_ptr_key(struct notifier_block *nb, unsigned long action, void *data)760{761 get_random_bytes(&ptr_key, sizeof(ptr_key));762 763 /* Pairs with smp_rmb() before reading ptr_key. */764 smp_wmb();765 WRITE_ONCE(filled_random_ptr_key, true);766 return NOTIFY_DONE;767}768 769static HWJS_SUSPENDS int __init vsprintf_init_hashval(void)770{771 static struct notifier_block fill_ptr_key_nb = { .notifier_call = fill_ptr_key };772 execute_with_initialized_rng(&fill_ptr_key_nb);773 return 0;774}775subsys_initcall(vsprintf_init_hashval)776 777/* Maps a pointer to a 32 bit unique identifier. */778static inline int __ptr_to_hashval(const void *ptr, unsigned long *hashval_out)779{780 unsigned long hashval;781 782 if (!READ_ONCE(filled_random_ptr_key))783 return -EBUSY;784 785 /* Pairs with smp_wmb() after writing ptr_key. */786 smp_rmb();787 788#ifdef CONFIG_64BIT789 hashval = (unsigned long)siphash_1u64((u64)ptr, &ptr_key);790 /*791 * Mask off the first 32 bits, this makes explicit that we have792 * modified the address (and 32 bits is plenty for a unique ID).793 */794 hashval = hashval & 0xffffffff;795#else796 hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key);797#endif798 *hashval_out = hashval;799 return 0;800}801 802int ptr_to_hashval(const void *ptr, unsigned long *hashval_out)803{804 return __ptr_to_hashval(ptr, hashval_out);805}806 807static char *ptr_to_id(char *buf, char *end, const void *ptr,808 struct printf_spec spec)809{810 const char *str = sizeof(ptr) == 8 ? "(____ptrval____)" : "(ptrval)";811 unsigned long hashval;812 int ret;813 814 /*815 * Print the real pointer value for NULL and error pointers,816 * as they are not actual addresses.817 */818 if (IS_ERR_OR_NULL(ptr))819 return pointer_string(buf, end, ptr, spec);820 821 /* When debugging early boot use non-cryptographically secure hash. */822 if (unlikely(debug_boot_weak_hash)) {823 hashval = hash_long((unsigned long)ptr, 32);824 return pointer_string(buf, end, (const void *)hashval, spec);825 }826 827 ret = __ptr_to_hashval(ptr, &hashval);828 if (ret) {829 spec.field_width = 2 * sizeof(ptr);830 /* string length must be less than default_width */831 return error_string(buf, end, str, spec);832 }833 834 return pointer_string(buf, end, (const void *)hashval, spec);835}836 837static char *default_pointer(char *buf, char *end, const void *ptr,838 struct printf_spec spec)839{840 /*841 * default is to _not_ leak addresses, so hash before printing,842 * unless no_hash_pointers is specified on the command line.843 */844 if (unlikely(no_hash_pointers))845 return pointer_string(buf, end, ptr, spec);846 847 return ptr_to_id(buf, end, ptr, spec);848}849 850int kptr_restrict __read_mostly;851 852static noinline_for_stack853char *restricted_pointer(char *buf, char *end, const void *ptr,854 struct printf_spec spec)855{856 switch (kptr_restrict) {857 case 0:858 /* Handle as %p, hash and do _not_ leak addresses. */859 return default_pointer(buf, end, ptr, spec);860 case 1: {861 const struct cred *cred;862 863 /*864 * kptr_restrict==1 cannot be used in IRQ context865 * because its test for CAP_SYSLOG would be meaningless.866 */867 if (in_hardirq() || in_serving_softirq() || in_nmi()) {868 if (spec.field_width == -1)869 spec.field_width = 2 * sizeof(ptr);870 return error_string(buf, end, "pK-error", spec);871 }872 873 /*874 * Only print the real pointer value if the current875 * process has CAP_SYSLOG and is running with the876 * same credentials it started with. This is because877 * access to files is checked at open() time, but %pK878 * checks permission at read() time. We don't want to879 * leak pointer values if a binary opens a file using880 * %pK and then elevates privileges before reading it.881 */882 cred = current_cred();883 if (!has_capability_noaudit(current, CAP_SYSLOG) ||884 !uid_eq(cred->euid, cred->uid) ||885 !gid_eq(cred->egid, cred->gid))886 ptr = NULL;887 break;888 }889 case 2:890 default:891 /* Always print 0's for %pK */892 ptr = NULL;893 break;894 }895 896 return pointer_string(buf, end, ptr, spec);897}898 899static noinline_for_stack900char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,901 const char *fmt)902{903 const char *array[4], *s;904 const struct dentry *p;905 int depth;906 int i, n;907 908 switch (fmt[1]) {909 case '2': case '3': case '4':910 depth = fmt[1] - '0';911 break;912 default:913 depth = 1;914 }915 916 rcu_read_lock();917 for (i = 0; i < depth; i++, d = p) {918 if (check_pointer(&buf, end, d, spec)) {919 rcu_read_unlock();920 return buf;921 }922 923 p = READ_ONCE(d->d_parent);924 array[i] = READ_ONCE(d->d_name.name);925 if (p == d) {926 if (i)927 array[i] = "";928 i++;929 break;930 }931 }932 s = array[--i];933 for (n = 0; n != spec.precision; n++, buf++) {934 char c = *s++;935 if (!c) {936 if (!i)937 break;938 c = '/';939 s = array[--i];940 }941 if (buf < end)942 *buf = c;943 }944 rcu_read_unlock();945 return widen_string(buf, n, end, spec);946}947 948static noinline_for_stack949char *file_dentry_name(char *buf, char *end, const struct file *f,950 struct printf_spec spec, const char *fmt)951{952 if (check_pointer(&buf, end, f, spec))953 return buf;954 955 return dentry_name(buf, end, f->f_path.dentry, spec, fmt);956}957#ifdef CONFIG_BLOCK958static noinline_for_stack959char *bdev_name(char *buf, char *end, struct block_device *bdev,960 struct printf_spec spec, const char *fmt)961{962 struct gendisk *hd;963 964 if (check_pointer(&buf, end, bdev, spec))965 return buf;966 967 hd = bdev->bd_disk;968 buf = string(buf, end, hd->disk_name, spec);969 if (bdev_is_partition(bdev)) {970 if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) {971 if (buf < end)972 *buf = 'p';973 buf++;974 }975 buf = number(buf, end, bdev_partno(bdev), spec);976 }977 return buf;978}979#endif980 981static noinline_for_stack982char *symbol_string(char *buf, char *end, void *ptr,983 struct printf_spec spec, const char *fmt)984{985 unsigned long value;986#ifdef CONFIG_KALLSYMS987 char sym[KSYM_SYMBOL_LEN];988#endif989 990 if (fmt[1] == 'R')991 ptr = __builtin_extract_return_addr(ptr);992 value = (unsigned long)ptr;993 994#ifdef CONFIG_KALLSYMS995 if (*fmt == 'B' && fmt[1] == 'b')996 sprint_backtrace_build_id(sym, value);997 else if (*fmt == 'B')998 sprint_backtrace(sym, value);999 else if (*fmt == 'S' && (fmt[1] == 'b' || (fmt[1] == 'R' && fmt[2] == 'b')))1000 sprint_symbol_build_id(sym, value);1001 else if (*fmt != 's')1002 sprint_symbol(sym, value);1003 else1004 sprint_symbol_no_offset(sym, value);1005 1006 return string_nocheck(buf, end, sym, spec);1007#else1008 return special_hex_number(buf, end, value, sizeof(void *));1009#endif1010}1011 1012static const struct printf_spec default_str_spec = {1013 .field_width = -1,1014 .precision = -1,1015};1016 1017static const struct printf_spec default_flag_spec = {1018 .base = 16,1019 .precision = -1,1020 .flags = SPECIAL | SMALL,1021};1022 1023static const struct printf_spec default_dec_spec = {1024 .base = 10,1025 .precision = -1,1026};1027 1028static const struct printf_spec default_dec02_spec = {1029 .base = 10,1030 .field_width = 2,1031 .precision = -1,1032 .flags = ZEROPAD,1033};1034 1035static const struct printf_spec default_dec04_spec = {1036 .base = 10,1037 .field_width = 4,1038 .precision = -1,1039 .flags = ZEROPAD,1040};1041 1042static noinline_for_stack1043char *resource_string(char *buf, char *end, struct resource *res,1044 struct printf_spec spec, const char *fmt)1045{1046#ifndef IO_RSRC_PRINTK_SIZE1047#define IO_RSRC_PRINTK_SIZE 61048#endif1049 1050#ifndef MEM_RSRC_PRINTK_SIZE1051#define MEM_RSRC_PRINTK_SIZE 101052#endif1053 static const struct printf_spec io_spec = {1054 .base = 16,1055 .field_width = IO_RSRC_PRINTK_SIZE,1056 .precision = -1,1057 .flags = SPECIAL | SMALL | ZEROPAD,1058 };1059 static const struct printf_spec mem_spec = {1060 .base = 16,1061 .field_width = MEM_RSRC_PRINTK_SIZE,1062 .precision = -1,1063 .flags = SPECIAL | SMALL | ZEROPAD,1064 };1065 static const struct printf_spec bus_spec = {1066 .base = 16,1067 .field_width = 2,1068 .precision = -1,1069 .flags = SMALL | ZEROPAD,1070 };1071 static const struct printf_spec str_spec = {1072 .field_width = -1,1073 .precision = 10,1074 .flags = LEFT,1075 };1076 1077 /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)1078 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */1079#define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)1080#define FLAG_BUF_SIZE (2 * sizeof(res->flags))1081#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")1082#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")1083 char sym[MAX(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,1084 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];1085 1086 char *p = sym, *pend = sym + sizeof(sym);1087 int decode = (fmt[0] == 'R') ? 1 : 0;1088 const struct printf_spec *specp;1089 1090 if (check_pointer(&buf, end, res, spec))1091 return buf;1092 1093 *p++ = '[';1094 if (res->flags & IORESOURCE_IO) {1095 p = string_nocheck(p, pend, "io ", str_spec);1096 specp = &io_spec;1097 } else if (res->flags & IORESOURCE_MEM) {1098 p = string_nocheck(p, pend, "mem ", str_spec);1099 specp = &mem_spec;1100 } else if (res->flags & IORESOURCE_IRQ) {1101 p = string_nocheck(p, pend, "irq ", str_spec);1102 specp = &default_dec_spec;1103 } else if (res->flags & IORESOURCE_DMA) {1104 p = string_nocheck(p, pend, "dma ", str_spec);1105 specp = &default_dec_spec;1106 } else if (res->flags & IORESOURCE_BUS) {1107 p = string_nocheck(p, pend, "bus ", str_spec);1108 specp = &bus_spec;1109 } else {1110 p = string_nocheck(p, pend, "??? ", str_spec);1111 specp = &mem_spec;1112 decode = 0;1113 }1114 if (decode && res->flags & IORESOURCE_UNSET) {1115 p = string_nocheck(p, pend, "size ", str_spec);1116 p = number(p, pend, resource_size(res), *specp);1117 } else {1118 p = number(p, pend, res->start, *specp);1119 if (res->start != res->end) {1120 *p++ = '-';1121 p = number(p, pend, res->end, *specp);1122 }1123 }1124 if (decode) {1125 if (res->flags & IORESOURCE_MEM_64)1126 p = string_nocheck(p, pend, " 64bit", str_spec);1127 if (res->flags & IORESOURCE_PREFETCH)1128 p = string_nocheck(p, pend, " pref", str_spec);1129 if (res->flags & IORESOURCE_WINDOW)1130 p = string_nocheck(p, pend, " window", str_spec);1131 if (res->flags & IORESOURCE_DISABLED)1132 p = string_nocheck(p, pend, " disabled", str_spec);1133 } else {1134 p = string_nocheck(p, pend, " flags ", str_spec);1135 p = number(p, pend, res->flags, default_flag_spec);1136 }1137 *p++ = ']';1138 *p = '\0';1139 1140 return string_nocheck(buf, end, sym, spec);1141}1142 1143static noinline_for_stack1144char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,1145 const char *fmt)1146{1147 int i, len = 1; /* if we pass '%ph[CDN]', field width remains1148 negative value, fallback to the default */1149 char separator;1150 1151 if (spec.field_width == 0)1152 /* nothing to print */1153 return buf;1154 1155 if (check_pointer(&buf, end, addr, spec))1156 return buf;1157 1158 switch (fmt[1]) {1159 case 'C':1160 separator = ':';1161 break;1162 case 'D':1163 separator = '-';1164 break;1165 case 'N':1166 separator = 0;1167 break;1168 default:1169 separator = ' ';1170 break;1171 }1172 1173 if (spec.field_width > 0)1174 len = min_t(int, spec.field_width, 64);1175 1176 for (i = 0; i < len; ++i) {1177 if (buf < end)1178 *buf = hex_asc_hi(addr[i]);1179 ++buf;1180 if (buf < end)1181 *buf = hex_asc_lo(addr[i]);1182 ++buf;1183 1184 if (separator && i != len - 1) {1185 if (buf < end)1186 *buf = separator;1187 ++buf;1188 }1189 }1190 1191 return buf;1192}1193 1194static noinline_for_stack1195char *bitmap_string(char *buf, char *end, const unsigned long *bitmap,1196 struct printf_spec spec, const char *fmt)1197{1198 const int CHUNKSZ = 32;1199 int nr_bits = max_t(int, spec.field_width, 0);1200 int i, chunksz;1201 bool first = true;1202 1203 if (check_pointer(&buf, end, bitmap, spec))1204 return buf;1205 1206 /* reused to print numbers */1207 spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };1208 1209 chunksz = nr_bits & (CHUNKSZ - 1);1210 if (chunksz == 0)1211 chunksz = CHUNKSZ;1212 1213 i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ;1214 for (; i >= 0; i -= CHUNKSZ) {1215 u32 chunkmask, val;1216 int word, bit;1217 1218 chunkmask = ((1ULL << chunksz) - 1);1219 word = i / BITS_PER_LONG;1220 bit = i % BITS_PER_LONG;1221 val = (bitmap[word] >> bit) & chunkmask;1222 1223 if (!first) {1224 if (buf < end)1225 *buf = ',';1226 buf++;1227 }1228 first = false;1229 1230 spec.field_width = DIV_ROUND_UP(chunksz, 4);1231 buf = number(buf, end, val, spec);1232 1233 chunksz = CHUNKSZ;1234 }1235 return buf;1236}1237 1238static noinline_for_stack1239char *bitmap_list_string(char *buf, char *end, const unsigned long *bitmap,1240 struct printf_spec spec, const char *fmt)1241{1242 int nr_bits = max_t(int, spec.field_width, 0);1243 bool first = true;1244 int rbot, rtop;1245 1246 if (check_pointer(&buf, end, bitmap, spec))1247 return buf;1248 1249 for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) {1250 if (!first) {1251 if (buf < end)1252 *buf = ',';1253 buf++;1254 }1255 first = false;1256 1257 buf = number(buf, end, rbot, default_dec_spec);1258 if (rtop == rbot + 1)1259 continue;1260 1261 if (buf < end)1262 *buf = '-';1263 buf = number(++buf, end, rtop - 1, default_dec_spec);1264 }1265 return buf;1266}1267 1268static noinline_for_stack1269char *mac_address_string(char *buf, char *end, u8 *addr,1270 struct printf_spec spec, const char *fmt)1271{1272 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];1273 char *p = mac_addr;1274 int i;1275 char separator;1276 bool reversed = false;1277 1278 if (check_pointer(&buf, end, addr, spec))1279 return buf;1280 1281 switch (fmt[1]) {1282 case 'F':1283 separator = '-';1284 break;1285 1286 case 'R':1287 reversed = true;1288 fallthrough;1289 1290 default:1291 separator = ':';1292 break;1293 }1294 1295 for (i = 0; i < 6; i++) {1296 if (reversed)1297 p = hex_byte_pack(p, addr[5 - i]);1298 else1299 p = hex_byte_pack(p, addr[i]);1300 1301 if (fmt[0] == 'M' && i != 5)1302 *p++ = separator;1303 }1304 *p = '\0';1305 1306 return string_nocheck(buf, end, mac_addr, spec);1307}1308 1309static noinline_for_stack1310char *ip4_string(char *p, const u8 *addr, const char *fmt)1311{1312 int i;1313 bool leading_zeros = (fmt[0] == 'i');1314 int index;1315 int step;1316 1317 switch (fmt[2]) {1318 case 'h':1319#ifdef __BIG_ENDIAN1320 index = 0;1321 step = 1;1322#else1323 index = 3;1324 step = -1;1325#endif1326 break;1327 case 'l':1328 index = 3;1329 step = -1;1330 break;1331 case 'n':1332 case 'b':1333 default:1334 index = 0;1335 step = 1;1336 break;1337 }1338 for (i = 0; i < 4; i++) {1339 char temp[4] __aligned(2); /* hold each IP quad in reverse order */1340 int digits = put_dec_trunc8(temp, addr[index]) - temp;1341 if (leading_zeros) {1342 if (digits < 3)1343 *p++ = '0';1344 if (digits < 2)1345 *p++ = '0';1346 }1347 /* reverse the digits in the quad */1348 while (digits--)1349 *p++ = temp[digits];1350 if (i < 3)1351 *p++ = '.';1352 index += step;1353 }1354 *p = '\0';1355 1356 return p;1357}1358 1359static noinline_for_stack1360char *ip6_compressed_string(char *p, const char *addr)1361{1362 int i, j, range;1363 unsigned char zerolength[8];1364 int longest = 1;1365 int colonpos = -1;1366 u16 word;1367 u8 hi, lo;1368 bool needcolon = false;1369 bool useIPv4;1370 struct in6_addr in6;1371 1372 memcpy(&in6, addr, sizeof(struct in6_addr));1373 1374 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);1375 1376 memset(zerolength, 0, sizeof(zerolength));1377 1378 if (useIPv4)1379 range = 6;1380 else1381 range = 8;1382 1383 /* find position of longest 0 run */1384 for (i = 0; i < range; i++) {1385 for (j = i; j < range; j++) {1386 if (in6.s6_addr16[j] != 0)1387 break;1388 zerolength[i]++;1389 }1390 }1391 for (i = 0; i < range; i++) {1392 if (zerolength[i] > longest) {1393 longest = zerolength[i];1394 colonpos = i;1395 }1396 }1397 if (longest == 1) /* don't compress a single 0 */1398 colonpos = -1;1399 1400 /* emit address */1401 for (i = 0; i < range; i++) {1402 if (i == colonpos) {1403 if (needcolon || i == 0)1404 *p++ = ':';1405 *p++ = ':';1406 needcolon = false;1407 i += longest - 1;1408 continue;1409 }1410 if (needcolon) {1411 *p++ = ':';1412 needcolon = false;1413 }1414 /* hex u16 without leading 0s */1415 word = ntohs(in6.s6_addr16[i]);1416 hi = word >> 8;1417 lo = word & 0xff;1418 if (hi) {1419 if (hi > 0x0f)1420 p = hex_byte_pack(p, hi);1421 else1422 *p++ = hex_asc_lo(hi);1423 p = hex_byte_pack(p, lo);1424 }1425 else if (lo > 0x0f)1426 p = hex_byte_pack(p, lo);1427 else1428 *p++ = hex_asc_lo(lo);1429 needcolon = true;1430 }1431 1432 if (useIPv4) {1433 if (needcolon)1434 *p++ = ':';1435 p = ip4_string(p, &in6.s6_addr[12], "I4");1436 }1437 *p = '\0';1438 1439 return p;1440}1441 1442static noinline_for_stack1443char *ip6_string(char *p, const char *addr, const char *fmt)1444{1445 int i;1446 1447 for (i = 0; i < 8; i++) {1448 p = hex_byte_pack(p, *addr++);1449 p = hex_byte_pack(p, *addr++);1450 if (fmt[0] == 'I' && i != 7)1451 *p++ = ':';1452 }1453 *p = '\0';1454 1455 return p;1456}1457 1458static noinline_for_stack1459char *ip6_addr_string(char *buf, char *end, const u8 *addr,1460 struct printf_spec spec, const char *fmt)1461{1462 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];1463 1464 if (fmt[0] == 'I' && fmt[2] == 'c')1465 ip6_compressed_string(ip6_addr, addr);1466 else1467 ip6_string(ip6_addr, addr, fmt);1468 1469 return string_nocheck(buf, end, ip6_addr, spec);1470}1471 1472static noinline_for_stack1473char *ip4_addr_string(char *buf, char *end, const u8 *addr,1474 struct printf_spec spec, const char *fmt)1475{1476 char ip4_addr[sizeof("255.255.255.255")];1477 1478 ip4_string(ip4_addr, addr, fmt);1479 1480 return string_nocheck(buf, end, ip4_addr, spec);1481}1482 1483static noinline_for_stack1484char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,1485 struct printf_spec spec, const char *fmt)1486{1487 bool have_p = false, have_s = false, have_f = false, have_c = false;1488 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +1489 sizeof(":12345") + sizeof("/123456789") +1490 sizeof("%1234567890")];1491 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);1492 const u8 *addr = (const u8 *) &sa->sin6_addr;1493 char fmt6[2] = { fmt[0], '6' };1494 u8 off = 0;1495 1496 fmt++;1497 while (isalpha(*++fmt)) {1498 switch (*fmt) {1499 case 'p':1500 have_p = true;1501 break;1502 case 'f':1503 have_f = true;1504 break;1505 case 's':1506 have_s = true;1507 break;1508 case 'c':1509 have_c = true;1510 break;1511 }1512 }1513 1514 if (have_p || have_s || have_f) {1515 *p = '[';1516 off = 1;1517 }1518 1519 if (fmt6[0] == 'I' && have_c)1520 p = ip6_compressed_string(ip6_addr + off, addr);1521 else1522 p = ip6_string(ip6_addr + off, addr, fmt6);1523 1524 if (have_p || have_s || have_f)1525 *p++ = ']';1526 1527 if (have_p) {1528 *p++ = ':';1529 p = number(p, pend, ntohs(sa->sin6_port), spec);1530 }1531 if (have_f) {1532 *p++ = '/';1533 p = number(p, pend, ntohl(sa->sin6_flowinfo &1534 IPV6_FLOWINFO_MASK), spec);1535 }1536 if (have_s) {1537 *p++ = '%';1538 p = number(p, pend, sa->sin6_scope_id, spec);1539 }1540 *p = '\0';1541 1542 return string_nocheck(buf, end, ip6_addr, spec);1543}1544 1545static noinline_for_stack1546char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,1547 struct printf_spec spec, const char *fmt)1548{1549 bool have_p = false;1550 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];1551 char *pend = ip4_addr + sizeof(ip4_addr);1552 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;1553 char fmt4[3] = { fmt[0], '4', 0 };1554 1555 fmt++;1556 while (isalpha(*++fmt)) {1557 switch (*fmt) {1558 case 'p':1559 have_p = true;1560 break;1561 case 'h':1562 case 'l':1563 case 'n':1564 case 'b':1565 fmt4[2] = *fmt;1566 break;1567 }1568 }1569 1570 p = ip4_string(ip4_addr, addr, fmt4);1571 if (have_p) {1572 *p++ = ':';1573 p = number(p, pend, ntohs(sa->sin_port), spec);1574 }1575 *p = '\0';1576 1577 return string_nocheck(buf, end, ip4_addr, spec);1578}1579 1580static noinline_for_stack1581char *ip_addr_string(char *buf, char *end, const void *ptr,1582 struct printf_spec spec, const char *fmt)1583{1584 char *err_fmt_msg;1585 1586 if (check_pointer(&buf, end, ptr, spec))1587 return buf;1588 1589 switch (fmt[1]) {1590 case '6':1591 return ip6_addr_string(buf, end, ptr, spec, fmt);1592 case '4':1593 return ip4_addr_string(buf, end, ptr, spec, fmt);1594 case 'S': {1595 const union {1596 struct sockaddr raw;1597 struct sockaddr_in v4;1598 struct sockaddr_in6 v6;1599 } *sa = ptr;1600 1601 switch (sa->raw.sa_family) {1602 case AF_INET:1603 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);1604 case AF_INET6:1605 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);1606 default:1607 return error_string(buf, end, "(einval)", spec);1608 }}1609 }1610 1611 err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)";1612 return error_string(buf, end, err_fmt_msg, spec);1613}1614 1615static noinline_for_stack1616char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,1617 const char *fmt)1618{1619 bool found = true;1620 int count = 1;1621 unsigned int flags = 0;1622 int len;1623 1624 if (spec.field_width == 0)1625 return buf; /* nothing to print */1626 1627 if (check_pointer(&buf, end, addr, spec))1628 return buf;1629 1630 do {1631 switch (fmt[count++]) {1632 case 'a':1633 flags |= ESCAPE_ANY;1634 break;1635 case 'c':1636 flags |= ESCAPE_SPECIAL;1637 break;1638 case 'h':1639 flags |= ESCAPE_HEX;1640 break;1641 case 'n':1642 flags |= ESCAPE_NULL;1643 break;1644 case 'o':1645 flags |= ESCAPE_OCTAL;1646 break;1647 case 'p':1648 flags |= ESCAPE_NP;1649 break;1650 case 's':1651 flags |= ESCAPE_SPACE;1652 break;1653 default:1654 found = false;1655 break;1656 }1657 } while (found);1658 1659 if (!flags)1660 flags = ESCAPE_ANY_NP;1661 1662 len = spec.field_width < 0 ? 1 : spec.field_width;1663 1664 /*1665 * string_escape_mem() writes as many characters as it can to1666 * the given buffer, and returns the total size of the output1667 * had the buffer been big enough.1668 */1669 buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL);1670 1671 return buf;1672}1673 1674static char *va_format(char *buf, char *end, struct va_format *va_fmt,1675 struct printf_spec spec, const char *fmt)1676{1677 va_list va;1678 1679 if (check_pointer(&buf, end, va_fmt, spec))1680 return buf;1681 1682 va_copy(va, *va_fmt->va);1683 buf += vsnprintf(buf, end > buf ? end - buf : 0, va_fmt->fmt, va);1684 va_end(va);1685 1686 return buf;1687}1688 1689static noinline_for_stack1690char *uuid_string(char *buf, char *end, const u8 *addr,1691 struct printf_spec spec, const char *fmt)1692{1693 char uuid[UUID_STRING_LEN + 1];1694 char *p = uuid;1695 int i;1696 const u8 *index = uuid_index;1697 bool uc = false;1698 1699 if (check_pointer(&buf, end, addr, spec))1700 return buf;1701 1702 switch (*(++fmt)) {1703 case 'L':1704 uc = true;1705 fallthrough;1706 case 'l':1707 index = guid_index;1708 break;1709 case 'B':1710 uc = true;1711 break;1712 }1713 1714 for (i = 0; i < 16; i++) {1715 if (uc)1716 p = hex_byte_pack_upper(p, addr[index[i]]);1717 else1718 p = hex_byte_pack(p, addr[index[i]]);1719 switch (i) {1720 case 3:1721 case 5:1722 case 7:1723 case 9:1724 *p++ = '-';1725 break;1726 }1727 }1728 1729 *p = 0;1730 1731 return string_nocheck(buf, end, uuid, spec);1732}1733 1734static noinline_for_stack1735char *netdev_bits(char *buf, char *end, const void *addr,1736 struct printf_spec spec, const char *fmt)1737{1738 unsigned long long num;1739 int size;1740 1741 if (check_pointer(&buf, end, addr, spec))1742 return buf;1743 1744 switch (fmt[1]) {1745 case 'F':1746 num = *(const netdev_features_t *)addr;1747 size = sizeof(netdev_features_t);1748 break;1749 default:1750 return error_string(buf, end, "(%pN?)", spec);1751 }1752 1753 return special_hex_number(buf, end, num, size);1754}1755 1756static noinline_for_stack1757char *fourcc_string(char *buf, char *end, const u32 *fourcc,1758 struct printf_spec spec, const char *fmt)1759{1760 char output[sizeof("0123 little-endian (0x01234567)")];1761 char *p = output;1762 unsigned int i;1763 u32 orig, val;1764 1765 if (fmt[1] != 'c' || fmt[2] != 'c')1766 return error_string(buf, end, "(%p4?)", spec);1767 1768 if (check_pointer(&buf, end, fourcc, spec))1769 return buf;1770 1771 orig = get_unaligned(fourcc);1772 val = orig & ~BIT(31);1773 1774 for (i = 0; i < sizeof(u32); i++) {1775 unsigned char c = val >> (i * 8);1776 1777 /* Print non-control ASCII characters as-is, dot otherwise */1778 *p++ = isascii(c) && isprint(c) ? c : '.';1779 }1780 1781 *p++ = ' ';1782 strcpy(p, orig & BIT(31) ? "big-endian" : "little-endian");1783 p += strlen(p);1784 1785 *p++ = ' ';1786 *p++ = '(';1787 p = special_hex_number(p, output + sizeof(output) - 2, orig, sizeof(u32));1788 *p++ = ')';1789 *p = '\0';1790 1791 return string(buf, end, output, spec);1792}1793 1794static noinline_for_stack1795char *address_val(char *buf, char *end, const void *addr,1796 struct printf_spec spec, const char *fmt)1797{1798 unsigned long long num;1799 int size;1800 1801 if (check_pointer(&buf, end, addr, spec))1802 return buf;1803 1804 switch (fmt[1]) {1805 case 'd':1806 num = *(const dma_addr_t *)addr;1807 size = sizeof(dma_addr_t);1808 break;1809 case 'p':1810 default:1811 num = *(const phys_addr_t *)addr;1812 size = sizeof(phys_addr_t);1813 break;1814 }1815 1816 return special_hex_number(buf, end, num, size);1817}1818 1819static noinline_for_stack1820char *date_str(char *buf, char *end, const struct rtc_time *tm, bool r)1821{1822 int year = tm->tm_year + (r ? 0 : 1900);1823 int mon = tm->tm_mon + (r ? 0 : 1);1824 1825 buf = number(buf, end, year, default_dec04_spec);1826 if (buf < end)1827 *buf = '-';1828 buf++;1829 1830 buf = number(buf, end, mon, default_dec02_spec);1831 if (buf < end)1832 *buf = '-';1833 buf++;1834 1835 return number(buf, end, tm->tm_mday, default_dec02_spec);1836}1837 1838static noinline_for_stack1839char *time_str(char *buf, char *end, const struct rtc_time *tm, bool r)1840{1841 buf = number(buf, end, tm->tm_hour, default_dec02_spec);1842 if (buf < end)1843 *buf = ':';1844 buf++;1845 1846 buf = number(buf, end, tm->tm_min, default_dec02_spec);1847 if (buf < end)1848 *buf = ':';1849 buf++;1850 1851 return number(buf, end, tm->tm_sec, default_dec02_spec);1852}1853 1854static noinline_for_stack1855char *rtc_str(char *buf, char *end, const struct rtc_time *tm,1856 struct printf_spec spec, const char *fmt)1857{1858 bool have_t = true, have_d = true;1859 bool raw = false, iso8601_separator = true;1860 bool found = true;1861 int count = 2;1862 1863 if (check_pointer(&buf, end, tm, spec))1864 return buf;1865 1866 switch (fmt[count]) {1867 case 'd':1868 have_t = false;1869 count++;1870 break;1871 case 't':1872 have_d = false;1873 count++;1874 break;1875 }1876 1877 do {1878 switch (fmt[count++]) {1879 case 'r':1880 raw = true;1881 break;1882 case 's':1883 iso8601_separator = false;1884 break;1885 default:1886 found = false;1887 break;1888 }1889 } while (found);1890 1891 if (have_d)1892 buf = date_str(buf, end, tm, raw);1893 if (have_d && have_t) {1894 if (buf < end)1895 *buf = iso8601_separator ? 'T' : ' ';1896 buf++;1897 }1898 if (have_t)1899 buf = time_str(buf, end, tm, raw);1900 1901 return buf;1902}1903 1904static noinline_for_stack1905char *time64_str(char *buf, char *end, const time64_t time,1906 struct printf_spec spec, const char *fmt)1907{1908 struct rtc_time rtc_time;1909 struct tm tm;1910 1911 time64_to_tm(time, 0, &tm);1912 1913 rtc_time.tm_sec = tm.tm_sec;1914 rtc_time.tm_min = tm.tm_min;1915 rtc_time.tm_hour = tm.tm_hour;1916 rtc_time.tm_mday = tm.tm_mday;1917 rtc_time.tm_mon = tm.tm_mon;1918 rtc_time.tm_year = tm.tm_year;1919 rtc_time.tm_wday = tm.tm_wday;1920 rtc_time.tm_yday = tm.tm_yday;1921 1922 rtc_time.tm_isdst = 0;1923 1924 return rtc_str(buf, end, &rtc_time, spec, fmt);1925}1926 1927static noinline_for_stack1928char *time_and_date(char *buf, char *end, void *ptr, struct printf_spec spec,1929 const char *fmt)1930{1931 switch (fmt[1]) {1932 case 'R':1933 return rtc_str(buf, end, (const struct rtc_time *)ptr, spec, fmt);1934 case 'T':1935 return time64_str(buf, end, *(const time64_t *)ptr, spec, fmt);1936 default:1937 return error_string(buf, end, "(%pt?)", spec);1938 }1939}1940 1941static noinline_for_stack1942char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec,1943 const char *fmt)1944{1945 if (!IS_ENABLED(CONFIG_HAVE_CLK))1946 return error_string(buf, end, "(%pC?)", spec);1947 1948 if (check_pointer(&buf, end, clk, spec))1949 return buf;1950 1951 switch (fmt[1]) {1952 case 'n':1953 default:1954#ifdef CONFIG_COMMON_CLK1955 return string(buf, end, __clk_get_name(clk), spec);1956#else1957 return ptr_to_id(buf, end, clk, spec);1958#endif1959 }1960}1961 1962static1963char *format_flags(char *buf, char *end, unsigned long flags,1964 const struct trace_print_flags *names)1965{1966 unsigned long mask;1967 1968 for ( ; flags && names->name; names++) {1969 mask = names->mask;1970 if ((flags & mask) != mask)1971 continue;1972 1973 buf = string(buf, end, names->name, default_str_spec);1974 1975 flags &= ~mask;1976 if (flags) {1977 if (buf < end)1978 *buf = '|';1979 buf++;1980 }1981 }1982 1983 if (flags)1984 buf = number(buf, end, flags, default_flag_spec);1985 1986 return buf;1987}1988 1989struct page_flags_fields {1990 int width;1991 int shift;1992 int mask;1993 const struct printf_spec *spec;1994 const char *name;1995};1996 1997static const struct page_flags_fields pff[] = {1998 {SECTIONS_WIDTH, SECTIONS_PGSHIFT, SECTIONS_MASK,1999 &default_dec_spec, "section"},2000 {NODES_WIDTH, NODES_PGSHIFT, NODES_MASK,2001 &default_dec_spec, "node"},2002 {ZONES_WIDTH, ZONES_PGSHIFT, ZONES_MASK,2003 &default_dec_spec, "zone"},2004 {LAST_CPUPID_WIDTH, LAST_CPUPID_PGSHIFT, LAST_CPUPID_MASK,2005 &default_flag_spec, "lastcpupid"},2006 {KASAN_TAG_WIDTH, KASAN_TAG_PGSHIFT, KASAN_TAG_MASK,2007 &default_flag_spec, "kasantag"},2008};2009 2010static2011char *format_page_flags(char *buf, char *end, unsigned long flags)2012{2013 unsigned long main_flags = flags & PAGEFLAGS_MASK;2014 bool append = false;2015 int i;2016 2017 buf = number(buf, end, flags, default_flag_spec);2018 if (buf < end)2019 *buf = '(';2020 buf++;2021 2022 /* Page flags from the main area. */2023 if (main_flags) {2024 buf = format_flags(buf, end, main_flags, pageflag_names);2025 append = true;2026 }2027 2028 /* Page flags from the fields area */2029 for (i = 0; i < ARRAY_SIZE(pff); i++) {2030 /* Skip undefined fields. */2031 if (!pff[i].width)2032 continue;2033 2034 /* Format: Flag Name + '=' (equals sign) + Number + '|' (separator) */2035 if (append) {2036 if (buf < end)2037 *buf = '|';2038 buf++;2039 }2040 2041 buf = string(buf, end, pff[i].name, default_str_spec);2042 if (buf < end)2043 *buf = '=';2044 buf++;2045 buf = number(buf, end, (flags >> pff[i].shift) & pff[i].mask,2046 *pff[i].spec);2047 2048 append = true;2049 }2050 if (buf < end)2051 *buf = ')';2052 buf++;2053 2054 return buf;2055}2056 2057static noinline_for_stack2058char *flags_string(char *buf, char *end, void *flags_ptr,2059 struct printf_spec spec, const char *fmt)2060{2061 unsigned long flags;2062 const struct trace_print_flags *names;2063 2064 if (check_pointer(&buf, end, flags_ptr, spec))2065 return buf;2066 2067 switch (fmt[1]) {2068 case 'p':2069 return format_page_flags(buf, end, *(unsigned long *)flags_ptr);2070 case 'v':2071 flags = *(unsigned long *)flags_ptr;2072 names = vmaflag_names;2073 break;2074 case 'g':2075 flags = (__force unsigned long)(*(gfp_t *)flags_ptr);2076 names = gfpflag_names;2077 break;2078 default:2079 return error_string(buf, end, "(%pG?)", spec);2080 }2081 2082 return format_flags(buf, end, flags, names);2083}2084 2085static noinline_for_stack2086char *fwnode_full_name_string(struct fwnode_handle *fwnode, char *buf,2087 char *end)2088{2089 int depth;2090 2091 /* Loop starting from the root node to the current node. */2092 for (depth = fwnode_count_parents(fwnode); depth >= 0; depth--) {2093 /*2094 * Only get a reference for other nodes (i.e. parent nodes).2095 * fwnode refcount may be 0 here.2096 */2097 struct fwnode_handle *__fwnode = depth ?2098 fwnode_get_nth_parent(fwnode, depth) : fwnode;2099 2100 buf = string(buf, end, fwnode_get_name_prefix(__fwnode),2101 default_str_spec);2102 buf = string(buf, end, fwnode_get_name(__fwnode),2103 default_str_spec);2104 2105 if (depth)2106 fwnode_handle_put(__fwnode);2107 }2108 2109 return buf;2110}2111 2112static noinline_for_stack2113char *device_node_string(char *buf, char *end, struct device_node *dn,2114 struct printf_spec spec, const char *fmt)2115{2116 char tbuf[sizeof("xxxx") + 1];2117 const char *p;2118 int ret;2119 char *buf_start = buf;2120 struct property *prop;2121 bool has_mult, pass;2122 2123 struct printf_spec str_spec = spec;2124 str_spec.field_width = -1;2125 2126 if (fmt[0] != 'F')2127 return error_string(buf, end, "(%pO?)", spec);2128 2129 if (!IS_ENABLED(CONFIG_OF))2130 return error_string(buf, end, "(%pOF?)", spec);2131 2132 if (check_pointer(&buf, end, dn, spec))2133 return buf;2134 2135 /* simple case without anything any more format specifiers */2136 fmt++;2137 if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0)2138 fmt = "f";2139 2140 for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) {2141 int precision;2142 if (pass) {2143 if (buf < end)2144 *buf = ':';2145 buf++;2146 }2147 2148 switch (*fmt) {2149 case 'f': /* full_name */2150 buf = fwnode_full_name_string(of_fwnode_handle(dn), buf,2151 end);2152 break;2153 case 'n': /* name */2154 p = fwnode_get_name(of_fwnode_handle(dn));2155 precision = str_spec.precision;2156 str_spec.precision = strchrnul(p, '@') - p;2157 buf = string(buf, end, p, str_spec);2158 str_spec.precision = precision;2159 break;2160 case 'p': /* phandle */2161 buf = number(buf, end, (unsigned int)dn->phandle, default_dec_spec);2162 break;2163 case 'P': /* path-spec */2164 p = fwnode_get_name(of_fwnode_handle(dn));2165 if (!p[1])2166 p = "/";2167 buf = string(buf, end, p, str_spec);2168 break;2169 case 'F': /* flags */2170 tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';2171 tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-';2172 tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-';2173 tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-';2174 tbuf[4] = 0;2175 buf = string_nocheck(buf, end, tbuf, str_spec);2176 break;2177 case 'c': /* major compatible string */2178 ret = of_property_read_string(dn, "compatible", &p);2179 if (!ret)2180 buf = string(buf, end, p, str_spec);2181 break;2182 case 'C': /* full compatible string */2183 has_mult = false;2184 of_property_for_each_string(dn, "compatible", prop, p) {2185 if (has_mult)2186 buf = string_nocheck(buf, end, ",", str_spec);2187 buf = string_nocheck(buf, end, "\"", str_spec);2188 buf = string(buf, end, p, str_spec);2189 buf = string_nocheck(buf, end, "\"", str_spec);2190 2191 has_mult = true;2192 }2193 break;2194 default:2195 break;2196 }2197 }2198 2199 return widen_string(buf, buf - buf_start, end, spec);2200}2201 2202static noinline_for_stack2203char *fwnode_string(char *buf, char *end, struct fwnode_handle *fwnode,2204 struct printf_spec spec, const char *fmt)2205{2206 struct printf_spec str_spec = spec;2207 char *buf_start = buf;2208 2209 str_spec.field_width = -1;2210 2211 if (*fmt != 'w')2212 return error_string(buf, end, "(%pf?)", spec);2213 2214 if (check_pointer(&buf, end, fwnode, spec))2215 return buf;2216 2217 fmt++;2218 2219 switch (*fmt) {2220 case 'P': /* name */2221 buf = string(buf, end, fwnode_get_name(fwnode), str_spec);2222 break;2223 case 'f': /* full_name */2224 default:2225 buf = fwnode_full_name_string(fwnode, buf, end);2226 break;2227 }2228 2229 return widen_string(buf, buf - buf_start, end, spec);2230}2231 2232int __init no_hash_pointers_enable(char *str)2233{2234 if (no_hash_pointers)2235 return 0;2236 2237 no_hash_pointers = true;2238 2239 pr_warn("**********************************************************\n");2240 pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n");2241 pr_warn("** **\n");2242 pr_warn("** This system shows unhashed kernel memory addresses **\n");2243 pr_warn("** via the console, logs, and other interfaces. This **\n");2244 pr_warn("** might reduce the security of your system. **\n");2245 pr_warn("** **\n");2246 pr_warn("** If you see this message and you are not debugging **\n");2247 pr_warn("** the kernel, report this immediately to your system **\n");2248 pr_warn("** administrator! **\n");2249 pr_warn("** **\n");2250 pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n");2251 pr_warn("**********************************************************\n");2252 2253 return 0;2254}2255early_param("no_hash_pointers", no_hash_pointers_enable);2256 2257/* Used for Rust formatting ('%pA'). */2258char *rust_fmt_argument(char *buf, char *end, void *ptr);2259 2260/*2261 * Show a '%p' thing. A kernel extension is that the '%p' is followed2262 * by an extra set of alphanumeric characters that are extended format2263 * specifiers.2264 *2265 * Please update scripts/checkpatch.pl when adding/removing conversion2266 * characters. (Search for "check for vsprintf extension").2267 *2268 * Right now we handle:2269 *2270 * - 'S' For symbolic direct pointers (or function descriptors) with offset2271 * - 's' For symbolic direct pointers (or function descriptors) without offset2272 * - '[Ss]R' as above with __builtin_extract_return_addr() translation2273 * - 'S[R]b' as above with module build ID (for use in backtraces)2274 * - '[Ff]' %pf and %pF were obsoleted and later removed in favor of2275 * %ps and %pS. Be careful when re-using these specifiers.2276 * - 'B' For backtraced symbolic direct pointers with offset2277 * - 'Bb' as above with module build ID (for use in backtraces)2278 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]2279 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]2280 * - 'b[l]' For a bitmap, the number of bits is determined by the field2281 * width which must be explicitly specified either as part of the2282 * format string '%32b[l]' or through '%*b[l]', [l] selects2283 * range-list format instead of hex format2284 * - 'M' For a 6-byte MAC address, it prints the address in the2285 * usual colon-separated hex notation2286 * - 'm' For a 6-byte MAC address, it prints the hex address without colons2287 * - 'MF' For a 6-byte MAC FDDI address, it prints the address2288 * with a dash-separated hex notation2289 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)2290 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way2291 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)2292 * IPv6 uses colon separated network-order 16 bit hex with leading 0's2293 * [S][pfs]2294 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to2295 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s]2296 * - 'i' [46] for 'raw' IPv4/IPv6 addresses2297 * IPv6 omits the colons (01020304...0f)2298 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)2299 * [S][pfs]2300 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to2301 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s]2302 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order2303 * - 'I[6S]c' for IPv6 addresses printed as specified by2304 * https://tools.ietf.org/html/rfc59522305 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination2306 * of the following flags (see string_escape_mem() for the2307 * details):2308 * a - ESCAPE_ANY2309 * c - ESCAPE_SPECIAL2310 * h - ESCAPE_HEX2311 * n - ESCAPE_NULL2312 * o - ESCAPE_OCTAL2313 * p - ESCAPE_NP2314 * s - ESCAPE_SPACE2315 * By default ESCAPE_ANY_NP is used.2316 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form2317 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"2318 * Options for %pU are:2319 * b big endian lower case hex (default)2320 * B big endian UPPER case hex2321 * l little endian lower case hex2322 * L little endian UPPER case hex2323 * big endian output byte order is:2324 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]2325 * little endian output byte order is:2326 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]2327 * - 'V' For a struct va_format which contains a format string * and va_list *,2328 * call vsnprintf(->format, *->va_list).2329 * Implements a "recursive vsnprintf".2330 * Do not use this feature without some mechanism to verify the2331 * correctness of the format string and va_list arguments.2332 * - 'K' For a kernel pointer that should be hidden from unprivileged users.2333 * Use only for procfs, sysfs and similar files, not printk(); please2334 * read the documentation (path below) first.2335 * - 'NF' For a netdev_features_t2336 * - '4cc' V4L2 or DRM FourCC code, with endianness and raw numerical value.2337 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with2338 * a certain separator (' ' by default):2339 * C colon2340 * D dash2341 * N no separator2342 * The maximum supported length is 64 bytes of the input. Consider2343 * to use print_hex_dump() for the larger input.2344 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives2345 * (default assumed to be phys_addr_t, passed by reference)2346 * - 'd[234]' For a dentry name (optionally 2-4 last components)2347 * - 'D[234]' Same as 'd' but for a struct file2348 * - 'g' For block_device name (gendisk + partition number)2349 * - 't[RT][dt][r][s]' For time and date as represented by:2350 * R struct rtc_time2351 * T time64_t2352 * - 'C' For a clock, it prints the name (Common Clock Framework) or address2353 * (legacy clock framework) of the clock2354 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address2355 * (legacy clock framework) of the clock2356 * - 'G' For flags to be printed as a collection of symbolic strings that would2357 * construct the specific value. Supported flags given by option:2358 * p page flags (see struct page) given as pointer to unsigned long2359 * g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t2360 * v vma flags (VM_*) given as pointer to unsigned long2361 * - 'OF[fnpPcCF]' For a device tree object2362 * Without any optional arguments prints the full_name2363 * f device node full_name2364 * n device node name2365 * p device node phandle2366 * P device node path spec (name + @unit)2367 * F device node flags2368 * c major compatible string2369 * C full compatible string2370 * - 'fw[fP]' For a firmware node (struct fwnode_handle) pointer2371 * Without an option prints the full name of the node2372 * f full name2373 * P node name, including a possible unit address2374 * - 'x' For printing the address unmodified. Equivalent to "%lx".2375 * Please read the documentation (path below) before using!2376 * - '[ku]s' For a BPF/tracing related format specifier, e.g. used out of2377 * bpf_trace_printk() where [ku] prefix specifies either kernel (k)2378 * or user (u) memory to probe, and:2379 * s a string, equivalent to "%s" on direct vsnprintf() use2380 *2381 * ** When making changes please also update:2382 * Documentation/core-api/printk-formats.rst2383 *2384 * Note: The default behaviour (unadorned %p) is to hash the address,2385 * rendering it useful as a unique identifier.2386 *2387 * There is also a '%pA' format specifier, but it is only intended to be used2388 * from Rust code to format core::fmt::Arguments. Do *not* use it from C.2389 * See rust/kernel/print.rs for details.2390 */2391static noinline_for_stack2392char *pointer(const char *fmt, char *buf, char *end, void *ptr,2393 struct printf_spec spec)2394{2395 switch (*fmt) {2396 case 'S':2397 case 's':2398 ptr = dereference_symbol_descriptor(ptr);2399 fallthrough;2400 case 'B':2401 return symbol_string(buf, end, ptr, spec, fmt);2402 case 'R':2403 case 'r':2404 return resource_string(buf, end, ptr, spec, fmt);2405 case 'h':2406 return hex_string(buf, end, ptr, spec, fmt);2407 case 'b':2408 switch (fmt[1]) {2409 case 'l':2410 return bitmap_list_string(buf, end, ptr, spec, fmt);2411 default:2412 return bitmap_string(buf, end, ptr, spec, fmt);2413 }2414 case 'M': /* Colon separated: 00:01:02:03:04:05 */2415 case 'm': /* Contiguous: 000102030405 */2416 /* [mM]F (FDDI) */2417 /* [mM]R (Reverse order; Bluetooth) */2418 return mac_address_string(buf, end, ptr, spec, fmt);2419 case 'I': /* Formatted IP supported2420 * 4: 1.2.3.42421 * 6: 0001:0203:...:07082422 * 6c: 1::708 or 1::1.2.3.42423 */2424 case 'i': /* Contiguous:2425 * 4: 001.002.003.0042426 * 6: 000102...0f2427 */2428 return ip_addr_string(buf, end, ptr, spec, fmt);2429 case 'E':2430 return escaped_string(buf, end, ptr, spec, fmt);2431 case 'U':2432 return uuid_string(buf, end, ptr, spec, fmt);2433 case 'V':2434 return va_format(buf, end, ptr, spec, fmt);2435 case 'K':2436 return restricted_pointer(buf, end, ptr, spec);2437 case 'N':2438 return netdev_bits(buf, end, ptr, spec, fmt);2439 case '4':2440 return fourcc_string(buf, end, ptr, spec, fmt);2441 case 'a':2442 return address_val(buf, end, ptr, spec, fmt);2443 case 'd':2444 return dentry_name(buf, end, ptr, spec, fmt);2445 case 't':2446 return time_and_date(buf, end, ptr, spec, fmt);2447 case 'C':2448 return clock(buf, end, ptr, spec, fmt);2449 case 'D':2450 return file_dentry_name(buf, end, ptr, spec, fmt);2451#ifdef CONFIG_BLOCK2452 case 'g':2453 return bdev_name(buf, end, ptr, spec, fmt);2454#endif2455 2456 case 'G':2457 return flags_string(buf, end, ptr, spec, fmt);2458 case 'O':2459 return device_node_string(buf, end, ptr, spec, fmt + 1);2460 case 'f':2461 return fwnode_string(buf, end, ptr, spec, fmt + 1);2462 case 'A':2463 if (!IS_ENABLED(CONFIG_RUST)) {2464 WARN_ONCE(1, "Please remove %%pA from non-Rust code\n");2465 return error_string(buf, end, "(%pA?)", spec);2466 }2467 return rust_fmt_argument(buf, end, ptr);2468 case 'x':2469 return pointer_string(buf, end, ptr, spec);2470 case 'e':2471 /* %pe with a non-ERR_PTR gets treated as plain %p */2472 if (!IS_ERR(ptr))2473 return default_pointer(buf, end, ptr, spec);2474 return err_ptr(buf, end, ptr, spec);2475 case 'u':2476 case 'k':2477 switch (fmt[1]) {2478 case 's':2479 return string(buf, end, ptr, spec);2480 default:2481 return error_string(buf, end, "(einval)", spec);2482 }2483 default:2484 return default_pointer(buf, end, ptr, spec);2485 }2486}2487 2488/*2489 * Helper function to decode printf style format.2490 * Each call decode a token from the format and return the2491 * number of characters read (or likely the delta where it wants2492 * to go on the next call).2493 * The decoded token is returned through the parameters2494 *2495 * 'h', 'l', or 'L' for integer fields2496 * 'z' support added 23/7/1999 S.H.2497 * 'z' changed to 'Z' --davidm 1/25/992498 * 'Z' changed to 'z' --adobriyan 2017-01-252499 * 't' added for ptrdiff_t2500 *2501 * @fmt: the format string2502 * @type of the token returned2503 * @flags: various flags such as +, -, # tokens..2504 * @field_width: overwritten width2505 * @base: base of the number (octal, hex, ...)2506 * @precision: precision of a number2507 * @qualifier: qualifier of a number (long, size_t, ...)2508 */2509static noinline_for_stack2510int format_decode(const char *fmt, struct printf_spec *spec)2511{2512 const char *start = fmt;2513 char qualifier;2514 2515 /* we finished early by reading the field width */2516 if (spec->type == FORMAT_TYPE_WIDTH) {2517 if (spec->field_width < 0) {2518 spec->field_width = -spec->field_width;2519 spec->flags |= LEFT;2520 }2521 spec->type = FORMAT_TYPE_NONE;2522 goto precision;2523 }2524 2525 /* we finished early by reading the precision */2526 if (spec->type == FORMAT_TYPE_PRECISION) {2527 if (spec->precision < 0)2528 spec->precision = 0;2529 2530 spec->type = FORMAT_TYPE_NONE;2531 goto qualifier;2532 }2533 2534 /* By default */2535 spec->type = FORMAT_TYPE_NONE;2536 2537 for (; *fmt ; ++fmt) {2538 if (*fmt == '%')2539 break;2540 }2541 2542 /* Return the current non-format string */2543 if (fmt != start || !*fmt)2544 return fmt - start;2545 2546 /* Process flags */2547 spec->flags = 0;2548 2549 while (1) { /* this also skips first '%' */2550 bool found = true;2551 2552 ++fmt;2553 2554 switch (*fmt) {2555 case '-': spec->flags |= LEFT; break;2556 case '+': spec->flags |= PLUS; break;2557 case ' ': spec->flags |= SPACE; break;2558 case '#': spec->flags |= SPECIAL; break;2559 case '0': spec->flags |= ZEROPAD; break;2560 default: found = false;2561 }2562 2563 if (!found)2564 break;2565 }2566 2567 /* get field width */2568 spec->field_width = -1;2569 2570 if (isdigit(*fmt))2571 spec->field_width = skip_atoi(&fmt);2572 else if (*fmt == '*') {2573 /* it's the next argument */2574 spec->type = FORMAT_TYPE_WIDTH;2575 return ++fmt - start;2576 }2577 2578precision:2579 /* get the precision */2580 spec->precision = -1;2581 if (*fmt == '.') {2582 ++fmt;2583 if (isdigit(*fmt)) {2584 spec->precision = skip_atoi(&fmt);2585 if (spec->precision < 0)2586 spec->precision = 0;2587 } else if (*fmt == '*') {2588 /* it's the next argument */2589 spec->type = FORMAT_TYPE_PRECISION;2590 return ++fmt - start;2591 }2592 }2593 2594qualifier:2595 /* get the conversion qualifier */2596 qualifier = 0;2597 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||2598 *fmt == 'z' || *fmt == 't') {2599 qualifier = *fmt++;2600 if (unlikely(qualifier == *fmt)) {2601 if (qualifier == 'l') {2602 qualifier = 'L';2603 ++fmt;2604 } else if (qualifier == 'h') {2605 qualifier = 'H';2606 ++fmt;2607 }2608 }2609 }2610 2611 /* default base */2612 spec->base = 10;2613 switch (*fmt) {2614 case 'c':2615 spec->type = FORMAT_TYPE_CHAR;2616 return ++fmt - start;2617 2618 case 's':2619 spec->type = FORMAT_TYPE_STR;2620 return ++fmt - start;2621 2622 case 'p':2623 spec->type = FORMAT_TYPE_PTR;2624 return ++fmt - start;2625 2626 case '%':2627 spec->type = FORMAT_TYPE_PERCENT_CHAR;2628 return ++fmt - start;2629 2630 /* integer number formats - set up the flags and "break" */2631 case 'o':2632 spec->base = 8;2633 break;2634 2635 case 'x':2636 spec->flags |= SMALL;2637 fallthrough;2638 2639 case 'X':2640 spec->base = 16;2641 break;2642 2643 case 'd':2644 case 'i':2645 spec->flags |= SIGN;2646 break;2647 case 'u':2648 break;2649 2650 case 'n':2651 /*2652 * Since %n poses a greater security risk than2653 * utility, treat it as any other invalid or2654 * unsupported format specifier.2655 */2656 fallthrough;2657 2658 default:2659 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt);2660 spec->type = FORMAT_TYPE_INVALID;2661 return fmt - start;2662 }2663 2664 if (qualifier == 'L')2665 spec->type = FORMAT_TYPE_LONG_LONG;2666 else if (qualifier == 'l') {2667 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG);2668 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN);2669 } else if (qualifier == 'z') {2670 spec->type = FORMAT_TYPE_SIZE_T;2671 } else if (qualifier == 't') {2672 spec->type = FORMAT_TYPE_PTRDIFF;2673 } else if (qualifier == 'H') {2674 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE);2675 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN);2676 } else if (qualifier == 'h') {2677 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT);2678 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN);2679 } else {2680 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT);2681 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN);2682 }2683 2684 return ++fmt - start;2685}2686 2687static void2688set_field_width(struct printf_spec *spec, int width)2689{2690 spec->field_width = width;2691 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) {2692 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX);2693 }2694}2695 2696static void2697set_precision(struct printf_spec *spec, int prec)2698{2699 spec->precision = prec;2700 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) {2701 spec->precision = clamp(prec, 0, PRECISION_MAX);2702 }2703}2704 2705/**2706 * vsnprintf - Format a string and place it in a buffer2707 * @buf: The buffer to place the result into2708 * @size: The size of the buffer, including the trailing null space2709 * @fmt: The format string to use2710 * @args: Arguments for the format string2711 *2712 * This function generally follows C99 vsnprintf, but has some2713 * extensions and a few limitations:2714 *2715 * - ``%n`` is unsupported2716 * - ``%p*`` is handled by pointer()2717 *2718 * See pointer() or Documentation/core-api/printk-formats.rst for more2719 * extensive description.2720 *2721 * **Please update the documentation in both places when making changes**2722 *2723 * The return value is the number of characters which would2724 * be generated for the given input, excluding the trailing2725 * '\0', as per ISO C99. If you want to have the exact2726 * number of characters written into @buf as return value2727 * (not including the trailing '\0'), use vscnprintf(). If the2728 * return is greater than or equal to @size, the resulting2729 * string is truncated.2730 *2731 * If you're not already dealing with a va_list consider using snprintf().2732 */2733int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)2734{2735 unsigned long long num;2736 char *str, *end;2737 struct printf_spec spec = {0};2738 2739 /* Reject out-of-range values early. Large positive sizes are2740 used for unknown buffer sizes. */2741 if (WARN_ON_ONCE(size > INT_MAX))2742 return 0;2743 2744 str = buf;2745 end = buf + size;2746 2747 /* Make sure end is always >= buf */2748 if (end < buf) {2749 end = ((void *)-1);2750 size = end - buf;2751 }2752 2753 while (*fmt) {2754 const char *old_fmt = fmt;2755 int read = format_decode(fmt, &spec);2756 2757 fmt += read;2758 2759 switch (spec.type) {2760 case FORMAT_TYPE_NONE: {2761 int copy = read;2762 if (str < end) {2763 if (copy > end - str)2764 copy = end - str;2765 memcpy(str, old_fmt, copy);2766 }2767 str += read;2768 break;2769 }2770 2771 case FORMAT_TYPE_WIDTH:2772 set_field_width(&spec, va_arg(args, int));2773 break;2774 2775 case FORMAT_TYPE_PRECISION:2776 set_precision(&spec, va_arg(args, int));2777 break;2778 2779 case FORMAT_TYPE_CHAR: {2780 char c;2781 2782 if (!(spec.flags & LEFT)) {2783 while (--spec.field_width > 0) {2784 if (str < end)2785 *str = ' ';2786 ++str;2787 2788 }2789 }2790 c = (unsigned char) va_arg(args, int);2791 if (str < end)2792 *str = c;2793 ++str;2794 while (--spec.field_width > 0) {2795 if (str < end)2796 *str = ' ';2797 ++str;2798 }2799 break;2800 }2801 2802 case FORMAT_TYPE_STR:2803 str = string(str, end, va_arg(args, char *), spec);2804 break;2805 2806 case FORMAT_TYPE_PTR:2807 str = pointer(fmt, str, end, va_arg(args, void *),2808 spec);2809 while (isalnum(*fmt))2810 fmt++;2811 break;2812 2813 case FORMAT_TYPE_PERCENT_CHAR:2814 if (str < end)2815 *str = '%';2816 ++str;2817 break;2818 2819 case FORMAT_TYPE_INVALID:2820 /*2821 * Presumably the arguments passed gcc's type2822 * checking, but there is no safe or sane way2823 * for us to continue parsing the format and2824 * fetching from the va_list; the remaining2825 * specifiers and arguments would be out of2826 * sync.2827 */2828 goto out;2829 2830 default:2831 switch (spec.type) {2832 case FORMAT_TYPE_LONG_LONG:2833 num = va_arg(args, long long);2834 break;2835 case FORMAT_TYPE_ULONG:2836 num = va_arg(args, unsigned long);2837 break;2838 case FORMAT_TYPE_LONG:2839 num = va_arg(args, long);2840 break;2841 case FORMAT_TYPE_SIZE_T:2842 if (spec.flags & SIGN)2843 num = va_arg(args, ssize_t);2844 else2845 num = va_arg(args, size_t);2846 break;2847 case FORMAT_TYPE_PTRDIFF:2848 num = va_arg(args, ptrdiff_t);2849 break;2850 case FORMAT_TYPE_UBYTE:2851 num = (unsigned char) va_arg(args, int);2852 break;2853 case FORMAT_TYPE_BYTE:2854 num = (signed char) va_arg(args, int);2855 break;2856 case FORMAT_TYPE_USHORT:2857 num = (unsigned short) va_arg(args, int);2858 break;2859 case FORMAT_TYPE_SHORT:2860 num = (short) va_arg(args, int);2861 break;2862 case FORMAT_TYPE_INT:2863 num = (int) va_arg(args, int);2864 break;2865 default:2866 num = va_arg(args, unsigned int);2867 }2868 2869 str = number(str, end, num, spec);2870 }2871 }2872 2873out:2874 if (size > 0) {2875 if (str < end)2876 *str = '\0';2877 else2878 end[-1] = '\0';2879 }2880 2881 /* the trailing null byte doesn't count towards the total */2882 return str-buf;2883 2884}2885EXPORT_SYMBOL(vsnprintf);2886 2887/**2888 * vscnprintf - Format a string and place it in a buffer2889 * @buf: The buffer to place the result into2890 * @size: The size of the buffer, including the trailing null space2891 * @fmt: The format string to use2892 * @args: Arguments for the format string2893 *2894 * The return value is the number of characters which have been written into2895 * the @buf not including the trailing '\0'. If @size is == 0 the function2896 * returns 0.2897 *2898 * If you're not already dealing with a va_list consider using scnprintf().2899 *2900 * See the vsnprintf() documentation for format string extensions over C99.2901 */2902int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)2903{2904 int i;2905 2906 if (unlikely(!size))2907 return 0;2908 2909 i = vsnprintf(buf, size, fmt, args);2910 2911 if (likely(i < size))2912 return i;2913 2914 return size - 1;2915}2916EXPORT_SYMBOL(vscnprintf);2917 2918/**2919 * snprintf - Format a string and place it in a buffer2920 * @buf: The buffer to place the result into2921 * @size: The size of the buffer, including the trailing null space2922 * @fmt: The format string to use2923 * @...: Arguments for the format string2924 *2925 * The return value is the number of characters which would be2926 * generated for the given input, excluding the trailing null,2927 * as per ISO C99. If the return is greater than or equal to2928 * @size, the resulting string is truncated.2929 *2930 * See the vsnprintf() documentation for format string extensions over C99.2931 */2932int snprintf(char *buf, size_t size, const char *fmt, ...)2933{2934 va_list args;2935 int i;2936 2937 va_start(args, fmt);2938 i = vsnprintf(buf, size, fmt, args);2939 va_end(args);2940 2941 return i;2942}2943EXPORT_SYMBOL(snprintf);2944 2945/**2946 * scnprintf - Format a string and place it in a buffer2947 * @buf: The buffer to place the result into2948 * @size: The size of the buffer, including the trailing null space2949 * @fmt: The format string to use2950 * @...: Arguments for the format string2951 *2952 * The return value is the number of characters written into @buf not including2953 * the trailing '\0'. If @size is == 0 the function returns 0.2954 */2955 2956int scnprintf(char *buf, size_t size, const char *fmt, ...)2957{2958 va_list args;2959 int i;2960 2961 va_start(args, fmt);2962 i = vscnprintf(buf, size, fmt, args);2963 va_end(args);2964 2965 return i;2966}2967EXPORT_SYMBOL(scnprintf);2968 2969/**2970 * vsprintf - Format a string and place it in a buffer2971 * @buf: The buffer to place the result into2972 * @fmt: The format string to use2973 * @args: Arguments for the format string2974 *2975 * The function returns the number of characters written2976 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid2977 * buffer overflows.2978 *2979 * If you're not already dealing with a va_list consider using sprintf().2980 *2981 * See the vsnprintf() documentation for format string extensions over C99.2982 */2983int vsprintf(char *buf, const char *fmt, va_list args)2984{2985 return vsnprintf(buf, INT_MAX, fmt, args);2986}2987EXPORT_SYMBOL(vsprintf);2988 2989/**2990 * sprintf - Format a string and place it in a buffer2991 * @buf: The buffer to place the result into2992 * @fmt: The format string to use2993 * @...: Arguments for the format string2994 *2995 * The function returns the number of characters written2996 * into @buf. Use snprintf() or scnprintf() in order to avoid2997 * buffer overflows.2998 *2999 * See the vsnprintf() documentation for format string extensions over C99.3000 */3001int sprintf(char *buf, const char *fmt, ...)3002{3003 va_list args;3004 int i;3005 3006 va_start(args, fmt);3007 i = vsnprintf(buf, INT_MAX, fmt, args);3008 va_end(args);3009 3010 return i;3011}3012EXPORT_SYMBOL(sprintf);3013 3014#ifdef CONFIG_BINARY_PRINTF3015/*3016 * bprintf service:3017 * vbin_printf() - VA arguments to binary data3018 * bstr_printf() - Binary data to text string3019 */3020 3021/**3022 * vbin_printf - Parse a format string and place args' binary value in a buffer3023 * @bin_buf: The buffer to place args' binary value3024 * @size: The size of the buffer(by words(32bits), not characters)3025 * @fmt: The format string to use3026 * @args: Arguments for the format string3027 *3028 * The format follows C99 vsnprintf, except %n is ignored, and its argument3029 * is skipped.3030 *3031 * The return value is the number of words(32bits) which would be generated for3032 * the given input.3033 *3034 * NOTE:3035 * If the return value is greater than @size, the resulting bin_buf is NOT3036 * valid for bstr_printf().3037 */3038int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)3039{3040 struct printf_spec spec = {0};3041 char *str, *end;3042 int width;3043 3044 str = (char *)bin_buf;3045 end = (char *)(bin_buf + size);3046 3047#define save_arg(type) \3048({ \3049 unsigned long long value; \3050 if (sizeof(type) == 8) { \3051 unsigned long long val8; \3052 str = PTR_ALIGN(str, sizeof(u32)); \3053 val8 = va_arg(args, unsigned long long); \3054 if (str + sizeof(type) <= end) { \3055 *(u32 *)str = *(u32 *)&val8; \3056 *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \3057 } \3058 value = val8; \3059 } else { \3060 unsigned int val4; \3061 str = PTR_ALIGN(str, sizeof(type)); \3062 val4 = va_arg(args, int); \3063 if (str + sizeof(type) <= end) \3064 *(typeof(type) *)str = (type)(long)val4; \3065 value = (unsigned long long)val4; \3066 } \3067 str += sizeof(type); \3068 value; \3069})3070 3071 while (*fmt) {3072 int read = format_decode(fmt, &spec);3073 3074 fmt += read;3075 3076 switch (spec.type) {3077 case FORMAT_TYPE_NONE:3078 case FORMAT_TYPE_PERCENT_CHAR:3079 break;3080 case FORMAT_TYPE_INVALID:3081 goto out;3082 3083 case FORMAT_TYPE_WIDTH:3084 case FORMAT_TYPE_PRECISION:3085 width = (int)save_arg(int);3086 /* Pointers may require the width */3087 if (*fmt == 'p')3088 set_field_width(&spec, width);3089 break;3090 3091 case FORMAT_TYPE_CHAR:3092 save_arg(char);3093 break;3094 3095 case FORMAT_TYPE_STR: {3096 const char *save_str = va_arg(args, char *);3097 const char *err_msg;3098 size_t len;3099 3100 err_msg = check_pointer_msg(save_str);3101 if (err_msg)3102 save_str = err_msg;3103 3104 len = strlen(save_str) + 1;3105 if (str + len < end)3106 memcpy(str, save_str, len);3107 str += len;3108 break;3109 }3110 3111 case FORMAT_TYPE_PTR:3112 /* Dereferenced pointers must be done now */3113 switch (*fmt) {3114 /* Dereference of functions is still OK */3115 case 'S':3116 case 's':3117 case 'x':3118 case 'K':3119 case 'e':3120 save_arg(void *);3121 break;3122 default:3123 if (!isalnum(*fmt)) {3124 save_arg(void *);3125 break;3126 }3127 str = pointer(fmt, str, end, va_arg(args, void *),3128 spec);3129 if (str + 1 < end)3130 *str++ = '\0';3131 else3132 end[-1] = '\0'; /* Must be nul terminated */3133 }3134 /* skip all alphanumeric pointer suffixes */3135 while (isalnum(*fmt))3136 fmt++;3137 break;3138 3139 default:3140 switch (spec.type) {3141 3142 case FORMAT_TYPE_LONG_LONG:3143 save_arg(long long);3144 break;3145 case FORMAT_TYPE_ULONG:3146 case FORMAT_TYPE_LONG:3147 save_arg(unsigned long);3148 break;3149 case FORMAT_TYPE_SIZE_T:3150 save_arg(size_t);3151 break;3152 case FORMAT_TYPE_PTRDIFF:3153 save_arg(ptrdiff_t);3154 break;3155 case FORMAT_TYPE_UBYTE:3156 case FORMAT_TYPE_BYTE:3157 save_arg(char);3158 break;3159 case FORMAT_TYPE_USHORT:3160 case FORMAT_TYPE_SHORT:3161 save_arg(short);3162 break;3163 default:3164 save_arg(int);3165 }3166 }3167 }3168 3169out:3170 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;3171#undef save_arg3172}3173EXPORT_SYMBOL_GPL(vbin_printf);3174 3175/**3176 * bstr_printf - Format a string from binary arguments and place it in a buffer3177 * @buf: The buffer to place the result into3178 * @size: The size of the buffer, including the trailing null space3179 * @fmt: The format string to use3180 * @bin_buf: Binary arguments for the format string3181 *3182 * This function like C99 vsnprintf, but the difference is that vsnprintf gets3183 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is3184 * a binary buffer that generated by vbin_printf.3185 *3186 * The format follows C99 vsnprintf, but has some extensions:3187 * see vsnprintf comment for details.3188 *3189 * The return value is the number of characters which would3190 * be generated for the given input, excluding the trailing3191 * '\0', as per ISO C99. If you want to have the exact3192 * number of characters written into @buf as return value3193 * (not including the trailing '\0'), use vscnprintf(). If the3194 * return is greater than or equal to @size, the resulting3195 * string is truncated.3196 */3197int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)3198{3199 struct printf_spec spec = {0};3200 char *str, *end;3201 const char *args = (const char *)bin_buf;3202 3203 if (WARN_ON_ONCE(size > INT_MAX))3204 return 0;3205 3206 str = buf;3207 end = buf + size;3208 3209#define get_arg(type) \3210({ \3211 typeof(type) value; \3212 if (sizeof(type) == 8) { \3213 args = PTR_ALIGN(args, sizeof(u32)); \3214 *(u32 *)&value = *(u32 *)args; \3215 *((u32 *)&value + 1) = *(u32 *)(args + 4); \3216 } else { \3217 args = PTR_ALIGN(args, sizeof(type)); \3218 value = *(typeof(type) *)args; \3219 } \3220 args += sizeof(type); \3221 value; \3222})3223 3224 /* Make sure end is always >= buf */3225 if (end < buf) {3226 end = ((void *)-1);3227 size = end - buf;3228 }3229 3230 while (*fmt) {3231 const char *old_fmt = fmt;3232 int read = format_decode(fmt, &spec);3233 3234 fmt += read;3235 3236 switch (spec.type) {3237 case FORMAT_TYPE_NONE: {3238 int copy = read;3239 if (str < end) {3240 if (copy > end - str)3241 copy = end - str;3242 memcpy(str, old_fmt, copy);3243 }3244 str += read;3245 break;3246 }3247 3248 case FORMAT_TYPE_WIDTH:3249 set_field_width(&spec, get_arg(int));3250 break;3251 3252 case FORMAT_TYPE_PRECISION:3253 set_precision(&spec, get_arg(int));3254 break;3255 3256 case FORMAT_TYPE_CHAR: {3257 char c;3258 3259 if (!(spec.flags & LEFT)) {3260 while (--spec.field_width > 0) {3261 if (str < end)3262 *str = ' ';3263 ++str;3264 }3265 }3266 c = (unsigned char) get_arg(char);3267 if (str < end)3268 *str = c;3269 ++str;3270 while (--spec.field_width > 0) {3271 if (str < end)3272 *str = ' ';3273 ++str;3274 }3275 break;3276 }3277 3278 case FORMAT_TYPE_STR: {3279 const char *str_arg = args;3280 args += strlen(str_arg) + 1;3281 str = string(str, end, (char *)str_arg, spec);3282 break;3283 }3284 3285 case FORMAT_TYPE_PTR: {3286 bool process = false;3287 int copy, len;3288 /* Non function dereferences were already done */3289 switch (*fmt) {3290 case 'S':3291 case 's':3292 case 'x':3293 case 'K':3294 case 'e':3295 process = true;3296 break;3297 default:3298 if (!isalnum(*fmt)) {3299 process = true;3300 break;3301 }3302 /* Pointer dereference was already processed */3303 if (str < end) {3304 len = copy = strlen(args);3305 if (copy > end - str)3306 copy = end - str;3307 memcpy(str, args, copy);3308 str += len;3309 args += len + 1;3310 }3311 }3312 if (process)3313 str = pointer(fmt, str, end, get_arg(void *), spec);3314 3315 while (isalnum(*fmt))3316 fmt++;3317 break;3318 }3319 3320 case FORMAT_TYPE_PERCENT_CHAR:3321 if (str < end)3322 *str = '%';3323 ++str;3324 break;3325 3326 case FORMAT_TYPE_INVALID:3327 goto out;3328 3329 default: {3330 unsigned long long num;3331 3332 switch (spec.type) {3333 3334 case FORMAT_TYPE_LONG_LONG:3335 num = get_arg(long long);3336 break;3337 case FORMAT_TYPE_ULONG:3338 case FORMAT_TYPE_LONG:3339 num = get_arg(unsigned long);3340 break;3341 case FORMAT_TYPE_SIZE_T:3342 num = get_arg(size_t);3343 break;3344 case FORMAT_TYPE_PTRDIFF:3345 num = get_arg(ptrdiff_t);3346 break;3347 case FORMAT_TYPE_UBYTE:3348 num = get_arg(unsigned char);3349 break;3350 case FORMAT_TYPE_BYTE:3351 num = get_arg(signed char);3352 break;3353 case FORMAT_TYPE_USHORT:3354 num = get_arg(unsigned short);3355 break;3356 case FORMAT_TYPE_SHORT:3357 num = get_arg(short);3358 break;3359 case FORMAT_TYPE_UINT:3360 num = get_arg(unsigned int);3361 break;3362 default:3363 num = get_arg(int);3364 }3365 3366 str = number(str, end, num, spec);3367 } /* default: */3368 } /* switch(spec.type) */3369 } /* while(*fmt) */3370 3371out:3372 if (size > 0) {3373 if (str < end)3374 *str = '\0';3375 else3376 end[-1] = '\0';3377 }3378 3379#undef get_arg3380 3381 /* the trailing null byte doesn't count towards the total */3382 return str - buf;3383}3384EXPORT_SYMBOL_GPL(bstr_printf);3385 3386/**3387 * bprintf - Parse a format string and place args' binary value in a buffer3388 * @bin_buf: The buffer to place args' binary value3389 * @size: The size of the buffer(by words(32bits), not characters)3390 * @fmt: The format string to use3391 * @...: Arguments for the format string3392 *3393 * The function returns the number of words(u32) written3394 * into @bin_buf.3395 */3396int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)3397{3398 va_list args;3399 int ret;3400 3401 va_start(args, fmt);3402 ret = vbin_printf(bin_buf, size, fmt, args);3403 va_end(args);3404 3405 return ret;3406}3407EXPORT_SYMBOL_GPL(bprintf);3408 3409#endif /* CONFIG_BINARY_PRINTF */3410 3411/**3412 * vsscanf - Unformat a buffer into a list of arguments3413 * @buf: input buffer3414 * @fmt: format of buffer3415 * @args: arguments3416 */3417int vsscanf(const char *buf, const char *fmt, va_list args)3418{3419 const char *str = buf;3420 char *next;3421 char digit;3422 int num = 0;3423 u8 qualifier;3424 unsigned int base;3425 union {3426 long long s;3427 unsigned long long u;3428 } val;3429 s16 field_width;3430 bool is_sign;3431 3432 while (*fmt) {3433 /* skip any white space in format */3434 /* white space in format matches any amount of3435 * white space, including none, in the input.3436 */3437 if (isspace(*fmt)) {3438 fmt = skip_spaces(++fmt);3439 str = skip_spaces(str);3440 }3441 3442 /* anything that is not a conversion must match exactly */3443 if (*fmt != '%' && *fmt) {3444 if (*fmt++ != *str++)3445 break;3446 continue;3447 }3448 3449 if (!*fmt)3450 break;3451 ++fmt;3452 3453 /* skip this conversion.3454 * advance both strings to next white space3455 */3456 if (*fmt == '*') {3457 if (!*str)3458 break;3459 while (!isspace(*fmt) && *fmt != '%' && *fmt) {3460 /* '%*[' not yet supported, invalid format */3461 if (*fmt == '[')3462 return num;3463 fmt++;3464 }3465 while (!isspace(*str) && *str)3466 str++;3467 continue;3468 }3469 3470 /* get field width */3471 field_width = -1;3472 if (isdigit(*fmt)) {3473 field_width = skip_atoi(&fmt);3474 if (field_width <= 0)3475 break;3476 }3477 3478 /* get conversion qualifier */3479 qualifier = -1;3480 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||3481 *fmt == 'z') {3482 qualifier = *fmt++;3483 if (unlikely(qualifier == *fmt)) {3484 if (qualifier == 'h') {3485 qualifier = 'H';3486 fmt++;3487 } else if (qualifier == 'l') {3488 qualifier = 'L';3489 fmt++;3490 }3491 }3492 }3493 3494 if (!*fmt)3495 break;3496 3497 if (*fmt == 'n') {3498 /* return number of characters read so far */3499 *va_arg(args, int *) = str - buf;3500 ++fmt;3501 continue;3502 }3503 3504 if (!*str)3505 break;3506 3507 base = 10;3508 is_sign = false;3509 3510 switch (*fmt++) {3511 case 'c':3512 {3513 char *s = (char *)va_arg(args, char*);3514 if (field_width == -1)3515 field_width = 1;3516 do {3517 *s++ = *str++;3518 } while (--field_width > 0 && *str);3519 num++;3520 }3521 continue;3522 case 's':3523 {3524 char *s = (char *)va_arg(args, char *);3525 if (field_width == -1)3526 field_width = SHRT_MAX;3527 /* first, skip leading white space in buffer */3528 str = skip_spaces(str);3529 3530 /* now copy until next white space */3531 while (*str && !isspace(*str) && field_width--)3532 *s++ = *str++;3533 *s = '\0';3534 num++;3535 }3536 continue;3537 /*3538 * Warning: This implementation of the '[' conversion specifier3539 * deviates from its glibc counterpart in the following ways:3540 * (1) It does NOT support ranges i.e. '-' is NOT a special3541 * character3542 * (2) It cannot match the closing bracket ']' itself3543 * (3) A field width is required3544 * (4) '%*[' (discard matching input) is currently not supported3545 *3546 * Example usage:3547 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]",3548 * buf1, buf2, buf3);3549 * if (ret < 3)3550 * // etc..3551 */3552 case '[':3553 {3554 char *s = (char *)va_arg(args, char *);3555 DECLARE_BITMAP(set, 256) = {0};3556 unsigned int len = 0;3557 bool negate = (*fmt == '^');3558 3559 /* field width is required */3560 if (field_width == -1)3561 return num;3562 3563 if (negate)3564 ++fmt;3565 3566 for ( ; *fmt && *fmt != ']'; ++fmt, ++len)3567 __set_bit((u8)*fmt, set);3568 3569 /* no ']' or no character set found */3570 if (!*fmt || !len)3571 return num;3572 ++fmt;3573 3574 if (negate) {3575 bitmap_complement(set, set, 256);3576 /* exclude null '\0' byte */3577 __clear_bit(0, set);3578 }3579 3580 /* match must be non-empty */3581 if (!test_bit((u8)*str, set))3582 return num;3583 3584 while (test_bit((u8)*str, set) && field_width--)3585 *s++ = *str++;3586 *s = '\0';3587 ++num;3588 }3589 continue;3590 case 'o':3591 base = 8;3592 break;3593 case 'x':3594 case 'X':3595 base = 16;3596 break;3597 case 'i':3598 base = 0;3599 fallthrough;3600 case 'd':3601 is_sign = true;3602 fallthrough;3603 case 'u':3604 break;3605 case '%':3606 /* looking for '%' in str */3607 if (*str++ != '%')3608 return num;3609 continue;3610 default:3611 /* invalid format; stop here */3612 return num;3613 }3614 3615 /* have some sort of integer conversion.3616 * first, skip white space in buffer.3617 */3618 str = skip_spaces(str);3619 3620 digit = *str;3621 if (is_sign && digit == '-') {3622 if (field_width == 1)3623 break;3624 3625 digit = *(str + 1);3626 }3627 3628 if (!digit3629 || (base == 16 && !isxdigit(digit))3630 || (base == 10 && !isdigit(digit))3631 || (base == 8 && !isodigit(digit))3632 || (base == 0 && !isdigit(digit)))3633 break;3634 3635 if (is_sign)3636 val.s = simple_strntoll(str, &next, base,3637 field_width >= 0 ? field_width : INT_MAX);3638 else3639 val.u = simple_strntoull(str, &next, base,3640 field_width >= 0 ? field_width : INT_MAX);3641 3642 switch (qualifier) {3643 case 'H': /* that's 'hh' in format */3644 if (is_sign)3645 *va_arg(args, signed char *) = val.s;3646 else3647 *va_arg(args, unsigned char *) = val.u;3648 break;3649 case 'h':3650 if (is_sign)3651 *va_arg(args, short *) = val.s;3652 else3653 *va_arg(args, unsigned short *) = val.u;3654 break;3655 case 'l':3656 if (is_sign)3657 *va_arg(args, long *) = val.s;3658 else3659 *va_arg(args, unsigned long *) = val.u;3660 break;3661 case 'L':3662 if (is_sign)3663 *va_arg(args, long long *) = val.s;3664 else3665 *va_arg(args, unsigned long long *) = val.u;3666 break;3667 case 'z':3668 *va_arg(args, size_t *) = val.u;3669 break;3670 default:3671 if (is_sign)3672 *va_arg(args, int *) = val.s;3673 else3674 *va_arg(args, unsigned int *) = val.u;3675 break;3676 }3677 num++;3678 3679 if (!next)3680 break;3681 str = next;3682 }3683 3684 return num;3685}3686EXPORT_SYMBOL(vsscanf);3687 3688/**3689 * sscanf - Unformat a buffer into a list of arguments3690 * @buf: input buffer3691 * @fmt: formatting of buffer3692 * @...: resulting arguments3693 */3694int sscanf(const char *buf, const char *fmt, ...)3695{3696 va_list args;3697 int i;3698 3699 va_start(args, fmt);3700 i = vsscanf(buf, fmt, args);3701 va_end(args);3702 3703 return i;3704}3705EXPORT_SYMBOL(sscanf);3706