Line data Source code
1 : /*
2 : * linux/lib/vsprintf.c
3 : *
4 : * Copyright (C) 1991, 1992 Linus Torvalds
5 : */
6 :
7 : /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8 : /*
9 : * Wirzenius wrote this portably, Torvalds fucked it up :-)
10 : */
11 :
12 : /*
13 : * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
14 : * - changed to provide snprintf and vsnprintf functions
15 : * So Feb 1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>
16 : * - scnprintf and vscnprintf
17 : */
18 :
19 : #include <stdarg.h>
20 : #include <linux/module.h> /* for KSYM_SYMBOL_LEN */
21 : #include <linux/types.h>
22 : #include <linux/string.h>
23 : #include <linux/ctype.h>
24 : #include <linux/kernel.h>
25 : #include <linux/kallsyms.h>
26 : #include <linux/math64.h>
27 : #include <linux/uaccess.h>
28 : #include <linux/ioport.h>
29 : #include <linux/dcache.h>
30 : #include <linux/cred.h>
31 : #include <net/addrconf.h>
32 :
33 : #include <asm/page.h> /* for PAGE_SIZE */
34 : #include <asm/sections.h> /* for dereference_function_descriptor() */
35 :
36 : #include <linux/string_helpers.h>
37 : #include "kstrtox.h"
38 :
39 : /**
40 : * simple_strtoull - convert a string to an unsigned long long
41 : * @cp: The start of the string
42 : * @endp: A pointer to the end of the parsed string will be placed here
43 : * @base: The number base to use
44 : *
45 : * This function is obsolete. Please use kstrtoull instead.
46 : */
47 93 : unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
48 : {
49 : unsigned long long result;
50 : unsigned int rv;
51 :
52 93 : cp = _parse_integer_fixup_radix(cp, &base);
53 93 : rv = _parse_integer(cp, base, &result);
54 : /* FIXME */
55 93 : cp += (rv & ~KSTRTOX_OVERFLOW);
56 :
57 93 : if (endp)
58 39 : *endp = (char *)cp;
59 :
60 93 : return result;
61 : }
62 : EXPORT_SYMBOL(simple_strtoull);
63 :
64 : /**
65 : * simple_strtoul - convert a string to an unsigned long
66 : * @cp: The start of the string
67 : * @endp: A pointer to the end of the parsed string will be placed here
68 : * @base: The number base to use
69 : *
70 : * This function is obsolete. Please use kstrtoul instead.
71 : */
72 72 : unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
73 : {
74 82 : return simple_strtoull(cp, endp, base);
75 : }
76 : EXPORT_SYMBOL(simple_strtoul);
77 :
78 : /**
79 : * simple_strtol - convert a string to a signed long
80 : * @cp: The start of the string
81 : * @endp: A pointer to the end of the parsed string will be placed here
82 : * @base: The number base to use
83 : *
84 : * This function is obsolete. Please use kstrtol instead.
85 : */
86 7 : long simple_strtol(const char *cp, char **endp, unsigned int base)
87 : {
88 7 : if (*cp == '-')
89 0 : return -simple_strtoul(cp + 1, endp, base);
90 :
91 7 : return simple_strtoul(cp, endp, base);
92 : }
93 : EXPORT_SYMBOL(simple_strtol);
94 :
95 : /**
96 : * simple_strtoll - convert a string to a signed long long
97 : * @cp: The start of the string
98 : * @endp: A pointer to the end of the parsed string will be placed here
99 : * @base: The number base to use
100 : *
101 : * This function is obsolete. Please use kstrtoll instead.
102 : */
103 0 : long long simple_strtoll(const char *cp, char **endp, unsigned int base)
104 : {
105 0 : if (*cp == '-')
106 0 : return -simple_strtoull(cp + 1, endp, base);
107 :
108 0 : return simple_strtoull(cp, endp, base);
109 : }
110 : EXPORT_SYMBOL(simple_strtoll);
111 :
112 : static noinline_for_stack
113 14832 : int skip_atoi(const char **s)
114 : {
115 : int i = 0;
116 :
117 45176 : while (isdigit(**s))
118 15512 : i = i*10 + *((*s)++) - '0';
119 :
120 14832 : return i;
121 : }
122 :
123 : /* Decimal conversion is by far the most typical, and is used
124 : * for /proc and /sys data. This directly impacts e.g. top performance
125 : * with many processes running. We optimize it for speed
126 : * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
127 : * (with permission from the author, Douglas W. Jones).
128 : */
129 :
130 : #if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
131 : /* Formats correctly any integer in [0, 999999999] */
132 : static noinline_for_stack
133 : char *put_dec_full9(char *buf, unsigned q)
134 : {
135 : unsigned r;
136 :
137 : /*
138 : * Possible ways to approx. divide by 10
139 : * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
140 : * (x * 0xcccd) >> 19 x < 81920 (x < 262149 when 64-bit mul)
141 : * (x * 0x6667) >> 18 x < 43699
142 : * (x * 0x3334) >> 17 x < 16389
143 : * (x * 0x199a) >> 16 x < 16389
144 : * (x * 0x0ccd) >> 15 x < 16389
145 : * (x * 0x0667) >> 14 x < 2739
146 : * (x * 0x0334) >> 13 x < 1029
147 : * (x * 0x019a) >> 12 x < 1029
148 : * (x * 0x00cd) >> 11 x < 1029 shorter code than * 0x67 (on i386)
149 : * (x * 0x0067) >> 10 x < 179
150 : * (x * 0x0034) >> 9 x < 69 same
151 : * (x * 0x001a) >> 8 x < 69 same
152 : * (x * 0x000d) >> 7 x < 69 same, shortest code (on i386)
153 : * (x * 0x0007) >> 6 x < 19
154 : * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
155 : */
156 : r = (q * (uint64_t)0x1999999a) >> 32;
157 : *buf++ = (q - 10 * r) + '0'; /* 1 */
158 : q = (r * (uint64_t)0x1999999a) >> 32;
159 : *buf++ = (r - 10 * q) + '0'; /* 2 */
160 : r = (q * (uint64_t)0x1999999a) >> 32;
161 : *buf++ = (q - 10 * r) + '0'; /* 3 */
162 : q = (r * (uint64_t)0x1999999a) >> 32;
163 : *buf++ = (r - 10 * q) + '0'; /* 4 */
164 : r = (q * (uint64_t)0x1999999a) >> 32;
165 : *buf++ = (q - 10 * r) + '0'; /* 5 */
166 : /* Now value is under 10000, can avoid 64-bit multiply */
167 : q = (r * 0x199a) >> 16;
168 : *buf++ = (r - 10 * q) + '0'; /* 6 */
169 : r = (q * 0xcd) >> 11;
170 : *buf++ = (q - 10 * r) + '0'; /* 7 */
171 : q = (r * 0xcd) >> 11;
172 : *buf++ = (r - 10 * q) + '0'; /* 8 */
173 : *buf++ = q + '0'; /* 9 */
174 : return buf;
175 : }
176 : #endif
177 :
178 : /* Similar to above but do not pad with zeros.
179 : * Code can be easily arranged to print 9 digits too, but our callers
180 : * always call put_dec_full9() instead when the number has 9 decimal digits.
181 : */
182 : static noinline_for_stack
183 25910 : char *put_dec_trunc8(char *buf, unsigned r)
184 : {
185 : unsigned q;
186 :
187 : /* Copy of previous function's body with added early returns */
188 63435 : while (r >= 10000) {
189 11615 : q = r + '0';
190 11615 : r = (r * (uint64_t)0x1999999a) >> 32;
191 11615 : *buf++ = q - 10*r;
192 : }
193 :
194 25910 : q = (r * 0x199a) >> 16; /* r <= 9999 */
195 25910 : *buf++ = (r - 10 * q) + '0';
196 25910 : if (q == 0)
197 : return buf;
198 25909 : r = (q * 0xcd) >> 11; /* q <= 999 */
199 25909 : *buf++ = (q - 10 * r) + '0';
200 25909 : if (r == 0)
201 : return buf;
202 20646 : q = (r * 0xcd) >> 11; /* r <= 99 */
203 20646 : *buf++ = (r - 10 * q) + '0';
204 20646 : if (q == 0)
205 : return buf;
206 14034 : *buf++ = q + '0'; /* q <= 9 */
207 14034 : return buf;
208 : }
209 :
210 : /* There are two algorithms to print larger numbers.
211 : * One is generic: divide by 1000000000 and repeatedly print
212 : * groups of (up to) 9 digits. It's conceptually simple,
213 : * but requires a (unsigned long long) / 1000000000 division.
214 : *
215 : * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
216 : * manipulates them cleverly and generates groups of 4 decimal digits.
217 : * It so happens that it does NOT require long long division.
218 : *
219 : * If long is > 32 bits, division of 64-bit values is relatively easy,
220 : * and we will use the first algorithm.
221 : * If long long is > 64 bits (strange architecture with VERY large long long),
222 : * second algorithm can't be used, and we again use the first one.
223 : *
224 : * Else (if long is 32 bits and long long is 64 bits) we use second one.
225 : */
226 :
227 : #if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
228 :
229 : /* First algorithm: generic */
230 :
231 : static
232 : char *put_dec(char *buf, unsigned long long n)
233 : {
234 : if (n >= 100*1000*1000) {
235 : while (n >= 1000*1000*1000)
236 : buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
237 : if (n >= 100*1000*1000)
238 : return put_dec_full9(buf, n);
239 : }
240 : return put_dec_trunc8(buf, n);
241 : }
242 :
243 : #else
244 :
245 : /* Second algorithm: valid only for 64-bit long longs */
246 :
247 : /* See comment in put_dec_full9 for choice of constants */
248 : static noinline_for_stack
249 10686 : void put_dec_full4(char *buf, unsigned q)
250 : {
251 : unsigned r;
252 10686 : r = (q * 0xccd) >> 15;
253 10686 : buf[0] = (q - 10 * r) + '0';
254 10686 : q = (r * 0xcd) >> 11;
255 10686 : buf[1] = (r - 10 * q) + '0';
256 10686 : r = (q * 0xcd) >> 11;
257 10686 : buf[2] = (q - 10 * r) + '0';
258 10686 : buf[3] = r + '0';
259 10686 : }
260 :
261 : /*
262 : * Call put_dec_full4 on x % 10000, return x / 10000.
263 : * The approximation x/10000 == (x * 0x346DC5D7) >> 43
264 : * holds for all x < 1,128,869,999. The largest value this
265 : * helper will ever be asked to convert is 1,125,520,955.
266 : * (d1 in the put_dec code, assuming n is all-ones).
267 : */
268 : static
269 : unsigned put_dec_helper4(char *buf, unsigned x)
270 : {
271 10686 : uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
272 :
273 10686 : put_dec_full4(buf, x - q * 10000);
274 : return q;
275 : }
276 :
277 : /* Based on code by Douglas W. Jones found at
278 : * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
279 : * (with permission from the author).
280 : * Performs no 64-bit division and hence should be fast on 32-bit machines.
281 : */
282 : static
283 29471 : char *put_dec(char *buf, unsigned long long n)
284 : {
285 : uint32_t d3, d2, d1, q, h;
286 :
287 29471 : if (n < 100*1000*1000)
288 25909 : return put_dec_trunc8(buf, n);
289 :
290 3562 : d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
291 3562 : h = (n >> 32);
292 3562 : d2 = (h ) & 0xffff;
293 3562 : d3 = (h >> 16); /* implicit "& 0xffff" */
294 :
295 3562 : q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
296 : q = put_dec_helper4(buf, q);
297 :
298 3562 : q += 7671 * d3 + 9496 * d2 + 6 * d1;
299 3562 : q = put_dec_helper4(buf+4, q);
300 :
301 3562 : q += 4749 * d3 + 42 * d2;
302 3562 : q = put_dec_helper4(buf+8, q);
303 :
304 3562 : q += 281 * d3;
305 3562 : buf += 12;
306 3562 : if (q)
307 1 : buf = put_dec_trunc8(buf, q);
308 10705 : else while (buf[-1] == '0')
309 7144 : --buf;
310 :
311 3562 : return buf;
312 : }
313 :
314 : #endif
315 :
316 : /*
317 : * Convert passed number to decimal string.
318 : * Returns the length of string. On buffer overflow, returns 0.
319 : *
320 : * If speed is not important, use snprintf(). It's easy to read the code.
321 : */
322 12538 : int num_to_str(char *buf, int size, unsigned long long num)
323 : {
324 : char tmp[sizeof(num) * 3];
325 : int idx, len;
326 :
327 : /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
328 12538 : if (num <= 9) {
329 0 : tmp[0] = '0' + num;
330 : len = 1;
331 : } else {
332 12538 : len = put_dec(tmp, num) - tmp;
333 : }
334 :
335 12538 : if (len > size)
336 : return 0;
337 69558 : for (idx = 0; idx < len; ++idx)
338 69558 : buf[idx] = tmp[len - idx - 1];
339 : return len;
340 : }
341 :
342 : #define ZEROPAD 1 /* pad with zero */
343 : #define SIGN 2 /* unsigned/signed long */
344 : #define PLUS 4 /* show plus */
345 : #define SPACE 8 /* space if plus */
346 : #define LEFT 16 /* left justified */
347 : #define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */
348 : #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */
349 :
350 : enum format_type {
351 : FORMAT_TYPE_NONE, /* Just a string part */
352 : FORMAT_TYPE_WIDTH,
353 : FORMAT_TYPE_PRECISION,
354 : FORMAT_TYPE_CHAR,
355 : FORMAT_TYPE_STR,
356 : FORMAT_TYPE_PTR,
357 : FORMAT_TYPE_PERCENT_CHAR,
358 : FORMAT_TYPE_INVALID,
359 : FORMAT_TYPE_LONG_LONG,
360 : FORMAT_TYPE_ULONG,
361 : FORMAT_TYPE_LONG,
362 : FORMAT_TYPE_UBYTE,
363 : FORMAT_TYPE_BYTE,
364 : FORMAT_TYPE_USHORT,
365 : FORMAT_TYPE_SHORT,
366 : FORMAT_TYPE_UINT,
367 : FORMAT_TYPE_INT,
368 : FORMAT_TYPE_SIZE_T,
369 : FORMAT_TYPE_PTRDIFF
370 : };
371 :
372 : struct printf_spec {
373 : u8 type; /* format_type enum */
374 : u8 flags; /* flags to number() */
375 : u8 base; /* number base, 8, 10 or 16 only */
376 : u8 qualifier; /* number qualifier, one of 'hHlLtzZ' */
377 : s16 field_width; /* width of output field */
378 : s16 precision; /* # of digits/chars */
379 : };
380 :
381 : static noinline_for_stack
382 47939 : char *number(char *buf, char *end, unsigned long long num,
383 : struct printf_spec spec)
384 : {
385 : /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
386 : static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
387 :
388 : char tmp[66];
389 : char sign;
390 : char locase;
391 47939 : int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
392 : int i;
393 47939 : bool is_zero = num == 0LL;
394 :
395 : /* locase = 0 or 0x20. ORing digits or letters with 'locase'
396 : * produces same digits or (maybe lowercased) letters */
397 47939 : locase = (spec.flags & SMALL);
398 47939 : if (spec.flags & LEFT)
399 160 : spec.flags &= ~ZEROPAD;
400 : sign = 0;
401 47939 : if (spec.flags & SIGN) {
402 12147 : if ((signed long long)num < 0) {
403 : sign = '-';
404 6 : num = -(signed long long)num;
405 6 : spec.field_width--;
406 12141 : } else if (spec.flags & PLUS) {
407 : sign = '+';
408 0 : spec.field_width--;
409 12141 : } else if (spec.flags & SPACE) {
410 : sign = ' ';
411 0 : spec.field_width--;
412 : }
413 : }
414 47939 : if (need_pfx) {
415 42 : if (spec.base == 16)
416 2 : spec.field_width -= 2;
417 40 : else if (!is_zero)
418 40 : spec.field_width--;
419 : }
420 :
421 : /* generate full string in tmp[], in reverse order */
422 : i = 0;
423 47939 : if (num < spec.base)
424 28959 : tmp[i++] = digits[num] | locase;
425 : /* Generic code, for any base:
426 : else do {
427 : tmp[i++] = (digits[do_div(num,base)] | locase);
428 : } while (num != 0);
429 : */
430 18980 : else if (spec.base != 10) { /* 8 or 16 */
431 2047 : int mask = spec.base - 1;
432 : int shift = 3;
433 :
434 2047 : if (spec.base == 16)
435 : shift = 4;
436 : do {
437 8809 : tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
438 8809 : num >>= shift;
439 8809 : } while (num);
440 : } else { /* base 10 */
441 16933 : i = put_dec(tmp, num) - tmp;
442 : }
443 :
444 : /* printing 100 using %2d gives "100", not "00" */
445 47939 : if (i > spec.precision)
446 47939 : spec.precision = i;
447 : /* leading space padding */
448 47939 : spec.field_width -= spec.precision;
449 47939 : if (!(spec.flags & (ZEROPAD+LEFT))) {
450 89083 : while (--spec.field_width >= 0) {
451 45062 : if (buf < end)
452 40848 : *buf = ' ';
453 45062 : ++buf;
454 : }
455 : }
456 : /* sign */
457 47939 : if (sign) {
458 6 : if (buf < end)
459 6 : *buf = sign;
460 6 : ++buf;
461 : }
462 : /* "0x" / "0" prefix */
463 47939 : if (need_pfx) {
464 42 : if (spec.base == 16 || !is_zero) {
465 42 : if (buf < end)
466 42 : *buf = '0';
467 42 : ++buf;
468 : }
469 42 : if (spec.base == 16) {
470 2 : if (buf < end)
471 2 : *buf = ('X' | locase);
472 2 : ++buf;
473 : }
474 : }
475 : /* zero or space padding */
476 47939 : if (!(spec.flags & LEFT)) {
477 47779 : char c = (spec.flags & ZEROPAD) ? '0' : ' ';
478 56764 : while (--spec.field_width >= 0) {
479 8985 : if (buf < end)
480 8809 : *buf = c;
481 8985 : ++buf;
482 : }
483 : }
484 : /* hmm even more zero padding? */
485 47939 : while (i <= --spec.precision) {
486 0 : if (buf < end)
487 0 : *buf = '0';
488 0 : ++buf;
489 : }
490 : /* actual digits of result */
491 149681 : while (--i >= 0) {
492 101742 : if (buf < end)
493 100051 : *buf = tmp[i];
494 101742 : ++buf;
495 : }
496 : /* trailing space padding */
497 50559 : while (--spec.field_width >= 0) {
498 2620 : if (buf < end)
499 2620 : *buf = ' ';
500 2620 : ++buf;
501 : }
502 :
503 47939 : return buf;
504 : }
505 :
506 : static noinline_for_stack
507 35982 : char *string(char *buf, char *end, const char *s, struct printf_spec spec)
508 : {
509 : int len, i;
510 :
511 35982 : if ((unsigned long)s < PAGE_SIZE)
512 : s = "(null)";
513 :
514 35982 : len = strnlen(s, spec.precision);
515 :
516 35982 : if (!(spec.flags & LEFT)) {
517 35532 : while (len < spec.field_width--) {
518 70 : if (buf < end)
519 70 : *buf = ' ';
520 70 : ++buf;
521 : }
522 : }
523 374345 : for (i = 0; i < len; ++i) {
524 374345 : if (buf < end)
525 301475 : *buf = *s;
526 374345 : ++buf; ++s;
527 : }
528 40443 : while (len < spec.field_width--) {
529 4461 : if (buf < end)
530 4461 : *buf = ' ';
531 4461 : ++buf;
532 : }
533 :
534 35982 : return buf;
535 : }
536 :
537 0 : static void widen(char *buf, char *end, unsigned len, unsigned spaces)
538 : {
539 : size_t size;
540 0 : if (buf >= end) /* nowhere to put anything */
541 : return;
542 0 : size = end - buf;
543 0 : if (size <= spaces) {
544 0 : memset(buf, ' ', size);
545 : return;
546 : }
547 0 : if (len) {
548 0 : if (len > size - spaces)
549 : len = size - spaces;
550 0 : memmove(buf + spaces, buf, len);
551 : }
552 0 : memset(buf, ' ', spaces);
553 : }
554 :
555 : static noinline_for_stack
556 0 : char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,
557 : const char *fmt)
558 : {
559 : const char *array[4], *s;
560 : const struct dentry *p;
561 : int depth;
562 : int i, n;
563 :
564 0 : switch (fmt[1]) {
565 : case '2': case '3': case '4':
566 0 : depth = fmt[1] - '0';
567 : break;
568 : default:
569 : depth = 1;
570 : }
571 :
572 : rcu_read_lock();
573 0 : for (i = 0; i < depth; i++, d = p) {
574 0 : p = ACCESS_ONCE(d->d_parent);
575 0 : array[i] = ACCESS_ONCE(d->d_name.name);
576 0 : if (p == d) {
577 0 : if (i)
578 0 : array[i] = "";
579 0 : i++;
580 : break;
581 : }
582 : }
583 0 : s = array[--i];
584 0 : for (n = 0; n != spec.precision; n++, buf++) {
585 0 : char c = *s++;
586 0 : if (!c) {
587 0 : if (!i)
588 : break;
589 : c = '/';
590 0 : s = array[--i];
591 : }
592 0 : if (buf < end)
593 0 : *buf = c;
594 : }
595 : rcu_read_unlock();
596 0 : if (n < spec.field_width) {
597 : /* we want to pad the sucker */
598 0 : unsigned spaces = spec.field_width - n;
599 0 : if (!(spec.flags & LEFT)) {
600 0 : widen(buf - n, end, n, spaces);
601 0 : return buf + spaces;
602 : }
603 0 : while (spaces--) {
604 0 : if (buf < end)
605 0 : *buf = ' ';
606 0 : ++buf;
607 : }
608 : }
609 : return buf;
610 : }
611 :
612 : static noinline_for_stack
613 0 : char *symbol_string(char *buf, char *end, void *ptr,
614 0 : struct printf_spec spec, const char *fmt)
615 : {
616 : unsigned long value;
617 : #ifdef CONFIG_KALLSYMS
618 : char sym[KSYM_SYMBOL_LEN];
619 : #endif
620 :
621 0 : if (fmt[1] == 'R')
622 0 : ptr = __builtin_extract_return_addr(ptr);
623 0 : value = (unsigned long)ptr;
624 :
625 : #ifdef CONFIG_KALLSYMS
626 : if (*fmt == 'B')
627 : sprint_backtrace(sym, value);
628 : else if (*fmt != 'f' && *fmt != 's')
629 : sprint_symbol(sym, value);
630 : else
631 : sprint_symbol_no_offset(sym, value);
632 :
633 : return string(buf, end, sym, spec);
634 : #else
635 : spec.field_width = 2 * sizeof(void *);
636 0 : spec.flags |= SPECIAL | SMALL | ZEROPAD;
637 : spec.base = 16;
638 :
639 0 : return number(buf, end, value, spec);
640 : #endif
641 : }
642 :
643 : static noinline_for_stack
644 0 : char *resource_string(char *buf, char *end, struct resource *res,
645 0 : struct printf_spec spec, const char *fmt)
646 : {
647 : #ifndef IO_RSRC_PRINTK_SIZE
648 : #define IO_RSRC_PRINTK_SIZE 6
649 : #endif
650 :
651 : #ifndef MEM_RSRC_PRINTK_SIZE
652 : #define MEM_RSRC_PRINTK_SIZE 10
653 : #endif
654 : static const struct printf_spec io_spec = {
655 : .base = 16,
656 : .field_width = IO_RSRC_PRINTK_SIZE,
657 : .precision = -1,
658 : .flags = SPECIAL | SMALL | ZEROPAD,
659 : };
660 : static const struct printf_spec mem_spec = {
661 : .base = 16,
662 : .field_width = MEM_RSRC_PRINTK_SIZE,
663 : .precision = -1,
664 : .flags = SPECIAL | SMALL | ZEROPAD,
665 : };
666 : static const struct printf_spec bus_spec = {
667 : .base = 16,
668 : .field_width = 2,
669 : .precision = -1,
670 : .flags = SMALL | ZEROPAD,
671 : };
672 : static const struct printf_spec dec_spec = {
673 : .base = 10,
674 : .precision = -1,
675 : .flags = 0,
676 : };
677 : static const struct printf_spec str_spec = {
678 : .field_width = -1,
679 : .precision = 10,
680 : .flags = LEFT,
681 : };
682 : static const struct printf_spec flag_spec = {
683 : .base = 16,
684 : .precision = -1,
685 : .flags = SPECIAL | SMALL,
686 : };
687 :
688 : /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
689 : * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
690 : #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
691 : #define FLAG_BUF_SIZE (2 * sizeof(res->flags))
692 : #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
693 : #define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
694 0 : char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
695 : 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
696 :
697 0 : char *p = sym, *pend = sym + sizeof(sym);
698 0 : int decode = (fmt[0] == 'R') ? 1 : 0;
699 : const struct printf_spec *specp;
700 :
701 0 : *p++ = '[';
702 0 : if (res->flags & IORESOURCE_IO) {
703 0 : p = string(p, pend, "io ", str_spec);
704 : specp = &io_spec;
705 0 : } else if (res->flags & IORESOURCE_MEM) {
706 0 : p = string(p, pend, "mem ", str_spec);
707 : specp = &mem_spec;
708 0 : } else if (res->flags & IORESOURCE_IRQ) {
709 0 : p = string(p, pend, "irq ", str_spec);
710 : specp = &dec_spec;
711 0 : } else if (res->flags & IORESOURCE_DMA) {
712 0 : p = string(p, pend, "dma ", str_spec);
713 : specp = &dec_spec;
714 0 : } else if (res->flags & IORESOURCE_BUS) {
715 0 : p = string(p, pend, "bus ", str_spec);
716 : specp = &bus_spec;
717 : } else {
718 0 : p = string(p, pend, "??? ", str_spec);
719 : specp = &mem_spec;
720 : decode = 0;
721 : }
722 0 : if (decode && res->flags & IORESOURCE_UNSET) {
723 0 : p = string(p, pend, "size ", str_spec);
724 0 : p = number(p, pend, resource_size(res), *specp);
725 : } else {
726 0 : p = number(p, pend, res->start, *specp);
727 0 : if (res->start != res->end) {
728 0 : *p++ = '-';
729 0 : p = number(p, pend, res->end, *specp);
730 : }
731 : }
732 0 : if (decode) {
733 0 : if (res->flags & IORESOURCE_MEM_64)
734 0 : p = string(p, pend, " 64bit", str_spec);
735 0 : if (res->flags & IORESOURCE_PREFETCH)
736 0 : p = string(p, pend, " pref", str_spec);
737 0 : if (res->flags & IORESOURCE_WINDOW)
738 0 : p = string(p, pend, " window", str_spec);
739 0 : if (res->flags & IORESOURCE_DISABLED)
740 0 : p = string(p, pend, " disabled", str_spec);
741 : } else {
742 0 : p = string(p, pend, " flags ", str_spec);
743 0 : p = number(p, pend, res->flags, flag_spec);
744 : }
745 0 : *p++ = ']';
746 0 : *p = '\0';
747 :
748 0 : return string(buf, end, sym, spec);
749 : }
750 :
751 : static noinline_for_stack
752 0 : char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
753 : const char *fmt)
754 : {
755 : int i, len = 1; /* if we pass '%ph[CDN]', field width remains
756 : negative value, fallback to the default */
757 : char separator;
758 :
759 0 : if (spec.field_width == 0)
760 : /* nothing to print */
761 : return buf;
762 :
763 0 : if (ZERO_OR_NULL_PTR(addr))
764 : /* NULL pointer */
765 0 : return string(buf, end, NULL, spec);
766 :
767 0 : switch (fmt[1]) {
768 : case 'C':
769 : separator = ':';
770 : break;
771 : case 'D':
772 : separator = '-';
773 : break;
774 : case 'N':
775 : separator = 0;
776 : break;
777 : default:
778 : separator = ' ';
779 : break;
780 : }
781 :
782 0 : if (spec.field_width > 0)
783 0 : len = min_t(int, spec.field_width, 64);
784 :
785 0 : for (i = 0; i < len && buf < end - 1; i++) {
786 0 : buf = hex_byte_pack(buf, addr[i]);
787 :
788 0 : if (buf < end && separator && i != len - 1)
789 0 : *buf++ = separator;
790 : }
791 :
792 : return buf;
793 : }
794 :
795 : static noinline_for_stack
796 1 : char *mac_address_string(char *buf, char *end, u8 *addr,
797 1 : struct printf_spec spec, const char *fmt)
798 : {
799 : char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
800 : char *p = mac_addr;
801 : int i;
802 : char separator;
803 : bool reversed = false;
804 :
805 1 : switch (fmt[1]) {
806 : case 'F':
807 : separator = '-';
808 : break;
809 :
810 : case 'R':
811 : reversed = true;
812 : /* fall through */
813 :
814 : default:
815 : separator = ':';
816 : break;
817 : }
818 :
819 6 : for (i = 0; i < 6; i++) {
820 6 : if (reversed)
821 0 : p = hex_byte_pack(p, addr[5 - i]);
822 : else
823 12 : p = hex_byte_pack(p, addr[i]);
824 :
825 6 : if (fmt[0] == 'M' && i != 5)
826 5 : *p++ = separator;
827 : }
828 1 : *p = '\0';
829 :
830 1 : return string(buf, end, mac_addr, spec);
831 : }
832 :
833 : static noinline_for_stack
834 0 : char *ip4_string(char *p, const u8 *addr, const char *fmt)
835 : {
836 : int i;
837 0 : bool leading_zeros = (fmt[0] == 'i');
838 : int index;
839 : int step;
840 :
841 0 : switch (fmt[2]) {
842 : case 'h':
843 : #ifdef __BIG_ENDIAN
844 : index = 0;
845 : step = 1;
846 : #else
847 : index = 3;
848 : step = -1;
849 : #endif
850 : break;
851 : case 'l':
852 : index = 3;
853 : step = -1;
854 : break;
855 : case 'n':
856 : case 'b':
857 : default:
858 : index = 0;
859 : step = 1;
860 0 : break;
861 : }
862 0 : for (i = 0; i < 4; i++) {
863 : char temp[3]; /* hold each IP quad in reverse order */
864 0 : int digits = put_dec_trunc8(temp, addr[index]) - temp;
865 0 : if (leading_zeros) {
866 0 : if (digits < 3)
867 0 : *p++ = '0';
868 0 : if (digits < 2)
869 0 : *p++ = '0';
870 : }
871 : /* reverse the digits in the quad */
872 0 : while (digits--)
873 0 : *p++ = temp[digits];
874 0 : if (i < 3)
875 0 : *p++ = '.';
876 0 : index += step;
877 : }
878 0 : *p = '\0';
879 :
880 0 : return p;
881 : }
882 :
883 : static noinline_for_stack
884 0 : char *ip6_compressed_string(char *p, const char *addr)
885 : {
886 : int i, j, range;
887 : unsigned char zerolength[8];
888 : int longest = 1;
889 : int colonpos = -1;
890 : u16 word;
891 : u8 hi, lo;
892 : bool needcolon = false;
893 : bool useIPv4;
894 : struct in6_addr in6;
895 :
896 0 : memcpy(&in6, addr, sizeof(struct in6_addr));
897 :
898 0 : useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
899 :
900 0 : memset(zerolength, 0, sizeof(zerolength));
901 :
902 0 : if (useIPv4)
903 : range = 6;
904 : else
905 : range = 8;
906 :
907 : /* find position of longest 0 run */
908 0 : for (i = 0; i < range; i++) {
909 0 : for (j = i; j < range; j++) {
910 0 : if (in6.s6_addr16[j] != 0)
911 : break;
912 0 : zerolength[i]++;
913 : }
914 : }
915 0 : for (i = 0; i < range; i++) {
916 0 : if (zerolength[i] > longest) {
917 : longest = zerolength[i];
918 : colonpos = i;
919 : }
920 : }
921 0 : if (longest == 1) /* don't compress a single 0 */
922 : colonpos = -1;
923 :
924 : /* emit address */
925 0 : for (i = 0; i < range; i++) {
926 0 : if (i == colonpos) {
927 0 : if (needcolon || i == 0)
928 0 : *p++ = ':';
929 0 : *p++ = ':';
930 : needcolon = false;
931 0 : i += longest - 1;
932 0 : continue;
933 : }
934 0 : if (needcolon) {
935 0 : *p++ = ':';
936 : needcolon = false;
937 : }
938 : /* hex u16 without leading 0s */
939 0 : word = ntohs(in6.s6_addr16[i]);
940 0 : hi = word >> 8;
941 0 : lo = word & 0xff;
942 0 : if (hi) {
943 0 : if (hi > 0x0f)
944 0 : p = hex_byte_pack(p, hi);
945 : else
946 0 : *p++ = hex_asc_lo(hi);
947 0 : p = hex_byte_pack(p, lo);
948 : }
949 0 : else if (lo > 0x0f)
950 0 : p = hex_byte_pack(p, lo);
951 : else
952 0 : *p++ = hex_asc_lo(lo);
953 : needcolon = true;
954 : }
955 :
956 0 : if (useIPv4) {
957 0 : if (needcolon)
958 0 : *p++ = ':';
959 0 : p = ip4_string(p, &in6.s6_addr[12], "I4");
960 : }
961 0 : *p = '\0';
962 :
963 0 : return p;
964 : }
965 :
966 : static noinline_for_stack
967 0 : char *ip6_string(char *p, const char *addr, const char *fmt)
968 : {
969 : int i;
970 :
971 0 : for (i = 0; i < 8; i++) {
972 0 : p = hex_byte_pack(p, *addr++);
973 0 : p = hex_byte_pack(p, *addr++);
974 0 : if (fmt[0] == 'I' && i != 7)
975 0 : *p++ = ':';
976 : }
977 0 : *p = '\0';
978 :
979 0 : return p;
980 : }
981 :
982 : static noinline_for_stack
983 0 : char *ip6_addr_string(char *buf, char *end, const u8 *addr,
984 0 : struct printf_spec spec, const char *fmt)
985 : {
986 : char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
987 :
988 0 : if (fmt[0] == 'I' && fmt[2] == 'c')
989 0 : ip6_compressed_string(ip6_addr, addr);
990 : else
991 0 : ip6_string(ip6_addr, addr, fmt);
992 :
993 0 : return string(buf, end, ip6_addr, spec);
994 : }
995 :
996 : static noinline_for_stack
997 0 : char *ip4_addr_string(char *buf, char *end, const u8 *addr,
998 0 : struct printf_spec spec, const char *fmt)
999 : {
1000 : char ip4_addr[sizeof("255.255.255.255")];
1001 :
1002 0 : ip4_string(ip4_addr, addr, fmt);
1003 :
1004 0 : return string(buf, end, ip4_addr, spec);
1005 : }
1006 :
1007 : static noinline_for_stack
1008 0 : char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
1009 : struct printf_spec spec, const char *fmt)
1010 : {
1011 : bool have_p = false, have_s = false, have_f = false, have_c = false;
1012 : char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
1013 : sizeof(":12345") + sizeof("/123456789") +
1014 : sizeof("%1234567890")];
1015 : char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);
1016 0 : const u8 *addr = (const u8 *) &sa->sin6_addr;
1017 0 : char fmt6[2] = { fmt[0], '6' };
1018 : u8 off = 0;
1019 :
1020 0 : fmt++;
1021 0 : while (isalpha(*++fmt)) {
1022 0 : switch (*fmt) {
1023 : case 'p':
1024 : have_p = true;
1025 : break;
1026 : case 'f':
1027 : have_f = true;
1028 : break;
1029 : case 's':
1030 : have_s = true;
1031 : break;
1032 : case 'c':
1033 : have_c = true;
1034 : break;
1035 : }
1036 : }
1037 :
1038 0 : if (have_p || have_s || have_f) {
1039 0 : *p = '[';
1040 : off = 1;
1041 : }
1042 :
1043 0 : if (fmt6[0] == 'I' && have_c)
1044 0 : p = ip6_compressed_string(ip6_addr + off, addr);
1045 : else
1046 0 : p = ip6_string(ip6_addr + off, addr, fmt6);
1047 :
1048 0 : if (have_p || have_s || have_f)
1049 0 : *p++ = ']';
1050 :
1051 0 : if (have_p) {
1052 0 : *p++ = ':';
1053 0 : p = number(p, pend, ntohs(sa->sin6_port), spec);
1054 : }
1055 0 : if (have_f) {
1056 0 : *p++ = '/';
1057 0 : p = number(p, pend, ntohl(sa->sin6_flowinfo &
1058 : IPV6_FLOWINFO_MASK), spec);
1059 : }
1060 0 : if (have_s) {
1061 0 : *p++ = '%';
1062 0 : p = number(p, pend, sa->sin6_scope_id, spec);
1063 : }
1064 0 : *p = '\0';
1065 :
1066 0 : return string(buf, end, ip6_addr, spec);
1067 : }
1068 :
1069 : static noinline_for_stack
1070 0 : char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
1071 0 : struct printf_spec spec, const char *fmt)
1072 : {
1073 : bool have_p = false;
1074 : char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];
1075 : char *pend = ip4_addr + sizeof(ip4_addr);
1076 0 : const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
1077 0 : char fmt4[3] = { fmt[0], '4', 0 };
1078 :
1079 0 : fmt++;
1080 0 : while (isalpha(*++fmt)) {
1081 : switch (*fmt) {
1082 : case 'p':
1083 : have_p = true;
1084 : break;
1085 : case 'h':
1086 : case 'l':
1087 : case 'n':
1088 : case 'b':
1089 0 : fmt4[2] = *fmt;
1090 : break;
1091 : }
1092 : }
1093 :
1094 0 : p = ip4_string(ip4_addr, addr, fmt4);
1095 0 : if (have_p) {
1096 0 : *p++ = ':';
1097 0 : p = number(p, pend, ntohs(sa->sin_port), spec);
1098 : }
1099 0 : *p = '\0';
1100 :
1101 0 : return string(buf, end, ip4_addr, spec);
1102 : }
1103 :
1104 : static noinline_for_stack
1105 0 : char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
1106 : const char *fmt)
1107 : {
1108 : bool found = true;
1109 : int count = 1;
1110 : unsigned int flags = 0;
1111 : int len;
1112 :
1113 0 : if (spec.field_width == 0)
1114 0 : return buf; /* nothing to print */
1115 :
1116 0 : if (ZERO_OR_NULL_PTR(addr))
1117 0 : return string(buf, end, NULL, spec); /* NULL pointer */
1118 :
1119 :
1120 : do {
1121 0 : switch (fmt[count++]) {
1122 : case 'a':
1123 0 : flags |= ESCAPE_ANY;
1124 : break;
1125 : case 'c':
1126 0 : flags |= ESCAPE_SPECIAL;
1127 : break;
1128 : case 'h':
1129 0 : flags |= ESCAPE_HEX;
1130 : break;
1131 : case 'n':
1132 0 : flags |= ESCAPE_NULL;
1133 : break;
1134 : case 'o':
1135 0 : flags |= ESCAPE_OCTAL;
1136 : break;
1137 : case 'p':
1138 0 : flags |= ESCAPE_NP;
1139 : break;
1140 : case 's':
1141 0 : flags |= ESCAPE_SPACE;
1142 : break;
1143 : default:
1144 : found = false;
1145 : break;
1146 : }
1147 0 : } while (found);
1148 :
1149 0 : if (!flags)
1150 : flags = ESCAPE_ANY_NP;
1151 :
1152 0 : len = spec.field_width < 0 ? 1 : spec.field_width;
1153 :
1154 : /* Ignore the error. We print as many characters as we can */
1155 0 : string_escape_mem(addr, len, &buf, end - buf, flags, NULL);
1156 :
1157 0 : return buf;
1158 : }
1159 :
1160 : static noinline_for_stack
1161 0 : char *uuid_string(char *buf, char *end, const u8 *addr,
1162 0 : struct printf_spec spec, const char *fmt)
1163 : {
1164 : char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
1165 : char *p = uuid;
1166 : int i;
1167 : static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
1168 : static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
1169 : const u8 *index = be;
1170 : bool uc = false;
1171 :
1172 0 : switch (*(++fmt)) {
1173 : case 'L':
1174 : uc = true; /* fall-through */
1175 : case 'l':
1176 : index = le;
1177 : break;
1178 : case 'B':
1179 : uc = true;
1180 : break;
1181 : }
1182 :
1183 0 : for (i = 0; i < 16; i++) {
1184 0 : p = hex_byte_pack(p, addr[index[i]]);
1185 : switch (i) {
1186 : case 3:
1187 : case 5:
1188 : case 7:
1189 : case 9:
1190 0 : *p++ = '-';
1191 : break;
1192 : }
1193 : }
1194 :
1195 0 : *p = 0;
1196 :
1197 0 : if (uc) {
1198 : p = uuid;
1199 : do {
1200 0 : *p = toupper(*p);
1201 0 : } while (*(++p));
1202 : }
1203 :
1204 0 : return string(buf, end, uuid, spec);
1205 : }
1206 :
1207 : static
1208 0 : char *netdev_feature_string(char *buf, char *end, const u8 *addr,
1209 0 : struct printf_spec spec)
1210 : {
1211 0 : spec.flags |= SPECIAL | SMALL | ZEROPAD;
1212 0 : if (spec.field_width == -1)
1213 : spec.field_width = 2 + 2 * sizeof(netdev_features_t);
1214 : spec.base = 16;
1215 :
1216 0 : return number(buf, end, *(const netdev_features_t *)addr, spec);
1217 : }
1218 :
1219 : static noinline_for_stack
1220 2 : char *address_val(char *buf, char *end, const void *addr,
1221 2 : struct printf_spec spec, const char *fmt)
1222 : {
1223 : unsigned long long num;
1224 :
1225 2 : spec.flags |= SPECIAL | SMALL | ZEROPAD;
1226 : spec.base = 16;
1227 :
1228 2 : switch (fmt[1]) {
1229 : case 'd':
1230 0 : num = *(const dma_addr_t *)addr;
1231 : spec.field_width = sizeof(dma_addr_t) * 2 + 2;
1232 : break;
1233 : case 'p':
1234 : default:
1235 2 : num = *(const phys_addr_t *)addr;
1236 : spec.field_width = sizeof(phys_addr_t) * 2 + 2;
1237 : break;
1238 : }
1239 :
1240 2 : return number(buf, end, num, spec);
1241 : }
1242 :
1243 : int kptr_restrict __read_mostly;
1244 :
1245 : /*
1246 : * Show a '%p' thing. A kernel extension is that the '%p' is followed
1247 : * by an extra set of alphanumeric characters that are extended format
1248 : * specifiers.
1249 : *
1250 : * Right now we handle:
1251 : *
1252 : * - 'F' For symbolic function descriptor pointers with offset
1253 : * - 'f' For simple symbolic function names without offset
1254 : * - 'S' For symbolic direct pointers with offset
1255 : * - 's' For symbolic direct pointers without offset
1256 : * - '[FfSs]R' as above with __builtin_extract_return_addr() translation
1257 : * - 'B' For backtraced symbolic direct pointers with offset
1258 : * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
1259 : * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
1260 : * - 'M' For a 6-byte MAC address, it prints the address in the
1261 : * usual colon-separated hex notation
1262 : * - 'm' For a 6-byte MAC address, it prints the hex address without colons
1263 : * - 'MF' For a 6-byte MAC FDDI address, it prints the address
1264 : * with a dash-separated hex notation
1265 : * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)
1266 : * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
1267 : * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
1268 : * IPv6 uses colon separated network-order 16 bit hex with leading 0's
1269 : * [S][pfs]
1270 : * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to
1271 : * [4] or [6] and is able to print port [p], flowinfo [f], scope [s]
1272 : * - 'i' [46] for 'raw' IPv4/IPv6 addresses
1273 : * IPv6 omits the colons (01020304...0f)
1274 : * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
1275 : * [S][pfs]
1276 : * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to
1277 : * [4] or [6] and is able to print port [p], flowinfo [f], scope [s]
1278 : * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order
1279 : * - 'I[6S]c' for IPv6 addresses printed as specified by
1280 : * http://tools.ietf.org/html/rfc5952
1281 : * - 'E[achnops]' For an escaped buffer, where rules are defined by combination
1282 : * of the following flags (see string_escape_mem() for the
1283 : * details):
1284 : * a - ESCAPE_ANY
1285 : * c - ESCAPE_SPECIAL
1286 : * h - ESCAPE_HEX
1287 : * n - ESCAPE_NULL
1288 : * o - ESCAPE_OCTAL
1289 : * p - ESCAPE_NP
1290 : * s - ESCAPE_SPACE
1291 : * By default ESCAPE_ANY_NP is used.
1292 : * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
1293 : * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
1294 : * Options for %pU are:
1295 : * b big endian lower case hex (default)
1296 : * B big endian UPPER case hex
1297 : * l little endian lower case hex
1298 : * L little endian UPPER case hex
1299 : * big endian output byte order is:
1300 : * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
1301 : * little endian output byte order is:
1302 : * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
1303 : * - 'V' For a struct va_format which contains a format string * and va_list *,
1304 : * call vsnprintf(->format, *->va_list).
1305 : * Implements a "recursive vsnprintf".
1306 : * Do not use this feature without some mechanism to verify the
1307 : * correctness of the format string and va_list arguments.
1308 : * - 'K' For a kernel pointer that should be hidden from unprivileged users
1309 : * - 'NF' For a netdev_features_t
1310 : * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
1311 : * a certain separator (' ' by default):
1312 : * C colon
1313 : * D dash
1314 : * N no separator
1315 : * The maximum supported length is 64 bytes of the input. Consider
1316 : * to use print_hex_dump() for the larger input.
1317 : * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives
1318 : * (default assumed to be phys_addr_t, passed by reference)
1319 : * - 'd[234]' For a dentry name (optionally 2-4 last components)
1320 : * - 'D[234]' Same as 'd' but for a struct file
1321 : *
1322 : * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
1323 : * function pointers are really function descriptors, which contain a
1324 : * pointer to the real address.
1325 : */
1326 : static noinline_for_stack
1327 63 : char *pointer(const char *fmt, char *buf, char *end, void *ptr,
1328 : struct printf_spec spec)
1329 : {
1330 63 : int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
1331 :
1332 63 : if (!ptr && *fmt != 'K') {
1333 : /*
1334 : * Print (null) with the same width as a pointer so it makes
1335 : * tabular output look nice.
1336 : */
1337 0 : if (spec.field_width == -1)
1338 0 : spec.field_width = default_width;
1339 0 : return string(buf, end, "(null)", spec);
1340 : }
1341 :
1342 63 : switch (*fmt) {
1343 : case 'F':
1344 : case 'f':
1345 : ptr = dereference_function_descriptor(ptr);
1346 : /* Fallthrough */
1347 : case 'S':
1348 : case 's':
1349 : case 'B':
1350 0 : return symbol_string(buf, end, ptr, spec, fmt);
1351 : case 'R':
1352 : case 'r':
1353 0 : return resource_string(buf, end, ptr, spec, fmt);
1354 : case 'h':
1355 0 : return hex_string(buf, end, ptr, spec, fmt);
1356 : case 'M': /* Colon separated: 00:01:02:03:04:05 */
1357 : case 'm': /* Contiguous: 000102030405 */
1358 : /* [mM]F (FDDI) */
1359 : /* [mM]R (Reverse order; Bluetooth) */
1360 1 : return mac_address_string(buf, end, ptr, spec, fmt);
1361 : case 'I': /* Formatted IP supported
1362 : * 4: 1.2.3.4
1363 : * 6: 0001:0203:...:0708
1364 : * 6c: 1::708 or 1::1.2.3.4
1365 : */
1366 : case 'i': /* Contiguous:
1367 : * 4: 001.002.003.004
1368 : * 6: 000102...0f
1369 : */
1370 0 : switch (fmt[1]) {
1371 : case '6':
1372 0 : return ip6_addr_string(buf, end, ptr, spec, fmt);
1373 : case '4':
1374 0 : return ip4_addr_string(buf, end, ptr, spec, fmt);
1375 : case 'S': {
1376 : const union {
1377 : struct sockaddr raw;
1378 : struct sockaddr_in v4;
1379 : struct sockaddr_in6 v6;
1380 : } *sa = ptr;
1381 :
1382 0 : switch (sa->raw.sa_family) {
1383 : case AF_INET:
1384 0 : return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
1385 : case AF_INET6:
1386 0 : return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
1387 : default:
1388 0 : return string(buf, end, "(invalid address)", spec);
1389 : }}
1390 : }
1391 : break;
1392 : case 'E':
1393 0 : return escaped_string(buf, end, ptr, spec, fmt);
1394 : case 'U':
1395 0 : return uuid_string(buf, end, ptr, spec, fmt);
1396 : case 'V':
1397 : {
1398 : va_list va;
1399 :
1400 47 : va_copy(va, *((struct va_format *)ptr)->va);
1401 47 : buf += vsnprintf(buf, end > buf ? end - buf : 0,
1402 : ((struct va_format *)ptr)->fmt, va);
1403 47 : va_end(va);
1404 : return buf;
1405 : }
1406 : case 'K':
1407 : /*
1408 : * %pK cannot be used in IRQ context because its test
1409 : * for CAP_SYSLOG would be meaningless.
1410 : */
1411 0 : if (kptr_restrict && (in_irq() || in_serving_softirq() ||
1412 0 : in_nmi())) {
1413 0 : if (spec.field_width == -1)
1414 0 : spec.field_width = default_width;
1415 0 : return string(buf, end, "pK-error", spec);
1416 : }
1417 :
1418 0 : switch (kptr_restrict) {
1419 : case 0:
1420 : /* Always print %pK values */
1421 : break;
1422 : case 1: {
1423 : /*
1424 : * Only print the real pointer value if the current
1425 : * process has CAP_SYSLOG and is running with the
1426 : * same credentials it started with. This is because
1427 : * access to files is checked at open() time, but %pK
1428 : * checks permission at read() time. We don't want to
1429 : * leak pointer values if a binary opens a file using
1430 : * %pK and then elevates privileges before reading it.
1431 : */
1432 0 : const struct cred *cred = current_cred();
1433 :
1434 0 : if (!has_capability_noaudit(current, CAP_SYSLOG) ||
1435 0 : !uid_eq(cred->euid, cred->uid) ||
1436 : !gid_eq(cred->egid, cred->gid))
1437 : ptr = NULL;
1438 : break;
1439 : }
1440 : case 2:
1441 : default:
1442 : /* Always print 0's for %pK */
1443 : ptr = NULL;
1444 : break;
1445 : }
1446 : break;
1447 :
1448 : case 'N':
1449 0 : switch (fmt[1]) {
1450 : case 'F':
1451 0 : return netdev_feature_string(buf, end, ptr, spec);
1452 : }
1453 : break;
1454 : case 'a':
1455 2 : return address_val(buf, end, ptr, spec, fmt);
1456 : case 'd':
1457 0 : return dentry_name(buf, end, ptr, spec, fmt);
1458 : case 'D':
1459 0 : return dentry_name(buf, end,
1460 0 : ((const struct file *)ptr)->f_path.dentry,
1461 : spec, fmt);
1462 : }
1463 13 : spec.flags |= SMALL;
1464 13 : if (spec.field_width == -1) {
1465 13 : spec.field_width = default_width;
1466 13 : spec.flags |= ZEROPAD;
1467 : }
1468 : spec.base = 16;
1469 :
1470 13 : return number(buf, end, (unsigned long) ptr, spec);
1471 : }
1472 :
1473 : /*
1474 : * Helper function to decode printf style format.
1475 : * Each call decode a token from the format and return the
1476 : * number of characters read (or likely the delta where it wants
1477 : * to go on the next call).
1478 : * The decoded token is returned through the parameters
1479 : *
1480 : * 'h', 'l', or 'L' for integer fields
1481 : * 'z' support added 23/7/1999 S.H.
1482 : * 'z' changed to 'Z' --davidm 1/25/99
1483 : * 't' added for ptrdiff_t
1484 : *
1485 : * @fmt: the format string
1486 : * @type of the token returned
1487 : * @flags: various flags such as +, -, # tokens..
1488 : * @field_width: overwritten width
1489 : * @base: base of the number (octal, hex, ...)
1490 : * @precision: precision of a number
1491 : * @qualifier: qualifier of a number (long, size_t, ...)
1492 : */
1493 : static noinline_for_stack
1494 144587 : int format_decode(const char *fmt, struct printf_spec *spec)
1495 : {
1496 144587 : const char *start = fmt;
1497 :
1498 : /* we finished early by reading the field width */
1499 144587 : if (spec->type == FORMAT_TYPE_WIDTH) {
1500 199 : if (spec->field_width < 0) {
1501 0 : spec->field_width = -spec->field_width;
1502 0 : spec->flags |= LEFT;
1503 : }
1504 199 : spec->type = FORMAT_TYPE_NONE;
1505 199 : goto precision;
1506 : }
1507 :
1508 : /* we finished early by reading the precision */
1509 144388 : if (spec->type == FORMAT_TYPE_PRECISION) {
1510 1 : if (spec->precision < 0)
1511 0 : spec->precision = 0;
1512 :
1513 1 : spec->type = FORMAT_TYPE_NONE;
1514 1 : goto qualifier;
1515 : }
1516 :
1517 : /* By default */
1518 144387 : spec->type = FORMAT_TYPE_NONE;
1519 :
1520 474104 : for (; *fmt ; ++fmt) {
1521 455725 : if (*fmt == '%')
1522 : break;
1523 : }
1524 :
1525 : /* Return the current non-format string */
1526 144387 : if (fmt != start || !*fmt)
1527 59546 : return fmt - start;
1528 :
1529 : /* Process flags */
1530 84841 : spec->flags = 0;
1531 :
1532 : while (1) { /* this also skips first '%' */
1533 : bool found = true;
1534 :
1535 89295 : ++fmt;
1536 :
1537 89295 : switch (*fmt) {
1538 680 : case '-': spec->flags |= LEFT; break;
1539 0 : case '+': spec->flags |= PLUS; break;
1540 0 : case ' ': spec->flags |= SPACE; break;
1541 40 : case '#': spec->flags |= SPECIAL; break;
1542 3734 : case '0': spec->flags |= ZEROPAD; break;
1543 : default: found = false;
1544 : }
1545 :
1546 89295 : if (!found)
1547 : break;
1548 : }
1549 :
1550 : /* get field width */
1551 84841 : spec->field_width = -1;
1552 :
1553 84841 : if (isdigit(*fmt))
1554 14831 : spec->field_width = skip_atoi(&fmt);
1555 70010 : else if (*fmt == '*') {
1556 : /* it's the next argument */
1557 199 : spec->type = FORMAT_TYPE_WIDTH;
1558 199 : return ++fmt - start;
1559 : }
1560 :
1561 : precision:
1562 : /* get the precision */
1563 84841 : spec->precision = -1;
1564 84841 : if (*fmt == '.') {
1565 1 : ++fmt;
1566 1 : if (isdigit(*fmt)) {
1567 0 : spec->precision = skip_atoi(&fmt);
1568 0 : if (spec->precision < 0)
1569 0 : spec->precision = 0;
1570 1 : } else if (*fmt == '*') {
1571 : /* it's the next argument */
1572 1 : spec->type = FORMAT_TYPE_PRECISION;
1573 1 : return ++fmt - start;
1574 : }
1575 : }
1576 :
1577 : qualifier:
1578 : /* get the conversion qualifier */
1579 84841 : spec->qualifier = -1;
1580 169627 : if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
1581 69866 : _tolower(*fmt) == 'z' || *fmt == 't') {
1582 14979 : spec->qualifier = *fmt++;
1583 14979 : if (unlikely(spec->qualifier == *fmt)) {
1584 1302 : if (spec->qualifier == 'l') {
1585 1302 : spec->qualifier = 'L';
1586 1302 : ++fmt;
1587 0 : } else if (spec->qualifier == 'h') {
1588 0 : spec->qualifier = 'H';
1589 0 : ++fmt;
1590 : }
1591 : }
1592 : }
1593 :
1594 : /* default base */
1595 84841 : spec->base = 10;
1596 84841 : switch (*fmt) {
1597 : case 'c':
1598 873 : spec->type = FORMAT_TYPE_CHAR;
1599 873 : return ++fmt - start;
1600 :
1601 : case 's':
1602 35981 : spec->type = FORMAT_TYPE_STR;
1603 35981 : return ++fmt - start;
1604 :
1605 : case 'p':
1606 63 : spec->type = FORMAT_TYPE_PTR;
1607 63 : return fmt - start;
1608 : /* skip alnum */
1609 :
1610 : case '%':
1611 0 : spec->type = FORMAT_TYPE_PERCENT_CHAR;
1612 0 : return ++fmt - start;
1613 :
1614 : /* integer number formats - set up the flags and "break" */
1615 : case 'o':
1616 156 : spec->base = 8;
1617 156 : break;
1618 :
1619 : case 'x':
1620 17837 : spec->flags |= SMALL;
1621 :
1622 : case 'X':
1623 18528 : spec->base = 16;
1624 18528 : break;
1625 :
1626 : case 'd':
1627 : case 'i':
1628 12147 : spec->flags |= SIGN;
1629 : case 'u':
1630 : break;
1631 :
1632 : case 'n':
1633 : /*
1634 : * Since %n poses a greater security risk than utility, treat
1635 : * it as an invalid format specifier. Warn about its use so
1636 : * that new instances don't get added.
1637 : */
1638 : WARN_ONCE(1, "Please remove ignored %%n in '%s'\n", fmt);
1639 : /* Fall-through */
1640 :
1641 : default:
1642 0 : spec->type = FORMAT_TYPE_INVALID;
1643 0 : return fmt - start;
1644 : }
1645 :
1646 47924 : if (spec->qualifier == 'L')
1647 1302 : spec->type = FORMAT_TYPE_LONG_LONG;
1648 46622 : else if (spec->qualifier == 'l') {
1649 13611 : if (spec->flags & SIGN)
1650 31 : spec->type = FORMAT_TYPE_LONG;
1651 : else
1652 13580 : spec->type = FORMAT_TYPE_ULONG;
1653 33011 : } else if (_tolower(spec->qualifier) == 'z') {
1654 7 : spec->type = FORMAT_TYPE_SIZE_T;
1655 33004 : } else if (spec->qualifier == 't') {
1656 4 : spec->type = FORMAT_TYPE_PTRDIFF;
1657 33000 : } else if (spec->qualifier == 'H') {
1658 0 : if (spec->flags & SIGN)
1659 0 : spec->type = FORMAT_TYPE_BYTE;
1660 : else
1661 0 : spec->type = FORMAT_TYPE_UBYTE;
1662 33000 : } else if (spec->qualifier == 'h') {
1663 55 : if (spec->flags & SIGN)
1664 1 : spec->type = FORMAT_TYPE_SHORT;
1665 : else
1666 54 : spec->type = FORMAT_TYPE_USHORT;
1667 : } else {
1668 32945 : if (spec->flags & SIGN)
1669 12108 : spec->type = FORMAT_TYPE_INT;
1670 : else
1671 20837 : spec->type = FORMAT_TYPE_UINT;
1672 : }
1673 :
1674 47924 : return ++fmt - start;
1675 : }
1676 :
1677 : /**
1678 : * vsnprintf - Format a string and place it in a buffer
1679 : * @buf: The buffer to place the result into
1680 : * @size: The size of the buffer, including the trailing null space
1681 : * @fmt: The format string to use
1682 : * @args: Arguments for the format string
1683 : *
1684 : * This function follows C99 vsnprintf, but has some extensions:
1685 : * %pS output the name of a text symbol with offset
1686 : * %ps output the name of a text symbol without offset
1687 : * %pF output the name of a function pointer with its offset
1688 : * %pf output the name of a function pointer without its offset
1689 : * %pB output the name of a backtrace symbol with its offset
1690 : * %pR output the address range in a struct resource with decoded flags
1691 : * %pr output the address range in a struct resource with raw flags
1692 : * %pM output a 6-byte MAC address with colons
1693 : * %pMR output a 6-byte MAC address with colons in reversed order
1694 : * %pMF output a 6-byte MAC address with dashes
1695 : * %pm output a 6-byte MAC address without colons
1696 : * %pmR output a 6-byte MAC address without colons in reversed order
1697 : * %pI4 print an IPv4 address without leading zeros
1698 : * %pi4 print an IPv4 address with leading zeros
1699 : * %pI6 print an IPv6 address with colons
1700 : * %pi6 print an IPv6 address without colons
1701 : * %pI6c print an IPv6 address as specified by RFC 5952
1702 : * %pIS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address
1703 : * %piS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address
1704 : * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
1705 : * case.
1706 : * %*pE[achnops] print an escaped buffer
1707 : * %*ph[CDN] a variable-length hex string with a separator (supports up to 64
1708 : * bytes of the input)
1709 : * %n is ignored
1710 : *
1711 : * ** Please update Documentation/printk-formats.txt when making changes **
1712 : *
1713 : * The return value is the number of characters which would
1714 : * be generated for the given input, excluding the trailing
1715 : * '\0', as per ISO C99. If you want to have the exact
1716 : * number of characters written into @buf as return value
1717 : * (not including the trailing '\0'), use vscnprintf(). If the
1718 : * return is greater than or equal to @size, the resulting
1719 : * string is truncated.
1720 : *
1721 : * If you're not already dealing with a va_list consider using snprintf().
1722 : */
1723 55388 : int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1724 : {
1725 : unsigned long long num;
1726 : char *str, *end;
1727 139356 : struct printf_spec spec = {0};
1728 :
1729 : /* Reject out-of-range values early. Large positive sizes are
1730 : used for unknown buffer sizes. */
1731 55388 : if (WARN_ON_ONCE((int) size < 0))
1732 : return 0;
1733 :
1734 : str = buf;
1735 55388 : end = buf + size;
1736 :
1737 : /* Make sure end is always >= buf */
1738 55388 : if (end < buf) {
1739 : end = ((void *)-1);
1740 6344 : size = end - buf;
1741 : }
1742 :
1743 199975 : while (*fmt) {
1744 : const char *old_fmt = fmt;
1745 144587 : int read = format_decode(fmt, &spec);
1746 :
1747 144587 : fmt += read;
1748 :
1749 144587 : switch (spec.type) {
1750 : case FORMAT_TYPE_NONE: {
1751 : int copy = read;
1752 59546 : if (str < end) {
1753 55723 : if (copy > end - str)
1754 : copy = end - str;
1755 55723 : memcpy(str, old_fmt, copy);
1756 : }
1757 59546 : str += read;
1758 59546 : break;
1759 : }
1760 :
1761 : case FORMAT_TYPE_WIDTH:
1762 199 : spec.field_width = va_arg(args, int);
1763 199 : break;
1764 :
1765 : case FORMAT_TYPE_PRECISION:
1766 1 : spec.precision = va_arg(args, int);
1767 1 : break;
1768 :
1769 : case FORMAT_TYPE_CHAR: {
1770 : char c;
1771 :
1772 873 : if (!(spec.flags & LEFT)) {
1773 873 : while (--spec.field_width > 0) {
1774 0 : if (str < end)
1775 0 : *str = ' ';
1776 0 : ++str;
1777 :
1778 : }
1779 : }
1780 873 : c = (unsigned char) va_arg(args, int);
1781 873 : if (str < end)
1782 873 : *str = c;
1783 873 : ++str;
1784 1746 : while (--spec.field_width > 0) {
1785 0 : if (str < end)
1786 0 : *str = ' ';
1787 0 : ++str;
1788 : }
1789 : break;
1790 : }
1791 :
1792 : case FORMAT_TYPE_STR:
1793 71962 : str = string(str, end, va_arg(args, char *), spec);
1794 35981 : break;
1795 :
1796 : case FORMAT_TYPE_PTR:
1797 126 : str = pointer(fmt+1, str, end, va_arg(args, void *),
1798 : spec);
1799 239 : while (isalnum(*fmt))
1800 113 : fmt++;
1801 : break;
1802 :
1803 : case FORMAT_TYPE_PERCENT_CHAR:
1804 0 : if (str < end)
1805 0 : *str = '%';
1806 0 : ++str;
1807 0 : break;
1808 :
1809 : case FORMAT_TYPE_INVALID:
1810 0 : if (str < end)
1811 0 : *str = '%';
1812 0 : ++str;
1813 0 : break;
1814 :
1815 : default:
1816 47924 : switch (spec.type) {
1817 : case FORMAT_TYPE_LONG_LONG:
1818 1302 : num = va_arg(args, long long);
1819 1302 : break;
1820 : case FORMAT_TYPE_ULONG:
1821 13580 : num = va_arg(args, unsigned long);
1822 13580 : break;
1823 : case FORMAT_TYPE_LONG:
1824 31 : num = va_arg(args, long);
1825 31 : break;
1826 : case FORMAT_TYPE_SIZE_T:
1827 7 : if (spec.flags & SIGN)
1828 1 : num = va_arg(args, ssize_t);
1829 : else
1830 6 : num = va_arg(args, size_t);
1831 : break;
1832 : case FORMAT_TYPE_PTRDIFF:
1833 4 : num = va_arg(args, ptrdiff_t);
1834 4 : break;
1835 : case FORMAT_TYPE_UBYTE:
1836 0 : num = (unsigned char) va_arg(args, int);
1837 0 : break;
1838 : case FORMAT_TYPE_BYTE:
1839 0 : num = (signed char) va_arg(args, int);
1840 0 : break;
1841 : case FORMAT_TYPE_USHORT:
1842 54 : num = (unsigned short) va_arg(args, int);
1843 54 : break;
1844 : case FORMAT_TYPE_SHORT:
1845 1 : num = (short) va_arg(args, int);
1846 1 : break;
1847 : case FORMAT_TYPE_INT:
1848 12108 : num = (int) va_arg(args, int);
1849 12108 : break;
1850 : default:
1851 20837 : num = va_arg(args, unsigned int);
1852 : }
1853 :
1854 47924 : str = number(str, end, num, spec);
1855 : }
1856 : }
1857 :
1858 55388 : if (size > 0) {
1859 52177 : if (str < end)
1860 52173 : *str = '\0';
1861 : else
1862 4 : end[-1] = '\0';
1863 : }
1864 :
1865 : /* the trailing null byte doesn't count towards the total */
1866 55388 : return str-buf;
1867 :
1868 : }
1869 : EXPORT_SYMBOL(vsnprintf);
1870 :
1871 : /**
1872 : * vscnprintf - Format a string and place it in a buffer
1873 : * @buf: The buffer to place the result into
1874 : * @size: The size of the buffer, including the trailing null space
1875 : * @fmt: The format string to use
1876 : * @args: Arguments for the format string
1877 : *
1878 : * The return value is the number of characters which have been written into
1879 : * the @buf not including the trailing '\0'. If @size is == 0 the function
1880 : * returns 0.
1881 : *
1882 : * If you're not already dealing with a va_list consider using scnprintf().
1883 : *
1884 : * See the vsnprintf() documentation for format string extensions over C99.
1885 : */
1886 757 : int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1887 : {
1888 : int i;
1889 :
1890 757 : i = vsnprintf(buf, size, fmt, args);
1891 :
1892 757 : if (likely(i < size))
1893 : return i;
1894 0 : if (size != 0)
1895 0 : return size - 1;
1896 : return 0;
1897 : }
1898 : EXPORT_SYMBOL(vscnprintf);
1899 :
1900 : /**
1901 : * snprintf - Format a string and place it in a buffer
1902 : * @buf: The buffer to place the result into
1903 : * @size: The size of the buffer, including the trailing null space
1904 : * @fmt: The format string to use
1905 : * @...: Arguments for the format string
1906 : *
1907 : * The return value is the number of characters which would be
1908 : * generated for the given input, excluding the trailing null,
1909 : * as per ISO C99. If the return is greater than or equal to
1910 : * @size, the resulting string is truncated.
1911 : *
1912 : * See the vsnprintf() documentation for format string extensions over C99.
1913 : */
1914 6515 : int snprintf(char *buf, size_t size, const char *fmt, ...)
1915 : {
1916 : va_list args;
1917 : int i;
1918 :
1919 6515 : va_start(args, fmt);
1920 6515 : i = vsnprintf(buf, size, fmt, args);
1921 6515 : va_end(args);
1922 :
1923 6515 : return i;
1924 : }
1925 : EXPORT_SYMBOL(snprintf);
1926 :
1927 : /**
1928 : * scnprintf - Format a string and place it in a buffer
1929 : * @buf: The buffer to place the result into
1930 : * @size: The size of the buffer, including the trailing null space
1931 : * @fmt: The format string to use
1932 : * @...: Arguments for the format string
1933 : *
1934 : * The return value is the number of characters written into @buf not including
1935 : * the trailing '\0'. If @size is == 0 the function returns 0.
1936 : */
1937 :
1938 391 : int scnprintf(char *buf, size_t size, const char *fmt, ...)
1939 : {
1940 : va_list args;
1941 : int i;
1942 :
1943 391 : va_start(args, fmt);
1944 391 : i = vscnprintf(buf, size, fmt, args);
1945 391 : va_end(args);
1946 :
1947 391 : return i;
1948 : }
1949 : EXPORT_SYMBOL(scnprintf);
1950 :
1951 : /**
1952 : * vsprintf - Format a string and place it in a buffer
1953 : * @buf: The buffer to place the result into
1954 : * @fmt: The format string to use
1955 : * @args: Arguments for the format string
1956 : *
1957 : * The function returns the number of characters written
1958 : * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
1959 : * buffer overflows.
1960 : *
1961 : * If you're not already dealing with a va_list consider using sprintf().
1962 : *
1963 : * See the vsnprintf() documentation for format string extensions over C99.
1964 : */
1965 0 : int vsprintf(char *buf, const char *fmt, va_list args)
1966 : {
1967 0 : return vsnprintf(buf, INT_MAX, fmt, args);
1968 : }
1969 : EXPORT_SYMBOL(vsprintf);
1970 :
1971 : /**
1972 : * sprintf - Format a string and place it in a buffer
1973 : * @buf: The buffer to place the result into
1974 : * @fmt: The format string to use
1975 : * @...: Arguments for the format string
1976 : *
1977 : * The function returns the number of characters written
1978 : * into @buf. Use snprintf() or scnprintf() in order to avoid
1979 : * buffer overflows.
1980 : *
1981 : * See the vsnprintf() documentation for format string extensions over C99.
1982 : */
1983 6344 : int sprintf(char *buf, const char *fmt, ...)
1984 : {
1985 : va_list args;
1986 : int i;
1987 :
1988 6344 : va_start(args, fmt);
1989 6344 : i = vsnprintf(buf, INT_MAX, fmt, args);
1990 6344 : va_end(args);
1991 :
1992 6344 : return i;
1993 : }
1994 : EXPORT_SYMBOL(sprintf);
1995 :
1996 : #ifdef CONFIG_BINARY_PRINTF
1997 : /*
1998 : * bprintf service:
1999 : * vbin_printf() - VA arguments to binary data
2000 : * bstr_printf() - Binary data to text string
2001 : */
2002 :
2003 : /**
2004 : * vbin_printf - Parse a format string and place args' binary value in a buffer
2005 : * @bin_buf: The buffer to place args' binary value
2006 : * @size: The size of the buffer(by words(32bits), not characters)
2007 : * @fmt: The format string to use
2008 : * @args: Arguments for the format string
2009 : *
2010 : * The format follows C99 vsnprintf, except %n is ignored, and its argument
2011 : * is skipped.
2012 : *
2013 : * The return value is the number of words(32bits) which would be generated for
2014 : * the given input.
2015 : *
2016 : * NOTE:
2017 : * If the return value is greater than @size, the resulting bin_buf is NOT
2018 : * valid for bstr_printf().
2019 : */
2020 : int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
2021 : {
2022 : struct printf_spec spec = {0};
2023 : char *str, *end;
2024 :
2025 : str = (char *)bin_buf;
2026 : end = (char *)(bin_buf + size);
2027 :
2028 : #define save_arg(type) \
2029 : do { \
2030 : if (sizeof(type) == 8) { \
2031 : unsigned long long value; \
2032 : str = PTR_ALIGN(str, sizeof(u32)); \
2033 : value = va_arg(args, unsigned long long); \
2034 : if (str + sizeof(type) <= end) { \
2035 : *(u32 *)str = *(u32 *)&value; \
2036 : *(u32 *)(str + 4) = *((u32 *)&value + 1); \
2037 : } \
2038 : } else { \
2039 : unsigned long value; \
2040 : str = PTR_ALIGN(str, sizeof(type)); \
2041 : value = va_arg(args, int); \
2042 : if (str + sizeof(type) <= end) \
2043 : *(typeof(type) *)str = (type)value; \
2044 : } \
2045 : str += sizeof(type); \
2046 : } while (0)
2047 :
2048 : while (*fmt) {
2049 : int read = format_decode(fmt, &spec);
2050 :
2051 : fmt += read;
2052 :
2053 : switch (spec.type) {
2054 : case FORMAT_TYPE_NONE:
2055 : case FORMAT_TYPE_INVALID:
2056 : case FORMAT_TYPE_PERCENT_CHAR:
2057 : break;
2058 :
2059 : case FORMAT_TYPE_WIDTH:
2060 : case FORMAT_TYPE_PRECISION:
2061 : save_arg(int);
2062 : break;
2063 :
2064 : case FORMAT_TYPE_CHAR:
2065 : save_arg(char);
2066 : break;
2067 :
2068 : case FORMAT_TYPE_STR: {
2069 : const char *save_str = va_arg(args, char *);
2070 : size_t len;
2071 :
2072 : if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
2073 : || (unsigned long)save_str < PAGE_SIZE)
2074 : save_str = "(null)";
2075 : len = strlen(save_str) + 1;
2076 : if (str + len < end)
2077 : memcpy(str, save_str, len);
2078 : str += len;
2079 : break;
2080 : }
2081 :
2082 : case FORMAT_TYPE_PTR:
2083 : save_arg(void *);
2084 : /* skip all alphanumeric pointer suffixes */
2085 : while (isalnum(*fmt))
2086 : fmt++;
2087 : break;
2088 :
2089 : default:
2090 : switch (spec.type) {
2091 :
2092 : case FORMAT_TYPE_LONG_LONG:
2093 : save_arg(long long);
2094 : break;
2095 : case FORMAT_TYPE_ULONG:
2096 : case FORMAT_TYPE_LONG:
2097 : save_arg(unsigned long);
2098 : break;
2099 : case FORMAT_TYPE_SIZE_T:
2100 : save_arg(size_t);
2101 : break;
2102 : case FORMAT_TYPE_PTRDIFF:
2103 : save_arg(ptrdiff_t);
2104 : break;
2105 : case FORMAT_TYPE_UBYTE:
2106 : case FORMAT_TYPE_BYTE:
2107 : save_arg(char);
2108 : break;
2109 : case FORMAT_TYPE_USHORT:
2110 : case FORMAT_TYPE_SHORT:
2111 : save_arg(short);
2112 : break;
2113 : default:
2114 : save_arg(int);
2115 : }
2116 : }
2117 : }
2118 :
2119 : return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
2120 : #undef save_arg
2121 : }
2122 : EXPORT_SYMBOL_GPL(vbin_printf);
2123 :
2124 : /**
2125 : * bstr_printf - Format a string from binary arguments and place it in a buffer
2126 : * @buf: The buffer to place the result into
2127 : * @size: The size of the buffer, including the trailing null space
2128 : * @fmt: The format string to use
2129 : * @bin_buf: Binary arguments for the format string
2130 : *
2131 : * This function like C99 vsnprintf, but the difference is that vsnprintf gets
2132 : * arguments from stack, and bstr_printf gets arguments from @bin_buf which is
2133 : * a binary buffer that generated by vbin_printf.
2134 : *
2135 : * The format follows C99 vsnprintf, but has some extensions:
2136 : * see vsnprintf comment for details.
2137 : *
2138 : * The return value is the number of characters which would
2139 : * be generated for the given input, excluding the trailing
2140 : * '\0', as per ISO C99. If you want to have the exact
2141 : * number of characters written into @buf as return value
2142 : * (not including the trailing '\0'), use vscnprintf(). If the
2143 : * return is greater than or equal to @size, the resulting
2144 : * string is truncated.
2145 : */
2146 : int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
2147 : {
2148 : struct printf_spec spec = {0};
2149 : char *str, *end;
2150 : const char *args = (const char *)bin_buf;
2151 :
2152 : if (WARN_ON_ONCE((int) size < 0))
2153 : return 0;
2154 :
2155 : str = buf;
2156 : end = buf + size;
2157 :
2158 : #define get_arg(type) \
2159 : ({ \
2160 : typeof(type) value; \
2161 : if (sizeof(type) == 8) { \
2162 : args = PTR_ALIGN(args, sizeof(u32)); \
2163 : *(u32 *)&value = *(u32 *)args; \
2164 : *((u32 *)&value + 1) = *(u32 *)(args + 4); \
2165 : } else { \
2166 : args = PTR_ALIGN(args, sizeof(type)); \
2167 : value = *(typeof(type) *)args; \
2168 : } \
2169 : args += sizeof(type); \
2170 : value; \
2171 : })
2172 :
2173 : /* Make sure end is always >= buf */
2174 : if (end < buf) {
2175 : end = ((void *)-1);
2176 : size = end - buf;
2177 : }
2178 :
2179 : while (*fmt) {
2180 : const char *old_fmt = fmt;
2181 : int read = format_decode(fmt, &spec);
2182 :
2183 : fmt += read;
2184 :
2185 : switch (spec.type) {
2186 : case FORMAT_TYPE_NONE: {
2187 : int copy = read;
2188 : if (str < end) {
2189 : if (copy > end - str)
2190 : copy = end - str;
2191 : memcpy(str, old_fmt, copy);
2192 : }
2193 : str += read;
2194 : break;
2195 : }
2196 :
2197 : case FORMAT_TYPE_WIDTH:
2198 : spec.field_width = get_arg(int);
2199 : break;
2200 :
2201 : case FORMAT_TYPE_PRECISION:
2202 : spec.precision = get_arg(int);
2203 : break;
2204 :
2205 : case FORMAT_TYPE_CHAR: {
2206 : char c;
2207 :
2208 : if (!(spec.flags & LEFT)) {
2209 : while (--spec.field_width > 0) {
2210 : if (str < end)
2211 : *str = ' ';
2212 : ++str;
2213 : }
2214 : }
2215 : c = (unsigned char) get_arg(char);
2216 : if (str < end)
2217 : *str = c;
2218 : ++str;
2219 : while (--spec.field_width > 0) {
2220 : if (str < end)
2221 : *str = ' ';
2222 : ++str;
2223 : }
2224 : break;
2225 : }
2226 :
2227 : case FORMAT_TYPE_STR: {
2228 : const char *str_arg = args;
2229 : args += strlen(str_arg) + 1;
2230 : str = string(str, end, (char *)str_arg, spec);
2231 : break;
2232 : }
2233 :
2234 : case FORMAT_TYPE_PTR:
2235 : str = pointer(fmt+1, str, end, get_arg(void *), spec);
2236 : while (isalnum(*fmt))
2237 : fmt++;
2238 : break;
2239 :
2240 : case FORMAT_TYPE_PERCENT_CHAR:
2241 : case FORMAT_TYPE_INVALID:
2242 : if (str < end)
2243 : *str = '%';
2244 : ++str;
2245 : break;
2246 :
2247 : default: {
2248 : unsigned long long num;
2249 :
2250 : switch (spec.type) {
2251 :
2252 : case FORMAT_TYPE_LONG_LONG:
2253 : num = get_arg(long long);
2254 : break;
2255 : case FORMAT_TYPE_ULONG:
2256 : case FORMAT_TYPE_LONG:
2257 : num = get_arg(unsigned long);
2258 : break;
2259 : case FORMAT_TYPE_SIZE_T:
2260 : num = get_arg(size_t);
2261 : break;
2262 : case FORMAT_TYPE_PTRDIFF:
2263 : num = get_arg(ptrdiff_t);
2264 : break;
2265 : case FORMAT_TYPE_UBYTE:
2266 : num = get_arg(unsigned char);
2267 : break;
2268 : case FORMAT_TYPE_BYTE:
2269 : num = get_arg(signed char);
2270 : break;
2271 : case FORMAT_TYPE_USHORT:
2272 : num = get_arg(unsigned short);
2273 : break;
2274 : case FORMAT_TYPE_SHORT:
2275 : num = get_arg(short);
2276 : break;
2277 : case FORMAT_TYPE_UINT:
2278 : num = get_arg(unsigned int);
2279 : break;
2280 : default:
2281 : num = get_arg(int);
2282 : }
2283 :
2284 : str = number(str, end, num, spec);
2285 : } /* default: */
2286 : } /* switch(spec.type) */
2287 : } /* while(*fmt) */
2288 :
2289 : if (size > 0) {
2290 : if (str < end)
2291 : *str = '\0';
2292 : else
2293 : end[-1] = '\0';
2294 : }
2295 :
2296 : #undef get_arg
2297 :
2298 : /* the trailing null byte doesn't count towards the total */
2299 : return str - buf;
2300 : }
2301 : EXPORT_SYMBOL_GPL(bstr_printf);
2302 :
2303 : /**
2304 : * bprintf - Parse a format string and place args' binary value in a buffer
2305 : * @bin_buf: The buffer to place args' binary value
2306 : * @size: The size of the buffer(by words(32bits), not characters)
2307 : * @fmt: The format string to use
2308 : * @...: Arguments for the format string
2309 : *
2310 : * The function returns the number of words(u32) written
2311 : * into @bin_buf.
2312 : */
2313 : int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
2314 : {
2315 : va_list args;
2316 : int ret;
2317 :
2318 : va_start(args, fmt);
2319 : ret = vbin_printf(bin_buf, size, fmt, args);
2320 : va_end(args);
2321 :
2322 : return ret;
2323 : }
2324 : EXPORT_SYMBOL_GPL(bprintf);
2325 :
2326 : #endif /* CONFIG_BINARY_PRINTF */
2327 :
2328 : /**
2329 : * vsscanf - Unformat a buffer into a list of arguments
2330 : * @buf: input buffer
2331 : * @fmt: format of buffer
2332 : * @args: arguments
2333 : */
2334 5 : int vsscanf(const char *buf, const char *fmt, va_list args)
2335 : {
2336 : const char *str = buf;
2337 : char *next;
2338 : char digit;
2339 : int num = 0;
2340 : u8 qualifier;
2341 : unsigned int base;
2342 : union {
2343 : long long s;
2344 : unsigned long long u;
2345 : } val;
2346 : s16 field_width;
2347 : bool is_sign;
2348 :
2349 14 : while (*fmt) {
2350 : /* skip any white space in format */
2351 : /* white space in format matchs any amount of
2352 : * white space, including none, in the input.
2353 : */
2354 5 : if (isspace(*fmt)) {
2355 0 : fmt = skip_spaces(++fmt);
2356 0 : str = skip_spaces(str);
2357 : }
2358 :
2359 : /* anything that is not a conversion must match exactly */
2360 5 : if (*fmt != '%' && *fmt) {
2361 1 : if (*fmt++ != *str++)
2362 : break;
2363 0 : continue;
2364 : }
2365 :
2366 4 : if (!*fmt)
2367 : break;
2368 4 : ++fmt;
2369 :
2370 : /* skip this conversion.
2371 : * advance both strings to next white space
2372 : */
2373 4 : if (*fmt == '*') {
2374 0 : if (!*str)
2375 : break;
2376 0 : while (!isspace(*fmt) && *fmt != '%' && *fmt)
2377 0 : fmt++;
2378 0 : while (!isspace(*str) && *str)
2379 0 : str++;
2380 0 : continue;
2381 : }
2382 :
2383 : /* get field width */
2384 : field_width = -1;
2385 4 : if (isdigit(*fmt)) {
2386 1 : field_width = skip_atoi(&fmt);
2387 1 : if (field_width <= 0)
2388 : break;
2389 : }
2390 :
2391 : /* get conversion qualifier */
2392 : qualifier = -1;
2393 8 : if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2394 : _tolower(*fmt) == 'z') {
2395 0 : qualifier = *fmt++;
2396 0 : if (unlikely(qualifier == *fmt)) {
2397 0 : if (qualifier == 'h') {
2398 : qualifier = 'H';
2399 0 : fmt++;
2400 0 : } else if (qualifier == 'l') {
2401 : qualifier = 'L';
2402 0 : fmt++;
2403 : }
2404 : }
2405 : }
2406 :
2407 4 : if (!*fmt)
2408 : break;
2409 :
2410 4 : if (*fmt == 'n') {
2411 : /* return number of characters read so far */
2412 0 : *va_arg(args, int *) = str - buf;
2413 0 : ++fmt;
2414 0 : continue;
2415 : }
2416 :
2417 4 : if (!*str)
2418 : break;
2419 :
2420 4 : base = 10;
2421 : is_sign = false;
2422 :
2423 4 : switch (*fmt++) {
2424 : case 'c':
2425 : {
2426 0 : char *s = (char *)va_arg(args, char*);
2427 0 : if (field_width == -1)
2428 : field_width = 1;
2429 : do {
2430 0 : *s++ = *str++;
2431 0 : } while (--field_width > 0 && *str);
2432 0 : num++;
2433 : }
2434 0 : continue;
2435 : case 's':
2436 : {
2437 1 : char *s = (char *)va_arg(args, char *);
2438 1 : if (field_width == -1)
2439 : field_width = SHRT_MAX;
2440 : /* first, skip leading white space in buffer */
2441 1 : str = skip_spaces(str);
2442 :
2443 : /* now copy until next white space */
2444 10 : while (*str && !isspace(*str) && field_width--)
2445 8 : *s++ = *str++;
2446 1 : *s = '\0';
2447 1 : num++;
2448 : }
2449 1 : continue;
2450 : case 'o':
2451 0 : base = 8;
2452 0 : break;
2453 : case 'x':
2454 : case 'X':
2455 0 : base = 16;
2456 0 : break;
2457 : case 'i':
2458 0 : base = 0;
2459 : case 'd':
2460 : is_sign = true;
2461 : case 'u':
2462 : break;
2463 : case '%':
2464 : /* looking for '%' in str */
2465 0 : if (*str++ != '%')
2466 : return num;
2467 0 : continue;
2468 : default:
2469 : /* invalid format; stop here */
2470 : return num;
2471 : }
2472 :
2473 : /* have some sort of integer conversion.
2474 : * first, skip white space in buffer.
2475 : */
2476 3 : str = skip_spaces(str);
2477 :
2478 3 : digit = *str;
2479 3 : if (is_sign && digit == '-')
2480 0 : digit = *(str + 1);
2481 :
2482 3 : if (!digit
2483 3 : || (base == 16 && !isxdigit(digit))
2484 3 : || (base == 10 && !isdigit(digit))
2485 3 : || (base == 8 && (!isdigit(digit) || digit > '7'))
2486 3 : || (base == 0 && !isdigit(digit)))
2487 : break;
2488 :
2489 3 : if (is_sign)
2490 : val.s = qualifier != 'L' ?
2491 0 : simple_strtol(str, &next, base) :
2492 : simple_strtoll(str, &next, base);
2493 : else
2494 3 : val.u = qualifier != 'L' ?
2495 6 : simple_strtoul(str, &next, base) :
2496 : simple_strtoull(str, &next, base);
2497 :
2498 3 : if (field_width > 0 && next - str > field_width) {
2499 0 : if (base == 0)
2500 0 : _parse_integer_fixup_radix(str, &base);
2501 0 : while (next - str > field_width) {
2502 0 : if (is_sign)
2503 0 : val.s = div_s64(val.s, base);
2504 : else
2505 0 : val.u = div_u64(val.u, base);
2506 0 : --next;
2507 : }
2508 : }
2509 :
2510 3 : switch (qualifier) {
2511 : case 'H': /* that's 'hh' in format */
2512 0 : if (is_sign)
2513 0 : *va_arg(args, signed char *) = val.s;
2514 : else
2515 0 : *va_arg(args, unsigned char *) = val.u;
2516 : break;
2517 : case 'h':
2518 0 : if (is_sign)
2519 0 : *va_arg(args, short *) = val.s;
2520 : else
2521 0 : *va_arg(args, unsigned short *) = val.u;
2522 : break;
2523 : case 'l':
2524 0 : if (is_sign)
2525 0 : *va_arg(args, long *) = val.s;
2526 : else
2527 0 : *va_arg(args, unsigned long *) = val.u;
2528 : break;
2529 : case 'L':
2530 0 : if (is_sign)
2531 0 : *va_arg(args, long long *) = val.s;
2532 : else
2533 0 : *va_arg(args, unsigned long long *) = val.u;
2534 : break;
2535 : case 'Z':
2536 : case 'z':
2537 0 : *va_arg(args, size_t *) = val.u;
2538 0 : break;
2539 : default:
2540 3 : if (is_sign)
2541 0 : *va_arg(args, int *) = val.s;
2542 : else
2543 3 : *va_arg(args, unsigned int *) = val.u;
2544 : break;
2545 : }
2546 3 : num++;
2547 :
2548 3 : if (!next)
2549 : break;
2550 : str = next;
2551 : }
2552 :
2553 5 : return num;
2554 : }
2555 : EXPORT_SYMBOL(vsscanf);
2556 :
2557 : /**
2558 : * sscanf - Unformat a buffer into a list of arguments
2559 : * @buf: input buffer
2560 : * @fmt: formatting of buffer
2561 : * @...: resulting arguments
2562 : */
2563 5 : int sscanf(const char *buf, const char *fmt, ...)
2564 : {
2565 : va_list args;
2566 : int i;
2567 :
2568 5 : va_start(args, fmt);
2569 5 : i = vsscanf(buf, fmt, args);
2570 5 : va_end(args);
2571 :
2572 5 : return i;
2573 : }
2574 : EXPORT_SYMBOL(sscanf);
|
