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