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