xref: /openbmc/linux/fs/seq_file.c (revision 67e2fae3)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/fs/seq_file.c
4  *
5  * helper functions for making synthetic files from sequences of records.
6  * initial implementation -- AV, Oct 2001.
7  */
8 
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 
11 #include <linux/cache.h>
12 #include <linux/fs.h>
13 #include <linux/export.h>
14 #include <linux/seq_file.h>
15 #include <linux/vmalloc.h>
16 #include <linux/slab.h>
17 #include <linux/cred.h>
18 #include <linux/mm.h>
19 #include <linux/printk.h>
20 #include <linux/string_helpers.h>
21 
22 #include <linux/uaccess.h>
23 #include <asm/page.h>
24 
25 static struct kmem_cache *seq_file_cache __ro_after_init;
26 
27 static void seq_set_overflow(struct seq_file *m)
28 {
29 	m->count = m->size;
30 }
31 
32 static void *seq_buf_alloc(unsigned long size)
33 {
34 	return kvmalloc(size, GFP_KERNEL_ACCOUNT);
35 }
36 
37 /**
38  *	seq_open -	initialize sequential file
39  *	@file: file we initialize
40  *	@op: method table describing the sequence
41  *
42  *	seq_open() sets @file, associating it with a sequence described
43  *	by @op.  @op->start() sets the iterator up and returns the first
44  *	element of sequence. @op->stop() shuts it down.  @op->next()
45  *	returns the next element of sequence.  @op->show() prints element
46  *	into the buffer.  In case of error ->start() and ->next() return
47  *	ERR_PTR(error).  In the end of sequence they return %NULL. ->show()
48  *	returns 0 in case of success and negative number in case of error.
49  *	Returning SEQ_SKIP means "discard this element and move on".
50  *	Note: seq_open() will allocate a struct seq_file and store its
51  *	pointer in @file->private_data. This pointer should not be modified.
52  */
53 int seq_open(struct file *file, const struct seq_operations *op)
54 {
55 	struct seq_file *p;
56 
57 	WARN_ON(file->private_data);
58 
59 	p = kmem_cache_zalloc(seq_file_cache, GFP_KERNEL);
60 	if (!p)
61 		return -ENOMEM;
62 
63 	file->private_data = p;
64 
65 	mutex_init(&p->lock);
66 	p->op = op;
67 
68 	// No refcounting: the lifetime of 'p' is constrained
69 	// to the lifetime of the file.
70 	p->file = file;
71 
72 	/*
73 	 * seq_files support lseek() and pread().  They do not implement
74 	 * write() at all, but we clear FMODE_PWRITE here for historical
75 	 * reasons.
76 	 *
77 	 * If a client of seq_files a) implements file.write() and b) wishes to
78 	 * support pwrite() then that client will need to implement its own
79 	 * file.open() which calls seq_open() and then sets FMODE_PWRITE.
80 	 */
81 	file->f_mode &= ~FMODE_PWRITE;
82 	return 0;
83 }
84 EXPORT_SYMBOL(seq_open);
85 
86 static int traverse(struct seq_file *m, loff_t offset)
87 {
88 	loff_t pos = 0;
89 	int error = 0;
90 	void *p;
91 
92 	m->index = 0;
93 	m->count = m->from = 0;
94 	if (!offset)
95 		return 0;
96 
97 	if (!m->buf) {
98 		m->buf = seq_buf_alloc(m->size = PAGE_SIZE);
99 		if (!m->buf)
100 			return -ENOMEM;
101 	}
102 	p = m->op->start(m, &m->index);
103 	while (p) {
104 		error = PTR_ERR(p);
105 		if (IS_ERR(p))
106 			break;
107 		error = m->op->show(m, p);
108 		if (error < 0)
109 			break;
110 		if (unlikely(error)) {
111 			error = 0;
112 			m->count = 0;
113 		}
114 		if (seq_has_overflowed(m))
115 			goto Eoverflow;
116 		p = m->op->next(m, p, &m->index);
117 		if (pos + m->count > offset) {
118 			m->from = offset - pos;
119 			m->count -= m->from;
120 			break;
121 		}
122 		pos += m->count;
123 		m->count = 0;
124 		if (pos == offset)
125 			break;
126 	}
127 	m->op->stop(m, p);
128 	return error;
129 
130 Eoverflow:
131 	m->op->stop(m, p);
132 	kvfree(m->buf);
133 	m->count = 0;
134 	m->buf = seq_buf_alloc(m->size <<= 1);
135 	return !m->buf ? -ENOMEM : -EAGAIN;
136 }
137 
138 /**
139  *	seq_read -	->read() method for sequential files.
140  *	@file: the file to read from
141  *	@buf: the buffer to read to
142  *	@size: the maximum number of bytes to read
143  *	@ppos: the current position in the file
144  *
145  *	Ready-made ->f_op->read()
146  */
147 ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
148 {
149 	struct seq_file *m = file->private_data;
150 	size_t copied = 0;
151 	size_t n;
152 	void *p;
153 	int err = 0;
154 
155 	mutex_lock(&m->lock);
156 
157 	/*
158 	 * if request is to read from zero offset, reset iterator to first
159 	 * record as it might have been already advanced by previous requests
160 	 */
161 	if (*ppos == 0) {
162 		m->index = 0;
163 		m->count = 0;
164 	}
165 
166 	/* Don't assume *ppos is where we left it */
167 	if (unlikely(*ppos != m->read_pos)) {
168 		while ((err = traverse(m, *ppos)) == -EAGAIN)
169 			;
170 		if (err) {
171 			/* With prejudice... */
172 			m->read_pos = 0;
173 			m->index = 0;
174 			m->count = 0;
175 			goto Done;
176 		} else {
177 			m->read_pos = *ppos;
178 		}
179 	}
180 
181 	/* grab buffer if we didn't have one */
182 	if (!m->buf) {
183 		m->buf = seq_buf_alloc(m->size = PAGE_SIZE);
184 		if (!m->buf)
185 			goto Enomem;
186 	}
187 	/* if not empty - flush it first */
188 	if (m->count) {
189 		n = min(m->count, size);
190 		err = copy_to_user(buf, m->buf + m->from, n);
191 		if (err)
192 			goto Efault;
193 		m->count -= n;
194 		m->from += n;
195 		size -= n;
196 		buf += n;
197 		copied += n;
198 		if (!size)
199 			goto Done;
200 	}
201 	/* we need at least one record in buffer */
202 	m->from = 0;
203 	p = m->op->start(m, &m->index);
204 	while (1) {
205 		err = PTR_ERR(p);
206 		if (!p || IS_ERR(p))
207 			break;
208 		err = m->op->show(m, p);
209 		if (err < 0)
210 			break;
211 		if (unlikely(err))
212 			m->count = 0;
213 		if (unlikely(!m->count)) {
214 			p = m->op->next(m, p, &m->index);
215 			continue;
216 		}
217 		if (m->count < m->size)
218 			goto Fill;
219 		m->op->stop(m, p);
220 		kvfree(m->buf);
221 		m->count = 0;
222 		m->buf = seq_buf_alloc(m->size <<= 1);
223 		if (!m->buf)
224 			goto Enomem;
225 		p = m->op->start(m, &m->index);
226 	}
227 	m->op->stop(m, p);
228 	m->count = 0;
229 	goto Done;
230 Fill:
231 	/* they want more? let's try to get some more */
232 	while (1) {
233 		size_t offs = m->count;
234 		loff_t pos = m->index;
235 
236 		p = m->op->next(m, p, &m->index);
237 		if (pos == m->index) {
238 			pr_info_ratelimited("buggy .next function %ps did not update position index\n",
239 					    m->op->next);
240 			m->index++;
241 		}
242 		if (!p || IS_ERR(p)) {
243 			err = PTR_ERR(p);
244 			break;
245 		}
246 		if (m->count >= size)
247 			break;
248 		err = m->op->show(m, p);
249 		if (seq_has_overflowed(m) || err) {
250 			m->count = offs;
251 			if (likely(err <= 0))
252 				break;
253 		}
254 	}
255 	m->op->stop(m, p);
256 	n = min(m->count, size);
257 	err = copy_to_user(buf, m->buf, n);
258 	if (err)
259 		goto Efault;
260 	copied += n;
261 	m->count -= n;
262 	m->from = n;
263 Done:
264 	if (!copied)
265 		copied = err;
266 	else {
267 		*ppos += copied;
268 		m->read_pos += copied;
269 	}
270 	mutex_unlock(&m->lock);
271 	return copied;
272 Enomem:
273 	err = -ENOMEM;
274 	goto Done;
275 Efault:
276 	err = -EFAULT;
277 	goto Done;
278 }
279 EXPORT_SYMBOL(seq_read);
280 
281 /**
282  *	seq_lseek -	->llseek() method for sequential files.
283  *	@file: the file in question
284  *	@offset: new position
285  *	@whence: 0 for absolute, 1 for relative position
286  *
287  *	Ready-made ->f_op->llseek()
288  */
289 loff_t seq_lseek(struct file *file, loff_t offset, int whence)
290 {
291 	struct seq_file *m = file->private_data;
292 	loff_t retval = -EINVAL;
293 
294 	mutex_lock(&m->lock);
295 	switch (whence) {
296 	case SEEK_CUR:
297 		offset += file->f_pos;
298 		/* fall through */
299 	case SEEK_SET:
300 		if (offset < 0)
301 			break;
302 		retval = offset;
303 		if (offset != m->read_pos) {
304 			while ((retval = traverse(m, offset)) == -EAGAIN)
305 				;
306 			if (retval) {
307 				/* with extreme prejudice... */
308 				file->f_pos = 0;
309 				m->read_pos = 0;
310 				m->index = 0;
311 				m->count = 0;
312 			} else {
313 				m->read_pos = offset;
314 				retval = file->f_pos = offset;
315 			}
316 		} else {
317 			file->f_pos = offset;
318 		}
319 	}
320 	mutex_unlock(&m->lock);
321 	return retval;
322 }
323 EXPORT_SYMBOL(seq_lseek);
324 
325 /**
326  *	seq_release -	free the structures associated with sequential file.
327  *	@file: file in question
328  *	@inode: its inode
329  *
330  *	Frees the structures associated with sequential file; can be used
331  *	as ->f_op->release() if you don't have private data to destroy.
332  */
333 int seq_release(struct inode *inode, struct file *file)
334 {
335 	struct seq_file *m = file->private_data;
336 	kvfree(m->buf);
337 	kmem_cache_free(seq_file_cache, m);
338 	return 0;
339 }
340 EXPORT_SYMBOL(seq_release);
341 
342 /**
343  *	seq_escape -	print string into buffer, escaping some characters
344  *	@m:	target buffer
345  *	@s:	string
346  *	@esc:	set of characters that need escaping
347  *
348  *	Puts string into buffer, replacing each occurrence of character from
349  *	@esc with usual octal escape.
350  *	Use seq_has_overflowed() to check for errors.
351  */
352 void seq_escape(struct seq_file *m, const char *s, const char *esc)
353 {
354 	char *buf;
355 	size_t size = seq_get_buf(m, &buf);
356 	int ret;
357 
358 	ret = string_escape_str(s, buf, size, ESCAPE_OCTAL, esc);
359 	seq_commit(m, ret < size ? ret : -1);
360 }
361 EXPORT_SYMBOL(seq_escape);
362 
363 void seq_escape_mem_ascii(struct seq_file *m, const char *src, size_t isz)
364 {
365 	char *buf;
366 	size_t size = seq_get_buf(m, &buf);
367 	int ret;
368 
369 	ret = string_escape_mem_ascii(src, isz, buf, size);
370 	seq_commit(m, ret < size ? ret : -1);
371 }
372 EXPORT_SYMBOL(seq_escape_mem_ascii);
373 
374 void seq_vprintf(struct seq_file *m, const char *f, va_list args)
375 {
376 	int len;
377 
378 	if (m->count < m->size) {
379 		len = vsnprintf(m->buf + m->count, m->size - m->count, f, args);
380 		if (m->count + len < m->size) {
381 			m->count += len;
382 			return;
383 		}
384 	}
385 	seq_set_overflow(m);
386 }
387 EXPORT_SYMBOL(seq_vprintf);
388 
389 void seq_printf(struct seq_file *m, const char *f, ...)
390 {
391 	va_list args;
392 
393 	va_start(args, f);
394 	seq_vprintf(m, f, args);
395 	va_end(args);
396 }
397 EXPORT_SYMBOL(seq_printf);
398 
399 /**
400  *	mangle_path -	mangle and copy path to buffer beginning
401  *	@s: buffer start
402  *	@p: beginning of path in above buffer
403  *	@esc: set of characters that need escaping
404  *
405  *      Copy the path from @p to @s, replacing each occurrence of character from
406  *      @esc with usual octal escape.
407  *      Returns pointer past last written character in @s, or NULL in case of
408  *      failure.
409  */
410 char *mangle_path(char *s, const char *p, const char *esc)
411 {
412 	while (s <= p) {
413 		char c = *p++;
414 		if (!c) {
415 			return s;
416 		} else if (!strchr(esc, c)) {
417 			*s++ = c;
418 		} else if (s + 4 > p) {
419 			break;
420 		} else {
421 			*s++ = '\\';
422 			*s++ = '0' + ((c & 0300) >> 6);
423 			*s++ = '0' + ((c & 070) >> 3);
424 			*s++ = '0' + (c & 07);
425 		}
426 	}
427 	return NULL;
428 }
429 EXPORT_SYMBOL(mangle_path);
430 
431 /**
432  * seq_path - seq_file interface to print a pathname
433  * @m: the seq_file handle
434  * @path: the struct path to print
435  * @esc: set of characters to escape in the output
436  *
437  * return the absolute path of 'path', as represented by the
438  * dentry / mnt pair in the path parameter.
439  */
440 int seq_path(struct seq_file *m, const struct path *path, const char *esc)
441 {
442 	char *buf;
443 	size_t size = seq_get_buf(m, &buf);
444 	int res = -1;
445 
446 	if (size) {
447 		char *p = d_path(path, buf, size);
448 		if (!IS_ERR(p)) {
449 			char *end = mangle_path(buf, p, esc);
450 			if (end)
451 				res = end - buf;
452 		}
453 	}
454 	seq_commit(m, res);
455 
456 	return res;
457 }
458 EXPORT_SYMBOL(seq_path);
459 
460 /**
461  * seq_file_path - seq_file interface to print a pathname of a file
462  * @m: the seq_file handle
463  * @file: the struct file to print
464  * @esc: set of characters to escape in the output
465  *
466  * return the absolute path to the file.
467  */
468 int seq_file_path(struct seq_file *m, struct file *file, const char *esc)
469 {
470 	return seq_path(m, &file->f_path, esc);
471 }
472 EXPORT_SYMBOL(seq_file_path);
473 
474 /*
475  * Same as seq_path, but relative to supplied root.
476  */
477 int seq_path_root(struct seq_file *m, const struct path *path,
478 		  const struct path *root, const char *esc)
479 {
480 	char *buf;
481 	size_t size = seq_get_buf(m, &buf);
482 	int res = -ENAMETOOLONG;
483 
484 	if (size) {
485 		char *p;
486 
487 		p = __d_path(path, root, buf, size);
488 		if (!p)
489 			return SEQ_SKIP;
490 		res = PTR_ERR(p);
491 		if (!IS_ERR(p)) {
492 			char *end = mangle_path(buf, p, esc);
493 			if (end)
494 				res = end - buf;
495 			else
496 				res = -ENAMETOOLONG;
497 		}
498 	}
499 	seq_commit(m, res);
500 
501 	return res < 0 && res != -ENAMETOOLONG ? res : 0;
502 }
503 
504 /*
505  * returns the path of the 'dentry' from the root of its filesystem.
506  */
507 int seq_dentry(struct seq_file *m, struct dentry *dentry, const char *esc)
508 {
509 	char *buf;
510 	size_t size = seq_get_buf(m, &buf);
511 	int res = -1;
512 
513 	if (size) {
514 		char *p = dentry_path(dentry, buf, size);
515 		if (!IS_ERR(p)) {
516 			char *end = mangle_path(buf, p, esc);
517 			if (end)
518 				res = end - buf;
519 		}
520 	}
521 	seq_commit(m, res);
522 
523 	return res;
524 }
525 EXPORT_SYMBOL(seq_dentry);
526 
527 static void *single_start(struct seq_file *p, loff_t *pos)
528 {
529 	return NULL + (*pos == 0);
530 }
531 
532 static void *single_next(struct seq_file *p, void *v, loff_t *pos)
533 {
534 	++*pos;
535 	return NULL;
536 }
537 
538 static void single_stop(struct seq_file *p, void *v)
539 {
540 }
541 
542 int single_open(struct file *file, int (*show)(struct seq_file *, void *),
543 		void *data)
544 {
545 	struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL_ACCOUNT);
546 	int res = -ENOMEM;
547 
548 	if (op) {
549 		op->start = single_start;
550 		op->next = single_next;
551 		op->stop = single_stop;
552 		op->show = show;
553 		res = seq_open(file, op);
554 		if (!res)
555 			((struct seq_file *)file->private_data)->private = data;
556 		else
557 			kfree(op);
558 	}
559 	return res;
560 }
561 EXPORT_SYMBOL(single_open);
562 
563 int single_open_size(struct file *file, int (*show)(struct seq_file *, void *),
564 		void *data, size_t size)
565 {
566 	char *buf = seq_buf_alloc(size);
567 	int ret;
568 	if (!buf)
569 		return -ENOMEM;
570 	ret = single_open(file, show, data);
571 	if (ret) {
572 		kvfree(buf);
573 		return ret;
574 	}
575 	((struct seq_file *)file->private_data)->buf = buf;
576 	((struct seq_file *)file->private_data)->size = size;
577 	return 0;
578 }
579 EXPORT_SYMBOL(single_open_size);
580 
581 int single_release(struct inode *inode, struct file *file)
582 {
583 	const struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
584 	int res = seq_release(inode, file);
585 	kfree(op);
586 	return res;
587 }
588 EXPORT_SYMBOL(single_release);
589 
590 int seq_release_private(struct inode *inode, struct file *file)
591 {
592 	struct seq_file *seq = file->private_data;
593 
594 	kfree(seq->private);
595 	seq->private = NULL;
596 	return seq_release(inode, file);
597 }
598 EXPORT_SYMBOL(seq_release_private);
599 
600 void *__seq_open_private(struct file *f, const struct seq_operations *ops,
601 		int psize)
602 {
603 	int rc;
604 	void *private;
605 	struct seq_file *seq;
606 
607 	private = kzalloc(psize, GFP_KERNEL_ACCOUNT);
608 	if (private == NULL)
609 		goto out;
610 
611 	rc = seq_open(f, ops);
612 	if (rc < 0)
613 		goto out_free;
614 
615 	seq = f->private_data;
616 	seq->private = private;
617 	return private;
618 
619 out_free:
620 	kfree(private);
621 out:
622 	return NULL;
623 }
624 EXPORT_SYMBOL(__seq_open_private);
625 
626 int seq_open_private(struct file *filp, const struct seq_operations *ops,
627 		int psize)
628 {
629 	return __seq_open_private(filp, ops, psize) ? 0 : -ENOMEM;
630 }
631 EXPORT_SYMBOL(seq_open_private);
632 
633 void seq_putc(struct seq_file *m, char c)
634 {
635 	if (m->count >= m->size)
636 		return;
637 
638 	m->buf[m->count++] = c;
639 }
640 EXPORT_SYMBOL(seq_putc);
641 
642 void seq_puts(struct seq_file *m, const char *s)
643 {
644 	int len = strlen(s);
645 
646 	if (m->count + len >= m->size) {
647 		seq_set_overflow(m);
648 		return;
649 	}
650 	memcpy(m->buf + m->count, s, len);
651 	m->count += len;
652 }
653 EXPORT_SYMBOL(seq_puts);
654 
655 /**
656  * A helper routine for putting decimal numbers without rich format of printf().
657  * only 'unsigned long long' is supported.
658  * @m: seq_file identifying the buffer to which data should be written
659  * @delimiter: a string which is printed before the number
660  * @num: the number
661  * @width: a minimum field width
662  *
663  * This routine will put strlen(delimiter) + number into seq_filed.
664  * This routine is very quick when you show lots of numbers.
665  * In usual cases, it will be better to use seq_printf(). It's easier to read.
666  */
667 void seq_put_decimal_ull_width(struct seq_file *m, const char *delimiter,
668 			 unsigned long long num, unsigned int width)
669 {
670 	int len;
671 
672 	if (m->count + 2 >= m->size) /* we'll write 2 bytes at least */
673 		goto overflow;
674 
675 	if (delimiter && delimiter[0]) {
676 		if (delimiter[1] == 0)
677 			seq_putc(m, delimiter[0]);
678 		else
679 			seq_puts(m, delimiter);
680 	}
681 
682 	if (!width)
683 		width = 1;
684 
685 	if (m->count + width >= m->size)
686 		goto overflow;
687 
688 	len = num_to_str(m->buf + m->count, m->size - m->count, num, width);
689 	if (!len)
690 		goto overflow;
691 
692 	m->count += len;
693 	return;
694 
695 overflow:
696 	seq_set_overflow(m);
697 }
698 
699 void seq_put_decimal_ull(struct seq_file *m, const char *delimiter,
700 			 unsigned long long num)
701 {
702 	return seq_put_decimal_ull_width(m, delimiter, num, 0);
703 }
704 EXPORT_SYMBOL(seq_put_decimal_ull);
705 
706 /**
707  * seq_put_hex_ll - put a number in hexadecimal notation
708  * @m: seq_file identifying the buffer to which data should be written
709  * @delimiter: a string which is printed before the number
710  * @v: the number
711  * @width: a minimum field width
712  *
713  * seq_put_hex_ll(m, "", v, 8) is equal to seq_printf(m, "%08llx", v)
714  *
715  * This routine is very quick when you show lots of numbers.
716  * In usual cases, it will be better to use seq_printf(). It's easier to read.
717  */
718 void seq_put_hex_ll(struct seq_file *m, const char *delimiter,
719 				unsigned long long v, unsigned int width)
720 {
721 	unsigned int len;
722 	int i;
723 
724 	if (delimiter && delimiter[0]) {
725 		if (delimiter[1] == 0)
726 			seq_putc(m, delimiter[0]);
727 		else
728 			seq_puts(m, delimiter);
729 	}
730 
731 	/* If x is 0, the result of __builtin_clzll is undefined */
732 	if (v == 0)
733 		len = 1;
734 	else
735 		len = (sizeof(v) * 8 - __builtin_clzll(v) + 3) / 4;
736 
737 	if (len < width)
738 		len = width;
739 
740 	if (m->count + len > m->size) {
741 		seq_set_overflow(m);
742 		return;
743 	}
744 
745 	for (i = len - 1; i >= 0; i--) {
746 		m->buf[m->count + i] = hex_asc[0xf & v];
747 		v = v >> 4;
748 	}
749 	m->count += len;
750 }
751 
752 void seq_put_decimal_ll(struct seq_file *m, const char *delimiter, long long num)
753 {
754 	int len;
755 
756 	if (m->count + 3 >= m->size) /* we'll write 2 bytes at least */
757 		goto overflow;
758 
759 	if (delimiter && delimiter[0]) {
760 		if (delimiter[1] == 0)
761 			seq_putc(m, delimiter[0]);
762 		else
763 			seq_puts(m, delimiter);
764 	}
765 
766 	if (m->count + 2 >= m->size)
767 		goto overflow;
768 
769 	if (num < 0) {
770 		m->buf[m->count++] = '-';
771 		num = -num;
772 	}
773 
774 	if (num < 10) {
775 		m->buf[m->count++] = num + '0';
776 		return;
777 	}
778 
779 	len = num_to_str(m->buf + m->count, m->size - m->count, num, 0);
780 	if (!len)
781 		goto overflow;
782 
783 	m->count += len;
784 	return;
785 
786 overflow:
787 	seq_set_overflow(m);
788 }
789 EXPORT_SYMBOL(seq_put_decimal_ll);
790 
791 /**
792  * seq_write - write arbitrary data to buffer
793  * @seq: seq_file identifying the buffer to which data should be written
794  * @data: data address
795  * @len: number of bytes
796  *
797  * Return 0 on success, non-zero otherwise.
798  */
799 int seq_write(struct seq_file *seq, const void *data, size_t len)
800 {
801 	if (seq->count + len < seq->size) {
802 		memcpy(seq->buf + seq->count, data, len);
803 		seq->count += len;
804 		return 0;
805 	}
806 	seq_set_overflow(seq);
807 	return -1;
808 }
809 EXPORT_SYMBOL(seq_write);
810 
811 /**
812  * seq_pad - write padding spaces to buffer
813  * @m: seq_file identifying the buffer to which data should be written
814  * @c: the byte to append after padding if non-zero
815  */
816 void seq_pad(struct seq_file *m, char c)
817 {
818 	int size = m->pad_until - m->count;
819 	if (size > 0) {
820 		if (size + m->count > m->size) {
821 			seq_set_overflow(m);
822 			return;
823 		}
824 		memset(m->buf + m->count, ' ', size);
825 		m->count += size;
826 	}
827 	if (c)
828 		seq_putc(m, c);
829 }
830 EXPORT_SYMBOL(seq_pad);
831 
832 /* A complete analogue of print_hex_dump() */
833 void seq_hex_dump(struct seq_file *m, const char *prefix_str, int prefix_type,
834 		  int rowsize, int groupsize, const void *buf, size_t len,
835 		  bool ascii)
836 {
837 	const u8 *ptr = buf;
838 	int i, linelen, remaining = len;
839 	char *buffer;
840 	size_t size;
841 	int ret;
842 
843 	if (rowsize != 16 && rowsize != 32)
844 		rowsize = 16;
845 
846 	for (i = 0; i < len && !seq_has_overflowed(m); i += rowsize) {
847 		linelen = min(remaining, rowsize);
848 		remaining -= rowsize;
849 
850 		switch (prefix_type) {
851 		case DUMP_PREFIX_ADDRESS:
852 			seq_printf(m, "%s%p: ", prefix_str, ptr + i);
853 			break;
854 		case DUMP_PREFIX_OFFSET:
855 			seq_printf(m, "%s%.8x: ", prefix_str, i);
856 			break;
857 		default:
858 			seq_printf(m, "%s", prefix_str);
859 			break;
860 		}
861 
862 		size = seq_get_buf(m, &buffer);
863 		ret = hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
864 					 buffer, size, ascii);
865 		seq_commit(m, ret < size ? ret : -1);
866 
867 		seq_putc(m, '\n');
868 	}
869 }
870 EXPORT_SYMBOL(seq_hex_dump);
871 
872 struct list_head *seq_list_start(struct list_head *head, loff_t pos)
873 {
874 	struct list_head *lh;
875 
876 	list_for_each(lh, head)
877 		if (pos-- == 0)
878 			return lh;
879 
880 	return NULL;
881 }
882 EXPORT_SYMBOL(seq_list_start);
883 
884 struct list_head *seq_list_start_head(struct list_head *head, loff_t pos)
885 {
886 	if (!pos)
887 		return head;
888 
889 	return seq_list_start(head, pos - 1);
890 }
891 EXPORT_SYMBOL(seq_list_start_head);
892 
893 struct list_head *seq_list_next(void *v, struct list_head *head, loff_t *ppos)
894 {
895 	struct list_head *lh;
896 
897 	lh = ((struct list_head *)v)->next;
898 	++*ppos;
899 	return lh == head ? NULL : lh;
900 }
901 EXPORT_SYMBOL(seq_list_next);
902 
903 /**
904  * seq_hlist_start - start an iteration of a hlist
905  * @head: the head of the hlist
906  * @pos:  the start position of the sequence
907  *
908  * Called at seq_file->op->start().
909  */
910 struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos)
911 {
912 	struct hlist_node *node;
913 
914 	hlist_for_each(node, head)
915 		if (pos-- == 0)
916 			return node;
917 	return NULL;
918 }
919 EXPORT_SYMBOL(seq_hlist_start);
920 
921 /**
922  * seq_hlist_start_head - start an iteration of a hlist
923  * @head: the head of the hlist
924  * @pos:  the start position of the sequence
925  *
926  * Called at seq_file->op->start(). Call this function if you want to
927  * print a header at the top of the output.
928  */
929 struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos)
930 {
931 	if (!pos)
932 		return SEQ_START_TOKEN;
933 
934 	return seq_hlist_start(head, pos - 1);
935 }
936 EXPORT_SYMBOL(seq_hlist_start_head);
937 
938 /**
939  * seq_hlist_next - move to the next position of the hlist
940  * @v:    the current iterator
941  * @head: the head of the hlist
942  * @ppos: the current position
943  *
944  * Called at seq_file->op->next().
945  */
946 struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
947 				  loff_t *ppos)
948 {
949 	struct hlist_node *node = v;
950 
951 	++*ppos;
952 	if (v == SEQ_START_TOKEN)
953 		return head->first;
954 	else
955 		return node->next;
956 }
957 EXPORT_SYMBOL(seq_hlist_next);
958 
959 /**
960  * seq_hlist_start_rcu - start an iteration of a hlist protected by RCU
961  * @head: the head of the hlist
962  * @pos:  the start position of the sequence
963  *
964  * Called at seq_file->op->start().
965  *
966  * This list-traversal primitive may safely run concurrently with
967  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
968  * as long as the traversal is guarded by rcu_read_lock().
969  */
970 struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
971 				       loff_t pos)
972 {
973 	struct hlist_node *node;
974 
975 	__hlist_for_each_rcu(node, head)
976 		if (pos-- == 0)
977 			return node;
978 	return NULL;
979 }
980 EXPORT_SYMBOL(seq_hlist_start_rcu);
981 
982 /**
983  * seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU
984  * @head: the head of the hlist
985  * @pos:  the start position of the sequence
986  *
987  * Called at seq_file->op->start(). Call this function if you want to
988  * print a header at the top of the output.
989  *
990  * This list-traversal primitive may safely run concurrently with
991  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
992  * as long as the traversal is guarded by rcu_read_lock().
993  */
994 struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
995 					    loff_t pos)
996 {
997 	if (!pos)
998 		return SEQ_START_TOKEN;
999 
1000 	return seq_hlist_start_rcu(head, pos - 1);
1001 }
1002 EXPORT_SYMBOL(seq_hlist_start_head_rcu);
1003 
1004 /**
1005  * seq_hlist_next_rcu - move to the next position of the hlist protected by RCU
1006  * @v:    the current iterator
1007  * @head: the head of the hlist
1008  * @ppos: the current position
1009  *
1010  * Called at seq_file->op->next().
1011  *
1012  * This list-traversal primitive may safely run concurrently with
1013  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
1014  * as long as the traversal is guarded by rcu_read_lock().
1015  */
1016 struct hlist_node *seq_hlist_next_rcu(void *v,
1017 				      struct hlist_head *head,
1018 				      loff_t *ppos)
1019 {
1020 	struct hlist_node *node = v;
1021 
1022 	++*ppos;
1023 	if (v == SEQ_START_TOKEN)
1024 		return rcu_dereference(head->first);
1025 	else
1026 		return rcu_dereference(node->next);
1027 }
1028 EXPORT_SYMBOL(seq_hlist_next_rcu);
1029 
1030 /**
1031  * seq_hlist_start_precpu - start an iteration of a percpu hlist array
1032  * @head: pointer to percpu array of struct hlist_heads
1033  * @cpu:  pointer to cpu "cursor"
1034  * @pos:  start position of sequence
1035  *
1036  * Called at seq_file->op->start().
1037  */
1038 struct hlist_node *
1039 seq_hlist_start_percpu(struct hlist_head __percpu *head, int *cpu, loff_t pos)
1040 {
1041 	struct hlist_node *node;
1042 
1043 	for_each_possible_cpu(*cpu) {
1044 		hlist_for_each(node, per_cpu_ptr(head, *cpu)) {
1045 			if (pos-- == 0)
1046 				return node;
1047 		}
1048 	}
1049 	return NULL;
1050 }
1051 EXPORT_SYMBOL(seq_hlist_start_percpu);
1052 
1053 /**
1054  * seq_hlist_next_percpu - move to the next position of the percpu hlist array
1055  * @v:    pointer to current hlist_node
1056  * @head: pointer to percpu array of struct hlist_heads
1057  * @cpu:  pointer to cpu "cursor"
1058  * @pos:  start position of sequence
1059  *
1060  * Called at seq_file->op->next().
1061  */
1062 struct hlist_node *
1063 seq_hlist_next_percpu(void *v, struct hlist_head __percpu *head,
1064 			int *cpu, loff_t *pos)
1065 {
1066 	struct hlist_node *node = v;
1067 
1068 	++*pos;
1069 
1070 	if (node->next)
1071 		return node->next;
1072 
1073 	for (*cpu = cpumask_next(*cpu, cpu_possible_mask); *cpu < nr_cpu_ids;
1074 	     *cpu = cpumask_next(*cpu, cpu_possible_mask)) {
1075 		struct hlist_head *bucket = per_cpu_ptr(head, *cpu);
1076 
1077 		if (!hlist_empty(bucket))
1078 			return bucket->first;
1079 	}
1080 	return NULL;
1081 }
1082 EXPORT_SYMBOL(seq_hlist_next_percpu);
1083 
1084 void __init seq_file_init(void)
1085 {
1086 	seq_file_cache = KMEM_CACHE(seq_file, SLAB_ACCOUNT|SLAB_PANIC);
1087 }
1088