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