1 // SPDX-License-Identifier: LGPL-2.1+
2 /* Copyright (C) 2022 Kent Overstreet */
3
4 #include <linux/bitmap.h>
5 #include <linux/err.h>
6 #include <linux/export.h>
7 #include <linux/kernel.h>
8 #include <linux/slab.h>
9 #include <linux/string_helpers.h>
10
11 #include "printbuf.h"
12
__printbuf_linelen(struct printbuf * buf,unsigned pos)13 static inline unsigned __printbuf_linelen(struct printbuf *buf, unsigned pos)
14 {
15 return pos - buf->last_newline;
16 }
17
printbuf_linelen(struct printbuf * buf)18 static inline unsigned printbuf_linelen(struct printbuf *buf)
19 {
20 return __printbuf_linelen(buf, buf->pos);
21 }
22
23 /*
24 * Returns spaces from start of line, if set, or 0 if unset:
25 */
cur_tabstop(struct printbuf * buf)26 static inline unsigned cur_tabstop(struct printbuf *buf)
27 {
28 return buf->cur_tabstop < buf->nr_tabstops
29 ? buf->_tabstops[buf->cur_tabstop]
30 : 0;
31 }
32
bch2_printbuf_make_room(struct printbuf * out,unsigned extra)33 int bch2_printbuf_make_room(struct printbuf *out, unsigned extra)
34 {
35 /* Reserved space for terminating nul: */
36 extra += 1;
37
38 if (out->pos + extra <= out->size)
39 return 0;
40
41 if (!out->heap_allocated) {
42 out->overflow = true;
43 return 0;
44 }
45
46 unsigned new_size = roundup_pow_of_two(out->size + extra);
47
48 /* Sanity check... */
49 if (new_size > PAGE_SIZE << MAX_PAGE_ORDER) {
50 out->allocation_failure = true;
51 out->overflow = true;
52 return -ENOMEM;
53 }
54
55 /*
56 * Note: output buffer must be freeable with kfree(), it's not required
57 * that the user use printbuf_exit().
58 */
59 char *buf = krealloc(out->buf, new_size, !out->atomic ? GFP_KERNEL : GFP_NOWAIT);
60
61 if (!buf) {
62 out->allocation_failure = true;
63 out->overflow = true;
64 return -ENOMEM;
65 }
66
67 out->buf = buf;
68 out->size = new_size;
69 return 0;
70 }
71
printbuf_advance_pos(struct printbuf * out,unsigned len)72 static void printbuf_advance_pos(struct printbuf *out, unsigned len)
73 {
74 out->pos += min(len, printbuf_remaining(out));
75 }
76
printbuf_insert_spaces(struct printbuf * out,unsigned pos,unsigned nr)77 static void printbuf_insert_spaces(struct printbuf *out, unsigned pos, unsigned nr)
78 {
79 unsigned move = out->pos - pos;
80
81 bch2_printbuf_make_room(out, nr);
82
83 if (pos + nr < out->size)
84 memmove(out->buf + pos + nr,
85 out->buf + pos,
86 min(move, out->size - 1 - pos - nr));
87
88 if (pos < out->size)
89 memset(out->buf + pos, ' ', min(nr, out->size - pos));
90
91 printbuf_advance_pos(out, nr);
92 printbuf_nul_terminate_reserved(out);
93 }
94
__printbuf_do_indent(struct printbuf * out,unsigned pos)95 static void __printbuf_do_indent(struct printbuf *out, unsigned pos)
96 {
97 while (true) {
98 int pad;
99 unsigned len = out->pos - pos;
100 char *p = out->buf + pos;
101 char *n = memscan(p, '\n', len);
102 if (cur_tabstop(out)) {
103 n = min(n, (char *) memscan(p, '\r', len));
104 n = min(n, (char *) memscan(p, '\t', len));
105 }
106
107 pos = n - out->buf;
108 if (pos == out->pos)
109 break;
110
111 switch (*n) {
112 case '\n':
113 pos++;
114 out->last_newline = pos;
115
116 printbuf_insert_spaces(out, pos, out->indent);
117
118 pos = min(pos + out->indent, out->pos);
119 out->last_field = pos;
120 out->cur_tabstop = 0;
121 break;
122 case '\r':
123 memmove(n, n + 1, out->pos - pos);
124 --out->pos;
125 pad = (int) cur_tabstop(out) - (int) __printbuf_linelen(out, pos);
126 if (pad > 0) {
127 printbuf_insert_spaces(out, out->last_field, pad);
128 pos += pad;
129 }
130
131 out->last_field = pos;
132 out->cur_tabstop++;
133 break;
134 case '\t':
135 pad = (int) cur_tabstop(out) - (int) __printbuf_linelen(out, pos) - 1;
136 if (pad > 0) {
137 *n = ' ';
138 printbuf_insert_spaces(out, pos, pad - 1);
139 pos += pad;
140 } else {
141 memmove(n, n + 1, out->pos - pos);
142 --out->pos;
143 }
144
145 out->last_field = pos;
146 out->cur_tabstop++;
147 break;
148 }
149 }
150 }
151
printbuf_do_indent(struct printbuf * out,unsigned pos)152 static inline void printbuf_do_indent(struct printbuf *out, unsigned pos)
153 {
154 if (out->has_indent_or_tabstops && !out->suppress_indent_tabstop_handling)
155 __printbuf_do_indent(out, pos);
156 }
157
bch2_prt_vprintf(struct printbuf * out,const char * fmt,va_list args)158 void bch2_prt_vprintf(struct printbuf *out, const char *fmt, va_list args)
159 {
160 int len;
161
162 do {
163 va_list args2;
164
165 va_copy(args2, args);
166 len = vsnprintf(out->buf + out->pos, printbuf_remaining_size(out), fmt, args2);
167 va_end(args2);
168 } while (len > printbuf_remaining(out) &&
169 !bch2_printbuf_make_room(out, len));
170
171 unsigned indent_pos = out->pos;
172 printbuf_advance_pos(out, len);
173 printbuf_do_indent(out, indent_pos);
174 }
175
bch2_prt_printf(struct printbuf * out,const char * fmt,...)176 void bch2_prt_printf(struct printbuf *out, const char *fmt, ...)
177 {
178 va_list args;
179 int len;
180
181 do {
182 va_start(args, fmt);
183 len = vsnprintf(out->buf + out->pos, printbuf_remaining_size(out), fmt, args);
184 va_end(args);
185 } while (len > printbuf_remaining(out) &&
186 !bch2_printbuf_make_room(out, len));
187
188 unsigned indent_pos = out->pos;
189 printbuf_advance_pos(out, len);
190 printbuf_do_indent(out, indent_pos);
191 }
192
193 /**
194 * bch2_printbuf_str() - returns printbuf's buf as a C string, guaranteed to be
195 * null terminated
196 * @buf: printbuf to terminate
197 * Returns: Printbuf contents, as a nul terminated C string
198 */
bch2_printbuf_str(const struct printbuf * buf)199 const char *bch2_printbuf_str(const struct printbuf *buf)
200 {
201 /*
202 * If we've written to a printbuf then it's guaranteed to be a null
203 * terminated string - but if we haven't, then we might not have
204 * allocated a buffer at all:
205 */
206 return buf->pos
207 ? buf->buf
208 : "";
209 }
210
211 /**
212 * bch2_printbuf_exit() - exit a printbuf, freeing memory it owns and poisoning it
213 * against accidental use.
214 * @buf: printbuf to exit
215 */
bch2_printbuf_exit(struct printbuf * buf)216 void bch2_printbuf_exit(struct printbuf *buf)
217 {
218 if (buf->heap_allocated) {
219 kfree(buf->buf);
220 buf->buf = ERR_PTR(-EINTR); /* poison value */
221 }
222 }
223
bch2_printbuf_tabstops_reset(struct printbuf * buf)224 void bch2_printbuf_tabstops_reset(struct printbuf *buf)
225 {
226 buf->nr_tabstops = 0;
227 }
228
bch2_printbuf_tabstop_pop(struct printbuf * buf)229 void bch2_printbuf_tabstop_pop(struct printbuf *buf)
230 {
231 if (buf->nr_tabstops)
232 --buf->nr_tabstops;
233 }
234
235 /*
236 * bch2_printbuf_tabstop_set() - add a tabstop, n spaces from the previous tabstop
237 *
238 * @buf: printbuf to control
239 * @spaces: number of spaces from previous tabpstop
240 *
241 * In the future this function may allocate memory if setting more than
242 * PRINTBUF_INLINE_TABSTOPS or setting tabstops more than 255 spaces from start
243 * of line.
244 */
bch2_printbuf_tabstop_push(struct printbuf * buf,unsigned spaces)245 int bch2_printbuf_tabstop_push(struct printbuf *buf, unsigned spaces)
246 {
247 unsigned prev_tabstop = buf->nr_tabstops
248 ? buf->_tabstops[buf->nr_tabstops - 1]
249 : 0;
250
251 if (WARN_ON(buf->nr_tabstops >= ARRAY_SIZE(buf->_tabstops)))
252 return -EINVAL;
253
254 buf->_tabstops[buf->nr_tabstops++] = prev_tabstop + spaces;
255 buf->has_indent_or_tabstops = true;
256 return 0;
257 }
258
259 /**
260 * bch2_printbuf_indent_add() - add to the current indent level
261 *
262 * @buf: printbuf to control
263 * @spaces: number of spaces to add to the current indent level
264 *
265 * Subsequent lines, and the current line if the output position is at the start
266 * of the current line, will be indented by @spaces more spaces.
267 */
bch2_printbuf_indent_add(struct printbuf * buf,unsigned spaces)268 void bch2_printbuf_indent_add(struct printbuf *buf, unsigned spaces)
269 {
270 if (WARN_ON_ONCE(buf->indent + spaces < buf->indent))
271 spaces = 0;
272
273 buf->indent += spaces;
274 prt_chars(buf, ' ', spaces);
275
276 buf->has_indent_or_tabstops = true;
277 }
278
279 /**
280 * bch2_printbuf_indent_add_nextline() - add to the current indent level for
281 * subsequent lines
282 *
283 * @buf: printbuf to control
284 * @spaces: number of spaces to add to the current indent level
285 *
286 * Subsequent lines - not the current line - will be indented by @spaces more
287 * spaces.
288 */
bch2_printbuf_indent_add_nextline(struct printbuf * buf,unsigned spaces)289 void bch2_printbuf_indent_add_nextline(struct printbuf *buf, unsigned spaces)
290 {
291 if (WARN_ON_ONCE(buf->indent + spaces < buf->indent))
292 spaces = 0;
293
294 buf->indent += spaces;
295 buf->has_indent_or_tabstops = true;
296 }
297
298 /**
299 * bch2_printbuf_indent_sub() - subtract from the current indent level
300 *
301 * @buf: printbuf to control
302 * @spaces: number of spaces to subtract from the current indent level
303 *
304 * Subsequent lines, and the current line if the output position is at the start
305 * of the current line, will be indented by @spaces less spaces.
306 */
bch2_printbuf_indent_sub(struct printbuf * buf,unsigned spaces)307 void bch2_printbuf_indent_sub(struct printbuf *buf, unsigned spaces)
308 {
309 if (WARN_ON_ONCE(spaces > buf->indent))
310 spaces = buf->indent;
311
312 if (buf->last_newline + buf->indent == buf->pos) {
313 buf->pos -= spaces;
314 printbuf_nul_terminate(buf);
315 }
316 buf->indent -= spaces;
317
318 if (!buf->indent && !buf->nr_tabstops)
319 buf->has_indent_or_tabstops = false;
320 }
321
bch2_prt_newline(struct printbuf * buf)322 void bch2_prt_newline(struct printbuf *buf)
323 {
324 bch2_printbuf_make_room(buf, 1 + buf->indent);
325
326 __prt_char_reserved(buf, '\n');
327
328 buf->last_newline = buf->pos;
329
330 __prt_chars_reserved(buf, ' ', buf->indent);
331
332 printbuf_nul_terminate_reserved(buf);
333
334 buf->last_field = buf->pos;
335 buf->cur_tabstop = 0;
336 }
337
bch2_printbuf_strip_trailing_newline(struct printbuf * out)338 void bch2_printbuf_strip_trailing_newline(struct printbuf *out)
339 {
340 for (int p = out->pos - 1; p >= 0; --p) {
341 if (out->buf[p] == '\n') {
342 out->pos = p;
343 break;
344 }
345 if (out->buf[p] != ' ')
346 break;
347 }
348
349 printbuf_nul_terminate_reserved(out);
350 }
351
__prt_tab(struct printbuf * out)352 static void __prt_tab(struct printbuf *out)
353 {
354 int spaces = max_t(int, 0, cur_tabstop(out) - printbuf_linelen(out));
355
356 prt_chars(out, ' ', spaces);
357
358 out->last_field = out->pos;
359 out->cur_tabstop++;
360 }
361
362 /**
363 * bch2_prt_tab() - Advance printbuf to the next tabstop
364 * @out: printbuf to control
365 *
366 * Advance output to the next tabstop by printing spaces.
367 */
bch2_prt_tab(struct printbuf * out)368 void bch2_prt_tab(struct printbuf *out)
369 {
370 if (WARN_ON(!cur_tabstop(out)))
371 return;
372
373 __prt_tab(out);
374 }
375
__prt_tab_rjust(struct printbuf * buf)376 static void __prt_tab_rjust(struct printbuf *buf)
377 {
378 int pad = (int) cur_tabstop(buf) - (int) printbuf_linelen(buf);
379 if (pad > 0)
380 printbuf_insert_spaces(buf, buf->last_field, pad);
381
382 buf->last_field = buf->pos;
383 buf->cur_tabstop++;
384 }
385
386 /**
387 * bch2_prt_tab_rjust - Advance printbuf to the next tabstop, right justifying
388 * previous output
389 *
390 * @buf: printbuf to control
391 *
392 * Advance output to the next tabstop by inserting spaces immediately after the
393 * previous tabstop, right justifying previously outputted text.
394 */
bch2_prt_tab_rjust(struct printbuf * buf)395 void bch2_prt_tab_rjust(struct printbuf *buf)
396 {
397 if (WARN_ON(!cur_tabstop(buf)))
398 return;
399
400 __prt_tab_rjust(buf);
401 }
402
403 /**
404 * bch2_prt_bytes_indented() - Print an array of chars, handling embedded control characters
405 *
406 * @out: output printbuf
407 * @str: string to print
408 * @count: number of bytes to print
409 *
410 * The following contol characters are handled as so:
411 * \n: prt_newline newline that obeys current indent level
412 * \t: prt_tab advance to next tabstop
413 * \r: prt_tab_rjust advance to next tabstop, with right justification
414 */
bch2_prt_bytes_indented(struct printbuf * out,const char * str,unsigned count)415 void bch2_prt_bytes_indented(struct printbuf *out, const char *str, unsigned count)
416 {
417 unsigned indent_pos = out->pos;
418 prt_bytes(out, str, count);
419 printbuf_do_indent(out, indent_pos);
420 }
421
422 /**
423 * bch2_prt_human_readable_u64() - Print out a u64 in human readable units
424 * @out: output printbuf
425 * @v: integer to print
426 *
427 * Units of 2^10 (default) or 10^3 are controlled via @out->si_units
428 */
bch2_prt_human_readable_u64(struct printbuf * out,u64 v)429 void bch2_prt_human_readable_u64(struct printbuf *out, u64 v)
430 {
431 bch2_printbuf_make_room(out, 10);
432 unsigned len = string_get_size(v, 1, !out->si_units,
433 out->buf + out->pos,
434 printbuf_remaining_size(out));
435 printbuf_advance_pos(out, len);
436 }
437
438 /**
439 * bch2_prt_human_readable_s64() - Print out a s64 in human readable units
440 * @out: output printbuf
441 * @v: integer to print
442 *
443 * Units of 2^10 (default) or 10^3 are controlled via @out->si_units
444 */
bch2_prt_human_readable_s64(struct printbuf * out,s64 v)445 void bch2_prt_human_readable_s64(struct printbuf *out, s64 v)
446 {
447 if (v < 0)
448 prt_char(out, '-');
449 bch2_prt_human_readable_u64(out, abs(v));
450 }
451
452 /**
453 * bch2_prt_units_u64() - Print out a u64 according to printbuf unit options
454 * @out: output printbuf
455 * @v: integer to print
456 *
457 * Units are either raw (default), or human reabable units (controlled via
458 * @buf->human_readable_units)
459 */
bch2_prt_units_u64(struct printbuf * out,u64 v)460 void bch2_prt_units_u64(struct printbuf *out, u64 v)
461 {
462 if (out->human_readable_units)
463 bch2_prt_human_readable_u64(out, v);
464 else
465 bch2_prt_printf(out, "%llu", v);
466 }
467
468 /**
469 * bch2_prt_units_s64() - Print out a s64 according to printbuf unit options
470 * @out: output printbuf
471 * @v: integer to print
472 *
473 * Units are either raw (default), or human reabable units (controlled via
474 * @buf->human_readable_units)
475 */
bch2_prt_units_s64(struct printbuf * out,s64 v)476 void bch2_prt_units_s64(struct printbuf *out, s64 v)
477 {
478 if (v < 0)
479 prt_char(out, '-');
480 bch2_prt_units_u64(out, abs(v));
481 }
482
bch2_prt_string_option(struct printbuf * out,const char * const list[],size_t selected)483 void bch2_prt_string_option(struct printbuf *out,
484 const char * const list[],
485 size_t selected)
486 {
487 for (size_t i = 0; list[i]; i++)
488 bch2_prt_printf(out, i == selected ? "[%s] " : "%s ", list[i]);
489 }
490
bch2_prt_bitflags(struct printbuf * out,const char * const list[],u64 flags)491 void bch2_prt_bitflags(struct printbuf *out,
492 const char * const list[], u64 flags)
493 {
494 unsigned bit, nr = 0;
495 bool first = true;
496
497 while (list[nr])
498 nr++;
499
500 while (flags && (bit = __ffs64(flags)) < nr) {
501 if (!first)
502 bch2_prt_printf(out, ",");
503 first = false;
504 bch2_prt_printf(out, "%s", list[bit]);
505 flags ^= BIT_ULL(bit);
506 }
507 }
508
bch2_prt_bitflags_vector(struct printbuf * out,const char * const list[],unsigned long * v,unsigned nr)509 void bch2_prt_bitflags_vector(struct printbuf *out,
510 const char * const list[],
511 unsigned long *v, unsigned nr)
512 {
513 bool first = true;
514 unsigned i;
515
516 for (i = 0; i < nr; i++)
517 if (!list[i]) {
518 nr = i - 1;
519 break;
520 }
521
522 for_each_set_bit(i, v, nr) {
523 if (!first)
524 bch2_prt_printf(out, ",");
525 first = false;
526 bch2_prt_printf(out, "%s", list[i]);
527 }
528 }
529