1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Helpers for formatting and printing strings |
4 | * |
5 | * Copyright 31 August 2008 James Bottomley |
6 | * Copyright (C) 2013, Intel Corporation |
7 | */ |
8 | #include <linux/bug.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/math64.h> |
11 | #include <linux/export.h> |
12 | #include <linux/ctype.h> |
13 | #include <linux/device.h> |
14 | #include <linux/errno.h> |
15 | #include <linux/fs.h> |
16 | #include <linux/limits.h> |
17 | #include <linux/mm.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/string.h> |
20 | #include <linux/string_helpers.h> |
21 | |
22 | /** |
23 | * string_get_size - get the size in the specified units |
24 | * @size: The size to be converted in blocks |
25 | * @blk_size: Size of the block (use 1 for size in bytes) |
26 | * @units: units to use (powers of 1000 or 1024) |
27 | * @buf: buffer to format to |
28 | * @len: length of buffer |
29 | * |
30 | * This function returns a string formatted to 3 significant figures |
31 | * giving the size in the required units. @buf should have room for |
32 | * at least 9 bytes and will always be zero terminated. |
33 | * |
34 | * Return value: number of characters of output that would have been written |
35 | * (which may be greater than len, if output was truncated). |
36 | */ |
37 | int string_get_size(u64 size, u64 blk_size, const enum string_size_units units, |
38 | char *buf, int len) |
39 | { |
40 | static const char *const units_10[] = { |
41 | "B" , "kB" , "MB" , "GB" , "TB" , "PB" , "EB" , "ZB" , "YB" |
42 | }; |
43 | static const char *const units_2[] = { |
44 | "B" , "KiB" , "MiB" , "GiB" , "TiB" , "PiB" , "EiB" , "ZiB" , "YiB" |
45 | }; |
46 | static const char *const *const units_str[] = { |
47 | [STRING_UNITS_10] = units_10, |
48 | [STRING_UNITS_2] = units_2, |
49 | }; |
50 | static const unsigned int divisor[] = { |
51 | [STRING_UNITS_10] = 1000, |
52 | [STRING_UNITS_2] = 1024, |
53 | }; |
54 | static const unsigned int rounding[] = { 500, 50, 5 }; |
55 | int i = 0, j; |
56 | u32 remainder = 0, sf_cap; |
57 | char tmp[8]; |
58 | const char *unit; |
59 | |
60 | tmp[0] = '\0'; |
61 | |
62 | if (blk_size == 0) |
63 | size = 0; |
64 | if (size == 0) |
65 | goto out; |
66 | |
67 | /* This is Napier's algorithm. Reduce the original block size to |
68 | * |
69 | * coefficient * divisor[units]^i |
70 | * |
71 | * we do the reduction so both coefficients are just under 32 bits so |
72 | * that multiplying them together won't overflow 64 bits and we keep |
73 | * as much precision as possible in the numbers. |
74 | * |
75 | * Note: it's safe to throw away the remainders here because all the |
76 | * precision is in the coefficients. |
77 | */ |
78 | while (blk_size >> 32) { |
79 | do_div(blk_size, divisor[units]); |
80 | i++; |
81 | } |
82 | |
83 | while (size >> 32) { |
84 | do_div(size, divisor[units]); |
85 | i++; |
86 | } |
87 | |
88 | /* now perform the actual multiplication keeping i as the sum of the |
89 | * two logarithms */ |
90 | size *= blk_size; |
91 | |
92 | /* and logarithmically reduce it until it's just under the divisor */ |
93 | while (size >= divisor[units]) { |
94 | remainder = do_div(size, divisor[units]); |
95 | i++; |
96 | } |
97 | |
98 | /* work out in j how many digits of precision we need from the |
99 | * remainder */ |
100 | sf_cap = size; |
101 | for (j = 0; sf_cap*10 < 1000; j++) |
102 | sf_cap *= 10; |
103 | |
104 | if (units == STRING_UNITS_2) { |
105 | /* express the remainder as a decimal. It's currently the |
106 | * numerator of a fraction whose denominator is |
107 | * divisor[units], which is 1 << 10 for STRING_UNITS_2 */ |
108 | remainder *= 1000; |
109 | remainder >>= 10; |
110 | } |
111 | |
112 | /* add a 5 to the digit below what will be printed to ensure |
113 | * an arithmetical round up and carry it through to size */ |
114 | remainder += rounding[j]; |
115 | if (remainder >= 1000) { |
116 | remainder -= 1000; |
117 | size += 1; |
118 | } |
119 | |
120 | if (j) { |
121 | snprintf(buf: tmp, size: sizeof(tmp), fmt: ".%03u" , remainder); |
122 | tmp[j+1] = '\0'; |
123 | } |
124 | |
125 | out: |
126 | if (i >= ARRAY_SIZE(units_2)) |
127 | unit = "UNK" ; |
128 | else |
129 | unit = units_str[units][i]; |
130 | |
131 | return snprintf(buf, size: len, fmt: "%u%s %s" , (u32)size, |
132 | tmp, unit); |
133 | } |
134 | EXPORT_SYMBOL(string_get_size); |
135 | |
136 | /** |
137 | * parse_int_array_user - Split string into a sequence of integers |
138 | * @from: The user space buffer to read from |
139 | * @count: The maximum number of bytes to read |
140 | * @array: Returned pointer to sequence of integers |
141 | * |
142 | * On success @array is allocated and initialized with a sequence of |
143 | * integers extracted from the @from plus an additional element that |
144 | * begins the sequence and specifies the integers count. |
145 | * |
146 | * Caller takes responsibility for freeing @array when it is no longer |
147 | * needed. |
148 | */ |
149 | int parse_int_array_user(const char __user *from, size_t count, int **array) |
150 | { |
151 | int *ints, nints; |
152 | char *buf; |
153 | int ret = 0; |
154 | |
155 | buf = memdup_user_nul(from, count); |
156 | if (IS_ERR(ptr: buf)) |
157 | return PTR_ERR(ptr: buf); |
158 | |
159 | get_options(str: buf, nints: 0, ints: &nints); |
160 | if (!nints) { |
161 | ret = -ENOENT; |
162 | goto free_buf; |
163 | } |
164 | |
165 | ints = kcalloc(n: nints + 1, size: sizeof(*ints), GFP_KERNEL); |
166 | if (!ints) { |
167 | ret = -ENOMEM; |
168 | goto free_buf; |
169 | } |
170 | |
171 | get_options(str: buf, nints: nints + 1, ints); |
172 | *array = ints; |
173 | |
174 | free_buf: |
175 | kfree(objp: buf); |
176 | return ret; |
177 | } |
178 | EXPORT_SYMBOL(parse_int_array_user); |
179 | |
180 | static bool unescape_space(char **src, char **dst) |
181 | { |
182 | char *p = *dst, *q = *src; |
183 | |
184 | switch (*q) { |
185 | case 'n': |
186 | *p = '\n'; |
187 | break; |
188 | case 'r': |
189 | *p = '\r'; |
190 | break; |
191 | case 't': |
192 | *p = '\t'; |
193 | break; |
194 | case 'v': |
195 | *p = '\v'; |
196 | break; |
197 | case 'f': |
198 | *p = '\f'; |
199 | break; |
200 | default: |
201 | return false; |
202 | } |
203 | *dst += 1; |
204 | *src += 1; |
205 | return true; |
206 | } |
207 | |
208 | static bool unescape_octal(char **src, char **dst) |
209 | { |
210 | char *p = *dst, *q = *src; |
211 | u8 num; |
212 | |
213 | if (isodigit(c: *q) == 0) |
214 | return false; |
215 | |
216 | num = (*q++) & 7; |
217 | while (num < 32 && isodigit(c: *q) && (q - *src < 3)) { |
218 | num <<= 3; |
219 | num += (*q++) & 7; |
220 | } |
221 | *p = num; |
222 | *dst += 1; |
223 | *src = q; |
224 | return true; |
225 | } |
226 | |
227 | static bool unescape_hex(char **src, char **dst) |
228 | { |
229 | char *p = *dst, *q = *src; |
230 | int digit; |
231 | u8 num; |
232 | |
233 | if (*q++ != 'x') |
234 | return false; |
235 | |
236 | num = digit = hex_to_bin(ch: *q++); |
237 | if (digit < 0) |
238 | return false; |
239 | |
240 | digit = hex_to_bin(ch: *q); |
241 | if (digit >= 0) { |
242 | q++; |
243 | num = (num << 4) | digit; |
244 | } |
245 | *p = num; |
246 | *dst += 1; |
247 | *src = q; |
248 | return true; |
249 | } |
250 | |
251 | static bool unescape_special(char **src, char **dst) |
252 | { |
253 | char *p = *dst, *q = *src; |
254 | |
255 | switch (*q) { |
256 | case '\"': |
257 | *p = '\"'; |
258 | break; |
259 | case '\\': |
260 | *p = '\\'; |
261 | break; |
262 | case 'a': |
263 | *p = '\a'; |
264 | break; |
265 | case 'e': |
266 | *p = '\e'; |
267 | break; |
268 | default: |
269 | return false; |
270 | } |
271 | *dst += 1; |
272 | *src += 1; |
273 | return true; |
274 | } |
275 | |
276 | /** |
277 | * string_unescape - unquote characters in the given string |
278 | * @src: source buffer (escaped) |
279 | * @dst: destination buffer (unescaped) |
280 | * @size: size of the destination buffer (0 to unlimit) |
281 | * @flags: combination of the flags. |
282 | * |
283 | * Description: |
284 | * The function unquotes characters in the given string. |
285 | * |
286 | * Because the size of the output will be the same as or less than the size of |
287 | * the input, the transformation may be performed in place. |
288 | * |
289 | * Caller must provide valid source and destination pointers. Be aware that |
290 | * destination buffer will always be NULL-terminated. Source string must be |
291 | * NULL-terminated as well. The supported flags are:: |
292 | * |
293 | * UNESCAPE_SPACE: |
294 | * '\f' - form feed |
295 | * '\n' - new line |
296 | * '\r' - carriage return |
297 | * '\t' - horizontal tab |
298 | * '\v' - vertical tab |
299 | * UNESCAPE_OCTAL: |
300 | * '\NNN' - byte with octal value NNN (1 to 3 digits) |
301 | * UNESCAPE_HEX: |
302 | * '\xHH' - byte with hexadecimal value HH (1 to 2 digits) |
303 | * UNESCAPE_SPECIAL: |
304 | * '\"' - double quote |
305 | * '\\' - backslash |
306 | * '\a' - alert (BEL) |
307 | * '\e' - escape |
308 | * UNESCAPE_ANY: |
309 | * all previous together |
310 | * |
311 | * Return: |
312 | * The amount of the characters processed to the destination buffer excluding |
313 | * trailing '\0' is returned. |
314 | */ |
315 | int string_unescape(char *src, char *dst, size_t size, unsigned int flags) |
316 | { |
317 | char *out = dst; |
318 | |
319 | while (*src && --size) { |
320 | if (src[0] == '\\' && src[1] != '\0' && size > 1) { |
321 | src++; |
322 | size--; |
323 | |
324 | if (flags & UNESCAPE_SPACE && |
325 | unescape_space(src: &src, dst: &out)) |
326 | continue; |
327 | |
328 | if (flags & UNESCAPE_OCTAL && |
329 | unescape_octal(src: &src, dst: &out)) |
330 | continue; |
331 | |
332 | if (flags & UNESCAPE_HEX && |
333 | unescape_hex(src: &src, dst: &out)) |
334 | continue; |
335 | |
336 | if (flags & UNESCAPE_SPECIAL && |
337 | unescape_special(src: &src, dst: &out)) |
338 | continue; |
339 | |
340 | *out++ = '\\'; |
341 | } |
342 | *out++ = *src++; |
343 | } |
344 | *out = '\0'; |
345 | |
346 | return out - dst; |
347 | } |
348 | EXPORT_SYMBOL(string_unescape); |
349 | |
350 | static bool escape_passthrough(unsigned char c, char **dst, char *end) |
351 | { |
352 | char *out = *dst; |
353 | |
354 | if (out < end) |
355 | *out = c; |
356 | *dst = out + 1; |
357 | return true; |
358 | } |
359 | |
360 | static bool escape_space(unsigned char c, char **dst, char *end) |
361 | { |
362 | char *out = *dst; |
363 | unsigned char to; |
364 | |
365 | switch (c) { |
366 | case '\n': |
367 | to = 'n'; |
368 | break; |
369 | case '\r': |
370 | to = 'r'; |
371 | break; |
372 | case '\t': |
373 | to = 't'; |
374 | break; |
375 | case '\v': |
376 | to = 'v'; |
377 | break; |
378 | case '\f': |
379 | to = 'f'; |
380 | break; |
381 | default: |
382 | return false; |
383 | } |
384 | |
385 | if (out < end) |
386 | *out = '\\'; |
387 | ++out; |
388 | if (out < end) |
389 | *out = to; |
390 | ++out; |
391 | |
392 | *dst = out; |
393 | return true; |
394 | } |
395 | |
396 | static bool escape_special(unsigned char c, char **dst, char *end) |
397 | { |
398 | char *out = *dst; |
399 | unsigned char to; |
400 | |
401 | switch (c) { |
402 | case '\\': |
403 | to = '\\'; |
404 | break; |
405 | case '\a': |
406 | to = 'a'; |
407 | break; |
408 | case '\e': |
409 | to = 'e'; |
410 | break; |
411 | case '"': |
412 | to = '"'; |
413 | break; |
414 | default: |
415 | return false; |
416 | } |
417 | |
418 | if (out < end) |
419 | *out = '\\'; |
420 | ++out; |
421 | if (out < end) |
422 | *out = to; |
423 | ++out; |
424 | |
425 | *dst = out; |
426 | return true; |
427 | } |
428 | |
429 | static bool escape_null(unsigned char c, char **dst, char *end) |
430 | { |
431 | char *out = *dst; |
432 | |
433 | if (c) |
434 | return false; |
435 | |
436 | if (out < end) |
437 | *out = '\\'; |
438 | ++out; |
439 | if (out < end) |
440 | *out = '0'; |
441 | ++out; |
442 | |
443 | *dst = out; |
444 | return true; |
445 | } |
446 | |
447 | static bool escape_octal(unsigned char c, char **dst, char *end) |
448 | { |
449 | char *out = *dst; |
450 | |
451 | if (out < end) |
452 | *out = '\\'; |
453 | ++out; |
454 | if (out < end) |
455 | *out = ((c >> 6) & 0x07) + '0'; |
456 | ++out; |
457 | if (out < end) |
458 | *out = ((c >> 3) & 0x07) + '0'; |
459 | ++out; |
460 | if (out < end) |
461 | *out = ((c >> 0) & 0x07) + '0'; |
462 | ++out; |
463 | |
464 | *dst = out; |
465 | return true; |
466 | } |
467 | |
468 | static bool escape_hex(unsigned char c, char **dst, char *end) |
469 | { |
470 | char *out = *dst; |
471 | |
472 | if (out < end) |
473 | *out = '\\'; |
474 | ++out; |
475 | if (out < end) |
476 | *out = 'x'; |
477 | ++out; |
478 | if (out < end) |
479 | *out = hex_asc_hi(c); |
480 | ++out; |
481 | if (out < end) |
482 | *out = hex_asc_lo(c); |
483 | ++out; |
484 | |
485 | *dst = out; |
486 | return true; |
487 | } |
488 | |
489 | /** |
490 | * string_escape_mem - quote characters in the given memory buffer |
491 | * @src: source buffer (unescaped) |
492 | * @isz: source buffer size |
493 | * @dst: destination buffer (escaped) |
494 | * @osz: destination buffer size |
495 | * @flags: combination of the flags |
496 | * @only: NULL-terminated string containing characters used to limit |
497 | * the selected escape class. If characters are included in @only |
498 | * that would not normally be escaped by the classes selected |
499 | * in @flags, they will be copied to @dst unescaped. |
500 | * |
501 | * Description: |
502 | * The process of escaping byte buffer includes several parts. They are applied |
503 | * in the following sequence. |
504 | * |
505 | * 1. The character is not matched to the one from @only string and thus |
506 | * must go as-is to the output. |
507 | * 2. The character is matched to the printable and ASCII classes, if asked, |
508 | * and in case of match it passes through to the output. |
509 | * 3. The character is matched to the printable or ASCII class, if asked, |
510 | * and in case of match it passes through to the output. |
511 | * 4. The character is checked if it falls into the class given by @flags. |
512 | * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any |
513 | * character. Note that they actually can't go together, otherwise |
514 | * %ESCAPE_HEX will be ignored. |
515 | * |
516 | * Caller must provide valid source and destination pointers. Be aware that |
517 | * destination buffer will not be NULL-terminated, thus caller have to append |
518 | * it if needs. The supported flags are:: |
519 | * |
520 | * %ESCAPE_SPACE: (special white space, not space itself) |
521 | * '\f' - form feed |
522 | * '\n' - new line |
523 | * '\r' - carriage return |
524 | * '\t' - horizontal tab |
525 | * '\v' - vertical tab |
526 | * %ESCAPE_SPECIAL: |
527 | * '\"' - double quote |
528 | * '\\' - backslash |
529 | * '\a' - alert (BEL) |
530 | * '\e' - escape |
531 | * %ESCAPE_NULL: |
532 | * '\0' - null |
533 | * %ESCAPE_OCTAL: |
534 | * '\NNN' - byte with octal value NNN (3 digits) |
535 | * %ESCAPE_ANY: |
536 | * all previous together |
537 | * %ESCAPE_NP: |
538 | * escape only non-printable characters, checked by isprint() |
539 | * %ESCAPE_ANY_NP: |
540 | * all previous together |
541 | * %ESCAPE_HEX: |
542 | * '\xHH' - byte with hexadecimal value HH (2 digits) |
543 | * %ESCAPE_NA: |
544 | * escape only non-ascii characters, checked by isascii() |
545 | * %ESCAPE_NAP: |
546 | * escape only non-printable or non-ascii characters |
547 | * %ESCAPE_APPEND: |
548 | * append characters from @only to be escaped by the given classes |
549 | * |
550 | * %ESCAPE_APPEND would help to pass additional characters to the escaped, when |
551 | * one of %ESCAPE_NP, %ESCAPE_NA, or %ESCAPE_NAP is provided. |
552 | * |
553 | * One notable caveat, the %ESCAPE_NAP, %ESCAPE_NP and %ESCAPE_NA have the |
554 | * higher priority than the rest of the flags (%ESCAPE_NAP is the highest). |
555 | * It doesn't make much sense to use either of them without %ESCAPE_OCTAL |
556 | * or %ESCAPE_HEX, because they cover most of the other character classes. |
557 | * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to |
558 | * the above. |
559 | * |
560 | * Return: |
561 | * The total size of the escaped output that would be generated for |
562 | * the given input and flags. To check whether the output was |
563 | * truncated, compare the return value to osz. There is room left in |
564 | * dst for a '\0' terminator if and only if ret < osz. |
565 | */ |
566 | int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz, |
567 | unsigned int flags, const char *only) |
568 | { |
569 | char *p = dst; |
570 | char *end = p + osz; |
571 | bool is_dict = only && *only; |
572 | bool is_append = flags & ESCAPE_APPEND; |
573 | |
574 | while (isz--) { |
575 | unsigned char c = *src++; |
576 | bool in_dict = is_dict && strchr(only, c); |
577 | |
578 | /* |
579 | * Apply rules in the following sequence: |
580 | * - the @only string is supplied and does not contain a |
581 | * character under question |
582 | * - the character is printable and ASCII, when @flags has |
583 | * %ESCAPE_NAP bit set |
584 | * - the character is printable, when @flags has |
585 | * %ESCAPE_NP bit set |
586 | * - the character is ASCII, when @flags has |
587 | * %ESCAPE_NA bit set |
588 | * - the character doesn't fall into a class of symbols |
589 | * defined by given @flags |
590 | * In these cases we just pass through a character to the |
591 | * output buffer. |
592 | * |
593 | * When %ESCAPE_APPEND is passed, the characters from @only |
594 | * have been excluded from the %ESCAPE_NAP, %ESCAPE_NP, and |
595 | * %ESCAPE_NA cases. |
596 | */ |
597 | if (!(is_append || in_dict) && is_dict && |
598 | escape_passthrough(c, dst: &p, end)) |
599 | continue; |
600 | |
601 | if (!(is_append && in_dict) && isascii(c) && isprint(c) && |
602 | flags & ESCAPE_NAP && escape_passthrough(c, dst: &p, end)) |
603 | continue; |
604 | |
605 | if (!(is_append && in_dict) && isprint(c) && |
606 | flags & ESCAPE_NP && escape_passthrough(c, dst: &p, end)) |
607 | continue; |
608 | |
609 | if (!(is_append && in_dict) && isascii(c) && |
610 | flags & ESCAPE_NA && escape_passthrough(c, dst: &p, end)) |
611 | continue; |
612 | |
613 | if (flags & ESCAPE_SPACE && escape_space(c, dst: &p, end)) |
614 | continue; |
615 | |
616 | if (flags & ESCAPE_SPECIAL && escape_special(c, dst: &p, end)) |
617 | continue; |
618 | |
619 | if (flags & ESCAPE_NULL && escape_null(c, dst: &p, end)) |
620 | continue; |
621 | |
622 | /* ESCAPE_OCTAL and ESCAPE_HEX always go last */ |
623 | if (flags & ESCAPE_OCTAL && escape_octal(c, dst: &p, end)) |
624 | continue; |
625 | |
626 | if (flags & ESCAPE_HEX && escape_hex(c, dst: &p, end)) |
627 | continue; |
628 | |
629 | escape_passthrough(c, dst: &p, end); |
630 | } |
631 | |
632 | return p - dst; |
633 | } |
634 | EXPORT_SYMBOL(string_escape_mem); |
635 | |
636 | /* |
637 | * Return an allocated string that has been escaped of special characters |
638 | * and double quotes, making it safe to log in quotes. |
639 | */ |
640 | char *kstrdup_quotable(const char *src, gfp_t gfp) |
641 | { |
642 | size_t slen, dlen; |
643 | char *dst; |
644 | const int flags = ESCAPE_HEX; |
645 | const char esc[] = "\f\n\r\t\v\a\e\\\"" ; |
646 | |
647 | if (!src) |
648 | return NULL; |
649 | slen = strlen(src); |
650 | |
651 | dlen = string_escape_mem(src, slen, NULL, 0, flags, esc); |
652 | dst = kmalloc(size: dlen + 1, flags: gfp); |
653 | if (!dst) |
654 | return NULL; |
655 | |
656 | WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen); |
657 | dst[dlen] = '\0'; |
658 | |
659 | return dst; |
660 | } |
661 | EXPORT_SYMBOL_GPL(kstrdup_quotable); |
662 | |
663 | /* |
664 | * Returns allocated NULL-terminated string containing process |
665 | * command line, with inter-argument NULLs replaced with spaces, |
666 | * and other special characters escaped. |
667 | */ |
668 | char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp) |
669 | { |
670 | char *buffer, *quoted; |
671 | int i, res; |
672 | |
673 | buffer = kmalloc(PAGE_SIZE, GFP_KERNEL); |
674 | if (!buffer) |
675 | return NULL; |
676 | |
677 | res = get_cmdline(task, buffer, PAGE_SIZE - 1); |
678 | buffer[res] = '\0'; |
679 | |
680 | /* Collapse trailing NULLs, leave res pointing to last non-NULL. */ |
681 | while (--res >= 0 && buffer[res] == '\0') |
682 | ; |
683 | |
684 | /* Replace inter-argument NULLs. */ |
685 | for (i = 0; i <= res; i++) |
686 | if (buffer[i] == '\0') |
687 | buffer[i] = ' '; |
688 | |
689 | /* Make sure result is printable. */ |
690 | quoted = kstrdup_quotable(buffer, gfp); |
691 | kfree(objp: buffer); |
692 | return quoted; |
693 | } |
694 | EXPORT_SYMBOL_GPL(kstrdup_quotable_cmdline); |
695 | |
696 | /* |
697 | * Returns allocated NULL-terminated string containing pathname, |
698 | * with special characters escaped, able to be safely logged. If |
699 | * there is an error, the leading character will be "<". |
700 | */ |
701 | char *kstrdup_quotable_file(struct file *file, gfp_t gfp) |
702 | { |
703 | char *temp, *pathname; |
704 | |
705 | if (!file) |
706 | return kstrdup(s: "<unknown>" , gfp); |
707 | |
708 | /* We add 11 spaces for ' (deleted)' to be appended */ |
709 | temp = kmalloc(PATH_MAX + 11, GFP_KERNEL); |
710 | if (!temp) |
711 | return kstrdup(s: "<no_memory>" , gfp); |
712 | |
713 | pathname = file_path(file, temp, PATH_MAX + 11); |
714 | if (IS_ERR(ptr: pathname)) |
715 | pathname = kstrdup(s: "<too_long>" , gfp); |
716 | else |
717 | pathname = kstrdup_quotable(pathname, gfp); |
718 | |
719 | kfree(objp: temp); |
720 | return pathname; |
721 | } |
722 | EXPORT_SYMBOL_GPL(kstrdup_quotable_file); |
723 | |
724 | /* |
725 | * Returns duplicate string in which the @old characters are replaced by @new. |
726 | */ |
727 | char *kstrdup_and_replace(const char *src, char old, char new, gfp_t gfp) |
728 | { |
729 | char *dst; |
730 | |
731 | dst = kstrdup(s: src, gfp); |
732 | if (!dst) |
733 | return NULL; |
734 | |
735 | return strreplace(str: dst, old, new); |
736 | } |
737 | EXPORT_SYMBOL_GPL(kstrdup_and_replace); |
738 | |
739 | /** |
740 | * kasprintf_strarray - allocate and fill array of sequential strings |
741 | * @gfp: flags for the slab allocator |
742 | * @prefix: prefix to be used |
743 | * @n: amount of lines to be allocated and filled |
744 | * |
745 | * Allocates and fills @n strings using pattern "%s-%zu", where prefix |
746 | * is provided by caller. The caller is responsible to free them with |
747 | * kfree_strarray() after use. |
748 | * |
749 | * Returns array of strings or NULL when memory can't be allocated. |
750 | */ |
751 | char **kasprintf_strarray(gfp_t gfp, const char *prefix, size_t n) |
752 | { |
753 | char **names; |
754 | size_t i; |
755 | |
756 | names = kcalloc(n: n + 1, size: sizeof(char *), flags: gfp); |
757 | if (!names) |
758 | return NULL; |
759 | |
760 | for (i = 0; i < n; i++) { |
761 | names[i] = kasprintf(gfp, fmt: "%s-%zu" , prefix, i); |
762 | if (!names[i]) { |
763 | kfree_strarray(array: names, n: i); |
764 | return NULL; |
765 | } |
766 | } |
767 | |
768 | return names; |
769 | } |
770 | EXPORT_SYMBOL_GPL(kasprintf_strarray); |
771 | |
772 | /** |
773 | * kfree_strarray - free a number of dynamically allocated strings contained |
774 | * in an array and the array itself |
775 | * |
776 | * @array: Dynamically allocated array of strings to free. |
777 | * @n: Number of strings (starting from the beginning of the array) to free. |
778 | * |
779 | * Passing a non-NULL @array and @n == 0 as well as NULL @array are valid |
780 | * use-cases. If @array is NULL, the function does nothing. |
781 | */ |
782 | void kfree_strarray(char **array, size_t n) |
783 | { |
784 | unsigned int i; |
785 | |
786 | if (!array) |
787 | return; |
788 | |
789 | for (i = 0; i < n; i++) |
790 | kfree(objp: array[i]); |
791 | kfree(objp: array); |
792 | } |
793 | EXPORT_SYMBOL_GPL(kfree_strarray); |
794 | |
795 | struct strarray { |
796 | char **array; |
797 | size_t n; |
798 | }; |
799 | |
800 | static void devm_kfree_strarray(struct device *dev, void *res) |
801 | { |
802 | struct strarray *array = res; |
803 | |
804 | kfree_strarray(array->array, array->n); |
805 | } |
806 | |
807 | char **devm_kasprintf_strarray(struct device *dev, const char *prefix, size_t n) |
808 | { |
809 | struct strarray *ptr; |
810 | |
811 | ptr = devres_alloc(devm_kfree_strarray, sizeof(*ptr), GFP_KERNEL); |
812 | if (!ptr) |
813 | return ERR_PTR(error: -ENOMEM); |
814 | |
815 | ptr->array = kasprintf_strarray(GFP_KERNEL, prefix, n); |
816 | if (!ptr->array) { |
817 | devres_free(res: ptr); |
818 | return ERR_PTR(error: -ENOMEM); |
819 | } |
820 | |
821 | ptr->n = n; |
822 | devres_add(dev, res: ptr); |
823 | |
824 | return ptr->array; |
825 | } |
826 | EXPORT_SYMBOL_GPL(devm_kasprintf_strarray); |
827 | |
828 | /** |
829 | * strscpy_pad() - Copy a C-string into a sized buffer |
830 | * @dest: Where to copy the string to |
831 | * @src: Where to copy the string from |
832 | * @count: Size of destination buffer |
833 | * |
834 | * Copy the string, or as much of it as fits, into the dest buffer. The |
835 | * behavior is undefined if the string buffers overlap. The destination |
836 | * buffer is always %NUL terminated, unless it's zero-sized. |
837 | * |
838 | * If the source string is shorter than the destination buffer, zeros |
839 | * the tail of the destination buffer. |
840 | * |
841 | * For full explanation of why you may want to consider using the |
842 | * 'strscpy' functions please see the function docstring for strscpy(). |
843 | * |
844 | * Returns: |
845 | * * The number of characters copied (not including the trailing %NUL) |
846 | * * -E2BIG if count is 0 or @src was truncated. |
847 | */ |
848 | ssize_t strscpy_pad(char *dest, const char *src, size_t count) |
849 | { |
850 | ssize_t written; |
851 | |
852 | written = strscpy(p: dest, q: src, size: count); |
853 | if (written < 0 || written == count - 1) |
854 | return written; |
855 | |
856 | memset(dest + written + 1, 0, count - written - 1); |
857 | |
858 | return written; |
859 | } |
860 | EXPORT_SYMBOL(strscpy_pad); |
861 | |
862 | /** |
863 | * skip_spaces - Removes leading whitespace from @str. |
864 | * @str: The string to be stripped. |
865 | * |
866 | * Returns a pointer to the first non-whitespace character in @str. |
867 | */ |
868 | char *skip_spaces(const char *str) |
869 | { |
870 | while (isspace(*str)) |
871 | ++str; |
872 | return (char *)str; |
873 | } |
874 | EXPORT_SYMBOL(skip_spaces); |
875 | |
876 | /** |
877 | * strim - Removes leading and trailing whitespace from @s. |
878 | * @s: The string to be stripped. |
879 | * |
880 | * Note that the first trailing whitespace is replaced with a %NUL-terminator |
881 | * in the given string @s. Returns a pointer to the first non-whitespace |
882 | * character in @s. |
883 | */ |
884 | char *strim(char *s) |
885 | { |
886 | size_t size; |
887 | char *end; |
888 | |
889 | size = strlen(s); |
890 | if (!size) |
891 | return s; |
892 | |
893 | end = s + size - 1; |
894 | while (end >= s && isspace(*end)) |
895 | end--; |
896 | *(end + 1) = '\0'; |
897 | |
898 | return skip_spaces(s); |
899 | } |
900 | EXPORT_SYMBOL(strim); |
901 | |
902 | /** |
903 | * sysfs_streq - return true if strings are equal, modulo trailing newline |
904 | * @s1: one string |
905 | * @s2: another string |
906 | * |
907 | * This routine returns true iff two strings are equal, treating both |
908 | * NUL and newline-then-NUL as equivalent string terminations. It's |
909 | * geared for use with sysfs input strings, which generally terminate |
910 | * with newlines but are compared against values without newlines. |
911 | */ |
912 | bool sysfs_streq(const char *s1, const char *s2) |
913 | { |
914 | while (*s1 && *s1 == *s2) { |
915 | s1++; |
916 | s2++; |
917 | } |
918 | |
919 | if (*s1 == *s2) |
920 | return true; |
921 | if (!*s1 && *s2 == '\n' && !s2[1]) |
922 | return true; |
923 | if (*s1 == '\n' && !s1[1] && !*s2) |
924 | return true; |
925 | return false; |
926 | } |
927 | EXPORT_SYMBOL(sysfs_streq); |
928 | |
929 | /** |
930 | * match_string - matches given string in an array |
931 | * @array: array of strings |
932 | * @n: number of strings in the array or -1 for NULL terminated arrays |
933 | * @string: string to match with |
934 | * |
935 | * This routine will look for a string in an array of strings up to the |
936 | * n-th element in the array or until the first NULL element. |
937 | * |
938 | * Historically the value of -1 for @n, was used to search in arrays that |
939 | * are NULL terminated. However, the function does not make a distinction |
940 | * when finishing the search: either @n elements have been compared OR |
941 | * the first NULL element was found. |
942 | * |
943 | * Return: |
944 | * index of a @string in the @array if matches, or %-EINVAL otherwise. |
945 | */ |
946 | int match_string(const char * const *array, size_t n, const char *string) |
947 | { |
948 | int index; |
949 | const char *item; |
950 | |
951 | for (index = 0; index < n; index++) { |
952 | item = array[index]; |
953 | if (!item) |
954 | break; |
955 | if (!strcmp(item, string)) |
956 | return index; |
957 | } |
958 | |
959 | return -EINVAL; |
960 | } |
961 | EXPORT_SYMBOL(match_string); |
962 | |
963 | /** |
964 | * __sysfs_match_string - matches given string in an array |
965 | * @array: array of strings |
966 | * @n: number of strings in the array or -1 for NULL terminated arrays |
967 | * @str: string to match with |
968 | * |
969 | * Returns index of @str in the @array or -EINVAL, just like match_string(). |
970 | * Uses sysfs_streq instead of strcmp for matching. |
971 | * |
972 | * This routine will look for a string in an array of strings up to the |
973 | * n-th element in the array or until the first NULL element. |
974 | * |
975 | * Historically the value of -1 for @n, was used to search in arrays that |
976 | * are NULL terminated. However, the function does not make a distinction |
977 | * when finishing the search: either @n elements have been compared OR |
978 | * the first NULL element was found. |
979 | */ |
980 | int __sysfs_match_string(const char * const *array, size_t n, const char *str) |
981 | { |
982 | const char *item; |
983 | int index; |
984 | |
985 | for (index = 0; index < n; index++) { |
986 | item = array[index]; |
987 | if (!item) |
988 | break; |
989 | if (sysfs_streq(item, str)) |
990 | return index; |
991 | } |
992 | |
993 | return -EINVAL; |
994 | } |
995 | EXPORT_SYMBOL(__sysfs_match_string); |
996 | |
997 | /** |
998 | * strreplace - Replace all occurrences of character in string. |
999 | * @str: The string to operate on. |
1000 | * @old: The character being replaced. |
1001 | * @new: The character @old is replaced with. |
1002 | * |
1003 | * Replaces the each @old character with a @new one in the given string @str. |
1004 | * |
1005 | * Return: pointer to the string @str itself. |
1006 | */ |
1007 | char *strreplace(char *str, char old, char new) |
1008 | { |
1009 | char *s = str; |
1010 | |
1011 | for (; *s; ++s) |
1012 | if (*s == old) |
1013 | *s = new; |
1014 | return str; |
1015 | } |
1016 | EXPORT_SYMBOL(strreplace); |
1017 | |
1018 | /** |
1019 | * memcpy_and_pad - Copy one buffer to another with padding |
1020 | * @dest: Where to copy to |
1021 | * @dest_len: The destination buffer size |
1022 | * @src: Where to copy from |
1023 | * @count: The number of bytes to copy |
1024 | * @pad: Character to use for padding if space is left in destination. |
1025 | */ |
1026 | void memcpy_and_pad(void *dest, size_t dest_len, const void *src, size_t count, |
1027 | int pad) |
1028 | { |
1029 | if (dest_len > count) { |
1030 | memcpy(dest, src, count); |
1031 | memset(dest + count, pad, dest_len - count); |
1032 | } else { |
1033 | memcpy(dest, src, dest_len); |
1034 | } |
1035 | } |
1036 | EXPORT_SYMBOL(memcpy_and_pad); |
1037 | |
1038 | #ifdef CONFIG_FORTIFY_SOURCE |
1039 | /* These are placeholders for fortify compile-time warnings. */ |
1040 | void __read_overflow2_field(size_t avail, size_t wanted) { } |
1041 | EXPORT_SYMBOL(__read_overflow2_field); |
1042 | void __write_overflow_field(size_t avail, size_t wanted) { } |
1043 | EXPORT_SYMBOL(__write_overflow_field); |
1044 | |
1045 | void fortify_panic(const char *name) |
1046 | { |
1047 | pr_emerg("detected buffer overflow in %s\n" , name); |
1048 | BUG(); |
1049 | } |
1050 | EXPORT_SYMBOL(fortify_panic); |
1051 | #endif /* CONFIG_FORTIFY_SOURCE */ |
1052 | |