1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_SEQ_BUF_H 3 #define _LINUX_SEQ_BUF_H 4 5 #include <linux/fs.h> 6 7 /* 8 * Trace sequences are used to allow a function to call several other functions 9 * to create a string of data to use. 10 */ 11 12 /** 13 * seq_buf - seq buffer structure 14 * @buffer: pointer to the buffer 15 * @size: size of the buffer 16 * @len: the amount of data inside the buffer 17 * @readpos: The next position to read in the buffer. 18 */ 19 struct seq_buf { 20 char *buffer; 21 size_t size; 22 size_t len; 23 loff_t readpos; 24 }; 25 26 static inline void seq_buf_clear(struct seq_buf *s) 27 { 28 s->len = 0; 29 s->readpos = 0; 30 } 31 32 static inline void 33 seq_buf_init(struct seq_buf *s, char *buf, unsigned int size) 34 { 35 s->buffer = buf; 36 s->size = size; 37 seq_buf_clear(s); 38 } 39 40 /* 41 * seq_buf have a buffer that might overflow. When this happens 42 * the len and size are set to be equal. 43 */ 44 static inline bool 45 seq_buf_has_overflowed(struct seq_buf *s) 46 { 47 return s->len > s->size; 48 } 49 50 static inline void 51 seq_buf_set_overflow(struct seq_buf *s) 52 { 53 s->len = s->size + 1; 54 } 55 56 /* 57 * How much buffer is left on the seq_buf? 58 */ 59 static inline unsigned int 60 seq_buf_buffer_left(struct seq_buf *s) 61 { 62 if (seq_buf_has_overflowed(s)) 63 return 0; 64 65 return s->size - s->len; 66 } 67 68 /* How much buffer was written? */ 69 static inline unsigned int seq_buf_used(struct seq_buf *s) 70 { 71 return min(s->len, s->size); 72 } 73 74 /** 75 * seq_buf_terminate - Make sure buffer is nul terminated 76 * @s: the seq_buf descriptor to terminate. 77 * 78 * This makes sure that the buffer in @s is nul terminated and 79 * safe to read as a string. 80 * 81 * Note, if this is called when the buffer has overflowed, then 82 * the last byte of the buffer is zeroed, and the len will still 83 * point passed it. 84 * 85 * After this function is called, s->buffer is safe to use 86 * in string operations. 87 */ 88 static inline void seq_buf_terminate(struct seq_buf *s) 89 { 90 if (WARN_ON(s->size == 0)) 91 return; 92 93 if (seq_buf_buffer_left(s)) 94 s->buffer[s->len] = 0; 95 else 96 s->buffer[s->size - 1] = 0; 97 } 98 99 /** 100 * seq_buf_get_buf - get buffer to write arbitrary data to 101 * @s: the seq_buf handle 102 * @bufp: the beginning of the buffer is stored here 103 * 104 * Return the number of bytes available in the buffer, or zero if 105 * there's no space. 106 */ 107 static inline size_t seq_buf_get_buf(struct seq_buf *s, char **bufp) 108 { 109 WARN_ON(s->len > s->size + 1); 110 111 if (s->len < s->size) { 112 *bufp = s->buffer + s->len; 113 return s->size - s->len; 114 } 115 116 *bufp = NULL; 117 return 0; 118 } 119 120 /** 121 * seq_buf_commit - commit data to the buffer 122 * @s: the seq_buf handle 123 * @num: the number of bytes to commit 124 * 125 * Commit @num bytes of data written to a buffer previously acquired 126 * by seq_buf_get. To signal an error condition, or that the data 127 * didn't fit in the available space, pass a negative @num value. 128 */ 129 static inline void seq_buf_commit(struct seq_buf *s, int num) 130 { 131 if (num < 0) { 132 seq_buf_set_overflow(s); 133 } else { 134 /* num must be negative on overflow */ 135 BUG_ON(s->len + num > s->size); 136 s->len += num; 137 } 138 } 139 140 extern __printf(2, 3) 141 int seq_buf_printf(struct seq_buf *s, const char *fmt, ...); 142 extern __printf(2, 0) 143 int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args); 144 extern int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s); 145 extern int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, 146 int cnt); 147 extern int seq_buf_puts(struct seq_buf *s, const char *str); 148 extern int seq_buf_putc(struct seq_buf *s, unsigned char c); 149 extern int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len); 150 extern int seq_buf_putmem_hex(struct seq_buf *s, const void *mem, 151 unsigned int len); 152 extern int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc); 153 extern int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str, 154 int prefix_type, int rowsize, int groupsize, 155 const void *buf, size_t len, bool ascii); 156 157 #ifdef CONFIG_BINARY_PRINTF 158 extern int 159 seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary); 160 #endif 161 162 #endif /* _LINUX_SEQ_BUF_H */ 163