Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : #ifndef _LINUX_SEQ_FILE_H
3 : #define _LINUX_SEQ_FILE_H
4 :
5 : #include <linux/types.h>
6 : #include <linux/string.h>
7 : #include <linux/bug.h>
8 : #include <linux/mutex.h>
9 : #include <linux/cpumask.h>
10 : #include <linux/nodemask.h>
11 : #include <linux/fs.h>
12 : #include <linux/cred.h>
13 :
14 : struct seq_operations;
15 :
16 : struct seq_file {
17 : char *buf;
18 : size_t size;
19 : size_t from;
20 : size_t count;
21 : size_t pad_until;
22 : loff_t index;
23 : loff_t read_pos;
24 : struct mutex lock;
25 : const struct seq_operations *op;
26 : int poll_event;
27 : const struct file *file;
28 : void *private;
29 : };
30 :
31 : struct seq_operations {
32 : void * (*start) (struct seq_file *m, loff_t *pos);
33 : void (*stop) (struct seq_file *m, void *v);
34 : void * (*next) (struct seq_file *m, void *v, loff_t *pos);
35 : int (*show) (struct seq_file *m, void *v);
36 : };
37 :
38 : #define SEQ_SKIP 1
39 :
40 : /**
41 : * seq_has_overflowed - check if the buffer has overflowed
42 : * @m: the seq_file handle
43 : *
44 : * seq_files have a buffer which may overflow. When this happens a larger
45 : * buffer is reallocated and all the data will be printed again.
46 : * The overflow state is true when m->count == m->size.
47 : *
48 : * Returns true if the buffer received more than it can hold.
49 : */
50 7369 : static inline bool seq_has_overflowed(struct seq_file *m)
51 : {
52 7369 : return m->count == m->size;
53 : }
54 :
55 : /**
56 : * seq_get_buf - get buffer to write arbitrary data to
57 : * @m: the seq_file handle
58 : * @bufp: the beginning of the buffer is stored here
59 : *
60 : * Return the number of bytes available in the buffer, or zero if
61 : * there's no space.
62 : */
63 21134 : static inline size_t seq_get_buf(struct seq_file *m, char **bufp)
64 : {
65 21134 : BUG_ON(m->count > m->size);
66 21134 : if (m->count < m->size)
67 21134 : *bufp = m->buf + m->count;
68 : else
69 0 : *bufp = NULL;
70 :
71 21134 : return m->size - m->count;
72 : }
73 :
74 : /**
75 : * seq_commit - commit data to the buffer
76 : * @m: the seq_file handle
77 : * @num: the number of bytes to commit
78 : *
79 : * Commit @num bytes of data written to a buffer previously acquired
80 : * by seq_buf_get. To signal an error condition, or that the data
81 : * didn't fit in the available space, pass a negative @num value.
82 : */
83 20931 : static inline void seq_commit(struct seq_file *m, int num)
84 : {
85 20931 : if (num < 0) {
86 0 : m->count = m->size;
87 : } else {
88 20931 : BUG_ON(m->count + num > m->size);
89 20931 : m->count += num;
90 : }
91 20931 : }
92 :
93 : /**
94 : * seq_setwidth - set padding width
95 : * @m: the seq_file handle
96 : * @size: the max number of bytes to pad.
97 : *
98 : * Call seq_setwidth() for setting max width, then call seq_printf() etc. and
99 : * finally call seq_pad() to pad the remaining bytes.
100 : */
101 0 : static inline void seq_setwidth(struct seq_file *m, size_t size)
102 : {
103 0 : m->pad_until = m->count + size;
104 : }
105 : void seq_pad(struct seq_file *m, char c);
106 :
107 : char *mangle_path(char *s, const char *p, const char *esc);
108 : int seq_open(struct file *, const struct seq_operations *);
109 : ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);
110 : ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter);
111 : loff_t seq_lseek(struct file *, loff_t, int);
112 : int seq_release(struct inode *, struct file *);
113 : int seq_write(struct seq_file *seq, const void *data, size_t len);
114 :
115 : __printf(2, 0)
116 : void seq_vprintf(struct seq_file *m, const char *fmt, va_list args);
117 : __printf(2, 3)
118 : void seq_printf(struct seq_file *m, const char *fmt, ...);
119 : void seq_putc(struct seq_file *m, char c);
120 : void seq_puts(struct seq_file *m, const char *s);
121 : void seq_put_decimal_ull_width(struct seq_file *m, const char *delimiter,
122 : unsigned long long num, unsigned int width);
123 : void seq_put_decimal_ull(struct seq_file *m, const char *delimiter,
124 : unsigned long long num);
125 : void seq_put_decimal_ll(struct seq_file *m, const char *delimiter, long long num);
126 : void seq_put_hex_ll(struct seq_file *m, const char *delimiter,
127 : unsigned long long v, unsigned int width);
128 :
129 : void seq_escape(struct seq_file *m, const char *s, const char *esc);
130 : void seq_escape_mem_ascii(struct seq_file *m, const char *src, size_t isz);
131 :
132 : void seq_hex_dump(struct seq_file *m, const char *prefix_str, int prefix_type,
133 : int rowsize, int groupsize, const void *buf, size_t len,
134 : bool ascii);
135 :
136 : int seq_path(struct seq_file *, const struct path *, const char *);
137 : int seq_file_path(struct seq_file *, struct file *, const char *);
138 : int seq_dentry(struct seq_file *, struct dentry *, const char *);
139 : int seq_path_root(struct seq_file *m, const struct path *path,
140 : const struct path *root, const char *esc);
141 :
142 : int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
143 : int single_open_size(struct file *, int (*)(struct seq_file *, void *), void *, size_t);
144 : int single_release(struct inode *, struct file *);
145 : void *__seq_open_private(struct file *, const struct seq_operations *, int);
146 : int seq_open_private(struct file *, const struct seq_operations *, int);
147 : int seq_release_private(struct inode *, struct file *);
148 :
149 : #define DEFINE_SEQ_ATTRIBUTE(__name) \
150 : static int __name ## _open(struct inode *inode, struct file *file) \
151 : { \
152 : int ret = seq_open(file, &__name ## _sops); \
153 : if (!ret && inode->i_private) { \
154 : struct seq_file *seq_f = file->private_data; \
155 : seq_f->private = inode->i_private; \
156 : } \
157 : return ret; \
158 : } \
159 : \
160 : static const struct file_operations __name ## _fops = { \
161 : .owner = THIS_MODULE, \
162 : .open = __name ## _open, \
163 : .read = seq_read, \
164 : .llseek = seq_lseek, \
165 : .release = seq_release, \
166 : }
167 :
168 : #define DEFINE_SHOW_ATTRIBUTE(__name) \
169 : static int __name ## _open(struct inode *inode, struct file *file) \
170 : { \
171 : return single_open(file, __name ## _show, inode->i_private); \
172 : } \
173 : \
174 : static const struct file_operations __name ## _fops = { \
175 : .owner = THIS_MODULE, \
176 : .open = __name ## _open, \
177 : .read = seq_read, \
178 : .llseek = seq_lseek, \
179 : .release = single_release, \
180 : }
181 :
182 : #define DEFINE_PROC_SHOW_ATTRIBUTE(__name) \
183 : static int __name ## _open(struct inode *inode, struct file *file) \
184 : { \
185 : return single_open(file, __name ## _show, inode->i_private); \
186 : } \
187 : \
188 : static const struct proc_ops __name ## _proc_ops = { \
189 : .proc_open = __name ## _open, \
190 : .proc_read = seq_read, \
191 : .proc_lseek = seq_lseek, \
192 : .proc_release = single_release, \
193 : }
194 :
195 56 : static inline struct user_namespace *seq_user_ns(struct seq_file *seq)
196 : {
197 : #ifdef CONFIG_USER_NS
198 : return seq->file->f_cred->user_ns;
199 : #else
200 56 : extern struct user_namespace init_user_ns;
201 56 : return &init_user_ns;
202 : #endif
203 : }
204 :
205 : /**
206 : * seq_show_options - display mount options with appropriate escapes.
207 : * @m: the seq_file handle
208 : * @name: the mount option name
209 : * @value: the mount option name's value, can be NULL
210 : */
211 289 : static inline void seq_show_option(struct seq_file *m, const char *name,
212 : const char *value)
213 : {
214 289 : seq_putc(m, ',');
215 289 : seq_escape(m, name, ",= \t\n\\");
216 289 : if (value) {
217 289 : seq_putc(m, '=');
218 289 : seq_escape(m, value, ", \t\n\\");
219 : }
220 289 : }
221 :
222 : /**
223 : * seq_show_option_n - display mount options with appropriate escapes
224 : * where @value must be a specific length.
225 : * @m: the seq_file handle
226 : * @name: the mount option name
227 : * @value: the mount option name's value, cannot be NULL
228 : * @length: the length of @value to display
229 : *
230 : * This is a macro since this uses "length" to define the size of the
231 : * stack buffer.
232 : */
233 : #define seq_show_option_n(m, name, value, length) { \
234 : char val_buf[length + 1]; \
235 : strncpy(val_buf, value, length); \
236 : val_buf[length] = '\0'; \
237 : seq_show_option(m, name, val_buf); \
238 : }
239 :
240 : #define SEQ_START_TOKEN ((void *)1)
241 : /*
242 : * Helpers for iteration over list_head-s in seq_files
243 : */
244 :
245 : extern struct list_head *seq_list_start(struct list_head *head,
246 : loff_t pos);
247 : extern struct list_head *seq_list_start_head(struct list_head *head,
248 : loff_t pos);
249 : extern struct list_head *seq_list_next(void *v, struct list_head *head,
250 : loff_t *ppos);
251 :
252 : /*
253 : * Helpers for iteration over hlist_head-s in seq_files
254 : */
255 :
256 : extern struct hlist_node *seq_hlist_start(struct hlist_head *head,
257 : loff_t pos);
258 : extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head,
259 : loff_t pos);
260 : extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
261 : loff_t *ppos);
262 :
263 : extern struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
264 : loff_t pos);
265 : extern struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
266 : loff_t pos);
267 : extern struct hlist_node *seq_hlist_next_rcu(void *v,
268 : struct hlist_head *head,
269 : loff_t *ppos);
270 :
271 : /* Helpers for iterating over per-cpu hlist_head-s in seq_files */
272 : extern struct hlist_node *seq_hlist_start_percpu(struct hlist_head __percpu *head, int *cpu, loff_t pos);
273 :
274 : extern struct hlist_node *seq_hlist_next_percpu(void *v, struct hlist_head __percpu *head, int *cpu, loff_t *pos);
275 :
276 : void seq_file_init(void);
277 : #endif
|
