GNU Linux-libre 6.9-gnu
[releases.git] / fs / bcachefs / printbuf.c
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
13 static inline unsigned printbuf_linelen(struct printbuf *buf)
14 {
15         return buf->pos - buf->last_newline;
16 }
17
18 int 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
50 void 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
68 void 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  */
91 const 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  */
108 void 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
116 void bch2_printbuf_tabstops_reset(struct printbuf *buf)
117 {
118         buf->nr_tabstops = 0;
119 }
120
121 void 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  */
137 int 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  */
160 void 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  */
180 void 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
195 void 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  */
217 static 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
224 static 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  */
240 void bch2_prt_tab(struct printbuf *out)
241 {
242         if (WARN_ON(!cur_tabstop(out)))
243                 return;
244
245         __prt_tab(out);
246 }
247
248 static 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  */
282 void 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  */
302 void 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  */
348 void 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  */
363 void 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  */
378 void 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  */
394 void 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
401 void 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
411 void 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
429 void 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 }