LCOV - code coverage report
Current view: top level - include/linux - seq_file.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _LINUX_SEQ_FILE_H
       2             : #define _LINUX_SEQ_FILE_H
       3             : 
       4             : #include <linux/types.h>
       5             : #include <linux/string.h>
       6             : #include <linux/mutex.h>
       7             : #include <linux/cpumask.h>
       8             : #include <linux/nodemask.h>
       9             : 
      10             : struct seq_operations;
      11             : struct file;
      12             : struct path;
      13             : struct inode;
      14             : struct dentry;
      15             : 
      16             : struct seq_file {
      17             :         char *buf;
      18             :         size_t size;
      19             :         size_t from;
      20             :         size_t count;
      21             :         loff_t index;
      22             :         loff_t read_pos;
      23             :         u64 version;
      24             :         struct mutex lock;
      25             :         const struct seq_operations *op;
      26             :         void *private;
      27             : };
      28           1 : 
      29             : struct seq_operations {
      30             :         void * (*start) (struct seq_file *m, loff_t *pos);
      31             :         void (*stop) (struct seq_file *m, void *v);
      32             :         void * (*next) (struct seq_file *m, void *v, loff_t *pos);
      33             :         int (*show) (struct seq_file *m, void *v);
      34             : };
      35             : 
      36             : #define SEQ_SKIP 1
      37             : 
      38             : /**
      39             :  * seq_get_buf - get buffer to write arbitrary data to
      40             :  * @m: the seq_file handle
      41             :  * @bufp: the beginning of the buffer is stored here
      42             :  *
      43             :  * Return the number of bytes available in the buffer, or zero if
      44             :  * there's no space.
      45             :  */
      46             : static inline size_t seq_get_buf(struct seq_file *m, char **bufp)
      47             : {
      48             :         BUG_ON(m->count > m->size);
      49             :         if (m->count < m->size)
      50             :                 *bufp = m->buf + m->count;
      51             :         else
      52             :                 *bufp = NULL;
      53             : 
      54             :         return m->size - m->count;
      55             : }
      56             : 
      57             : /**
      58             :  * seq_commit - commit data to the buffer
      59             :  * @m: the seq_file handle
      60             :  * @num: the number of bytes to commit
      61             :  *
      62             :  * Commit @num bytes of data written to a buffer previously acquired
      63             :  * by seq_buf_get.  To signal an error condition, or that the data
      64             :  * didn't fit in the available space, pass a negative @num value.
      65             :  */
      66             : static inline void seq_commit(struct seq_file *m, int num)
      67             : {
      68             :         if (num < 0) {
      69             :                 m->count = m->size;
      70             :         } else {
      71             :                 BUG_ON(m->count + num > m->size);
      72             :                 m->count += num;
      73             :         }
      74             : }
      75             : 
      76             : char *mangle_path(char *s, char *p, char *esc);
      77             : int seq_open(struct file *, const struct seq_operations *);
      78             : ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);
      79             : loff_t seq_lseek(struct file *, loff_t, int);
      80             : int seq_release(struct inode *, struct file *);
      81             : int seq_escape(struct seq_file *, const char *, const char *);
      82             : int seq_putc(struct seq_file *m, char c);
      83             : int seq_puts(struct seq_file *m, const char *s);
      84             : int seq_write(struct seq_file *seq, const void *data, size_t len);
      85             : 
      86             : int seq_printf(struct seq_file *, const char *, ...)
      87             :         __attribute__ ((format (printf,2,3)));
      88             : 
      89             : int seq_path(struct seq_file *, struct path *, char *);
      90             : int seq_dentry(struct seq_file *, struct dentry *, char *);
      91             : int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
      92             :                   char *esc);
      93             : int seq_bitmap(struct seq_file *m, const unsigned long *bits,
      94             :                                    unsigned int nr_bits);
      95             : static inline int seq_cpumask(struct seq_file *m, const struct cpumask *mask)
      96             : {
      97             :         return seq_bitmap(m, cpumask_bits(mask), nr_cpu_ids);
      98             : }
      99             : 
     100             : static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
     101             : {
     102             :         return seq_bitmap(m, mask->bits, MAX_NUMNODES);
     103             : }
     104             : 
     105             : int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
     106             :                 unsigned int nr_bits);
     107             : 
     108             : static inline int seq_cpumask_list(struct seq_file *m,
     109             :                                    const struct cpumask *mask)
     110             : {
     111             :         return seq_bitmap_list(m, cpumask_bits(mask), nr_cpu_ids);
     112             : }
     113             : 
     114             : static inline int seq_nodemask_list(struct seq_file *m, nodemask_t *mask)
     115             : {
     116             :         return seq_bitmap_list(m, mask->bits, MAX_NUMNODES);
     117             : }
     118             : 
     119             : int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
     120             : int single_release(struct inode *, struct file *);
     121             : void *__seq_open_private(struct file *, const struct seq_operations *, int);
     122             : int seq_open_private(struct file *, const struct seq_operations *, int);
     123             : int seq_release_private(struct inode *, struct file *);
     124             : 
     125             : #define SEQ_START_TOKEN ((void *)1)
     126             : 
     127             : /*
     128             :  * Helpers for iteration over list_head-s in seq_files
     129             :  */
     130             : 
     131             : extern struct list_head *seq_list_start(struct list_head *head,
     132             :                 loff_t pos);
     133             : extern struct list_head *seq_list_start_head(struct list_head *head,
     134             :                 loff_t pos);
     135             : extern struct list_head *seq_list_next(void *v, struct list_head *head,
     136             :                 loff_t *ppos);
     137             : 
     138             : #endif

Generated by: LCOV version 1.10