blob: ec337f64f52ddada251c9126561e5e38a38093e5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
André Goddard Rosa7b9186f2009-12-14 18:00:57 -080012/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * 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>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050020#include <linux/module.h> /* for KSYM_SYMBOL_LEN */
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/types.h>
22#include <linux/string.h>
23#include <linux/ctype.h>
24#include <linux/kernel.h>
Linus Torvalds0fe1ef22008-07-06 16:43:12 -070025#include <linux/kallsyms.h>
Jan Beulich53809752012-12-17 16:01:31 -080026#include <linux/math64.h>
Linus Torvalds0fe1ef22008-07-06 16:43:12 -070027#include <linux/uaccess.h>
Linus Torvalds332d2e72008-10-20 15:07:34 +110028#include <linux/ioport.h>
Al Viro4b6ccca2013-09-03 12:00:44 -040029#include <linux/dcache.h>
Ryan Mallon312b4e22013-11-12 15:08:51 -080030#include <linux/cred.h>
Joe Perches8a27f7c2009-08-17 12:29:44 +000031#include <net/addrconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Tim Schmielau4e57b682005-10-30 15:03:48 -080033#include <asm/page.h> /* for PAGE_SIZE */
James Bottomleydeac93d2008-09-03 20:43:36 -050034#include <asm/sections.h> /* for dereference_function_descriptor() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Andy Shevchenko71dca952014-10-13 15:55:18 -070036#include <linux/string_helpers.h>
Alexey Dobriyan1dff46d2011-10-31 17:12:28 -070037#include "kstrtox.h"
Harvey Harrisonaa46a632008-10-16 13:40:34 -070038
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 * 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
Eldad Zack462e4712012-12-17 16:03:05 -080044 *
45 * This function is obsolete. Please use kstrtoull instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 */
Harvey Harrison22d27052008-10-16 13:40:35 -070047unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
Alexey Dobriyan1dff46d2011-10-31 17:12:28 -070049 unsigned long long result;
50 unsigned int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Alexey Dobriyan1dff46d2011-10-31 17:12:28 -070052 cp = _parse_integer_fixup_radix(cp, &base);
53 rv = _parse_integer(cp, base, &result);
54 /* FIXME */
55 cp += (rv & ~KSTRTOX_OVERFLOW);
Harvey Harrisonaa46a632008-10-16 13:40:34 -070056
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (endp)
58 *endp = (char *)cp;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -080059
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 return result;
61}
Linus Torvalds1da177e2005-04-16 15:20:36 -070062EXPORT_SYMBOL(simple_strtoull);
63
64/**
André Goddard Rosa922ac252009-12-14 18:01:01 -080065 * 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
Eldad Zack462e4712012-12-17 16:03:05 -080069 *
70 * This function is obsolete. Please use kstrtoul instead.
André Goddard Rosa922ac252009-12-14 18:01:01 -080071 */
72unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
73{
74 return simple_strtoull(cp, endp, base);
75}
76EXPORT_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
Eldad Zack462e4712012-12-17 16:03:05 -080083 *
84 * This function is obsolete. Please use kstrtol instead.
André Goddard Rosa922ac252009-12-14 18:01:01 -080085 */
86long simple_strtol(const char *cp, char **endp, unsigned int base)
87{
88 if (*cp == '-')
89 return -simple_strtoul(cp + 1, endp, base);
90
91 return simple_strtoul(cp, endp, base);
92}
93EXPORT_SYMBOL(simple_strtol);
94
95/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 * 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
Eldad Zack462e4712012-12-17 16:03:05 -0800100 *
101 * This function is obsolete. Please use kstrtoll instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 */
Harvey Harrison22d27052008-10-16 13:40:35 -0700103long long simple_strtoll(const char *cp, char **endp, unsigned int base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800105 if (*cp == '-')
Harvey Harrison22d27052008-10-16 13:40:35 -0700106 return -simple_strtoull(cp + 1, endp, base);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800107
Harvey Harrison22d27052008-10-16 13:40:35 -0700108 return simple_strtoull(cp, endp, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109}
Hans Verkuil98d5ce02010-04-23 13:18:04 -0400110EXPORT_SYMBOL(simple_strtoll);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Joe Perchescf3b4292010-05-24 14:33:16 -0700112static noinline_for_stack
113int skip_atoi(const char **s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800115 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117 while (isdigit(**s))
118 i = i*10 + *((*s)++) - '0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 return i;
121}
122
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700123/* 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
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700126 * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
127 * (with permission from the author, Douglas W. Jones).
128 */
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700129
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700130#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
131/* Formats correctly any integer in [0, 999999999] */
Joe Perchescf3b4292010-05-24 14:33:16 -0700132static noinline_for_stack
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700133char *put_dec_full9(char *buf, unsigned q)
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700134{
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700135 unsigned r;
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700136
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800137 /*
138 * Possible ways to approx. divide by 10
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700139 * (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>
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800155 */
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700156 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
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700177
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700178/* 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 */
182static noinline_for_stack
183char *put_dec_trunc8(char *buf, unsigned r)
184{
185 unsigned q;
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700186
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700187 /* Copy of previous function's body with added early returns */
George Spelvincb239d02012-10-04 17:12:30 -0700188 while (r >= 10000) {
189 q = r + '0';
190 r = (r * (uint64_t)0x1999999a) >> 32;
191 *buf++ = q - 10*r;
192 }
193
George Spelvinf4000512012-10-04 17:12:32 -0700194 q = (r * 0x199a) >> 16; /* r <= 9999 */
195 *buf++ = (r - 10 * q) + '0';
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700196 if (q == 0)
197 return buf;
George Spelvinf4000512012-10-04 17:12:32 -0700198 r = (q * 0xcd) >> 11; /* q <= 999 */
199 *buf++ = (q - 10 * r) + '0';
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700200 if (r == 0)
201 return buf;
George Spelvinf4000512012-10-04 17:12:32 -0700202 q = (r * 0xcd) >> 11; /* r <= 99 */
203 *buf++ = (r - 10 * q) + '0';
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700204 if (q == 0)
205 return buf;
George Spelvinf4000512012-10-04 17:12:32 -0700206 *buf++ = q + '0'; /* q <= 9 */
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700207 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
231static
232char *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
George Spelvine49317d2012-10-04 17:12:27 -0700247/* See comment in put_dec_full9 for choice of constants */
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700248static noinline_for_stack
George Spelvin23591722012-10-04 17:12:29 -0700249void put_dec_full4(char *buf, unsigned q)
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700250{
251 unsigned r;
George Spelvine49317d2012-10-04 17:12:27 -0700252 r = (q * 0xccd) >> 15;
George Spelvin23591722012-10-04 17:12:29 -0700253 buf[0] = (q - 10 * r) + '0';
George Spelvine49317d2012-10-04 17:12:27 -0700254 q = (r * 0xcd) >> 11;
George Spelvin23591722012-10-04 17:12:29 -0700255 buf[1] = (r - 10 * q) + '0';
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700256 r = (q * 0xcd) >> 11;
George Spelvin23591722012-10-04 17:12:29 -0700257 buf[2] = (q - 10 * r) + '0';
258 buf[3] = r + '0';
259}
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 */
268static
269unsigned put_dec_helper4(char *buf, unsigned x)
270{
271 uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
272
273 put_dec_full4(buf, x - q * 10000);
274 return q;
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700275}
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 */
282static
283char *put_dec(char *buf, unsigned long long n)
284{
285 uint32_t d3, d2, d1, q, h;
286
287 if (n < 100*1000*1000)
288 return put_dec_trunc8(buf, n);
289
290 d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
291 h = (n >> 32);
292 d2 = (h ) & 0xffff;
293 d3 = (h >> 16); /* implicit "& 0xffff" */
294
295 q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
George Spelvin23591722012-10-04 17:12:29 -0700296 q = put_dec_helper4(buf, q);
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700297
George Spelvin23591722012-10-04 17:12:29 -0700298 q += 7671 * d3 + 9496 * d2 + 6 * d1;
299 q = put_dec_helper4(buf+4, q);
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700300
George Spelvin23591722012-10-04 17:12:29 -0700301 q += 4749 * d3 + 42 * d2;
302 q = put_dec_helper4(buf+8, q);
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700303
George Spelvin23591722012-10-04 17:12:29 -0700304 q += 281 * d3;
305 buf += 12;
306 if (q)
307 buf = put_dec_trunc8(buf, q);
308 else while (buf[-1] == '0')
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700309 --buf;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800310
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700311 return buf;
312}
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700313
314#endif
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700315
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700316/*
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 */
322int num_to_str(char *buf, int size, unsigned long long num)
323{
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700324 char tmp[sizeof(num) * 3];
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700325 int idx, len;
326
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700327 /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
328 if (num <= 9) {
329 tmp[0] = '0' + num;
330 len = 1;
331 } else {
332 len = put_dec(tmp, num) - tmp;
333 }
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700334
335 if (len > size)
336 return 0;
337 for (idx = 0; idx < len; ++idx)
338 buf[idx] = tmp[len - idx - 1];
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700339 return len;
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700340}
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342#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 */
Bjorn Helgaasb89dc5d2010-03-05 10:47:31 -0700347#define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */
348#define SPECIAL 64 /* prefix hex with "0x", octal with "0" */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100350enum format_type {
351 FORMAT_TYPE_NONE, /* Just a string part */
Vegard Nossumed681a92009-03-14 12:08:50 +0100352 FORMAT_TYPE_WIDTH,
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100353 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,
Zhaoleia4e94ef2009-03-27 17:07:05 +0800362 FORMAT_TYPE_UBYTE,
363 FORMAT_TYPE_BYTE,
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100364 FORMAT_TYPE_USHORT,
365 FORMAT_TYPE_SHORT,
366 FORMAT_TYPE_UINT,
367 FORMAT_TYPE_INT,
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100368 FORMAT_TYPE_SIZE_T,
369 FORMAT_TYPE_PTRDIFF
370};
371
372struct printf_spec {
Joe Perches4e310fd2010-04-14 09:27:40 -0700373 u8 type; /* format_type enum */
Joe Perchesef0658f2010-03-06 17:10:14 -0800374 u8 flags; /* flags to number() */
Joe Perches4e310fd2010-04-14 09:27:40 -0700375 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 */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100379};
380
Joe Perchescf3b4292010-05-24 14:33:16 -0700381static noinline_for_stack
382char *number(char *buf, char *end, unsigned long long num,
383 struct printf_spec spec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100385 /* 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;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100391 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 int i;
Pierre Carrier7c203422012-05-29 15:07:35 -0700393 bool is_zero = num == 0LL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100395 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
396 * produces same digits or (maybe lowercased) letters */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100397 locase = (spec.flags & SMALL);
398 if (spec.flags & LEFT)
399 spec.flags &= ~ZEROPAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 sign = 0;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100401 if (spec.flags & SIGN) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800402 if ((signed long long)num < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 sign = '-';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800404 num = -(signed long long)num;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100405 spec.field_width--;
406 } else if (spec.flags & PLUS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 sign = '+';
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100408 spec.field_width--;
409 } else if (spec.flags & SPACE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 sign = ' ';
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100411 spec.field_width--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700414 if (need_pfx) {
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100415 if (spec.base == 16)
Pierre Carrier7c203422012-05-29 15:07:35 -0700416 spec.field_width -= 2;
417 else if (!is_zero)
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100418 spec.field_width--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700420
421 /* generate full string in tmp[], in reverse order */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 i = 0;
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700423 if (num < spec.base)
424 tmp[i++] = digits[num] | locase;
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700425 /* Generic code, for any base:
426 else do {
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100427 tmp[i++] = (digits[do_div(num,base)] | locase);
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700428 } while (num != 0);
429 */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100430 else if (spec.base != 10) { /* 8 or 16 */
431 int mask = spec.base - 1;
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700432 int shift = 3;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800433
434 if (spec.base == 16)
435 shift = 4;
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700436 do {
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100437 tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700438 num >>= shift;
439 } while (num);
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700440 } else { /* base 10 */
441 i = put_dec(tmp, num) - tmp;
442 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700443
444 /* printing 100 using %2d gives "100", not "00" */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100445 if (i > spec.precision)
446 spec.precision = i;
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700447 /* leading space padding */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100448 spec.field_width -= spec.precision;
449 if (!(spec.flags & (ZEROPAD+LEFT))) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800450 while (--spec.field_width >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700451 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 *buf = ' ';
453 ++buf;
454 }
455 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700456 /* sign */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 if (sign) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700458 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 *buf = sign;
460 ++buf;
461 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700462 /* "0x" / "0" prefix */
463 if (need_pfx) {
Pierre Carrier7c203422012-05-29 15:07:35 -0700464 if (spec.base == 16 || !is_zero) {
465 if (buf < end)
466 *buf = '0';
467 ++buf;
468 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100469 if (spec.base == 16) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700470 if (buf < end)
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100471 *buf = ('X' | locase);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 ++buf;
473 }
474 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700475 /* zero or space padding */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100476 if (!(spec.flags & LEFT)) {
477 char c = (spec.flags & ZEROPAD) ? '0' : ' ';
478 while (--spec.field_width >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700479 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 *buf = c;
481 ++buf;
482 }
483 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700484 /* hmm even more zero padding? */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100485 while (i <= --spec.precision) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700486 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 *buf = '0';
488 ++buf;
489 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700490 /* actual digits of result */
491 while (--i >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700492 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 *buf = tmp[i];
494 ++buf;
495 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700496 /* trailing space padding */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100497 while (--spec.field_width >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700498 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 *buf = ' ';
500 ++buf;
501 }
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 return buf;
504}
505
Joe Perchescf3b4292010-05-24 14:33:16 -0700506static noinline_for_stack
507char *string(char *buf, char *end, const char *s, struct printf_spec spec)
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700508{
509 int len, i;
510
511 if ((unsigned long)s < PAGE_SIZE)
André Goddard Rosa0f4f81d2009-12-14 18:00:55 -0800512 s = "(null)";
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700513
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100514 len = strnlen(s, spec.precision);
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700515
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100516 if (!(spec.flags & LEFT)) {
517 while (len < spec.field_width--) {
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700518 if (buf < end)
519 *buf = ' ';
520 ++buf;
521 }
522 }
523 for (i = 0; i < len; ++i) {
524 if (buf < end)
525 *buf = *s;
526 ++buf; ++s;
527 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100528 while (len < spec.field_width--) {
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700529 if (buf < end)
530 *buf = ' ';
531 ++buf;
532 }
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800533
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700534 return buf;
535}
536
Al Viro4b6ccca2013-09-03 12:00:44 -0400537static void widen(char *buf, char *end, unsigned len, unsigned spaces)
538{
539 size_t size;
540 if (buf >= end) /* nowhere to put anything */
541 return;
542 size = end - buf;
543 if (size <= spaces) {
544 memset(buf, ' ', size);
545 return;
546 }
547 if (len) {
548 if (len > size - spaces)
549 len = size - spaces;
550 memmove(buf + spaces, buf, len);
551 }
552 memset(buf, ' ', spaces);
553}
554
555static noinline_for_stack
556char *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 switch (fmt[1]) {
565 case '2': case '3': case '4':
566 depth = fmt[1] - '0';
567 break;
568 default:
569 depth = 1;
570 }
571
572 rcu_read_lock();
573 for (i = 0; i < depth; i++, d = p) {
574 p = ACCESS_ONCE(d->d_parent);
575 array[i] = ACCESS_ONCE(d->d_name.name);
576 if (p == d) {
577 if (i)
578 array[i] = "";
579 i++;
580 break;
581 }
582 }
583 s = array[--i];
584 for (n = 0; n != spec.precision; n++, buf++) {
585 char c = *s++;
586 if (!c) {
587 if (!i)
588 break;
589 c = '/';
590 s = array[--i];
591 }
592 if (buf < end)
593 *buf = c;
594 }
595 rcu_read_unlock();
596 if (n < spec.field_width) {
597 /* we want to pad the sucker */
598 unsigned spaces = spec.field_width - n;
599 if (!(spec.flags & LEFT)) {
600 widen(buf - n, end, n, spaces);
601 return buf + spaces;
602 }
603 while (spaces--) {
604 if (buf < end)
605 *buf = ' ';
606 ++buf;
607 }
608 }
609 return buf;
610}
611
Joe Perchescf3b4292010-05-24 14:33:16 -0700612static noinline_for_stack
613char *symbol_string(char *buf, char *end, void *ptr,
Joe Perchesb0d33c22012-12-12 10:18:50 -0800614 struct printf_spec spec, const char *fmt)
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700615{
Joe Perchesb0d33c22012-12-12 10:18:50 -0800616 unsigned long value;
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700617#ifdef CONFIG_KALLSYMS
618 char sym[KSYM_SYMBOL_LEN];
Joe Perchesb0d33c22012-12-12 10:18:50 -0800619#endif
620
621 if (fmt[1] == 'R')
622 ptr = __builtin_extract_return_addr(ptr);
623 value = (unsigned long)ptr;
624
625#ifdef CONFIG_KALLSYMS
626 if (*fmt == 'B')
Namhyung Kim0f77a8d2011-03-24 11:42:29 +0900627 sprint_backtrace(sym, value);
Joe Perchesb0d33c22012-12-12 10:18:50 -0800628 else if (*fmt != 'f' && *fmt != 's')
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +0200629 sprint_symbol(sym, value);
630 else
Stephen Boyd4796dd22012-05-29 15:07:33 -0700631 sprint_symbol_no_offset(sym, value);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800632
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100633 return string(buf, end, sym, spec);
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700634#else
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800635 spec.field_width = 2 * sizeof(void *);
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100636 spec.flags |= SPECIAL | SMALL | ZEROPAD;
637 spec.base = 16;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800638
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100639 return number(buf, end, value, spec);
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700640#endif
641}
642
Joe Perchescf3b4292010-05-24 14:33:16 -0700643static noinline_for_stack
644char *resource_string(char *buf, char *end, struct resource *res,
645 struct printf_spec spec, const char *fmt)
Linus Torvalds332d2e72008-10-20 15:07:34 +1100646{
647#ifndef IO_RSRC_PRINTK_SIZE
Bjorn Helgaas28405372009-10-06 15:33:29 -0600648#define IO_RSRC_PRINTK_SIZE 6
Linus Torvalds332d2e72008-10-20 15:07:34 +1100649#endif
650
651#ifndef MEM_RSRC_PRINTK_SIZE
Bjorn Helgaas28405372009-10-06 15:33:29 -0600652#define MEM_RSRC_PRINTK_SIZE 10
Linus Torvalds332d2e72008-10-20 15:07:34 +1100653#endif
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700654 static const struct printf_spec io_spec = {
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100655 .base = 16,
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700656 .field_width = IO_RSRC_PRINTK_SIZE,
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100657 .precision = -1,
658 .flags = SPECIAL | SMALL | ZEROPAD,
659 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700660 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 };
Bjorn Helgaas0f4050c2010-03-05 10:47:42 -0700666 static const struct printf_spec bus_spec = {
667 .base = 16,
668 .field_width = 2,
669 .precision = -1,
670 .flags = SMALL | ZEROPAD,
671 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700672 static const struct printf_spec dec_spec = {
Bjorn Helgaasc91d3372009-10-06 15:33:34 -0600673 .base = 10,
674 .precision = -1,
675 .flags = 0,
676 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700677 static const struct printf_spec str_spec = {
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600678 .field_width = -1,
679 .precision = 10,
680 .flags = LEFT,
681 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700682 static const struct printf_spec flag_spec = {
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600683 .base = 16,
684 .precision = -1,
685 .flags = SPECIAL | SMALL,
686 };
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600687
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))
Bjorn Helgaas9d7cca02010-03-05 10:47:47 -0700692#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600693#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
694 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
695 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
696
Linus Torvalds332d2e72008-10-20 15:07:34 +1100697 char *p = sym, *pend = sym + sizeof(sym);
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600698 int decode = (fmt[0] == 'R') ? 1 : 0;
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700699 const struct printf_spec *specp;
Linus Torvalds332d2e72008-10-20 15:07:34 +1100700
701 *p++ = '[';
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700702 if (res->flags & IORESOURCE_IO) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600703 p = string(p, pend, "io ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700704 specp = &io_spec;
705 } else if (res->flags & IORESOURCE_MEM) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600706 p = string(p, pend, "mem ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700707 specp = &mem_spec;
708 } else if (res->flags & IORESOURCE_IRQ) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600709 p = string(p, pend, "irq ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700710 specp = &dec_spec;
711 } else if (res->flags & IORESOURCE_DMA) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600712 p = string(p, pend, "dma ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700713 specp = &dec_spec;
Bjorn Helgaas0f4050c2010-03-05 10:47:42 -0700714 } else if (res->flags & IORESOURCE_BUS) {
715 p = string(p, pend, "bus ", str_spec);
716 specp = &bus_spec;
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700717 } else {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600718 p = string(p, pend, "??? ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700719 specp = &mem_spec;
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600720 decode = 0;
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600721 }
Bjorn Helgaasd19cb802014-02-26 11:25:56 -0700722 if (decode && res->flags & IORESOURCE_UNSET) {
723 p = string(p, pend, "size ", str_spec);
724 p = number(p, pend, resource_size(res), *specp);
725 } else {
726 p = number(p, pend, res->start, *specp);
727 if (res->start != res->end) {
728 *p++ = '-';
729 p = number(p, pend, res->end, *specp);
730 }
Bjorn Helgaasc91d3372009-10-06 15:33:34 -0600731 }
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600732 if (decode) {
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600733 if (res->flags & IORESOURCE_MEM_64)
734 p = string(p, pend, " 64bit", str_spec);
735 if (res->flags & IORESOURCE_PREFETCH)
736 p = string(p, pend, " pref", str_spec);
Bjorn Helgaas9d7cca02010-03-05 10:47:47 -0700737 if (res->flags & IORESOURCE_WINDOW)
738 p = string(p, pend, " window", str_spec);
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600739 if (res->flags & IORESOURCE_DISABLED)
740 p = string(p, pend, " disabled", str_spec);
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600741 } else {
742 p = string(p, pend, " flags ", str_spec);
743 p = number(p, pend, res->flags, flag_spec);
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600744 }
Linus Torvalds332d2e72008-10-20 15:07:34 +1100745 *p++ = ']';
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600746 *p = '\0';
Linus Torvalds332d2e72008-10-20 15:07:34 +1100747
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100748 return string(buf, end, sym, spec);
Linus Torvalds332d2e72008-10-20 15:07:34 +1100749}
750
Joe Perchescf3b4292010-05-24 14:33:16 -0700751static noinline_for_stack
Andy Shevchenko31550a12012-07-30 14:40:27 -0700752char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
753 const char *fmt)
754{
Steven Rostedt360603a2013-05-28 15:47:39 -0400755 int i, len = 1; /* if we pass '%ph[CDN]', field width remains
Andy Shevchenko31550a12012-07-30 14:40:27 -0700756 negative value, fallback to the default */
757 char separator;
758
759 if (spec.field_width == 0)
760 /* nothing to print */
761 return buf;
762
763 if (ZERO_OR_NULL_PTR(addr))
764 /* NULL pointer */
765 return string(buf, end, NULL, spec);
766
767 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 if (spec.field_width > 0)
783 len = min_t(int, spec.field_width, 64);
784
785 for (i = 0; i < len && buf < end - 1; i++) {
786 buf = hex_byte_pack(buf, addr[i]);
787
788 if (buf < end && separator && i != len - 1)
789 *buf++ = separator;
790 }
791
792 return buf;
793}
794
795static noinline_for_stack
Joe Perchescf3b4292010-05-24 14:33:16 -0700796char *mac_address_string(char *buf, char *end, u8 *addr,
797 struct printf_spec spec, const char *fmt)
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700798{
Joe Perches8a27f7c2009-08-17 12:29:44 +0000799 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700800 char *p = mac_addr;
801 int i;
Joe Perchesbc7259a2010-01-07 11:43:50 +0000802 char separator;
Andrei Emeltchenko76597ff92012-07-30 14:40:23 -0700803 bool reversed = false;
Joe Perchesbc7259a2010-01-07 11:43:50 +0000804
Andrei Emeltchenko76597ff92012-07-30 14:40:23 -0700805 switch (fmt[1]) {
806 case 'F':
Joe Perchesbc7259a2010-01-07 11:43:50 +0000807 separator = '-';
Andrei Emeltchenko76597ff92012-07-30 14:40:23 -0700808 break;
809
810 case 'R':
811 reversed = true;
812 /* fall through */
813
814 default:
Joe Perchesbc7259a2010-01-07 11:43:50 +0000815 separator = ':';
Andrei Emeltchenko76597ff92012-07-30 14:40:23 -0700816 break;
Joe Perchesbc7259a2010-01-07 11:43:50 +0000817 }
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700818
819 for (i = 0; i < 6; i++) {
Andrei Emeltchenko76597ff92012-07-30 14:40:23 -0700820 if (reversed)
821 p = hex_byte_pack(p, addr[5 - i]);
822 else
823 p = hex_byte_pack(p, addr[i]);
824
Joe Perches8a27f7c2009-08-17 12:29:44 +0000825 if (fmt[0] == 'M' && i != 5)
Joe Perchesbc7259a2010-01-07 11:43:50 +0000826 *p++ = separator;
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700827 }
828 *p = '\0';
829
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100830 return string(buf, end, mac_addr, spec);
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700831}
832
Joe Perchescf3b4292010-05-24 14:33:16 -0700833static noinline_for_stack
834char *ip4_string(char *p, const u8 *addr, const char *fmt)
Harvey Harrison689afa72008-10-28 16:04:44 -0700835{
Harvey Harrison689afa72008-10-28 16:04:44 -0700836 int i;
Joe Perches0159f242010-01-13 20:23:30 -0800837 bool leading_zeros = (fmt[0] == 'i');
838 int index;
839 int step;
Harvey Harrison689afa72008-10-28 16:04:44 -0700840
Joe Perches0159f242010-01-13 20:23:30 -0800841 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 break;
861 }
Joe Perches8a27f7c2009-08-17 12:29:44 +0000862 for (i = 0; i < 4; i++) {
863 char temp[3]; /* hold each IP quad in reverse order */
Denys Vlasenko133fd9f2012-05-31 16:26:08 -0700864 int digits = put_dec_trunc8(temp, addr[index]) - temp;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000865 if (leading_zeros) {
866 if (digits < 3)
867 *p++ = '0';
868 if (digits < 2)
869 *p++ = '0';
870 }
871 /* reverse the digits in the quad */
872 while (digits--)
873 *p++ = temp[digits];
874 if (i < 3)
875 *p++ = '.';
Joe Perches0159f242010-01-13 20:23:30 -0800876 index += step;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000877 }
Joe Perches8a27f7c2009-08-17 12:29:44 +0000878 *p = '\0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800879
Joe Perches8a27f7c2009-08-17 12:29:44 +0000880 return p;
881}
882
Joe Perchescf3b4292010-05-24 14:33:16 -0700883static noinline_for_stack
884char *ip6_compressed_string(char *p, const char *addr)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000885{
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800886 int i, j, range;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000887 unsigned char zerolength[8];
888 int longest = 1;
889 int colonpos = -1;
890 u16 word;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800891 u8 hi, lo;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000892 bool needcolon = false;
Joe Percheseb78cd22009-09-18 13:04:06 +0000893 bool useIPv4;
894 struct in6_addr in6;
895
896 memcpy(&in6, addr, sizeof(struct in6_addr));
897
898 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000899
900 memset(zerolength, 0, sizeof(zerolength));
901
902 if (useIPv4)
903 range = 6;
904 else
905 range = 8;
906
907 /* find position of longest 0 run */
908 for (i = 0; i < range; i++) {
909 for (j = i; j < range; j++) {
Joe Percheseb78cd22009-09-18 13:04:06 +0000910 if (in6.s6_addr16[j] != 0)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000911 break;
912 zerolength[i]++;
913 }
914 }
915 for (i = 0; i < range; i++) {
916 if (zerolength[i] > longest) {
917 longest = zerolength[i];
918 colonpos = i;
919 }
920 }
Joe Perches29cf5192011-06-09 11:23:37 -0700921 if (longest == 1) /* don't compress a single 0 */
922 colonpos = -1;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000923
924 /* emit address */
925 for (i = 0; i < range; i++) {
926 if (i == colonpos) {
927 if (needcolon || i == 0)
928 *p++ = ':';
929 *p++ = ':';
930 needcolon = false;
931 i += longest - 1;
932 continue;
933 }
934 if (needcolon) {
935 *p++ = ':';
936 needcolon = false;
937 }
938 /* hex u16 without leading 0s */
Joe Percheseb78cd22009-09-18 13:04:06 +0000939 word = ntohs(in6.s6_addr16[i]);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000940 hi = word >> 8;
941 lo = word & 0xff;
942 if (hi) {
943 if (hi > 0x0f)
Andy Shevchenko55036ba2011-10-31 17:12:41 -0700944 p = hex_byte_pack(p, hi);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000945 else
946 *p++ = hex_asc_lo(hi);
Andy Shevchenko55036ba2011-10-31 17:12:41 -0700947 p = hex_byte_pack(p, lo);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000948 }
André Goddard Rosab5ff9922009-12-14 18:00:59 -0800949 else if (lo > 0x0f)
Andy Shevchenko55036ba2011-10-31 17:12:41 -0700950 p = hex_byte_pack(p, lo);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000951 else
952 *p++ = hex_asc_lo(lo);
953 needcolon = true;
954 }
955
956 if (useIPv4) {
957 if (needcolon)
958 *p++ = ':';
Joe Perches0159f242010-01-13 20:23:30 -0800959 p = ip4_string(p, &in6.s6_addr[12], "I4");
Joe Perches8a27f7c2009-08-17 12:29:44 +0000960 }
Joe Perches8a27f7c2009-08-17 12:29:44 +0000961 *p = '\0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800962
Joe Perches8a27f7c2009-08-17 12:29:44 +0000963 return p;
964}
965
Joe Perchescf3b4292010-05-24 14:33:16 -0700966static noinline_for_stack
967char *ip6_string(char *p, const char *addr, const char *fmt)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000968{
969 int i;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800970
Harvey Harrison689afa72008-10-28 16:04:44 -0700971 for (i = 0; i < 8; i++) {
Andy Shevchenko55036ba2011-10-31 17:12:41 -0700972 p = hex_byte_pack(p, *addr++);
973 p = hex_byte_pack(p, *addr++);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000974 if (fmt[0] == 'I' && i != 7)
Harvey Harrison689afa72008-10-28 16:04:44 -0700975 *p++ = ':';
976 }
977 *p = '\0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800978
Joe Perches8a27f7c2009-08-17 12:29:44 +0000979 return p;
980}
981
Joe Perchescf3b4292010-05-24 14:33:16 -0700982static noinline_for_stack
983char *ip6_addr_string(char *buf, char *end, const u8 *addr,
984 struct printf_spec spec, const char *fmt)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000985{
986 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
987
988 if (fmt[0] == 'I' && fmt[2] == 'c')
Joe Percheseb78cd22009-09-18 13:04:06 +0000989 ip6_compressed_string(ip6_addr, addr);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000990 else
Joe Percheseb78cd22009-09-18 13:04:06 +0000991 ip6_string(ip6_addr, addr, fmt);
Harvey Harrison689afa72008-10-28 16:04:44 -0700992
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +0100993 return string(buf, end, ip6_addr, spec);
Harvey Harrison689afa72008-10-28 16:04:44 -0700994}
995
Joe Perchescf3b4292010-05-24 14:33:16 -0700996static noinline_for_stack
997char *ip4_addr_string(char *buf, char *end, const u8 *addr,
998 struct printf_spec spec, const char *fmt)
Harvey Harrison4aa99602008-10-29 12:49:58 -0700999{
Joe Perches8a27f7c2009-08-17 12:29:44 +00001000 char ip4_addr[sizeof("255.255.255.255")];
Harvey Harrison4aa99602008-10-29 12:49:58 -07001001
Joe Perches0159f242010-01-13 20:23:30 -08001002 ip4_string(ip4_addr, addr, fmt);
Harvey Harrison4aa99602008-10-29 12:49:58 -07001003
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001004 return string(buf, end, ip4_addr, spec);
Harvey Harrison4aa99602008-10-29 12:49:58 -07001005}
1006
Joe Perchescf3b4292010-05-24 14:33:16 -07001007static noinline_for_stack
Daniel Borkmann10679642013-06-28 19:49:39 +02001008char *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 const u8 *addr = (const u8 *) &sa->sin6_addr;
1017 char fmt6[2] = { fmt[0], '6' };
1018 u8 off = 0;
1019
1020 fmt++;
1021 while (isalpha(*++fmt)) {
1022 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 if (have_p || have_s || have_f) {
1039 *p = '[';
1040 off = 1;
1041 }
1042
1043 if (fmt6[0] == 'I' && have_c)
1044 p = ip6_compressed_string(ip6_addr + off, addr);
1045 else
1046 p = ip6_string(ip6_addr + off, addr, fmt6);
1047
1048 if (have_p || have_s || have_f)
1049 *p++ = ']';
1050
1051 if (have_p) {
1052 *p++ = ':';
1053 p = number(p, pend, ntohs(sa->sin6_port), spec);
1054 }
1055 if (have_f) {
1056 *p++ = '/';
1057 p = number(p, pend, ntohl(sa->sin6_flowinfo &
1058 IPV6_FLOWINFO_MASK), spec);
1059 }
1060 if (have_s) {
1061 *p++ = '%';
1062 p = number(p, pend, sa->sin6_scope_id, spec);
1063 }
1064 *p = '\0';
1065
1066 return string(buf, end, ip6_addr, spec);
1067}
1068
1069static noinline_for_stack
1070char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
1071 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 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
1077 char fmt4[3] = { fmt[0], '4', 0 };
1078
1079 fmt++;
1080 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 fmt4[2] = *fmt;
1090 break;
1091 }
1092 }
1093
1094 p = ip4_string(ip4_addr, addr, fmt4);
1095 if (have_p) {
1096 *p++ = ':';
1097 p = number(p, pend, ntohs(sa->sin_port), spec);
1098 }
1099 *p = '\0';
1100
1101 return string(buf, end, ip4_addr, spec);
1102}
1103
1104static noinline_for_stack
Andy Shevchenko71dca952014-10-13 15:55:18 -07001105char *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 if (spec.field_width == 0)
1114 return buf; /* nothing to print */
1115
1116 if (ZERO_OR_NULL_PTR(addr))
1117 return string(buf, end, NULL, spec); /* NULL pointer */
1118
1119
1120 do {
1121 switch (fmt[count++]) {
1122 case 'a':
1123 flags |= ESCAPE_ANY;
1124 break;
1125 case 'c':
1126 flags |= ESCAPE_SPECIAL;
1127 break;
1128 case 'h':
1129 flags |= ESCAPE_HEX;
1130 break;
1131 case 'n':
1132 flags |= ESCAPE_NULL;
1133 break;
1134 case 'o':
1135 flags |= ESCAPE_OCTAL;
1136 break;
1137 case 'p':
1138 flags |= ESCAPE_NP;
1139 break;
1140 case 's':
1141 flags |= ESCAPE_SPACE;
1142 break;
1143 default:
1144 found = false;
1145 break;
1146 }
1147 } while (found);
1148
1149 if (!flags)
1150 flags = ESCAPE_ANY_NP;
1151
1152 len = spec.field_width < 0 ? 1 : spec.field_width;
1153
1154 /* Ignore the error. We print as many characters as we can */
1155 string_escape_mem(addr, len, &buf, end - buf, flags, NULL);
1156
1157 return buf;
1158}
1159
1160static noinline_for_stack
Joe Perchescf3b4292010-05-24 14:33:16 -07001161char *uuid_string(char *buf, char *end, const u8 *addr,
1162 struct printf_spec spec, const char *fmt)
Joe Perches9ac6e442009-12-14 18:01:09 -08001163{
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 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 for (i = 0; i < 16; i++) {
Andy Shevchenko55036ba2011-10-31 17:12:41 -07001184 p = hex_byte_pack(p, addr[index[i]]);
Joe Perches9ac6e442009-12-14 18:01:09 -08001185 switch (i) {
1186 case 3:
1187 case 5:
1188 case 7:
1189 case 9:
1190 *p++ = '-';
1191 break;
1192 }
1193 }
1194
1195 *p = 0;
1196
1197 if (uc) {
1198 p = uuid;
1199 do {
1200 *p = toupper(*p);
1201 } while (*(++p));
1202 }
1203
1204 return string(buf, end, uuid, spec);
1205}
1206
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001207static
1208char *netdev_feature_string(char *buf, char *end, const u8 *addr,
1209 struct printf_spec spec)
1210{
1211 spec.flags |= SPECIAL | SMALL | ZEROPAD;
1212 if (spec.field_width == -1)
1213 spec.field_width = 2 + 2 * sizeof(netdev_features_t);
1214 spec.base = 16;
1215
1216 return number(buf, end, *(const netdev_features_t *)addr, spec);
1217}
1218
Joe Perchesaaf07622014-01-23 15:54:17 -08001219static noinline_for_stack
1220char *address_val(char *buf, char *end, const void *addr,
1221 struct printf_spec spec, const char *fmt)
1222{
1223 unsigned long long num;
1224
1225 spec.flags |= SPECIAL | SMALL | ZEROPAD;
1226 spec.base = 16;
1227
1228 switch (fmt[1]) {
1229 case 'd':
1230 num = *(const dma_addr_t *)addr;
1231 spec.field_width = sizeof(dma_addr_t) * 2 + 2;
1232 break;
1233 case 'p':
1234 default:
1235 num = *(const phys_addr_t *)addr;
1236 spec.field_width = sizeof(phys_addr_t) * 2 + 2;
1237 break;
1238 }
1239
1240 return number(buf, end, num, spec);
1241}
1242
Ingo Molnar411f05f2011-05-12 23:00:28 +02001243int kptr_restrict __read_mostly;
Dan Rosenberg455cd5a2011-01-12 16:59:41 -08001244
Linus Torvalds4d8a7432008-07-06 16:24:57 -07001245/*
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 *
Linus Torvalds332d2e72008-10-20 15:07:34 +11001250 * Right now we handle:
Linus Torvalds0fe1ef22008-07-06 16:43:12 -07001251 *
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +02001252 * - 'F' For symbolic function descriptor pointers with offset
1253 * - 'f' For simple symbolic function names without offset
Steven Rostedt0efb4d22009-09-17 09:27:29 -04001254 * - 'S' For symbolic direct pointers with offset
1255 * - 's' For symbolic direct pointers without offset
Joe Perchesb0d33c22012-12-12 10:18:50 -08001256 * - '[FfSs]R' as above with __builtin_extract_return_addr() translation
Namhyung Kim0f77a8d2011-03-24 11:42:29 +09001257 * - 'B' For backtraced symbolic direct pointers with offset
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -06001258 * - '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]
Harvey Harrisondd45c9c2008-10-27 15:47:12 -07001260 * - 'M' For a 6-byte MAC address, it prints the address in the
1261 * usual colon-separated hex notation
Joe Perches8a27f7c2009-08-17 12:29:44 +00001262 * - 'm' For a 6-byte MAC address, it prints the hex address without colons
Joe Perchesbc7259a2010-01-07 11:43:50 +00001263 * - 'MF' For a 6-byte MAC FDDI address, it prints the address
Joe Perchesc8e00062010-01-11 00:44:14 -08001264 * with a dash-separated hex notation
Andy Shevchenko7c591542012-10-04 17:12:33 -07001265 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)
Joe Perches8a27f7c2009-08-17 12:29:44 +00001266 * - '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
Daniel Borkmann10679642013-06-28 19:49:39 +02001269 * [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]
Joe Perches8a27f7c2009-08-17 12:29:44 +00001272 * - '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)
Daniel Borkmann10679642013-06-28 19:49:39 +02001275 * [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
Joe Perches29cf5192011-06-09 11:23:37 -07001280 * http://tools.ietf.org/html/rfc5952
Andy Shevchenko71dca952014-10-13 15:55:18 -07001281 * - '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.
Joe Perches9ac6e442009-12-14 18:01:09 -08001292 * - '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]
Joe Perches7db6f5f2010-06-27 01:02:33 +00001303 * - '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.
Dan Rosenberg455cd5a2011-01-12 16:59:41 -08001308 * - 'K' For a kernel pointer that should be hidden from unprivileged users
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001309 * - 'NF' For a netdev_features_t
Andy Shevchenko31550a12012-07-30 14:40:27 -07001310 * - '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.
Joe Perchesaaf07622014-01-23 15:54:17 -08001317 * - '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)
Olof Johanssonc0d92a52013-11-12 15:09:50 -08001319 * - 'd[234]' For a dentry name (optionally 2-4 last components)
1320 * - 'D[234]' Same as 'd' but for a struct file
Joe Perches9ac6e442009-12-14 18:01:09 -08001321 *
Linus Torvalds332d2e72008-10-20 15:07:34 +11001322 * 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.
Linus Torvalds4d8a7432008-07-06 16:24:57 -07001325 */
Joe Perchescf3b4292010-05-24 14:33:16 -07001326static noinline_for_stack
1327char *pointer(const char *fmt, char *buf, char *end, void *ptr,
1328 struct printf_spec spec)
Linus Torvalds78a8bf62008-07-06 16:16:15 -07001329{
Grant Likely725fe002012-05-31 16:26:08 -07001330 int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
1331
Kees Cook9f36e2c2011-03-22 16:34:22 -07001332 if (!ptr && *fmt != 'K') {
Joe Perches5e057982010-10-26 14:22:50 -07001333 /*
1334 * Print (null) with the same width as a pointer so it makes
1335 * tabular output look nice.
1336 */
1337 if (spec.field_width == -1)
Grant Likely725fe002012-05-31 16:26:08 -07001338 spec.field_width = default_width;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001339 return string(buf, end, "(null)", spec);
Joe Perches5e057982010-10-26 14:22:50 -07001340 }
Linus Torvaldsd97106a2009-01-03 11:46:17 -08001341
Linus Torvalds0fe1ef22008-07-06 16:43:12 -07001342 switch (*fmt) {
1343 case 'F':
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +02001344 case 'f':
Linus Torvalds0fe1ef22008-07-06 16:43:12 -07001345 ptr = dereference_function_descriptor(ptr);
1346 /* Fallthrough */
1347 case 'S':
Joe Perches9ac6e442009-12-14 18:01:09 -08001348 case 's':
Namhyung Kim0f77a8d2011-03-24 11:42:29 +09001349 case 'B':
Joe Perchesb0d33c22012-12-12 10:18:50 -08001350 return symbol_string(buf, end, ptr, spec, fmt);
Linus Torvalds332d2e72008-10-20 15:07:34 +11001351 case 'R':
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -06001352 case 'r':
Bjorn Helgaasfd955412009-10-06 15:33:39 -06001353 return resource_string(buf, end, ptr, spec, fmt);
Andy Shevchenko31550a12012-07-30 14:40:27 -07001354 case 'h':
1355 return hex_string(buf, end, ptr, spec, fmt);
Joe Perches8a27f7c2009-08-17 12:29:44 +00001356 case 'M': /* Colon separated: 00:01:02:03:04:05 */
1357 case 'm': /* Contiguous: 000102030405 */
Andrei Emeltchenko76597ff92012-07-30 14:40:23 -07001358 /* [mM]F (FDDI) */
1359 /* [mM]R (Reverse order; Bluetooth) */
Joe Perches8a27f7c2009-08-17 12:29:44 +00001360 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 switch (fmt[1]) {
1371 case '6':
1372 return ip6_addr_string(buf, end, ptr, spec, fmt);
1373 case '4':
1374 return ip4_addr_string(buf, end, ptr, spec, fmt);
Daniel Borkmann10679642013-06-28 19:49:39 +02001375 case 'S': {
1376 const union {
1377 struct sockaddr raw;
1378 struct sockaddr_in v4;
1379 struct sockaddr_in6 v6;
1380 } *sa = ptr;
1381
1382 switch (sa->raw.sa_family) {
1383 case AF_INET:
1384 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
1385 case AF_INET6:
1386 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
1387 default:
1388 return string(buf, end, "(invalid address)", spec);
1389 }}
Joe Perches8a27f7c2009-08-17 12:29:44 +00001390 }
Harvey Harrison4aa99602008-10-29 12:49:58 -07001391 break;
Andy Shevchenko71dca952014-10-13 15:55:18 -07001392 case 'E':
1393 return escaped_string(buf, end, ptr, spec, fmt);
Joe Perches9ac6e442009-12-14 18:01:09 -08001394 case 'U':
1395 return uuid_string(buf, end, ptr, spec, fmt);
Joe Perches7db6f5f2010-06-27 01:02:33 +00001396 case 'V':
Jan Beulich5756b762012-03-05 16:49:24 +00001397 {
1398 va_list va;
1399
1400 va_copy(va, *((struct va_format *)ptr)->va);
1401 buf += vsnprintf(buf, end > buf ? end - buf : 0,
1402 ((struct va_format *)ptr)->fmt, va);
1403 va_end(va);
1404 return buf;
1405 }
Dan Rosenberg455cd5a2011-01-12 16:59:41 -08001406 case 'K':
1407 /*
1408 * %pK cannot be used in IRQ context because its test
1409 * for CAP_SYSLOG would be meaningless.
1410 */
Dan Rosenberg3715c5302012-07-30 14:40:26 -07001411 if (kptr_restrict && (in_irq() || in_serving_softirq() ||
1412 in_nmi())) {
Dan Rosenberg455cd5a2011-01-12 16:59:41 -08001413 if (spec.field_width == -1)
Grant Likely725fe002012-05-31 16:26:08 -07001414 spec.field_width = default_width;
Dan Rosenberg455cd5a2011-01-12 16:59:41 -08001415 return string(buf, end, "pK-error", spec);
Dan Rosenberg455cd5a2011-01-12 16:59:41 -08001416 }
Ryan Mallon312b4e22013-11-12 15:08:51 -08001417
1418 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 const struct cred *cred = current_cred();
1433
1434 if (!has_capability_noaudit(current, CAP_SYSLOG) ||
1435 !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 */
Joe Perches26297602011-03-22 16:34:19 -07001443 ptr = NULL;
Ryan Mallon312b4e22013-11-12 15:08:51 -08001444 break;
1445 }
Joe Perches26297602011-03-22 16:34:19 -07001446 break;
Ryan Mallon312b4e22013-11-12 15:08:51 -08001447
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001448 case 'N':
1449 switch (fmt[1]) {
1450 case 'F':
1451 return netdev_feature_string(buf, end, ptr, spec);
1452 }
1453 break;
Stepan Moskovchenko7d799212013-02-21 16:43:09 -08001454 case 'a':
Joe Perchesaaf07622014-01-23 15:54:17 -08001455 return address_val(buf, end, ptr, spec, fmt);
Al Viro4b6ccca2013-09-03 12:00:44 -04001456 case 'd':
1457 return dentry_name(buf, end, ptr, spec, fmt);
1458 case 'D':
1459 return dentry_name(buf, end,
1460 ((const struct file *)ptr)->f_path.dentry,
1461 spec, fmt);
Linus Torvalds0fe1ef22008-07-06 16:43:12 -07001462 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001463 spec.flags |= SMALL;
1464 if (spec.field_width == -1) {
Grant Likely725fe002012-05-31 16:26:08 -07001465 spec.field_width = default_width;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001466 spec.flags |= ZEROPAD;
Linus Torvalds78a8bf62008-07-06 16:16:15 -07001467 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001468 spec.base = 16;
1469
1470 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 */
Joe Perchescf3b4292010-05-24 14:33:16 -07001493static noinline_for_stack
1494int format_decode(const char *fmt, struct printf_spec *spec)
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001495{
1496 const char *start = fmt;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001497
1498 /* we finished early by reading the field width */
Vegard Nossumed681a92009-03-14 12:08:50 +01001499 if (spec->type == FORMAT_TYPE_WIDTH) {
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001500 if (spec->field_width < 0) {
1501 spec->field_width = -spec->field_width;
1502 spec->flags |= LEFT;
1503 }
1504 spec->type = FORMAT_TYPE_NONE;
1505 goto precision;
1506 }
1507
1508 /* we finished early by reading the precision */
1509 if (spec->type == FORMAT_TYPE_PRECISION) {
1510 if (spec->precision < 0)
1511 spec->precision = 0;
1512
1513 spec->type = FORMAT_TYPE_NONE;
1514 goto qualifier;
1515 }
1516
1517 /* By default */
1518 spec->type = FORMAT_TYPE_NONE;
1519
1520 for (; *fmt ; ++fmt) {
1521 if (*fmt == '%')
1522 break;
1523 }
1524
1525 /* Return the current non-format string */
1526 if (fmt != start || !*fmt)
1527 return fmt - start;
1528
1529 /* Process flags */
1530 spec->flags = 0;
1531
1532 while (1) { /* this also skips first '%' */
1533 bool found = true;
1534
1535 ++fmt;
1536
1537 switch (*fmt) {
1538 case '-': spec->flags |= LEFT; break;
1539 case '+': spec->flags |= PLUS; break;
1540 case ' ': spec->flags |= SPACE; break;
1541 case '#': spec->flags |= SPECIAL; break;
1542 case '0': spec->flags |= ZEROPAD; break;
1543 default: found = false;
1544 }
1545
1546 if (!found)
1547 break;
1548 }
1549
1550 /* get field width */
1551 spec->field_width = -1;
1552
1553 if (isdigit(*fmt))
1554 spec->field_width = skip_atoi(&fmt);
1555 else if (*fmt == '*') {
1556 /* it's the next argument */
Vegard Nossumed681a92009-03-14 12:08:50 +01001557 spec->type = FORMAT_TYPE_WIDTH;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001558 return ++fmt - start;
1559 }
1560
1561precision:
1562 /* get the precision */
1563 spec->precision = -1;
1564 if (*fmt == '.') {
1565 ++fmt;
1566 if (isdigit(*fmt)) {
1567 spec->precision = skip_atoi(&fmt);
1568 if (spec->precision < 0)
1569 spec->precision = 0;
1570 } else if (*fmt == '*') {
1571 /* it's the next argument */
Vegard Nossumadf26f82009-03-14 12:08:50 +01001572 spec->type = FORMAT_TYPE_PRECISION;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001573 return ++fmt - start;
1574 }
1575 }
1576
1577qualifier:
1578 /* get the conversion qualifier */
1579 spec->qualifier = -1;
Andy Shevchenko75fb8f22011-07-25 17:13:20 -07001580 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
1581 _tolower(*fmt) == 'z' || *fmt == 't') {
Zhaoleia4e94ef2009-03-27 17:07:05 +08001582 spec->qualifier = *fmt++;
1583 if (unlikely(spec->qualifier == *fmt)) {
1584 if (spec->qualifier == 'l') {
1585 spec->qualifier = 'L';
1586 ++fmt;
1587 } else if (spec->qualifier == 'h') {
1588 spec->qualifier = 'H';
1589 ++fmt;
1590 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001591 }
1592 }
1593
1594 /* default base */
1595 spec->base = 10;
1596 switch (*fmt) {
1597 case 'c':
1598 spec->type = FORMAT_TYPE_CHAR;
1599 return ++fmt - start;
1600
1601 case 's':
1602 spec->type = FORMAT_TYPE_STR;
1603 return ++fmt - start;
1604
1605 case 'p':
1606 spec->type = FORMAT_TYPE_PTR;
1607 return fmt - start;
1608 /* skip alnum */
1609
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001610 case '%':
1611 spec->type = FORMAT_TYPE_PERCENT_CHAR;
1612 return ++fmt - start;
1613
1614 /* integer number formats - set up the flags and "break" */
1615 case 'o':
1616 spec->base = 8;
1617 break;
1618
1619 case 'x':
1620 spec->flags |= SMALL;
1621
1622 case 'X':
1623 spec->base = 16;
1624 break;
1625
1626 case 'd':
1627 case 'i':
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001628 spec->flags |= SIGN;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001629 case 'u':
1630 break;
1631
Ryan Mallon708d96fd2014-04-03 14:48:37 -07001632 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
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001641 default:
1642 spec->type = FORMAT_TYPE_INVALID;
1643 return fmt - start;
1644 }
1645
1646 if (spec->qualifier == 'L')
1647 spec->type = FORMAT_TYPE_LONG_LONG;
1648 else if (spec->qualifier == 'l') {
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001649 if (spec->flags & SIGN)
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001650 spec->type = FORMAT_TYPE_LONG;
1651 else
1652 spec->type = FORMAT_TYPE_ULONG;
Andy Shevchenko75fb8f22011-07-25 17:13:20 -07001653 } else if (_tolower(spec->qualifier) == 'z') {
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001654 spec->type = FORMAT_TYPE_SIZE_T;
1655 } else if (spec->qualifier == 't') {
1656 spec->type = FORMAT_TYPE_PTRDIFF;
Zhaoleia4e94ef2009-03-27 17:07:05 +08001657 } else if (spec->qualifier == 'H') {
1658 if (spec->flags & SIGN)
1659 spec->type = FORMAT_TYPE_BYTE;
1660 else
1661 spec->type = FORMAT_TYPE_UBYTE;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001662 } else if (spec->qualifier == 'h') {
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001663 if (spec->flags & SIGN)
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001664 spec->type = FORMAT_TYPE_SHORT;
1665 else
1666 spec->type = FORMAT_TYPE_USHORT;
1667 } else {
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001668 if (spec->flags & SIGN)
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001669 spec->type = FORMAT_TYPE_INT;
1670 else
1671 spec->type = FORMAT_TYPE_UINT;
1672 }
1673
1674 return ++fmt - start;
Linus Torvalds78a8bf62008-07-06 16:16:15 -07001675}
1676
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677/**
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 *
Andi Kleen20036fd2008-10-15 22:02:02 -07001684 * This function follows C99 vsnprintf, but has some extensions:
Steven Rostedt91adcd22009-09-16 20:03:06 -04001685 * %pS output the name of a text symbol with offset
1686 * %ps output the name of a text symbol without offset
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +02001687 * %pF output the name of a function pointer with its offset
1688 * %pf output the name of a function pointer without its offset
Namhyung Kim0f77a8d2011-03-24 11:42:29 +09001689 * %pB output the name of a backtrace symbol with its offset
Uwe Kleine-König8a795032009-12-17 15:27:12 -08001690 * %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
Andy Shevchenko7c591542012-10-04 17:12:33 -07001693 * %pMR output a 6-byte MAC address with colons in reversed order
1694 * %pMF output a 6-byte MAC address with dashes
Uwe Kleine-König8a795032009-12-17 15:27:12 -08001695 * %pm output a 6-byte MAC address without colons
Andy Shevchenko7c591542012-10-04 17:12:33 -07001696 * %pmR output a 6-byte MAC address without colons in reversed order
Uwe Kleine-König8a795032009-12-17 15:27:12 -08001697 * %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
Jan Engelhardtf996f202011-07-14 18:48:56 +02001701 * %pI6c print an IPv6 address as specified by RFC 5952
Daniel Borkmann10679642013-06-28 19:49:39 +02001702 * %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
Uwe Kleine-König8a795032009-12-17 15:27:12 -08001704 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
1705 * case.
Andy Shevchenko71dca952014-10-13 15:55:18 -07001706 * %*pE[achnops] print an escaped buffer
Andy Shevchenko31550a12012-07-30 14:40:27 -07001707 * %*ph[CDN] a variable-length hex string with a separator (supports up to 64
1708 * bytes of the input)
Steven Rostedt0efb4d22009-09-17 09:27:29 -04001709 * %n is ignored
Andi Kleen20036fd2008-10-15 22:02:02 -07001710 *
Andrew Morton80f548e2012-07-30 14:40:25 -07001711 * ** Please update Documentation/printk-formats.txt when making changes **
1712 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 * 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
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001717 * (not including the trailing '\0'), use vscnprintf(). If the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 * return is greater than or equal to @size, the resulting
1719 * string is truncated.
1720 *
Uwe Kleine-Königba1835e2011-04-06 07:49:04 -07001721 * If you're not already dealing with a va_list consider using snprintf().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 */
1723int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1724{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 unsigned long long num;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001726 char *str, *end;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001727 struct printf_spec spec = {0};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001729 /* Reject out-of-range values early. Large positive sizes are
1730 used for unknown buffer sizes. */
Marcin Slusarz2f30b1f92009-09-21 17:04:29 -07001731 if (WARN_ON_ONCE((int) size < 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733
1734 str = buf;
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001735 end = buf + size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001737 /* Make sure end is always >= buf */
1738 if (end < buf) {
1739 end = ((void *)-1);
1740 size = end - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 }
1742
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001743 while (*fmt) {
1744 const char *old_fmt = fmt;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001745 int read = format_decode(fmt, &spec);
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001746
1747 fmt += read;
1748
1749 switch (spec.type) {
1750 case FORMAT_TYPE_NONE: {
1751 int copy = read;
1752 if (str < end) {
1753 if (copy > end - str)
1754 copy = end - str;
1755 memcpy(str, old_fmt, copy);
1756 }
1757 str += read;
1758 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 }
1760
Vegard Nossumed681a92009-03-14 12:08:50 +01001761 case FORMAT_TYPE_WIDTH:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001762 spec.field_width = va_arg(args, int);
1763 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001765 case FORMAT_TYPE_PRECISION:
1766 spec.precision = va_arg(args, int);
1767 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768
André Goddard Rosad4be1512009-12-14 18:00:59 -08001769 case FORMAT_TYPE_CHAR: {
1770 char c;
1771
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001772 if (!(spec.flags & LEFT)) {
1773 while (--spec.field_width > 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001774 if (str < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 *str = ' ';
1776 ++str;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001777
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001779 }
1780 c = (unsigned char) va_arg(args, int);
1781 if (str < end)
1782 *str = c;
1783 ++str;
1784 while (--spec.field_width > 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001785 if (str < end)
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001786 *str = ' ';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 ++str;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001788 }
1789 break;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001792 case FORMAT_TYPE_STR:
1793 str = string(str, end, va_arg(args, char *), spec);
1794 break;
1795
1796 case FORMAT_TYPE_PTR:
1797 str = pointer(fmt+1, str, end, va_arg(args, void *),
1798 spec);
1799 while (isalnum(*fmt))
1800 fmt++;
1801 break;
1802
1803 case FORMAT_TYPE_PERCENT_CHAR:
1804 if (str < end)
1805 *str = '%';
1806 ++str;
1807 break;
1808
1809 case FORMAT_TYPE_INVALID:
1810 if (str < end)
1811 *str = '%';
1812 ++str;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001813 break;
1814
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001815 default:
1816 switch (spec.type) {
1817 case FORMAT_TYPE_LONG_LONG:
1818 num = va_arg(args, long long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 break;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001820 case FORMAT_TYPE_ULONG:
1821 num = va_arg(args, unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 break;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001823 case FORMAT_TYPE_LONG:
1824 num = va_arg(args, long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 break;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001826 case FORMAT_TYPE_SIZE_T:
Jason Gunthorpeef124962012-12-17 15:59:58 -08001827 if (spec.flags & SIGN)
1828 num = va_arg(args, ssize_t);
1829 else
1830 num = va_arg(args, size_t);
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001831 break;
1832 case FORMAT_TYPE_PTRDIFF:
1833 num = va_arg(args, ptrdiff_t);
1834 break;
Zhaoleia4e94ef2009-03-27 17:07:05 +08001835 case FORMAT_TYPE_UBYTE:
1836 num = (unsigned char) va_arg(args, int);
1837 break;
1838 case FORMAT_TYPE_BYTE:
1839 num = (signed char) va_arg(args, int);
1840 break;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001841 case FORMAT_TYPE_USHORT:
1842 num = (unsigned short) va_arg(args, int);
1843 break;
1844 case FORMAT_TYPE_SHORT:
1845 num = (short) va_arg(args, int);
1846 break;
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001847 case FORMAT_TYPE_INT:
1848 num = (int) va_arg(args, int);
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001849 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 default:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001851 num = va_arg(args, unsigned int);
1852 }
1853
1854 str = number(str, end, num, spec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001857
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001858 if (size > 0) {
1859 if (str < end)
1860 *str = '\0';
1861 else
Linus Torvalds0a6047e2006-06-28 17:09:34 -07001862 end[-1] = '\0';
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001863 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001864
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001865 /* the trailing null byte doesn't count towards the total */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 return str-buf;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01001867
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869EXPORT_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
Anton Arapovb921c692011-01-12 16:59:49 -08001879 * the @buf not including the trailing '\0'. If @size is == 0 the function
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 * returns 0.
1881 *
Uwe Kleine-Königba1835e2011-04-06 07:49:04 -07001882 * If you're not already dealing with a va_list consider using scnprintf().
Andi Kleen20036fd2008-10-15 22:02:02 -07001883 *
1884 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 */
1886int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1887{
1888 int i;
1889
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001890 i = vsnprintf(buf, size, fmt, args);
1891
Anton Arapovb921c692011-01-12 16:59:49 -08001892 if (likely(i < size))
1893 return i;
1894 if (size != 0)
1895 return size - 1;
1896 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898EXPORT_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.
Andi Kleen20036fd2008-10-15 22:02:02 -07001911 *
1912 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001914int snprintf(char *buf, size_t size, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915{
1916 va_list args;
1917 int i;
1918
1919 va_start(args, fmt);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001920 i = vsnprintf(buf, size, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 return i;
1924}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925EXPORT_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
Changli Gaob903c0b2010-10-26 14:22:50 -07001935 * the trailing '\0'. If @size is == 0 the function returns 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 */
1937
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001938int scnprintf(char *buf, size_t size, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939{
1940 va_list args;
1941 int i;
1942
1943 va_start(args, fmt);
Anton Arapovb921c692011-01-12 16:59:49 -08001944 i = vscnprintf(buf, size, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001946
Anton Arapovb921c692011-01-12 16:59:49 -08001947 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948}
1949EXPORT_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
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001958 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 * buffer overflows.
1960 *
Uwe Kleine-Königba1835e2011-04-06 07:49:04 -07001961 * If you're not already dealing with a va_list consider using sprintf().
Andi Kleen20036fd2008-10-15 22:02:02 -07001962 *
1963 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 */
1965int vsprintf(char *buf, const char *fmt, va_list args)
1966{
1967 return vsnprintf(buf, INT_MAX, fmt, args);
1968}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969EXPORT_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
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001978 * into @buf. Use snprintf() or scnprintf() in order to avoid
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 * buffer overflows.
Andi Kleen20036fd2008-10-15 22:02:02 -07001980 *
1981 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001983int sprintf(char *buf, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984{
1985 va_list args;
1986 int i;
1987
1988 va_start(args, fmt);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001989 i = vsnprintf(buf, INT_MAX, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001991
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 return i;
1993}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994EXPORT_SYMBOL(sprintf);
1995
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001996#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
Masanari Iidada3dae52014-09-09 01:27:23 +09002011 * is skipped.
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002012 *
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 */
2020int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
2021{
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002022 struct printf_spec spec = {0};
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002023 char *str, *end;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002024
2025 str = (char *)bin_buf;
2026 end = (char *)(bin_buf + size);
2027
2028#define save_arg(type) \
2029do { \
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
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002048 while (*fmt) {
André Goddard Rosad4be1512009-12-14 18:00:59 -08002049 int read = format_decode(fmt, &spec);
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002050
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002051 fmt += read;
2052
2053 switch (spec.type) {
2054 case FORMAT_TYPE_NONE:
André Goddard Rosad4be1512009-12-14 18:00:59 -08002055 case FORMAT_TYPE_INVALID:
2056 case FORMAT_TYPE_PERCENT_CHAR:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002057 break;
2058
Vegard Nossumed681a92009-03-14 12:08:50 +01002059 case FORMAT_TYPE_WIDTH:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002060 case FORMAT_TYPE_PRECISION:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002061 save_arg(int);
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002062 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002063
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002064 case FORMAT_TYPE_CHAR:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002065 save_arg(char);
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002066 break;
2067
2068 case FORMAT_TYPE_STR: {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002069 const char *save_str = va_arg(args, char *);
2070 size_t len;
André Goddard Rosa6c356632009-12-14 18:00:56 -08002071
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002072 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
2073 || (unsigned long)save_str < PAGE_SIZE)
André Goddard Rosa0f4f81d2009-12-14 18:00:55 -08002074 save_str = "(null)";
André Goddard Rosa6c356632009-12-14 18:00:56 -08002075 len = strlen(save_str) + 1;
2076 if (str + len < end)
2077 memcpy(str, save_str, len);
2078 str += len;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002079 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002080 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002081
2082 case FORMAT_TYPE_PTR:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002083 save_arg(void *);
2084 /* skip all alphanumeric pointer suffixes */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002085 while (isalnum(*fmt))
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002086 fmt++;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002087 break;
2088
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002089 default:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002090 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;
Zhaoleia4e94ef2009-03-27 17:07:05 +08002105 case FORMAT_TYPE_UBYTE:
2106 case FORMAT_TYPE_BYTE:
2107 save_arg(char);
2108 break;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002109 case FORMAT_TYPE_USHORT:
2110 case FORMAT_TYPE_SHORT:
2111 save_arg(short);
2112 break;
2113 default:
2114 save_arg(int);
2115 }
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002116 }
2117 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002118
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002119 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002120#undef save_arg
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002121}
2122EXPORT_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:
Steven Rostedt0efb4d22009-09-17 09:27:29 -04002136 * see vsnprintf comment for details.
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002137 *
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 */
2146int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
2147{
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002148 struct printf_spec spec = {0};
André Goddard Rosad4be1512009-12-14 18:00:59 -08002149 char *str, *end;
2150 const char *args = (const char *)bin_buf;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002151
Marcin Slusarz2f30b1f92009-09-21 17:04:29 -07002152 if (WARN_ON_ONCE((int) size < 0))
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002153 return 0;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002154
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
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002179 while (*fmt) {
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002180 const char *old_fmt = fmt;
André Goddard Rosad4be1512009-12-14 18:00:59 -08002181 int read = format_decode(fmt, &spec);
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002182
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002183 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);
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002192 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002193 str += read;
2194 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002195 }
2196
Vegard Nossumed681a92009-03-14 12:08:50 +01002197 case FORMAT_TYPE_WIDTH:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002198 spec.field_width = get_arg(int);
2199 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002200
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002201 case FORMAT_TYPE_PRECISION:
2202 spec.precision = get_arg(int);
2203 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002204
André Goddard Rosad4be1512009-12-14 18:00:59 -08002205 case FORMAT_TYPE_CHAR: {
2206 char c;
2207
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002208 if (!(spec.flags & LEFT)) {
2209 while (--spec.field_width > 0) {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002210 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;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002219 while (--spec.field_width > 0) {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002220 if (str < end)
2221 *str = ' ';
2222 ++str;
2223 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002224 break;
André Goddard Rosad4be1512009-12-14 18:00:59 -08002225 }
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002226
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002227 case FORMAT_TYPE_STR: {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002228 const char *str_arg = args;
André Goddard Rosad4be1512009-12-14 18:00:59 -08002229 args += strlen(str_arg) + 1;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002230 str = string(str, end, (char *)str_arg, spec);
2231 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002232 }
2233
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002234 case FORMAT_TYPE_PTR:
2235 str = pointer(fmt+1, str, end, get_arg(void *), spec);
2236 while (isalnum(*fmt))
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002237 fmt++;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002238 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002239
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002240 case FORMAT_TYPE_PERCENT_CHAR:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002241 case FORMAT_TYPE_INVALID:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002242 if (str < end)
2243 *str = '%';
2244 ++str;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002245 break;
2246
André Goddard Rosad4be1512009-12-14 18:00:59 -08002247 default: {
2248 unsigned long long num;
2249
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002250 switch (spec.type) {
2251
2252 case FORMAT_TYPE_LONG_LONG:
2253 num = get_arg(long long);
2254 break;
2255 case FORMAT_TYPE_ULONG:
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002256 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;
Zhaoleia4e94ef2009-03-27 17:07:05 +08002265 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;
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002271 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);
André Goddard Rosad4be1512009-12-14 18:00:59 -08002285 } /* default: */
2286 } /* switch(spec.type) */
2287 } /* while(*fmt) */
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002288
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002289 if (size > 0) {
2290 if (str < end)
2291 *str = '\0';
2292 else
2293 end[-1] = '\0';
2294 }
Frederic Weisbeckerfef20d9c2009-03-06 17:21:50 +01002295
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002296#undef get_arg
2297
2298 /* the trailing null byte doesn't count towards the total */
2299 return str - buf;
2300}
2301EXPORT_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 */
2313int 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);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002321
Lai Jiangshan4370aa42009-03-06 17:21:46 +01002322 return ret;
2323}
2324EXPORT_SYMBOL_GPL(bprintf);
2325
2326#endif /* CONFIG_BINARY_PRINTF */
2327
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328/**
2329 * vsscanf - Unformat a buffer into a list of arguments
2330 * @buf: input buffer
2331 * @fmt: format of buffer
2332 * @args: arguments
2333 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002334int vsscanf(const char *buf, const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335{
2336 const char *str = buf;
2337 char *next;
2338 char digit;
2339 int num = 0;
Joe Perchesef0658f2010-03-06 17:10:14 -08002340 u8 qualifier;
Jan Beulich53809752012-12-17 16:01:31 -08002341 unsigned int base;
2342 union {
2343 long long s;
2344 unsigned long long u;
2345 } val;
Joe Perchesef0658f2010-03-06 17:10:14 -08002346 s16 field_width;
André Goddard Rosad4be1512009-12-14 18:00:59 -08002347 bool is_sign;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
Jan Beulichda990752012-10-04 17:13:24 -07002349 while (*fmt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 /* 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 if (isspace(*fmt)) {
André Goddard Rosae7d28602009-12-14 18:01:06 -08002355 fmt = skip_spaces(++fmt);
2356 str = skip_spaces(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 }
2358
2359 /* anything that is not a conversion must match exactly */
2360 if (*fmt != '%' && *fmt) {
2361 if (*fmt++ != *str++)
2362 break;
2363 continue;
2364 }
2365
2366 if (!*fmt)
2367 break;
2368 ++fmt;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002369
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 /* skip this conversion.
2371 * advance both strings to next white space
2372 */
2373 if (*fmt == '*') {
Jan Beulichda990752012-10-04 17:13:24 -07002374 if (!*str)
2375 break;
Andy Spencer8fccae22009-10-01 15:44:27 -07002376 while (!isspace(*fmt) && *fmt != '%' && *fmt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 fmt++;
2378 while (!isspace(*str) && *str)
2379 str++;
2380 continue;
2381 }
2382
2383 /* get field width */
2384 field_width = -1;
Jan Beulich53809752012-12-17 16:01:31 -08002385 if (isdigit(*fmt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 field_width = skip_atoi(&fmt);
Jan Beulich53809752012-12-17 16:01:31 -08002387 if (field_width <= 0)
2388 break;
2389 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
2391 /* get conversion qualifier */
2392 qualifier = -1;
Andy Shevchenko75fb8f22011-07-25 17:13:20 -07002393 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2394 _tolower(*fmt) == 'z') {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 qualifier = *fmt++;
2396 if (unlikely(qualifier == *fmt)) {
2397 if (qualifier == 'h') {
2398 qualifier = 'H';
2399 fmt++;
2400 } else if (qualifier == 'l') {
2401 qualifier = 'L';
2402 fmt++;
2403 }
2404 }
2405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406
Jan Beulichda990752012-10-04 17:13:24 -07002407 if (!*fmt)
2408 break;
2409
2410 if (*fmt == 'n') {
2411 /* return number of characters read so far */
2412 *va_arg(args, int *) = str - buf;
2413 ++fmt;
2414 continue;
2415 }
2416
2417 if (!*str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 break;
2419
André Goddard Rosad4be1512009-12-14 18:00:59 -08002420 base = 10;
Fabian Frederick3f623eb2014-06-04 16:11:52 -07002421 is_sign = false;
André Goddard Rosad4be1512009-12-14 18:00:59 -08002422
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002423 switch (*fmt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 case 'c':
2425 {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002426 char *s = (char *)va_arg(args, char*);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 if (field_width == -1)
2428 field_width = 1;
2429 do {
2430 *s++ = *str++;
2431 } while (--field_width > 0 && *str);
2432 num++;
2433 }
2434 continue;
2435 case 's':
2436 {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002437 char *s = (char *)va_arg(args, char *);
2438 if (field_width == -1)
Alexey Dobriyan4be929b2010-05-24 14:33:03 -07002439 field_width = SHRT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 /* first, skip leading white space in buffer */
André Goddard Rosae7d28602009-12-14 18:01:06 -08002441 str = skip_spaces(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442
2443 /* now copy until next white space */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002444 while (*str && !isspace(*str) && field_width--)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 *s++ = *str++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 *s = '\0';
2447 num++;
2448 }
2449 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 case 'o':
2451 base = 8;
2452 break;
2453 case 'x':
2454 case 'X':
2455 base = 16;
2456 break;
2457 case 'i':
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002458 base = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 case 'd':
Fabian Frederick3f623eb2014-06-04 16:11:52 -07002460 is_sign = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 case 'u':
2462 break;
2463 case '%':
2464 /* looking for '%' in str */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002465 if (*str++ != '%')
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 return num;
2467 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 */
André Goddard Rosae7d28602009-12-14 18:01:06 -08002476 str = skip_spaces(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477
2478 digit = *str;
2479 if (is_sign && digit == '-')
2480 digit = *(str + 1);
2481
2482 if (!digit
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002483 || (base == 16 && !isxdigit(digit))
2484 || (base == 10 && !isdigit(digit))
2485 || (base == 8 && (!isdigit(digit) || digit > '7'))
2486 || (base == 0 && !isdigit(digit)))
2487 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488
Jan Beulich53809752012-12-17 16:01:31 -08002489 if (is_sign)
2490 val.s = qualifier != 'L' ?
2491 simple_strtol(str, &next, base) :
2492 simple_strtoll(str, &next, base);
2493 else
2494 val.u = qualifier != 'L' ?
2495 simple_strtoul(str, &next, base) :
2496 simple_strtoull(str, &next, base);
2497
2498 if (field_width > 0 && next - str > field_width) {
2499 if (base == 0)
2500 _parse_integer_fixup_radix(str, &base);
2501 while (next - str > field_width) {
2502 if (is_sign)
2503 val.s = div_s64(val.s, base);
2504 else
2505 val.u = div_u64(val.u, base);
2506 --next;
2507 }
2508 }
2509
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002510 switch (qualifier) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 case 'H': /* that's 'hh' in format */
Jan Beulich53809752012-12-17 16:01:31 -08002512 if (is_sign)
2513 *va_arg(args, signed char *) = val.s;
2514 else
2515 *va_arg(args, unsigned char *) = val.u;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 break;
2517 case 'h':
Jan Beulich53809752012-12-17 16:01:31 -08002518 if (is_sign)
2519 *va_arg(args, short *) = val.s;
2520 else
2521 *va_arg(args, unsigned short *) = val.u;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 break;
2523 case 'l':
Jan Beulich53809752012-12-17 16:01:31 -08002524 if (is_sign)
2525 *va_arg(args, long *) = val.s;
2526 else
2527 *va_arg(args, unsigned long *) = val.u;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 break;
2529 case 'L':
Jan Beulich53809752012-12-17 16:01:31 -08002530 if (is_sign)
2531 *va_arg(args, long long *) = val.s;
2532 else
2533 *va_arg(args, unsigned long long *) = val.u;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 break;
2535 case 'Z':
2536 case 'z':
Jan Beulich53809752012-12-17 16:01:31 -08002537 *va_arg(args, size_t *) = val.u;
2538 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 default:
Jan Beulich53809752012-12-17 16:01:31 -08002540 if (is_sign)
2541 *va_arg(args, int *) = val.s;
2542 else
2543 *va_arg(args, unsigned int *) = val.u;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 break;
2545 }
2546 num++;
2547
2548 if (!next)
2549 break;
2550 str = next;
2551 }
Johannes Bergc6b40d12007-05-08 00:27:20 -07002552
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 return num;
2554}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555EXPORT_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 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002563int sscanf(const char *buf, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564{
2565 va_list args;
2566 int i;
2567
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002568 va_start(args, fmt);
2569 i = vsscanf(buf, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002571
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572 return i;
2573}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574EXPORT_SYMBOL(sscanf);