1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_SEQ_FILE_H
3 #define _LINUX_SEQ_FILE_H
5 #include <linux/types.h>
6 #include <linux/string.h>
8 #include <linux/mutex.h>
9 #include <linux/cpumask.h>
10 #include <linux/nodemask.h>
12 #include <linux/cred.h>
14 struct seq_operations
;
25 const struct seq_operations
*op
;
27 const struct file
*file
;
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
);
41 * seq_has_overflowed - check if the buffer has overflowed
42 * @m: the seq_file handle
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.
48 * Returns true if the buffer received more than it can hold.
50 static inline bool seq_has_overflowed(struct seq_file
*m
)
52 return m
->count
== m
->size
;
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
60 * Return the number of bytes available in the buffer, or zero if
63 static inline size_t seq_get_buf(struct seq_file
*m
, char **bufp
)
65 BUG_ON(m
->count
> m
->size
);
66 if (m
->count
< m
->size
)
67 *bufp
= m
->buf
+ m
->count
;
71 return m
->size
- m
->count
;
75 * seq_commit - commit data to the buffer
76 * @m: the seq_file handle
77 * @num: the number of bytes to commit
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.
83 static inline void seq_commit(struct seq_file
*m
, int num
)
88 BUG_ON(m
->count
+ num
> m
->size
);
94 * seq_setwidth - set padding width
95 * @m: the seq_file handle
96 * @size: the max number of bytes to pad.
98 * Call seq_setwidth() for setting max width, then call seq_printf() etc. and
99 * finally call seq_pad() to pad the remaining bytes.
101 static inline void seq_setwidth(struct seq_file
*m
, size_t size
)
103 m
->pad_until
= m
->count
+ size
;
105 void seq_pad(struct seq_file
*m
, char c
);
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
);
116 void seq_vprintf(struct seq_file
*m
, const char *fmt
, va_list args
);
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
);
129 void seq_escape_mem(struct seq_file
*m
, const char *src
, size_t len
,
130 unsigned int flags
, const char *esc
);
132 static inline void seq_escape_str(struct seq_file
*m
, const char *src
,
133 unsigned int flags
, const char *esc
)
135 seq_escape_mem(m
, src
, strlen(src
), flags
, esc
);
138 void seq_escape(struct seq_file
*m
, const char *s
, const char *esc
);
140 void seq_hex_dump(struct seq_file
*m
, const char *prefix_str
, int prefix_type
,
141 int rowsize
, int groupsize
, const void *buf
, size_t len
,
144 int seq_path(struct seq_file
*, const struct path
*, const char *);
145 int seq_file_path(struct seq_file
*, struct file
*, const char *);
146 int seq_dentry(struct seq_file
*, struct dentry
*, const char *);
147 int seq_path_root(struct seq_file
*m
, const struct path
*path
,
148 const struct path
*root
, const char *esc
);
150 int single_open(struct file
*, int (*)(struct seq_file
*, void *), void *);
151 int single_open_size(struct file
*, int (*)(struct seq_file
*, void *), void *, size_t);
152 int single_release(struct inode
*, struct file
*);
153 void *__seq_open_private(struct file
*, const struct seq_operations
*, int);
154 int seq_open_private(struct file
*, const struct seq_operations
*, int);
155 int seq_release_private(struct inode
*, struct file
*);
157 #ifdef CONFIG_BINARY_PRINTF
158 void seq_bprintf(struct seq_file
*m
, const char *f
, const u32
*binary
);
161 #define DEFINE_SEQ_ATTRIBUTE(__name) \
162 static int __name ## _open(struct inode *inode, struct file *file) \
164 int ret = seq_open(file, &__name ## _sops); \
165 if (!ret && inode->i_private) { \
166 struct seq_file *seq_f = file->private_data; \
167 seq_f->private = inode->i_private; \
172 static const struct file_operations __name ## _fops = { \
173 .owner = THIS_MODULE, \
174 .open = __name ## _open, \
176 .llseek = seq_lseek, \
177 .release = seq_release, \
180 #define DEFINE_SHOW_ATTRIBUTE(__name) \
181 static int __name ## _open(struct inode *inode, struct file *file) \
183 return single_open(file, __name ## _show, inode->i_private); \
186 static const struct file_operations __name ## _fops = { \
187 .owner = THIS_MODULE, \
188 .open = __name ## _open, \
190 .llseek = seq_lseek, \
191 .release = single_release, \
194 #define DEFINE_PROC_SHOW_ATTRIBUTE(__name) \
195 static int __name ## _open(struct inode *inode, struct file *file) \
197 return single_open(file, __name ## _show, inode->i_private); \
200 static const struct proc_ops __name ## _proc_ops = { \
201 .proc_open = __name ## _open, \
202 .proc_read = seq_read, \
203 .proc_lseek = seq_lseek, \
204 .proc_release = single_release, \
207 static inline struct user_namespace
*seq_user_ns(struct seq_file
*seq
)
209 #ifdef CONFIG_USER_NS
210 return seq
->file
->f_cred
->user_ns
;
212 extern struct user_namespace init_user_ns
;
213 return &init_user_ns
;
218 * seq_show_options - display mount options with appropriate escapes.
219 * @m: the seq_file handle
220 * @name: the mount option name
221 * @value: the mount option name's value, can be NULL
223 static inline void seq_show_option(struct seq_file
*m
, const char *name
,
227 seq_escape(m
, name
, ",= \t\n\\");
230 seq_escape(m
, value
, ", \t\n\\");
235 * seq_show_option_n - display mount options with appropriate escapes
236 * where @value must be a specific length.
237 * @m: the seq_file handle
238 * @name: the mount option name
239 * @value: the mount option name's value, cannot be NULL
240 * @length: the length of @value to display
242 * This is a macro since this uses "length" to define the size of the
245 #define seq_show_option_n(m, name, value, length) { \
246 char val_buf[length + 1]; \
247 strncpy(val_buf, value, length); \
248 val_buf[length] = '\0'; \
249 seq_show_option(m, name, val_buf); \
252 #define SEQ_START_TOKEN ((void *)1)
254 * Helpers for iteration over list_head-s in seq_files
257 extern struct list_head
*seq_list_start(struct list_head
*head
,
259 extern struct list_head
*seq_list_start_head(struct list_head
*head
,
261 extern struct list_head
*seq_list_next(void *v
, struct list_head
*head
,
265 * Helpers for iteration over hlist_head-s in seq_files
268 extern struct hlist_node
*seq_hlist_start(struct hlist_head
*head
,
270 extern struct hlist_node
*seq_hlist_start_head(struct hlist_head
*head
,
272 extern struct hlist_node
*seq_hlist_next(void *v
, struct hlist_head
*head
,
275 extern struct hlist_node
*seq_hlist_start_rcu(struct hlist_head
*head
,
277 extern struct hlist_node
*seq_hlist_start_head_rcu(struct hlist_head
*head
,
279 extern struct hlist_node
*seq_hlist_next_rcu(void *v
,
280 struct hlist_head
*head
,
283 /* Helpers for iterating over per-cpu hlist_head-s in seq_files */
284 extern struct hlist_node
*seq_hlist_start_percpu(struct hlist_head __percpu
*head
, int *cpu
, loff_t pos
);
286 extern struct hlist_node
*seq_hlist_next_percpu(void *v
, struct hlist_head __percpu
*head
, int *cpu
, loff_t
*pos
);
288 void seq_file_init(void);