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 static bool seq_buf_can_fit(struct seq_buf *s, size_t len) 29 { 30 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 int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s) 41 { 42 unsigned int len = seq_buf_used(s); 43 44 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 int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args) 58 { 59 int len; 60 61 WARN_ON(s->size == 0); 62 63 if (s->len < s->size) { 64 len = vsnprintf(s->buffer + s->len, s->size - s->len, fmt, args); 65 if (s->len + len < s->size) { 66 s->len += len; 67 return 0; 68 } 69 } 70 seq_buf_set_overflow(s); 71 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 int seq_buf_printf(struct seq_buf *s, const char *fmt, ...) 84 { 85 va_list ap; 86 int ret; 87 88 va_start(ap, fmt); 89 ret = seq_buf_vprintf(s, fmt, ap); 90 va_end(ap); 91 92 return ret; 93 } 94 EXPORT_SYMBOL_GPL(seq_buf_printf); 95 96 /** 97 * seq_buf_do_printk - printk seq_buf line by line 98 * @s: seq_buf descriptor 99 * @lvl: printk level 100 * 101 * printk()-s a multi-line sequential buffer line by line. The function 102 * makes sure that the buffer in @s is nul terminated and safe to read 103 * as a string. 104 */ 105 void seq_buf_do_printk(struct seq_buf *s, const char *lvl) 106 { 107 const char *start, *lf; 108 109 if (s->size == 0 || s->len == 0) 110 return; 111 112 start = seq_buf_str(s); 113 while ((lf = strchr(start, '\n'))) { 114 int len = lf - start + 1; 115 116 printk("%s%.*s", lvl, len, start); 117 start = ++lf; 118 } 119 120 /* No trailing LF */ 121 if (start < s->buffer + s->len) 122 printk("%s%s\n", lvl, start); 123 } 124 EXPORT_SYMBOL_GPL(seq_buf_do_printk); 125 126 #ifdef CONFIG_BINARY_PRINTF 127 /** 128 * seq_buf_bprintf - Write the printf string from binary arguments 129 * @s: seq_buf descriptor 130 * @fmt: The format string for the @binary arguments 131 * @binary: The binary arguments for @fmt. 132 * 133 * When recording in a fast path, a printf may be recorded with just 134 * saving the format and the arguments as they were passed to the 135 * function, instead of wasting cycles converting the arguments into 136 * ASCII characters. Instead, the arguments are saved in a 32 bit 137 * word array that is defined by the format string constraints. 138 * 139 * This function will take the format and the binary array and finish 140 * the conversion into the ASCII string within the buffer. 141 * 142 * Returns zero on success, -1 on overflow. 143 */ 144 int seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary) 145 { 146 unsigned int len = seq_buf_buffer_left(s); 147 int ret; 148 149 WARN_ON(s->size == 0); 150 151 if (s->len < s->size) { 152 ret = bstr_printf(s->buffer + s->len, len, fmt, binary); 153 if (s->len + ret < s->size) { 154 s->len += ret; 155 return 0; 156 } 157 } 158 seq_buf_set_overflow(s); 159 return -1; 160 } 161 #endif /* CONFIG_BINARY_PRINTF */ 162 163 /** 164 * seq_buf_puts - sequence printing of simple string 165 * @s: seq_buf descriptor 166 * @str: simple string to record 167 * 168 * Copy a simple string into the sequence buffer. 169 * 170 * Returns zero on success, -1 on overflow 171 */ 172 int seq_buf_puts(struct seq_buf *s, const char *str) 173 { 174 size_t len = strlen(str); 175 176 WARN_ON(s->size == 0); 177 178 /* Add 1 to len for the trailing null byte which must be there */ 179 len += 1; 180 181 if (seq_buf_can_fit(s, len)) { 182 memcpy(s->buffer + s->len, str, len); 183 /* Don't count the trailing null byte against the capacity */ 184 s->len += len - 1; 185 return 0; 186 } 187 seq_buf_set_overflow(s); 188 return -1; 189 } 190 191 /** 192 * seq_buf_putc - sequence printing of simple character 193 * @s: seq_buf descriptor 194 * @c: simple character to record 195 * 196 * Copy a single character into the sequence buffer. 197 * 198 * Returns zero on success, -1 on overflow 199 */ 200 int seq_buf_putc(struct seq_buf *s, unsigned char c) 201 { 202 WARN_ON(s->size == 0); 203 204 if (seq_buf_can_fit(s, 1)) { 205 s->buffer[s->len++] = c; 206 return 0; 207 } 208 seq_buf_set_overflow(s); 209 return -1; 210 } 211 212 /** 213 * seq_buf_putmem - write raw data into the sequenc buffer 214 * @s: seq_buf descriptor 215 * @mem: The raw memory to copy into the buffer 216 * @len: The length of the raw memory to copy (in bytes) 217 * 218 * There may be cases where raw memory needs to be written into the 219 * buffer and a strcpy() would not work. Using this function allows 220 * for such cases. 221 * 222 * Returns zero on success, -1 on overflow 223 */ 224 int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len) 225 { 226 WARN_ON(s->size == 0); 227 228 if (seq_buf_can_fit(s, len)) { 229 memcpy(s->buffer + s->len, mem, len); 230 s->len += len; 231 return 0; 232 } 233 seq_buf_set_overflow(s); 234 return -1; 235 } 236 237 #define MAX_MEMHEX_BYTES 8U 238 #define HEX_CHARS (MAX_MEMHEX_BYTES*2 + 1) 239 240 /** 241 * seq_buf_putmem_hex - write raw memory into the buffer in ASCII hex 242 * @s: seq_buf descriptor 243 * @mem: The raw memory to write its hex ASCII representation of 244 * @len: The length of the raw memory to copy (in bytes) 245 * 246 * This is similar to seq_buf_putmem() except instead of just copying the 247 * raw memory into the buffer it writes its ASCII representation of it 248 * in hex characters. 249 * 250 * Returns zero on success, -1 on overflow 251 */ 252 int seq_buf_putmem_hex(struct seq_buf *s, const void *mem, 253 unsigned int len) 254 { 255 unsigned char hex[HEX_CHARS]; 256 const unsigned char *data = mem; 257 unsigned int start_len; 258 int i, j; 259 260 WARN_ON(s->size == 0); 261 262 BUILD_BUG_ON(MAX_MEMHEX_BYTES * 2 >= HEX_CHARS); 263 264 while (len) { 265 start_len = min(len, MAX_MEMHEX_BYTES); 266 #ifdef __BIG_ENDIAN 267 for (i = 0, j = 0; i < start_len; i++) { 268 #else 269 for (i = start_len-1, j = 0; i >= 0; i--) { 270 #endif 271 hex[j++] = hex_asc_hi(data[i]); 272 hex[j++] = hex_asc_lo(data[i]); 273 } 274 if (WARN_ON_ONCE(j == 0 || j/2 > len)) 275 break; 276 277 /* j increments twice per loop */ 278 hex[j++] = ' '; 279 280 seq_buf_putmem(s, hex, j); 281 if (seq_buf_has_overflowed(s)) 282 return -1; 283 284 len -= start_len; 285 data += start_len; 286 } 287 return 0; 288 } 289 290 /** 291 * seq_buf_path - copy a path into the sequence buffer 292 * @s: seq_buf descriptor 293 * @path: path to write into the sequence buffer. 294 * @esc: set of characters to escape in the output 295 * 296 * Write a path name into the sequence buffer. 297 * 298 * Returns the number of written bytes on success, -1 on overflow 299 */ 300 int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc) 301 { 302 char *buf; 303 size_t size = seq_buf_get_buf(s, &buf); 304 int res = -1; 305 306 WARN_ON(s->size == 0); 307 308 if (size) { 309 char *p = d_path(path, buf, size); 310 if (!IS_ERR(p)) { 311 char *end = mangle_path(buf, p, esc); 312 if (end) 313 res = end - buf; 314 } 315 } 316 seq_buf_commit(s, res); 317 318 return res; 319 } 320 321 /** 322 * seq_buf_to_user - copy the sequence buffer to user space 323 * @s: seq_buf descriptor 324 * @ubuf: The userspace memory location to copy to 325 * @start: The first byte in the buffer to copy 326 * @cnt: The amount to copy 327 * 328 * Copies the sequence buffer into the userspace memory pointed to 329 * by @ubuf. It starts from @start and writes up to @cnt characters 330 * or until it reaches the end of the content in the buffer (@s->len), 331 * whichever comes first. 332 * 333 * On success, it returns a positive number of the number of bytes 334 * it copied. 335 * 336 * On failure it returns -EBUSY if all of the content in the 337 * sequence has been already read, which includes nothing in the 338 * sequence (@s->len == @start). 339 * 340 * Returns -EFAULT if the copy to userspace fails. 341 */ 342 int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, size_t start, int cnt) 343 { 344 int len; 345 int ret; 346 347 if (!cnt) 348 return 0; 349 350 len = seq_buf_used(s); 351 352 if (len <= start) 353 return -EBUSY; 354 355 len -= start; 356 if (cnt > len) 357 cnt = len; 358 ret = copy_to_user(ubuf, s->buffer + start, cnt); 359 if (ret == cnt) 360 return -EFAULT; 361 362 return cnt - ret; 363 } 364 365 /** 366 * seq_buf_hex_dump - print formatted hex dump into the sequence buffer 367 * @s: seq_buf descriptor 368 * @prefix_str: string to prefix each line with; 369 * caller supplies trailing spaces for alignment if desired 370 * @prefix_type: controls whether prefix of an offset, address, or none 371 * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE) 372 * @rowsize: number of bytes to print per line; must be 16 or 32 373 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1) 374 * @buf: data blob to dump 375 * @len: number of bytes in the @buf 376 * @ascii: include ASCII after the hex output 377 * 378 * Function is an analogue of print_hex_dump() and thus has similar interface. 379 * 380 * linebuf size is maximal length for one line. 381 * 32 * 3 - maximum bytes per line, each printed into 2 chars + 1 for 382 * separating space 383 * 2 - spaces separating hex dump and ascii representation 384 * 32 - ascii representation 385 * 1 - terminating '\0' 386 * 387 * Returns zero on success, -1 on overflow 388 */ 389 int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str, int prefix_type, 390 int rowsize, int groupsize, 391 const void *buf, size_t len, bool ascii) 392 { 393 const u8 *ptr = buf; 394 int i, linelen, remaining = len; 395 unsigned char linebuf[32 * 3 + 2 + 32 + 1]; 396 int ret; 397 398 if (rowsize != 16 && rowsize != 32) 399 rowsize = 16; 400 401 for (i = 0; i < len; i += rowsize) { 402 linelen = min(remaining, rowsize); 403 remaining -= rowsize; 404 405 hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize, 406 linebuf, sizeof(linebuf), ascii); 407 408 switch (prefix_type) { 409 case DUMP_PREFIX_ADDRESS: 410 ret = seq_buf_printf(s, "%s%p: %s\n", 411 prefix_str, ptr + i, linebuf); 412 break; 413 case DUMP_PREFIX_OFFSET: 414 ret = seq_buf_printf(s, "%s%.8x: %s\n", 415 prefix_str, i, linebuf); 416 break; 417 default: 418 ret = seq_buf_printf(s, "%s%s\n", prefix_str, linebuf); 419 break; 420 } 421 if (ret) 422 return ret; 423 } 424 return 0; 425 } 426