blob: 14cf9de1dbe1751645ea1734d20808c9df6c398e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/seq_file.c
3 *
4 * helper functions for making synthetic files from sequences of records.
5 * initial implementation -- AV, Oct 2001.
6 */
7
8#include <linux/fs.h>
Paul Gortmaker630d9c42011-11-16 23:57:37 -05009#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/seq_file.h>
11#include <linux/slab.h>
12
13#include <asm/uaccess.h>
14#include <asm/page.h>
15
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -070016
17/*
18 * seq_files have a buffer which can may overflow. When this happens a larger
19 * buffer is reallocated and all the data will be printed again.
20 * The overflow state is true when m->count == m->size.
21 */
22static bool seq_overflow(struct seq_file *m)
23{
24 return m->count == m->size;
25}
26
27static void seq_set_overflow(struct seq_file *m)
28{
29 m->count = m->size;
30}
31
Linus Torvalds1da177e2005-04-16 15:20:36 -070032/**
33 * seq_open - initialize sequential file
34 * @file: file we initialize
35 * @op: method table describing the sequence
36 *
37 * seq_open() sets @file, associating it with a sequence described
38 * by @op. @op->start() sets the iterator up and returns the first
39 * element of sequence. @op->stop() shuts it down. @op->next()
40 * returns the next element of sequence. @op->show() prints element
41 * into the buffer. In case of error ->start() and ->next() return
42 * ERR_PTR(error). In the end of sequence they return %NULL. ->show()
43 * returns 0 in case of success and negative number in case of error.
Al Viro521b5d02008-03-28 00:46:41 -040044 * Returning SEQ_SKIP means "discard this element and move on".
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 */
Helge Deller15ad7cd2006-12-06 20:40:36 -080046int seq_open(struct file *file, const struct seq_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -070047{
Al Viro1abe77b2005-11-07 17:15:34 -050048 struct seq_file *p = file->private_data;
49
50 if (!p) {
51 p = kmalloc(sizeof(*p), GFP_KERNEL);
52 if (!p)
53 return -ENOMEM;
54 file->private_data = p;
55 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 memset(p, 0, sizeof(*p));
Ingo Molnar0ac17592006-03-23 03:00:37 -080057 mutex_init(&p->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 p->op = op;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60 /*
61 * Wrappers around seq_open(e.g. swaps_open) need to be
62 * aware of this. If they set f_version themselves, they
63 * should call seq_open first and then set f_version.
64 */
65 file->f_version = 0;
66
Eric Biederman8f19d472009-02-18 14:48:16 -080067 /*
68 * seq_files support lseek() and pread(). They do not implement
69 * write() at all, but we clear FMODE_PWRITE here for historical
70 * reasons.
71 *
72 * If a client of seq_files a) implements file.write() and b) wishes to
73 * support pwrite() then that client will need to implement its own
74 * file.open() which calls seq_open() and then sets FMODE_PWRITE.
75 */
76 file->f_mode &= ~FMODE_PWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return 0;
78}
79EXPORT_SYMBOL(seq_open);
80
Eric Biederman33da8892009-02-04 15:12:25 -080081static int traverse(struct seq_file *m, loff_t offset)
82{
83 loff_t pos = 0, index;
84 int error = 0;
85 void *p;
86
87 m->version = 0;
88 index = 0;
89 m->count = m->from = 0;
90 if (!offset) {
91 m->index = index;
92 return 0;
93 }
94 if (!m->buf) {
95 m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
96 if (!m->buf)
97 return -ENOMEM;
98 }
99 p = m->op->start(m, &index);
100 while (p) {
101 error = PTR_ERR(p);
102 if (IS_ERR(p))
103 break;
104 error = m->op->show(m, p);
105 if (error < 0)
106 break;
107 if (unlikely(error)) {
108 error = 0;
109 m->count = 0;
110 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700111 if (seq_overflow(m))
Eric Biederman33da8892009-02-04 15:12:25 -0800112 goto Eoverflow;
113 if (pos + m->count > offset) {
114 m->from = offset - pos;
115 m->count -= m->from;
116 m->index = index;
117 break;
118 }
119 pos += m->count;
120 m->count = 0;
121 if (pos == offset) {
122 index++;
123 m->index = index;
124 break;
125 }
126 p = m->op->next(m, p, &index);
127 }
128 m->op->stop(m, p);
Alexey Dobriyanf01d1d52009-02-06 00:30:05 +0300129 m->index = index;
Eric Biederman33da8892009-02-04 15:12:25 -0800130 return error;
131
132Eoverflow:
133 m->op->stop(m, p);
134 kfree(m->buf);
135 m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
136 return !m->buf ? -ENOMEM : -EAGAIN;
137}
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139/**
140 * seq_read - ->read() method for sequential files.
Martin Waitz67be2dd2005-05-01 08:59:26 -0700141 * @file: the file to read from
142 * @buf: the buffer to read to
143 * @size: the maximum number of bytes to read
144 * @ppos: the current position in the file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 *
146 * Ready-made ->f_op->read()
147 */
148ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
149{
Joe Perches8209e2f2010-09-04 18:52:49 -0700150 struct seq_file *m = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 size_t copied = 0;
152 loff_t pos;
153 size_t n;
154 void *p;
155 int err = 0;
156
Ingo Molnar0ac17592006-03-23 03:00:37 -0800157 mutex_lock(&m->lock);
Eric Biederman8f19d472009-02-18 14:48:16 -0800158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 /*
160 * seq_file->op->..m_start/m_stop/m_next may do special actions
161 * or optimisations based on the file->f_version, so we want to
162 * pass the file->f_version to those methods.
163 *
164 * seq_file->version is just copy of f_version, and seq_file
165 * methods can treat it simply as file version.
166 * It is copied in first and copied out after all operations.
167 * It is convenient to have it as part of structure to avoid the
168 * need of passing another argument to all the seq_file methods.
169 */
170 m->version = file->f_version;
Earl Chew7904ac82012-03-21 16:33:43 -0700171
172 /* Don't assume *ppos is where we left it */
173 if (unlikely(*ppos != m->read_pos)) {
174 while ((err = traverse(m, *ppos)) == -EAGAIN)
175 ;
176 if (err) {
177 /* With prejudice... */
178 m->read_pos = 0;
179 m->version = 0;
180 m->index = 0;
181 m->count = 0;
182 goto Done;
183 } else {
184 m->read_pos = *ppos;
185 }
186 }
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 /* grab buffer if we didn't have one */
189 if (!m->buf) {
190 m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
191 if (!m->buf)
192 goto Enomem;
193 }
194 /* if not empty - flush it first */
195 if (m->count) {
196 n = min(m->count, size);
197 err = copy_to_user(buf, m->buf + m->from, n);
198 if (err)
199 goto Efault;
200 m->count -= n;
201 m->from += n;
202 size -= n;
203 buf += n;
204 copied += n;
205 if (!m->count)
206 m->index++;
207 if (!size)
208 goto Done;
209 }
210 /* we need at least one record in buffer */
Al Viro4cdfe842008-08-24 07:45:33 -0400211 pos = m->index;
212 p = m->op->start(m, &pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 err = PTR_ERR(p);
215 if (!p || IS_ERR(p))
216 break;
217 err = m->op->show(m, p);
Al Viro521b5d02008-03-28 00:46:41 -0400218 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 break;
Al Viro521b5d02008-03-28 00:46:41 -0400220 if (unlikely(err))
221 m->count = 0;
Al Viro4cdfe842008-08-24 07:45:33 -0400222 if (unlikely(!m->count)) {
223 p = m->op->next(m, p, &pos);
224 m->index = pos;
225 continue;
226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if (m->count < m->size)
228 goto Fill;
229 m->op->stop(m, p);
230 kfree(m->buf);
231 m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
232 if (!m->buf)
233 goto Enomem;
234 m->count = 0;
235 m->version = 0;
Al Viro4cdfe842008-08-24 07:45:33 -0400236 pos = m->index;
237 p = m->op->start(m, &pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239 m->op->stop(m, p);
240 m->count = 0;
241 goto Done;
242Fill:
243 /* they want more? let's try to get some more */
244 while (m->count < size) {
245 size_t offs = m->count;
246 loff_t next = pos;
247 p = m->op->next(m, p, &next);
248 if (!p || IS_ERR(p)) {
249 err = PTR_ERR(p);
250 break;
251 }
252 err = m->op->show(m, p);
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700253 if (seq_overflow(m) || err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 m->count = offs;
Al Viro521b5d02008-03-28 00:46:41 -0400255 if (likely(err <= 0))
256 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258 pos = next;
259 }
260 m->op->stop(m, p);
261 n = min(m->count, size);
262 err = copy_to_user(buf, m->buf, n);
263 if (err)
264 goto Efault;
265 copied += n;
266 m->count -= n;
267 if (m->count)
268 m->from = n;
269 else
270 pos++;
271 m->index = pos;
272Done:
273 if (!copied)
274 copied = err;
Eric Biederman8f19d472009-02-18 14:48:16 -0800275 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 *ppos += copied;
Eric Biederman8f19d472009-02-18 14:48:16 -0800277 m->read_pos += copied;
278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 file->f_version = m->version;
Ingo Molnar0ac17592006-03-23 03:00:37 -0800280 mutex_unlock(&m->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return copied;
282Enomem:
283 err = -ENOMEM;
284 goto Done;
285Efault:
286 err = -EFAULT;
287 goto Done;
288}
289EXPORT_SYMBOL(seq_read);
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291/**
292 * seq_lseek - ->llseek() method for sequential files.
Martin Waitz67be2dd2005-05-01 08:59:26 -0700293 * @file: the file in question
294 * @offset: new position
295 * @origin: 0 for absolute, 1 for relative position
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 *
297 * Ready-made ->f_op->llseek()
298 */
299loff_t seq_lseek(struct file *file, loff_t offset, int origin)
300{
Joe Perches8209e2f2010-09-04 18:52:49 -0700301 struct seq_file *m = file->private_data;
David Sterba16abef02008-04-22 15:09:22 +0200302 loff_t retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Ingo Molnar0ac17592006-03-23 03:00:37 -0800304 mutex_lock(&m->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 m->version = file->f_version;
306 switch (origin) {
307 case 1:
308 offset += file->f_pos;
309 case 0:
310 if (offset < 0)
311 break;
312 retval = offset;
Eric Biederman8f19d472009-02-18 14:48:16 -0800313 if (offset != m->read_pos) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 while ((retval=traverse(m, offset)) == -EAGAIN)
315 ;
316 if (retval) {
317 /* with extreme prejudice... */
318 file->f_pos = 0;
Eric Biederman8f19d472009-02-18 14:48:16 -0800319 m->read_pos = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 m->version = 0;
321 m->index = 0;
322 m->count = 0;
323 } else {
Eric Biederman8f19d472009-02-18 14:48:16 -0800324 m->read_pos = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 retval = file->f_pos = offset;
326 }
327 }
328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 file->f_version = m->version;
Alexey Dobriyan00c57462007-07-15 23:40:22 -0700330 mutex_unlock(&m->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 return retval;
332}
333EXPORT_SYMBOL(seq_lseek);
334
335/**
336 * seq_release - free the structures associated with sequential file.
337 * @file: file in question
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800338 * @inode: file->f_path.dentry->d_inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 *
340 * Frees the structures associated with sequential file; can be used
341 * as ->f_op->release() if you don't have private data to destroy.
342 */
343int seq_release(struct inode *inode, struct file *file)
344{
Joe Perches8209e2f2010-09-04 18:52:49 -0700345 struct seq_file *m = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 kfree(m->buf);
347 kfree(m);
348 return 0;
349}
350EXPORT_SYMBOL(seq_release);
351
352/**
353 * seq_escape - print string into buffer, escaping some characters
354 * @m: target buffer
355 * @s: string
356 * @esc: set of characters that need escaping
357 *
358 * Puts string into buffer, replacing each occurrence of character from
359 * @esc with usual octal escape. Returns 0 in case of success, -1 - in
360 * case of overflow.
361 */
362int seq_escape(struct seq_file *m, const char *s, const char *esc)
363{
364 char *end = m->buf + m->size;
365 char *p;
366 char c;
367
368 for (p = m->buf + m->count; (c = *s) != '\0' && p < end; s++) {
369 if (!strchr(esc, c)) {
370 *p++ = c;
371 continue;
372 }
373 if (p + 3 < end) {
374 *p++ = '\\';
375 *p++ = '0' + ((c & 0300) >> 6);
376 *p++ = '0' + ((c & 070) >> 3);
377 *p++ = '0' + (c & 07);
378 continue;
379 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700380 seq_set_overflow(m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 return -1;
382 }
383 m->count = p - m->buf;
384 return 0;
385}
386EXPORT_SYMBOL(seq_escape);
387
Steven Whitehousea4808142012-06-11 13:16:35 +0100388int seq_vprintf(struct seq_file *m, const char *f, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 int len;
391
392 if (m->count < m->size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 len = vsnprintf(m->buf + m->count, m->size - m->count, f, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 if (m->count + len < m->size) {
395 m->count += len;
396 return 0;
397 }
398 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700399 seq_set_overflow(m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return -1;
401}
Steven Whitehousea4808142012-06-11 13:16:35 +0100402EXPORT_SYMBOL(seq_vprintf);
403
404int seq_printf(struct seq_file *m, const char *f, ...)
405{
406 int ret;
407 va_list args;
408
409 va_start(args, f);
410 ret = seq_vprintf(m, f, args);
411 va_end(args);
412
413 return ret;
414}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415EXPORT_SYMBOL(seq_printf);
416
Török Edwin74e2f332008-11-22 13:28:48 +0200417/**
Török Edwin958086d2008-11-23 23:24:53 +0200418 * mangle_path - mangle and copy path to buffer beginning
419 * @s: buffer start
420 * @p: beginning of path in above buffer
421 * @esc: set of characters that need escaping
Török Edwin74e2f332008-11-22 13:28:48 +0200422 *
423 * Copy the path from @p to @s, replacing each occurrence of character from
424 * @esc with usual octal escape.
425 * Returns pointer past last written character in @s, or NULL in case of
426 * failure.
427 */
Al Viro8c9379e2011-12-08 20:18:57 -0500428char *mangle_path(char *s, const char *p, const char *esc)
Ram Pai6092d042008-03-27 13:06:20 +0100429{
430 while (s <= p) {
431 char c = *p++;
432 if (!c) {
433 return s;
434 } else if (!strchr(esc, c)) {
435 *s++ = c;
436 } else if (s + 4 > p) {
437 break;
438 } else {
439 *s++ = '\\';
440 *s++ = '0' + ((c & 0300) >> 6);
441 *s++ = '0' + ((c & 070) >> 3);
442 *s++ = '0' + (c & 07);
443 }
444 }
445 return NULL;
446}
Ingo Molnar604094f2008-11-28 18:03:22 +0100447EXPORT_SYMBOL(mangle_path);
Ram Pai6092d042008-03-27 13:06:20 +0100448
Arjan van de Ven52afeef2008-12-01 14:35:00 -0800449/**
450 * seq_path - seq_file interface to print a pathname
451 * @m: the seq_file handle
452 * @path: the struct path to print
453 * @esc: set of characters to escape in the output
454 *
455 * return the absolute path of 'path', as represented by the
456 * dentry / mnt pair in the path parameter.
Ram Pai6092d042008-03-27 13:06:20 +0100457 */
Al Viro8c9379e2011-12-08 20:18:57 -0500458int seq_path(struct seq_file *m, const struct path *path, const char *esc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Miklos Szeredif8439802009-09-21 14:48:36 +0200460 char *buf;
461 size_t size = seq_get_buf(m, &buf);
462 int res = -1;
463
464 if (size) {
465 char *p = d_path(path, buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 if (!IS_ERR(p)) {
Miklos Szeredif8439802009-09-21 14:48:36 +0200467 char *end = mangle_path(buf, p, esc);
468 if (end)
469 res = end - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
471 }
Miklos Szeredif8439802009-09-21 14:48:36 +0200472 seq_commit(m, res);
473
474 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475}
476EXPORT_SYMBOL(seq_path);
477
Ram Pai6092d042008-03-27 13:06:20 +0100478/*
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100479 * Same as seq_path, but relative to supplied root.
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100480 */
Al Viro8c9379e2011-12-08 20:18:57 -0500481int seq_path_root(struct seq_file *m, const struct path *path,
482 const struct path *root, const char *esc)
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100483{
Miklos Szeredif8439802009-09-21 14:48:36 +0200484 char *buf;
485 size_t size = seq_get_buf(m, &buf);
486 int res = -ENAMETOOLONG;
487
488 if (size) {
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100489 char *p;
490
Miklos Szeredif8439802009-09-21 14:48:36 +0200491 p = __d_path(path, root, buf, size);
Al Viro02125a82011-12-05 08:43:34 -0500492 if (!p)
493 return SEQ_SKIP;
Miklos Szeredif8439802009-09-21 14:48:36 +0200494 res = PTR_ERR(p);
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100495 if (!IS_ERR(p)) {
Miklos Szeredif8439802009-09-21 14:48:36 +0200496 char *end = mangle_path(buf, p, esc);
497 if (end)
498 res = end - buf;
499 else
500 res = -ENAMETOOLONG;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100501 }
502 }
Miklos Szeredif8439802009-09-21 14:48:36 +0200503 seq_commit(m, res);
504
Al Viro02125a82011-12-05 08:43:34 -0500505 return res < 0 && res != -ENAMETOOLONG ? res : 0;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100506}
507
508/*
Ram Pai6092d042008-03-27 13:06:20 +0100509 * returns the path of the 'dentry' from the root of its filesystem.
510 */
Al Viro8c9379e2011-12-08 20:18:57 -0500511int seq_dentry(struct seq_file *m, struct dentry *dentry, const char *esc)
Ram Pai6092d042008-03-27 13:06:20 +0100512{
Miklos Szeredif8439802009-09-21 14:48:36 +0200513 char *buf;
514 size_t size = seq_get_buf(m, &buf);
515 int res = -1;
516
517 if (size) {
518 char *p = dentry_path(dentry, buf, size);
Ram Pai6092d042008-03-27 13:06:20 +0100519 if (!IS_ERR(p)) {
Miklos Szeredif8439802009-09-21 14:48:36 +0200520 char *end = mangle_path(buf, p, esc);
521 if (end)
522 res = end - buf;
Ram Pai6092d042008-03-27 13:06:20 +0100523 }
524 }
Miklos Szeredif8439802009-09-21 14:48:36 +0200525 seq_commit(m, res);
526
527 return res;
Ram Pai6092d042008-03-27 13:06:20 +0100528}
529
Rusty Russellcb78a0c2008-12-30 09:05:14 +1030530int seq_bitmap(struct seq_file *m, const unsigned long *bits,
531 unsigned int nr_bits)
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700532{
Lai Jiangshan85dd0302008-10-18 20:28:18 -0700533 if (m->count < m->size) {
534 int len = bitmap_scnprintf(m->buf + m->count,
535 m->size - m->count, bits, nr_bits);
536 if (m->count + len < m->size) {
537 m->count += len;
538 return 0;
539 }
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700540 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700541 seq_set_overflow(m);
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700542 return -1;
543}
Lai Jiangshan85dd0302008-10-18 20:28:18 -0700544EXPORT_SYMBOL(seq_bitmap);
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700545
Rusty Russellaf76aba2009-03-30 22:05:11 -0600546int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
Lai Jiangshan3eda2012008-10-18 20:28:19 -0700547 unsigned int nr_bits)
548{
549 if (m->count < m->size) {
550 int len = bitmap_scnlistprintf(m->buf + m->count,
551 m->size - m->count, bits, nr_bits);
552 if (m->count + len < m->size) {
553 m->count += len;
554 return 0;
555 }
556 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700557 seq_set_overflow(m);
Lai Jiangshan3eda2012008-10-18 20:28:19 -0700558 return -1;
559}
560EXPORT_SYMBOL(seq_bitmap_list);
561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562static void *single_start(struct seq_file *p, loff_t *pos)
563{
564 return NULL + (*pos == 0);
565}
566
567static void *single_next(struct seq_file *p, void *v, loff_t *pos)
568{
569 ++*pos;
570 return NULL;
571}
572
573static void single_stop(struct seq_file *p, void *v)
574{
575}
576
577int single_open(struct file *file, int (*show)(struct seq_file *, void *),
578 void *data)
579{
580 struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
581 int res = -ENOMEM;
582
583 if (op) {
584 op->start = single_start;
585 op->next = single_next;
586 op->stop = single_stop;
587 op->show = show;
588 res = seq_open(file, op);
589 if (!res)
590 ((struct seq_file *)file->private_data)->private = data;
591 else
592 kfree(op);
593 }
594 return res;
595}
596EXPORT_SYMBOL(single_open);
597
598int single_release(struct inode *inode, struct file *file)
599{
Helge Deller15ad7cd2006-12-06 20:40:36 -0800600 const struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 int res = seq_release(inode, file);
602 kfree(op);
603 return res;
604}
605EXPORT_SYMBOL(single_release);
606
607int seq_release_private(struct inode *inode, struct file *file)
608{
609 struct seq_file *seq = file->private_data;
610
611 kfree(seq->private);
612 seq->private = NULL;
613 return seq_release(inode, file);
614}
615EXPORT_SYMBOL(seq_release_private);
616
Pavel Emelyanov39699032007-10-10 02:28:42 -0700617void *__seq_open_private(struct file *f, const struct seq_operations *ops,
618 int psize)
619{
620 int rc;
621 void *private;
622 struct seq_file *seq;
623
624 private = kzalloc(psize, GFP_KERNEL);
625 if (private == NULL)
626 goto out;
627
628 rc = seq_open(f, ops);
629 if (rc < 0)
630 goto out_free;
631
632 seq = f->private_data;
633 seq->private = private;
634 return private;
635
636out_free:
637 kfree(private);
638out:
639 return NULL;
640}
641EXPORT_SYMBOL(__seq_open_private);
642
643int seq_open_private(struct file *filp, const struct seq_operations *ops,
644 int psize)
645{
646 return __seq_open_private(filp, ops, psize) ? 0 : -ENOMEM;
647}
648EXPORT_SYMBOL(seq_open_private);
649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650int seq_putc(struct seq_file *m, char c)
651{
652 if (m->count < m->size) {
653 m->buf[m->count++] = c;
654 return 0;
655 }
656 return -1;
657}
658EXPORT_SYMBOL(seq_putc);
659
660int seq_puts(struct seq_file *m, const char *s)
661{
662 int len = strlen(s);
663 if (m->count + len < m->size) {
664 memcpy(m->buf + m->count, s, len);
665 m->count += len;
666 return 0;
667 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700668 seq_set_overflow(m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return -1;
670}
671EXPORT_SYMBOL(seq_puts);
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700672
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700673/*
674 * A helper routine for putting decimal numbers without rich format of printf().
675 * only 'unsigned long long' is supported.
676 * This routine will put one byte delimiter + number into seq_file.
677 * This routine is very quick when you show lots of numbers.
678 * In usual cases, it will be better to use seq_printf(). It's easier to read.
679 */
680int seq_put_decimal_ull(struct seq_file *m, char delimiter,
681 unsigned long long num)
682{
683 int len;
684
685 if (m->count + 2 >= m->size) /* we'll write 2 bytes at least */
686 goto overflow;
687
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700688 if (delimiter)
689 m->buf[m->count++] = delimiter;
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700690
691 if (num < 10) {
692 m->buf[m->count++] = num + '0';
693 return 0;
694 }
695
696 len = num_to_str(m->buf + m->count, m->size - m->count, num);
697 if (!len)
698 goto overflow;
699 m->count += len;
700 return 0;
701overflow:
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700702 seq_set_overflow(m);
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700703 return -1;
704}
705EXPORT_SYMBOL(seq_put_decimal_ull);
706
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700707int seq_put_decimal_ll(struct seq_file *m, char delimiter,
708 long long num)
709{
710 if (num < 0) {
711 if (m->count + 3 >= m->size) {
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700712 seq_set_overflow(m);
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700713 return -1;
714 }
715 if (delimiter)
716 m->buf[m->count++] = delimiter;
717 num = -num;
718 delimiter = '-';
719 }
720 return seq_put_decimal_ull(m, delimiter, num);
721
722}
723EXPORT_SYMBOL(seq_put_decimal_ll);
724
Peter Oberparleiter0b923602009-06-17 16:28:05 -0700725/**
726 * seq_write - write arbitrary data to buffer
727 * @seq: seq_file identifying the buffer to which data should be written
728 * @data: data address
729 * @len: number of bytes
730 *
731 * Return 0 on success, non-zero otherwise.
732 */
733int seq_write(struct seq_file *seq, const void *data, size_t len)
734{
735 if (seq->count + len < seq->size) {
736 memcpy(seq->buf + seq->count, data, len);
737 seq->count += len;
738 return 0;
739 }
KAMEZAWA Hiroyukie075f592012-03-23 15:02:55 -0700740 seq_set_overflow(seq);
Peter Oberparleiter0b923602009-06-17 16:28:05 -0700741 return -1;
742}
743EXPORT_SYMBOL(seq_write);
744
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700745struct list_head *seq_list_start(struct list_head *head, loff_t pos)
746{
747 struct list_head *lh;
748
749 list_for_each(lh, head)
750 if (pos-- == 0)
751 return lh;
752
753 return NULL;
754}
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700755EXPORT_SYMBOL(seq_list_start);
756
757struct list_head *seq_list_start_head(struct list_head *head, loff_t pos)
758{
759 if (!pos)
760 return head;
761
762 return seq_list_start(head, pos - 1);
763}
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700764EXPORT_SYMBOL(seq_list_start_head);
765
766struct list_head *seq_list_next(void *v, struct list_head *head, loff_t *ppos)
767{
768 struct list_head *lh;
769
770 lh = ((struct list_head *)v)->next;
771 ++*ppos;
772 return lh == head ? NULL : lh;
773}
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700774EXPORT_SYMBOL(seq_list_next);
Li Zefan66655de2010-02-08 23:18:22 +0000775
776/**
777 * seq_hlist_start - start an iteration of a hlist
778 * @head: the head of the hlist
779 * @pos: the start position of the sequence
780 *
781 * Called at seq_file->op->start().
782 */
783struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos)
784{
785 struct hlist_node *node;
786
787 hlist_for_each(node, head)
788 if (pos-- == 0)
789 return node;
790 return NULL;
791}
792EXPORT_SYMBOL(seq_hlist_start);
793
794/**
795 * seq_hlist_start_head - start an iteration of a hlist
796 * @head: the head of the hlist
797 * @pos: the start position of the sequence
798 *
799 * Called at seq_file->op->start(). Call this function if you want to
800 * print a header at the top of the output.
801 */
802struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos)
803{
804 if (!pos)
805 return SEQ_START_TOKEN;
806
807 return seq_hlist_start(head, pos - 1);
808}
809EXPORT_SYMBOL(seq_hlist_start_head);
810
811/**
812 * seq_hlist_next - move to the next position of the hlist
813 * @v: the current iterator
814 * @head: the head of the hlist
Randy Dunlap138860b2010-03-04 09:37:12 -0800815 * @ppos: the current position
Li Zefan66655de2010-02-08 23:18:22 +0000816 *
817 * Called at seq_file->op->next().
818 */
819struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
820 loff_t *ppos)
821{
822 struct hlist_node *node = v;
823
824 ++*ppos;
825 if (v == SEQ_START_TOKEN)
826 return head->first;
827 else
828 return node->next;
829}
830EXPORT_SYMBOL(seq_hlist_next);
stephen hemminger1cc52322010-02-22 07:57:17 +0000831
832/**
833 * seq_hlist_start_rcu - start an iteration of a hlist protected by RCU
834 * @head: the head of the hlist
835 * @pos: the start position of the sequence
836 *
837 * Called at seq_file->op->start().
838 *
839 * This list-traversal primitive may safely run concurrently with
840 * the _rcu list-mutation primitives such as hlist_add_head_rcu()
841 * as long as the traversal is guarded by rcu_read_lock().
842 */
843struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
844 loff_t pos)
845{
846 struct hlist_node *node;
847
848 __hlist_for_each_rcu(node, head)
849 if (pos-- == 0)
850 return node;
851 return NULL;
852}
853EXPORT_SYMBOL(seq_hlist_start_rcu);
854
855/**
856 * seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU
857 * @head: the head of the hlist
858 * @pos: the start position of the sequence
859 *
860 * Called at seq_file->op->start(). Call this function if you want to
861 * print a header at the top of the output.
862 *
863 * This list-traversal primitive may safely run concurrently with
864 * the _rcu list-mutation primitives such as hlist_add_head_rcu()
865 * as long as the traversal is guarded by rcu_read_lock().
866 */
867struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
868 loff_t pos)
869{
870 if (!pos)
871 return SEQ_START_TOKEN;
872
873 return seq_hlist_start_rcu(head, pos - 1);
874}
875EXPORT_SYMBOL(seq_hlist_start_head_rcu);
876
877/**
878 * seq_hlist_next_rcu - move to the next position of the hlist protected by RCU
879 * @v: the current iterator
880 * @head: the head of the hlist
Randy Dunlap138860b2010-03-04 09:37:12 -0800881 * @ppos: the current position
stephen hemminger1cc52322010-02-22 07:57:17 +0000882 *
883 * Called at seq_file->op->next().
884 *
885 * This list-traversal primitive may safely run concurrently with
886 * the _rcu list-mutation primitives such as hlist_add_head_rcu()
887 * as long as the traversal is guarded by rcu_read_lock().
888 */
889struct hlist_node *seq_hlist_next_rcu(void *v,
890 struct hlist_head *head,
891 loff_t *ppos)
892{
893 struct hlist_node *node = v;
894
895 ++*ppos;
896 if (v == SEQ_START_TOKEN)
897 return rcu_dereference(head->first);
898 else
899 return rcu_dereference(node->next);
900}
901EXPORT_SYMBOL(seq_hlist_next_rcu);