blob: 7d19816c4cc9799265e6b1b876eb0851bf214b44 [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>
9#include <linux/module.h>
10#include <linux/seq_file.h>
11#include <linux/slab.h>
12
13#include <asm/uaccess.h>
14#include <asm/page.h>
15
16/**
17 * seq_open - initialize sequential file
18 * @file: file we initialize
19 * @op: method table describing the sequence
20 *
21 * seq_open() sets @file, associating it with a sequence described
22 * by @op. @op->start() sets the iterator up and returns the first
23 * element of sequence. @op->stop() shuts it down. @op->next()
24 * returns the next element of sequence. @op->show() prints element
25 * into the buffer. In case of error ->start() and ->next() return
26 * ERR_PTR(error). In the end of sequence they return %NULL. ->show()
27 * returns 0 in case of success and negative number in case of error.
Al Viro521b5d02008-03-28 00:46:41 -040028 * Returning SEQ_SKIP means "discard this element and move on".
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 */
Helge Deller15ad7cd2006-12-06 20:40:36 -080030int seq_open(struct file *file, const struct seq_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -070031{
Al Viro1abe77b2005-11-07 17:15:34 -050032 struct seq_file *p = file->private_data;
33
34 if (!p) {
35 p = kmalloc(sizeof(*p), GFP_KERNEL);
36 if (!p)
37 return -ENOMEM;
38 file->private_data = p;
39 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 memset(p, 0, sizeof(*p));
Ingo Molnar0ac17592006-03-23 03:00:37 -080041 mutex_init(&p->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 p->op = op;
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44 /*
45 * Wrappers around seq_open(e.g. swaps_open) need to be
46 * aware of this. If they set f_version themselves, they
47 * should call seq_open first and then set f_version.
48 */
49 file->f_version = 0;
50
Eric Biederman8f19d472009-02-18 14:48:16 -080051 /*
52 * seq_files support lseek() and pread(). They do not implement
53 * write() at all, but we clear FMODE_PWRITE here for historical
54 * reasons.
55 *
56 * If a client of seq_files a) implements file.write() and b) wishes to
57 * support pwrite() then that client will need to implement its own
58 * file.open() which calls seq_open() and then sets FMODE_PWRITE.
59 */
60 file->f_mode &= ~FMODE_PWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 return 0;
62}
63EXPORT_SYMBOL(seq_open);
64
Eric Biederman33da8892009-02-04 15:12:25 -080065static int traverse(struct seq_file *m, loff_t offset)
66{
67 loff_t pos = 0, index;
68 int error = 0;
69 void *p;
70
71 m->version = 0;
72 index = 0;
73 m->count = m->from = 0;
74 if (!offset) {
75 m->index = index;
76 return 0;
77 }
78 if (!m->buf) {
79 m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
80 if (!m->buf)
81 return -ENOMEM;
82 }
83 p = m->op->start(m, &index);
84 while (p) {
85 error = PTR_ERR(p);
86 if (IS_ERR(p))
87 break;
88 error = m->op->show(m, p);
89 if (error < 0)
90 break;
91 if (unlikely(error)) {
92 error = 0;
93 m->count = 0;
94 }
95 if (m->count == m->size)
96 goto Eoverflow;
97 if (pos + m->count > offset) {
98 m->from = offset - pos;
99 m->count -= m->from;
100 m->index = index;
101 break;
102 }
103 pos += m->count;
104 m->count = 0;
105 if (pos == offset) {
106 index++;
107 m->index = index;
108 break;
109 }
110 p = m->op->next(m, p, &index);
111 }
112 m->op->stop(m, p);
Alexey Dobriyanf01d1d52009-02-06 00:30:05 +0300113 m->index = index;
Eric Biederman33da8892009-02-04 15:12:25 -0800114 return error;
115
116Eoverflow:
117 m->op->stop(m, p);
118 kfree(m->buf);
119 m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
120 return !m->buf ? -ENOMEM : -EAGAIN;
121}
122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123/**
124 * seq_read - ->read() method for sequential files.
Martin Waitz67be2dd2005-05-01 08:59:26 -0700125 * @file: the file to read from
126 * @buf: the buffer to read to
127 * @size: the maximum number of bytes to read
128 * @ppos: the current position in the file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 *
130 * Ready-made ->f_op->read()
131 */
132ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
133{
Joe Perches8209e2f2010-09-04 18:52:49 -0700134 struct seq_file *m = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 size_t copied = 0;
136 loff_t pos;
137 size_t n;
138 void *p;
139 int err = 0;
140
Ingo Molnar0ac17592006-03-23 03:00:37 -0800141 mutex_lock(&m->lock);
Eric Biederman8f19d472009-02-18 14:48:16 -0800142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 /*
144 * seq_file->op->..m_start/m_stop/m_next may do special actions
145 * or optimisations based on the file->f_version, so we want to
146 * pass the file->f_version to those methods.
147 *
148 * seq_file->version is just copy of f_version, and seq_file
149 * methods can treat it simply as file version.
150 * It is copied in first and copied out after all operations.
151 * It is convenient to have it as part of structure to avoid the
152 * need of passing another argument to all the seq_file methods.
153 */
154 m->version = file->f_version;
Earl Chew7904ac82012-03-21 16:33:43 -0700155
156 /* Don't assume *ppos is where we left it */
157 if (unlikely(*ppos != m->read_pos)) {
158 while ((err = traverse(m, *ppos)) == -EAGAIN)
159 ;
160 if (err) {
161 /* With prejudice... */
162 m->read_pos = 0;
163 m->version = 0;
164 m->index = 0;
165 m->count = 0;
166 goto Done;
167 } else {
168 m->read_pos = *ppos;
169 }
170 }
171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 /* grab buffer if we didn't have one */
173 if (!m->buf) {
174 m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
175 if (!m->buf)
176 goto Enomem;
177 }
178 /* if not empty - flush it first */
179 if (m->count) {
180 n = min(m->count, size);
181 err = copy_to_user(buf, m->buf + m->from, n);
182 if (err)
183 goto Efault;
184 m->count -= n;
185 m->from += n;
186 size -= n;
187 buf += n;
188 copied += n;
189 if (!m->count)
190 m->index++;
191 if (!size)
192 goto Done;
193 }
194 /* we need at least one record in buffer */
Al Viro4cdfe842008-08-24 07:45:33 -0400195 pos = m->index;
196 p = m->op->start(m, &pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 err = PTR_ERR(p);
199 if (!p || IS_ERR(p))
200 break;
201 err = m->op->show(m, p);
Al Viro521b5d02008-03-28 00:46:41 -0400202 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 break;
Al Viro521b5d02008-03-28 00:46:41 -0400204 if (unlikely(err))
205 m->count = 0;
Al Viro4cdfe842008-08-24 07:45:33 -0400206 if (unlikely(!m->count)) {
207 p = m->op->next(m, p, &pos);
208 m->index = pos;
209 continue;
210 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (m->count < m->size)
212 goto Fill;
213 m->op->stop(m, p);
214 kfree(m->buf);
215 m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
216 if (!m->buf)
217 goto Enomem;
218 m->count = 0;
219 m->version = 0;
Al Viro4cdfe842008-08-24 07:45:33 -0400220 pos = m->index;
221 p = m->op->start(m, &pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 }
223 m->op->stop(m, p);
224 m->count = 0;
225 goto Done;
226Fill:
227 /* they want more? let's try to get some more */
228 while (m->count < size) {
229 size_t offs = m->count;
230 loff_t next = pos;
231 p = m->op->next(m, p, &next);
232 if (!p || IS_ERR(p)) {
233 err = PTR_ERR(p);
234 break;
235 }
236 err = m->op->show(m, p);
Al Viro521b5d02008-03-28 00:46:41 -0400237 if (m->count == m->size || err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 m->count = offs;
Al Viro521b5d02008-03-28 00:46:41 -0400239 if (likely(err <= 0))
240 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242 pos = next;
243 }
244 m->op->stop(m, p);
245 n = min(m->count, size);
246 err = copy_to_user(buf, m->buf, n);
247 if (err)
248 goto Efault;
249 copied += n;
250 m->count -= n;
251 if (m->count)
252 m->from = n;
253 else
254 pos++;
255 m->index = pos;
256Done:
257 if (!copied)
258 copied = err;
Eric Biederman8f19d472009-02-18 14:48:16 -0800259 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 *ppos += copied;
Eric Biederman8f19d472009-02-18 14:48:16 -0800261 m->read_pos += copied;
262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 file->f_version = m->version;
Ingo Molnar0ac17592006-03-23 03:00:37 -0800264 mutex_unlock(&m->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return copied;
266Enomem:
267 err = -ENOMEM;
268 goto Done;
269Efault:
270 err = -EFAULT;
271 goto Done;
272}
273EXPORT_SYMBOL(seq_read);
274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275/**
276 * seq_lseek - ->llseek() method for sequential files.
Martin Waitz67be2dd2005-05-01 08:59:26 -0700277 * @file: the file in question
278 * @offset: new position
279 * @origin: 0 for absolute, 1 for relative position
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 *
281 * Ready-made ->f_op->llseek()
282 */
283loff_t seq_lseek(struct file *file, loff_t offset, int origin)
284{
Joe Perches8209e2f2010-09-04 18:52:49 -0700285 struct seq_file *m = file->private_data;
David Sterba16abef02008-04-22 15:09:22 +0200286 loff_t retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Ingo Molnar0ac17592006-03-23 03:00:37 -0800288 mutex_lock(&m->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 m->version = file->f_version;
290 switch (origin) {
291 case 1:
292 offset += file->f_pos;
293 case 0:
294 if (offset < 0)
295 break;
296 retval = offset;
Eric Biederman8f19d472009-02-18 14:48:16 -0800297 if (offset != m->read_pos) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 while ((retval=traverse(m, offset)) == -EAGAIN)
299 ;
300 if (retval) {
301 /* with extreme prejudice... */
302 file->f_pos = 0;
Eric Biederman8f19d472009-02-18 14:48:16 -0800303 m->read_pos = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 m->version = 0;
305 m->index = 0;
306 m->count = 0;
307 } else {
Eric Biederman8f19d472009-02-18 14:48:16 -0800308 m->read_pos = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 retval = file->f_pos = offset;
310 }
311 }
312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 file->f_version = m->version;
Alexey Dobriyan00c57462007-07-15 23:40:22 -0700314 mutex_unlock(&m->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 return retval;
316}
317EXPORT_SYMBOL(seq_lseek);
318
319/**
320 * seq_release - free the structures associated with sequential file.
321 * @file: file in question
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800322 * @inode: file->f_path.dentry->d_inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 *
324 * Frees the structures associated with sequential file; can be used
325 * as ->f_op->release() if you don't have private data to destroy.
326 */
327int seq_release(struct inode *inode, struct file *file)
328{
Joe Perches8209e2f2010-09-04 18:52:49 -0700329 struct seq_file *m = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 kfree(m->buf);
331 kfree(m);
332 return 0;
333}
334EXPORT_SYMBOL(seq_release);
335
336/**
337 * seq_escape - print string into buffer, escaping some characters
338 * @m: target buffer
339 * @s: string
340 * @esc: set of characters that need escaping
341 *
342 * Puts string into buffer, replacing each occurrence of character from
343 * @esc with usual octal escape. Returns 0 in case of success, -1 - in
344 * case of overflow.
345 */
346int seq_escape(struct seq_file *m, const char *s, const char *esc)
347{
348 char *end = m->buf + m->size;
349 char *p;
350 char c;
351
352 for (p = m->buf + m->count; (c = *s) != '\0' && p < end; s++) {
353 if (!strchr(esc, c)) {
354 *p++ = c;
355 continue;
356 }
357 if (p + 3 < end) {
358 *p++ = '\\';
359 *p++ = '0' + ((c & 0300) >> 6);
360 *p++ = '0' + ((c & 070) >> 3);
361 *p++ = '0' + (c & 07);
362 continue;
363 }
364 m->count = m->size;
365 return -1;
366 }
367 m->count = p - m->buf;
368 return 0;
369}
370EXPORT_SYMBOL(seq_escape);
371
372int seq_printf(struct seq_file *m, const char *f, ...)
373{
374 va_list args;
375 int len;
376
377 if (m->count < m->size) {
378 va_start(args, f);
379 len = vsnprintf(m->buf + m->count, m->size - m->count, f, args);
380 va_end(args);
381 if (m->count + len < m->size) {
382 m->count += len;
383 return 0;
384 }
385 }
386 m->count = m->size;
387 return -1;
388}
389EXPORT_SYMBOL(seq_printf);
390
Török Edwin74e2f332008-11-22 13:28:48 +0200391/**
Török Edwin958086d2008-11-23 23:24:53 +0200392 * mangle_path - mangle and copy path to buffer beginning
393 * @s: buffer start
394 * @p: beginning of path in above buffer
395 * @esc: set of characters that need escaping
Török Edwin74e2f332008-11-22 13:28:48 +0200396 *
397 * Copy the path from @p to @s, replacing each occurrence of character from
398 * @esc with usual octal escape.
399 * Returns pointer past last written character in @s, or NULL in case of
400 * failure.
401 */
Al Viro8c9379e2011-12-08 20:18:57 -0500402char *mangle_path(char *s, const char *p, const char *esc)
Ram Pai6092d042008-03-27 13:06:20 +0100403{
404 while (s <= p) {
405 char c = *p++;
406 if (!c) {
407 return s;
408 } else if (!strchr(esc, c)) {
409 *s++ = c;
410 } else if (s + 4 > p) {
411 break;
412 } else {
413 *s++ = '\\';
414 *s++ = '0' + ((c & 0300) >> 6);
415 *s++ = '0' + ((c & 070) >> 3);
416 *s++ = '0' + (c & 07);
417 }
418 }
419 return NULL;
420}
Ingo Molnar604094f2008-11-28 18:03:22 +0100421EXPORT_SYMBOL(mangle_path);
Ram Pai6092d042008-03-27 13:06:20 +0100422
Arjan van de Ven52afeef2008-12-01 14:35:00 -0800423/**
424 * seq_path - seq_file interface to print a pathname
425 * @m: the seq_file handle
426 * @path: the struct path to print
427 * @esc: set of characters to escape in the output
428 *
429 * return the absolute path of 'path', as represented by the
430 * dentry / mnt pair in the path parameter.
Ram Pai6092d042008-03-27 13:06:20 +0100431 */
Al Viro8c9379e2011-12-08 20:18:57 -0500432int seq_path(struct seq_file *m, const struct path *path, const char *esc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
Miklos Szeredif8439802009-09-21 14:48:36 +0200434 char *buf;
435 size_t size = seq_get_buf(m, &buf);
436 int res = -1;
437
438 if (size) {
439 char *p = d_path(path, buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 if (!IS_ERR(p)) {
Miklos Szeredif8439802009-09-21 14:48:36 +0200441 char *end = mangle_path(buf, p, esc);
442 if (end)
443 res = end - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
445 }
Miklos Szeredif8439802009-09-21 14:48:36 +0200446 seq_commit(m, res);
447
448 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449}
450EXPORT_SYMBOL(seq_path);
451
Ram Pai6092d042008-03-27 13:06:20 +0100452/*
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100453 * Same as seq_path, but relative to supplied root.
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100454 */
Al Viro8c9379e2011-12-08 20:18:57 -0500455int seq_path_root(struct seq_file *m, const struct path *path,
456 const struct path *root, const char *esc)
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100457{
Miklos Szeredif8439802009-09-21 14:48:36 +0200458 char *buf;
459 size_t size = seq_get_buf(m, &buf);
460 int res = -ENAMETOOLONG;
461
462 if (size) {
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100463 char *p;
464
Miklos Szeredif8439802009-09-21 14:48:36 +0200465 p = __d_path(path, root, buf, size);
Al Viro02125a82011-12-05 08:43:34 -0500466 if (!p)
467 return SEQ_SKIP;
Miklos Szeredif8439802009-09-21 14:48:36 +0200468 res = PTR_ERR(p);
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100469 if (!IS_ERR(p)) {
Miklos Szeredif8439802009-09-21 14:48:36 +0200470 char *end = mangle_path(buf, p, esc);
471 if (end)
472 res = end - buf;
473 else
474 res = -ENAMETOOLONG;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100475 }
476 }
Miklos Szeredif8439802009-09-21 14:48:36 +0200477 seq_commit(m, res);
478
Al Viro02125a82011-12-05 08:43:34 -0500479 return res < 0 && res != -ENAMETOOLONG ? res : 0;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +0100480}
481
482/*
Ram Pai6092d042008-03-27 13:06:20 +0100483 * returns the path of the 'dentry' from the root of its filesystem.
484 */
Al Viro8c9379e2011-12-08 20:18:57 -0500485int seq_dentry(struct seq_file *m, struct dentry *dentry, const char *esc)
Ram Pai6092d042008-03-27 13:06:20 +0100486{
Miklos Szeredif8439802009-09-21 14:48:36 +0200487 char *buf;
488 size_t size = seq_get_buf(m, &buf);
489 int res = -1;
490
491 if (size) {
492 char *p = dentry_path(dentry, buf, size);
Ram Pai6092d042008-03-27 13:06:20 +0100493 if (!IS_ERR(p)) {
Miklos Szeredif8439802009-09-21 14:48:36 +0200494 char *end = mangle_path(buf, p, esc);
495 if (end)
496 res = end - buf;
Ram Pai6092d042008-03-27 13:06:20 +0100497 }
498 }
Miklos Szeredif8439802009-09-21 14:48:36 +0200499 seq_commit(m, res);
500
501 return res;
Ram Pai6092d042008-03-27 13:06:20 +0100502}
503
Rusty Russellcb78a0c2008-12-30 09:05:14 +1030504int seq_bitmap(struct seq_file *m, const unsigned long *bits,
505 unsigned int nr_bits)
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700506{
Lai Jiangshan85dd0302008-10-18 20:28:18 -0700507 if (m->count < m->size) {
508 int len = bitmap_scnprintf(m->buf + m->count,
509 m->size - m->count, bits, nr_bits);
510 if (m->count + len < m->size) {
511 m->count += len;
512 return 0;
513 }
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700514 }
515 m->count = m->size;
516 return -1;
517}
Lai Jiangshan85dd0302008-10-18 20:28:18 -0700518EXPORT_SYMBOL(seq_bitmap);
Alexey Dobriyan50ac2d62008-08-12 15:09:02 -0700519
Rusty Russellaf76aba2009-03-30 22:05:11 -0600520int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
Lai Jiangshan3eda2012008-10-18 20:28:19 -0700521 unsigned int nr_bits)
522{
523 if (m->count < m->size) {
524 int len = bitmap_scnlistprintf(m->buf + m->count,
525 m->size - m->count, bits, nr_bits);
526 if (m->count + len < m->size) {
527 m->count += len;
528 return 0;
529 }
530 }
531 m->count = m->size;
532 return -1;
533}
534EXPORT_SYMBOL(seq_bitmap_list);
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536static void *single_start(struct seq_file *p, loff_t *pos)
537{
538 return NULL + (*pos == 0);
539}
540
541static void *single_next(struct seq_file *p, void *v, loff_t *pos)
542{
543 ++*pos;
544 return NULL;
545}
546
547static void single_stop(struct seq_file *p, void *v)
548{
549}
550
551int single_open(struct file *file, int (*show)(struct seq_file *, void *),
552 void *data)
553{
554 struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
555 int res = -ENOMEM;
556
557 if (op) {
558 op->start = single_start;
559 op->next = single_next;
560 op->stop = single_stop;
561 op->show = show;
562 res = seq_open(file, op);
563 if (!res)
564 ((struct seq_file *)file->private_data)->private = data;
565 else
566 kfree(op);
567 }
568 return res;
569}
570EXPORT_SYMBOL(single_open);
571
572int single_release(struct inode *inode, struct file *file)
573{
Helge Deller15ad7cd2006-12-06 20:40:36 -0800574 const struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 int res = seq_release(inode, file);
576 kfree(op);
577 return res;
578}
579EXPORT_SYMBOL(single_release);
580
581int seq_release_private(struct inode *inode, struct file *file)
582{
583 struct seq_file *seq = file->private_data;
584
585 kfree(seq->private);
586 seq->private = NULL;
587 return seq_release(inode, file);
588}
589EXPORT_SYMBOL(seq_release_private);
590
Pavel Emelyanov39699032007-10-10 02:28:42 -0700591void *__seq_open_private(struct file *f, const struct seq_operations *ops,
592 int psize)
593{
594 int rc;
595 void *private;
596 struct seq_file *seq;
597
598 private = kzalloc(psize, GFP_KERNEL);
599 if (private == NULL)
600 goto out;
601
602 rc = seq_open(f, ops);
603 if (rc < 0)
604 goto out_free;
605
606 seq = f->private_data;
607 seq->private = private;
608 return private;
609
610out_free:
611 kfree(private);
612out:
613 return NULL;
614}
615EXPORT_SYMBOL(__seq_open_private);
616
617int seq_open_private(struct file *filp, const struct seq_operations *ops,
618 int psize)
619{
620 return __seq_open_private(filp, ops, psize) ? 0 : -ENOMEM;
621}
622EXPORT_SYMBOL(seq_open_private);
623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624int seq_putc(struct seq_file *m, char c)
625{
626 if (m->count < m->size) {
627 m->buf[m->count++] = c;
628 return 0;
629 }
630 return -1;
631}
632EXPORT_SYMBOL(seq_putc);
633
634int seq_puts(struct seq_file *m, const char *s)
635{
636 int len = strlen(s);
637 if (m->count + len < m->size) {
638 memcpy(m->buf + m->count, s, len);
639 m->count += len;
640 return 0;
641 }
642 m->count = m->size;
643 return -1;
644}
645EXPORT_SYMBOL(seq_puts);
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700646
KAMEZAWA Hiroyuki1ac101a2012-03-23 15:02:54 -0700647/*
648 * A helper routine for putting decimal numbers without rich format of printf().
649 * only 'unsigned long long' is supported.
650 * This routine will put one byte delimiter + number into seq_file.
651 * This routine is very quick when you show lots of numbers.
652 * In usual cases, it will be better to use seq_printf(). It's easier to read.
653 */
654int seq_put_decimal_ull(struct seq_file *m, char delimiter,
655 unsigned long long num)
656{
657 int len;
658
659 if (m->count + 2 >= m->size) /* we'll write 2 bytes at least */
660 goto overflow;
661
662 m->buf[m->count++] = delimiter;
663
664 if (num < 10) {
665 m->buf[m->count++] = num + '0';
666 return 0;
667 }
668
669 len = num_to_str(m->buf + m->count, m->size - m->count, num);
670 if (!len)
671 goto overflow;
672 m->count += len;
673 return 0;
674overflow:
675 m->count = m->size;
676 return -1;
677}
678EXPORT_SYMBOL(seq_put_decimal_ull);
679
Peter Oberparleiter0b923602009-06-17 16:28:05 -0700680/**
681 * seq_write - write arbitrary data to buffer
682 * @seq: seq_file identifying the buffer to which data should be written
683 * @data: data address
684 * @len: number of bytes
685 *
686 * Return 0 on success, non-zero otherwise.
687 */
688int seq_write(struct seq_file *seq, const void *data, size_t len)
689{
690 if (seq->count + len < seq->size) {
691 memcpy(seq->buf + seq->count, data, len);
692 seq->count += len;
693 return 0;
694 }
695 seq->count = seq->size;
696 return -1;
697}
698EXPORT_SYMBOL(seq_write);
699
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700700struct list_head *seq_list_start(struct list_head *head, loff_t pos)
701{
702 struct list_head *lh;
703
704 list_for_each(lh, head)
705 if (pos-- == 0)
706 return lh;
707
708 return NULL;
709}
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700710EXPORT_SYMBOL(seq_list_start);
711
712struct list_head *seq_list_start_head(struct list_head *head, loff_t pos)
713{
714 if (!pos)
715 return head;
716
717 return seq_list_start(head, pos - 1);
718}
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700719EXPORT_SYMBOL(seq_list_start_head);
720
721struct list_head *seq_list_next(void *v, struct list_head *head, loff_t *ppos)
722{
723 struct list_head *lh;
724
725 lh = ((struct list_head *)v)->next;
726 ++*ppos;
727 return lh == head ? NULL : lh;
728}
Pavel Emelianovbcf67e12007-07-10 17:22:26 -0700729EXPORT_SYMBOL(seq_list_next);
Li Zefan66655de2010-02-08 23:18:22 +0000730
731/**
732 * seq_hlist_start - start an iteration of a hlist
733 * @head: the head of the hlist
734 * @pos: the start position of the sequence
735 *
736 * Called at seq_file->op->start().
737 */
738struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos)
739{
740 struct hlist_node *node;
741
742 hlist_for_each(node, head)
743 if (pos-- == 0)
744 return node;
745 return NULL;
746}
747EXPORT_SYMBOL(seq_hlist_start);
748
749/**
750 * seq_hlist_start_head - start an iteration of a hlist
751 * @head: the head of the hlist
752 * @pos: the start position of the sequence
753 *
754 * Called at seq_file->op->start(). Call this function if you want to
755 * print a header at the top of the output.
756 */
757struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos)
758{
759 if (!pos)
760 return SEQ_START_TOKEN;
761
762 return seq_hlist_start(head, pos - 1);
763}
764EXPORT_SYMBOL(seq_hlist_start_head);
765
766/**
767 * seq_hlist_next - move to the next position of the hlist
768 * @v: the current iterator
769 * @head: the head of the hlist
Randy Dunlap138860b2010-03-04 09:37:12 -0800770 * @ppos: the current position
Li Zefan66655de2010-02-08 23:18:22 +0000771 *
772 * Called at seq_file->op->next().
773 */
774struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
775 loff_t *ppos)
776{
777 struct hlist_node *node = v;
778
779 ++*ppos;
780 if (v == SEQ_START_TOKEN)
781 return head->first;
782 else
783 return node->next;
784}
785EXPORT_SYMBOL(seq_hlist_next);
stephen hemminger1cc52322010-02-22 07:57:17 +0000786
787/**
788 * seq_hlist_start_rcu - start an iteration of a hlist protected by RCU
789 * @head: the head of the hlist
790 * @pos: the start position of the sequence
791 *
792 * Called at seq_file->op->start().
793 *
794 * This list-traversal primitive may safely run concurrently with
795 * the _rcu list-mutation primitives such as hlist_add_head_rcu()
796 * as long as the traversal is guarded by rcu_read_lock().
797 */
798struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
799 loff_t pos)
800{
801 struct hlist_node *node;
802
803 __hlist_for_each_rcu(node, head)
804 if (pos-- == 0)
805 return node;
806 return NULL;
807}
808EXPORT_SYMBOL(seq_hlist_start_rcu);
809
810/**
811 * seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU
812 * @head: the head of the hlist
813 * @pos: the start position of the sequence
814 *
815 * Called at seq_file->op->start(). Call this function if you want to
816 * print a header at the top of the output.
817 *
818 * This list-traversal primitive may safely run concurrently with
819 * the _rcu list-mutation primitives such as hlist_add_head_rcu()
820 * as long as the traversal is guarded by rcu_read_lock().
821 */
822struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
823 loff_t pos)
824{
825 if (!pos)
826 return SEQ_START_TOKEN;
827
828 return seq_hlist_start_rcu(head, pos - 1);
829}
830EXPORT_SYMBOL(seq_hlist_start_head_rcu);
831
832/**
833 * seq_hlist_next_rcu - move to the next position of the hlist protected by RCU
834 * @v: the current iterator
835 * @head: the head of the hlist
Randy Dunlap138860b2010-03-04 09:37:12 -0800836 * @ppos: the current position
stephen hemminger1cc52322010-02-22 07:57:17 +0000837 *
838 * Called at seq_file->op->next().
839 *
840 * This list-traversal primitive may safely run concurrently with
841 * the _rcu list-mutation primitives such as hlist_add_head_rcu()
842 * as long as the traversal is guarded by rcu_read_lock().
843 */
844struct hlist_node *seq_hlist_next_rcu(void *v,
845 struct hlist_head *head,
846 loff_t *ppos)
847{
848 struct hlist_node *node = v;
849
850 ++*ppos;
851 if (v == SEQ_START_TOKEN)
852 return rcu_dereference(head->first);
853 else
854 return rcu_dereference(node->next);
855}
856EXPORT_SYMBOL(seq_hlist_next_rcu);