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