Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * seq_buf.c
4 : : *
5 : : * Copyright (C) 2014 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
6 : : *
7 : : * The seq_buf is a handy tool that allows you to pass a descriptor around
8 : : * to a buffer that other functions can write to. It is similar to the
9 : : * seq_file functionality but has some differences.
10 : : *
11 : : * To use it, the seq_buf must be initialized with seq_buf_init().
12 : : * This will set up the counters within the descriptor. You can call
13 : : * seq_buf_init() more than once to reset the seq_buf to start
14 : : * from scratch.
15 : : */
16 : : #include <linux/uaccess.h>
17 : : #include <linux/seq_file.h>
18 : : #include <linux/seq_buf.h>
19 : :
20 : : /**
21 : : * seq_buf_can_fit - can the new data fit in the current buffer?
22 : : * @s: the seq_buf descriptor
23 : : * @len: The length to see if it can fit in the current buffer
24 : : *
25 : : * Returns true if there's enough unused space in the seq_buf buffer
26 : : * to fit the amount of new data according to @len.
27 : : */
28 : 0 : static bool seq_buf_can_fit(struct seq_buf *s, size_t len)
29 : : {
30 : 0 : return s->len + len <= s->size;
31 : : }
32 : :
33 : : /**
34 : : * seq_buf_print_seq - move the contents of seq_buf into a seq_file
35 : : * @m: the seq_file descriptor that is the destination
36 : : * @s: the seq_buf descriptor that is the source.
37 : : *
38 : : * Returns zero on success, non zero otherwise
39 : : */
40 : 0 : int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s)
41 : : {
42 : 0 : unsigned int len = seq_buf_used(s);
43 : :
44 : 0 : return seq_write(m, s->buffer, len);
45 : : }
46 : :
47 : : /**
48 : : * seq_buf_vprintf - sequence printing of information.
49 : : * @s: seq_buf descriptor
50 : : * @fmt: printf format string
51 : : * @args: va_list of arguments from a printf() type function
52 : : *
53 : : * Writes a vnprintf() format into the sequencce buffer.
54 : : *
55 : : * Returns zero on success, -1 on overflow.
56 : : */
57 : 0 : int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args)
58 : : {
59 : 0 : int len;
60 : :
61 [ # # ]: 0 : WARN_ON(s->size == 0);
62 : :
63 [ # # ]: 0 : if (s->len < s->size) {
64 : 0 : len = vsnprintf(s->buffer + s->len, s->size - s->len, fmt, args);
65 [ # # ]: 0 : if (s->len + len < s->size) {
66 : 0 : s->len += len;
67 : 0 : return 0;
68 : : }
69 : : }
70 : 0 : seq_buf_set_overflow(s);
71 : 0 : return -1;
72 : : }
73 : :
74 : : /**
75 : : * seq_buf_printf - sequence printing of information
76 : : * @s: seq_buf descriptor
77 : : * @fmt: printf format string
78 : : *
79 : : * Writes a printf() format into the sequence buffer.
80 : : *
81 : : * Returns zero on success, -1 on overflow.
82 : : */
83 : 0 : int seq_buf_printf(struct seq_buf *s, const char *fmt, ...)
84 : : {
85 : 0 : va_list ap;
86 : 0 : int ret;
87 : :
88 : 0 : va_start(ap, fmt);
89 : 0 : ret = seq_buf_vprintf(s, fmt, ap);
90 : 0 : va_end(ap);
91 : :
92 : 0 : return ret;
93 : : }
94 : :
95 : : #ifdef CONFIG_BINARY_PRINTF
96 : : /**
97 : : * seq_buf_bprintf - Write the printf string from binary arguments
98 : : * @s: seq_buf descriptor
99 : : * @fmt: The format string for the @binary arguments
100 : : * @binary: The binary arguments for @fmt.
101 : : *
102 : : * When recording in a fast path, a printf may be recorded with just
103 : : * saving the format and the arguments as they were passed to the
104 : : * function, instead of wasting cycles converting the arguments into
105 : : * ASCII characters. Instead, the arguments are saved in a 32 bit
106 : : * word array that is defined by the format string constraints.
107 : : *
108 : : * This function will take the format and the binary array and finish
109 : : * the conversion into the ASCII string within the buffer.
110 : : *
111 : : * Returns zero on success, -1 on overflow.
112 : : */
113 : 0 : int seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary)
114 : : {
115 [ # # ]: 0 : unsigned int len = seq_buf_buffer_left(s);
116 : 0 : int ret;
117 : :
118 [ # # ]: 0 : WARN_ON(s->size == 0);
119 : :
120 [ # # ]: 0 : if (s->len < s->size) {
121 : 0 : ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
122 [ # # ]: 0 : if (s->len + ret < s->size) {
123 : 0 : s->len += ret;
124 : 0 : return 0;
125 : : }
126 : : }
127 : 0 : seq_buf_set_overflow(s);
128 : 0 : return -1;
129 : : }
130 : : #endif /* CONFIG_BINARY_PRINTF */
131 : :
132 : : /**
133 : : * seq_buf_puts - sequence printing of simple string
134 : : * @s: seq_buf descriptor
135 : : * @str: simple string to record
136 : : *
137 : : * Copy a simple string into the sequence buffer.
138 : : *
139 : : * Returns zero on success, -1 on overflow
140 : : */
141 : 0 : int seq_buf_puts(struct seq_buf *s, const char *str)
142 : : {
143 : 0 : size_t len = strlen(str);
144 : :
145 [ # # ]: 0 : WARN_ON(s->size == 0);
146 : :
147 : : /* Add 1 to len for the trailing null byte which must be there */
148 : 0 : len += 1;
149 : :
150 [ # # ]: 0 : if (seq_buf_can_fit(s, len)) {
151 : 0 : memcpy(s->buffer + s->len, str, len);
152 : : /* Don't count the trailing null byte against the capacity */
153 : 0 : s->len += len - 1;
154 : 0 : return 0;
155 : : }
156 : 0 : seq_buf_set_overflow(s);
157 : 0 : return -1;
158 : : }
159 : :
160 : : /**
161 : : * seq_buf_putc - sequence printing of simple character
162 : : * @s: seq_buf descriptor
163 : : * @c: simple character to record
164 : : *
165 : : * Copy a single character into the sequence buffer.
166 : : *
167 : : * Returns zero on success, -1 on overflow
168 : : */
169 : 0 : int seq_buf_putc(struct seq_buf *s, unsigned char c)
170 : : {
171 [ # # ]: 0 : WARN_ON(s->size == 0);
172 : :
173 [ # # ]: 0 : if (seq_buf_can_fit(s, 1)) {
174 : 0 : s->buffer[s->len++] = c;
175 : 0 : return 0;
176 : : }
177 : 0 : seq_buf_set_overflow(s);
178 : 0 : return -1;
179 : : }
180 : :
181 : : /**
182 : : * seq_buf_putmem - write raw data into the sequenc buffer
183 : : * @s: seq_buf descriptor
184 : : * @mem: The raw memory to copy into the buffer
185 : : * @len: The length of the raw memory to copy (in bytes)
186 : : *
187 : : * There may be cases where raw memory needs to be written into the
188 : : * buffer and a strcpy() would not work. Using this function allows
189 : : * for such cases.
190 : : *
191 : : * Returns zero on success, -1 on overflow
192 : : */
193 : 0 : int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len)
194 : : {
195 [ # # ]: 0 : WARN_ON(s->size == 0);
196 : :
197 [ # # ]: 0 : if (seq_buf_can_fit(s, len)) {
198 : 0 : memcpy(s->buffer + s->len, mem, len);
199 : 0 : s->len += len;
200 : 0 : return 0;
201 : : }
202 : 0 : seq_buf_set_overflow(s);
203 : 0 : return -1;
204 : : }
205 : :
206 : : #define MAX_MEMHEX_BYTES 8U
207 : : #define HEX_CHARS (MAX_MEMHEX_BYTES*2 + 1)
208 : :
209 : : /**
210 : : * seq_buf_putmem_hex - write raw memory into the buffer in ASCII hex
211 : : * @s: seq_buf descriptor
212 : : * @mem: The raw memory to write its hex ASCII representation of
213 : : * @len: The length of the raw memory to copy (in bytes)
214 : : *
215 : : * This is similar to seq_buf_putmem() except instead of just copying the
216 : : * raw memory into the buffer it writes its ASCII representation of it
217 : : * in hex characters.
218 : : *
219 : : * Returns zero on success, -1 on overflow
220 : : */
221 : 0 : int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
222 : : unsigned int len)
223 : : {
224 : 0 : unsigned char hex[HEX_CHARS];
225 : 0 : const unsigned char *data = mem;
226 : 0 : unsigned int start_len;
227 : 0 : int i, j;
228 : :
229 [ # # ]: 0 : WARN_ON(s->size == 0);
230 : :
231 [ # # ]: 0 : while (len) {
232 : 0 : start_len = min(len, HEX_CHARS - 1);
233 : : #ifdef __BIG_ENDIAN
234 : : for (i = 0, j = 0; i < start_len; i++) {
235 : : #else
236 [ # # ]: 0 : for (i = start_len-1, j = 0; i >= 0; i--) {
237 : : #endif
238 : 0 : hex[j++] = hex_asc_hi(data[i]);
239 : 0 : hex[j++] = hex_asc_lo(data[i]);
240 : : }
241 [ # # # # : 0 : if (WARN_ON_ONCE(j == 0 || j/2 > len))
# # # # ]
242 : : break;
243 : :
244 : : /* j increments twice per loop */
245 : 0 : len -= j / 2;
246 : 0 : hex[j++] = ' ';
247 : :
248 : 0 : seq_buf_putmem(s, hex, j);
249 [ # # ]: 0 : if (seq_buf_has_overflowed(s))
250 : : return -1;
251 : : }
252 : : return 0;
253 : : }
254 : :
255 : : /**
256 : : * seq_buf_path - copy a path into the sequence buffer
257 : : * @s: seq_buf descriptor
258 : : * @path: path to write into the sequence buffer.
259 : : * @esc: set of characters to escape in the output
260 : : *
261 : : * Write a path name into the sequence buffer.
262 : : *
263 : : * Returns the number of written bytes on success, -1 on overflow
264 : : */
265 : 0 : int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc)
266 : : {
267 : 0 : char *buf;
268 [ # # ]: 0 : size_t size = seq_buf_get_buf(s, &buf);
269 : 0 : int res = -1;
270 : :
271 [ # # ]: 0 : WARN_ON(s->size == 0);
272 : :
273 [ # # ]: 0 : if (size) {
274 : 0 : char *p = d_path(path, buf, size);
275 [ # # ]: 0 : if (!IS_ERR(p)) {
276 : 0 : char *end = mangle_path(buf, p, esc);
277 [ # # ]: 0 : if (end)
278 : 0 : res = end - buf;
279 : : }
280 : : }
281 [ # # ]: 0 : seq_buf_commit(s, res);
282 : :
283 : 0 : return res;
284 : : }
285 : :
286 : : /**
287 : : * seq_buf_to_user - copy the squence buffer to user space
288 : : * @s: seq_buf descriptor
289 : : * @ubuf: The userspace memory location to copy to
290 : : * @cnt: The amount to copy
291 : : *
292 : : * Copies the sequence buffer into the userspace memory pointed to
293 : : * by @ubuf. It starts from the last read position (@s->readpos)
294 : : * and writes up to @cnt characters or till it reaches the end of
295 : : * the content in the buffer (@s->len), which ever comes first.
296 : : *
297 : : * On success, it returns a positive number of the number of bytes
298 : : * it copied.
299 : : *
300 : : * On failure it returns -EBUSY if all of the content in the
301 : : * sequence has been already read, which includes nothing in the
302 : : * sequence (@s->len == @s->readpos).
303 : : *
304 : : * Returns -EFAULT if the copy to userspace fails.
305 : : */
306 : 0 : int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, int cnt)
307 : : {
308 : 0 : int len;
309 : 0 : int ret;
310 : :
311 [ # # ]: 0 : if (!cnt)
312 : : return 0;
313 : :
314 [ # # ]: 0 : len = seq_buf_used(s);
315 : :
316 [ # # ]: 0 : if (len <= s->readpos)
317 : : return -EBUSY;
318 : :
319 : 0 : len -= s->readpos;
320 : 0 : if (cnt > len)
321 : : cnt = len;
322 [ # # ]: 0 : ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
323 [ # # ]: 0 : if (ret == cnt)
324 : : return -EFAULT;
325 : :
326 : 0 : cnt -= ret;
327 : :
328 : 0 : s->readpos += cnt;
329 : 0 : return cnt;
330 : : }
331 : :
332 : : /**
333 : : * seq_buf_hex_dump - print formatted hex dump into the sequence buffer
334 : : * @s: seq_buf descriptor
335 : : * @prefix_str: string to prefix each line with;
336 : : * caller supplies trailing spaces for alignment if desired
337 : : * @prefix_type: controls whether prefix of an offset, address, or none
338 : : * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
339 : : * @rowsize: number of bytes to print per line; must be 16 or 32
340 : : * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
341 : : * @buf: data blob to dump
342 : : * @len: number of bytes in the @buf
343 : : * @ascii: include ASCII after the hex output
344 : : *
345 : : * Function is an analogue of print_hex_dump() and thus has similar interface.
346 : : *
347 : : * linebuf size is maximal length for one line.
348 : : * 32 * 3 - maximum bytes per line, each printed into 2 chars + 1 for
349 : : * separating space
350 : : * 2 - spaces separating hex dump and ascii representation
351 : : * 32 - ascii representation
352 : : * 1 - terminating '\0'
353 : : *
354 : : * Returns zero on success, -1 on overflow
355 : : */
356 : 0 : int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str, int prefix_type,
357 : : int rowsize, int groupsize,
358 : : const void *buf, size_t len, bool ascii)
359 : : {
360 : 0 : const u8 *ptr = buf;
361 : 0 : int i, linelen, remaining = len;
362 : 0 : unsigned char linebuf[32 * 3 + 2 + 32 + 1];
363 : 0 : int ret;
364 : :
365 [ # # ]: 0 : if (rowsize != 16 && rowsize != 32)
366 : 0 : rowsize = 16;
367 : :
368 [ # # ]: 0 : for (i = 0; i < len; i += rowsize) {
369 : 0 : linelen = min(remaining, rowsize);
370 : 0 : remaining -= rowsize;
371 : :
372 : 0 : hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
373 : : linebuf, sizeof(linebuf), ascii);
374 : :
375 [ # # # ]: 0 : switch (prefix_type) {
376 : 0 : case DUMP_PREFIX_ADDRESS:
377 : 0 : ret = seq_buf_printf(s, "%s%p: %s\n",
378 : : prefix_str, ptr + i, linebuf);
379 : 0 : break;
380 : 0 : case DUMP_PREFIX_OFFSET:
381 : 0 : ret = seq_buf_printf(s, "%s%.8x: %s\n",
382 : : prefix_str, i, linebuf);
383 : 0 : break;
384 : 0 : default:
385 : 0 : ret = seq_buf_printf(s, "%s%s\n", prefix_str, linebuf);
386 : 0 : break;
387 : : }
388 [ # # ]: 0 : if (ret)
389 : 0 : return ret;
390 : : }
391 : : return 0;
392 : : }
|
