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

          Line data    Source code
       1             : #ifndef _LINUX_PROC_FS_H
       2             : #define _LINUX_PROC_FS_H
       3             : 
       4             : #include <linux/slab.h>
       5             : #include <linux/fs.h>
       6             : #include <linux/spinlock.h>
       7             : #include <linux/magic.h>
       8             : #include <asm/atomic.h>
       9             : 
      10             : struct net;
      11             : struct completion;
      12             : struct mm_struct;
      13             : 
      14             : /*
      15             :  * The proc filesystem constants/structures
      16             :  */
      17             : 
      18             : /*
      19             :  * Offset of the first process in the /proc root directory..
      20             :  */
      21             : #define FIRST_PROCESS_ENTRY 256
      22             : 
      23             : /* Worst case buffer size needed for holding an integer. */
      24             : #define PROC_NUMBUF 13
      25             : 
      26             : /*
      27             :  * We always define these enumerators
      28             :  */
      29             : 
      30             : enum {
      31             :         PROC_ROOT_INO = 1,
      32             : };
      33             : 
      34             : /*
      35             :  * This is not completely implemented yet. The idea is to
      36             :  * create an in-memory tree (like the actual /proc filesystem
      37             :  * tree) of these proc_dir_entries, so that we can dynamically
      38             :  * add new files to /proc.
      39             :  *
      40             :  * The "next" pointer creates a linked list of one /proc directory,
      41             :  * while parent/subdir create the directory structure (every
      42             :  * /proc file has a parent, but "subdir" is NULL for all
      43             :  * non-directory entries).
      44             :  */
      45             : 
      46           1 : typedef int (read_proc_t)(char *page, char **start, off_t off,
      47             :                           int count, int *eof, void *data);
      48           1 : typedef int (write_proc_t)(struct file *file, const char __user *buffer,
      49           1 :                            unsigned long count, void *data);
      50             : 
      51             : struct proc_dir_entry {
      52             :         unsigned int low_ino;
      53             :         unsigned short namelen;
      54             :         const char *name;
      55             :         mode_t mode;
      56             :         nlink_t nlink;
      57             :         uid_t uid;
      58             :         gid_t gid;
      59             :         loff_t size;
      60             :         const struct inode_operations *proc_iops;
      61             :         /*
      62             :          * NULL ->proc_fops means "PDE is going away RSN" or
      63             :          * "PDE is just created". In either case, e.g. ->read_proc won't be
      64             :          * called because it's too late or too early, respectively.
      65             :          *
      66             :          * If you're allocating ->proc_fops dynamically, save a pointer
      67             :          * somewhere.
      68             :          */
      69             :         const struct file_operations *proc_fops;
      70             :         struct proc_dir_entry *next, *parent, *subdir;
      71             :         void *data;
      72             :         read_proc_t *read_proc;
      73             :         write_proc_t *write_proc;
      74             :         atomic_t count;         /* use count */
      75             :         int pde_users;  /* number of callers into module in progress */
      76             :         spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
      77             :         struct completion *pde_unload_completion;
      78             :         struct list_head pde_openers;   /* who did ->open, but not ->release */
      79             : };
      80             : 
      81             : enum kcore_type {
      82             :         KCORE_TEXT,
      83             :         KCORE_VMALLOC,
      84             :         KCORE_RAM,
      85             :         KCORE_VMEMMAP,
      86             :         KCORE_OTHER,
      87             : };
      88             : 
      89             : struct kcore_list {
      90             :         struct list_head list;
      91             :         unsigned long addr;
      92             :         size_t size;
      93             :         int type;
      94             : };
      95             : 
      96             : struct vmcore {
      97             :         struct list_head list;
      98             :         unsigned long long paddr;
      99             :         unsigned long long size;
     100             :         loff_t offset;
     101             : };
     102             : 
     103             : #ifdef CONFIG_PROC_FS
     104             : 
     105             : extern void proc_root_init(void);
     106             : 
     107             : void proc_flush_task(struct task_struct *task);
     108             : 
     109             : extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
     110             :                                                 struct proc_dir_entry *parent);
     111             : struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
     112             :                                 struct proc_dir_entry *parent,
     113             :                                 const struct file_operations *proc_fops,
     114             :                                 void *data);
     115             : extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
     116             : 
     117             : struct pid_namespace;
     118             : 
     119             : extern int pid_ns_prepare_proc(struct pid_namespace *ns);
     120             : extern void pid_ns_release_proc(struct pid_namespace *ns);
     121             : 
     122             : /*
     123             :  * proc_tty.c
     124             :  */
     125             : struct tty_driver;
     126             : extern void proc_tty_init(void);
     127             : extern void proc_tty_register_driver(struct tty_driver *driver);
     128             : extern void proc_tty_unregister_driver(struct tty_driver *driver);
     129             : 
     130             : /*
     131             :  * proc_devtree.c
     132             :  */
     133             : #ifdef CONFIG_PROC_DEVICETREE
     134             : struct device_node;
     135             : struct property;
     136             : extern void proc_device_tree_init(void);
     137             : extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
     138             : extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
     139             : extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
     140             :                                          struct property *prop);
     141             : extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
     142             :                                          struct property *newprop,
     143             :                                          struct property *oldprop);
     144             : #endif /* CONFIG_PROC_DEVICETREE */
     145             : 
     146             : extern struct proc_dir_entry *proc_symlink(const char *,
     147             :                 struct proc_dir_entry *, const char *);
     148             : extern struct proc_dir_entry *proc_mkdir(const char *,struct proc_dir_entry *);
     149             : extern struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
     150             :                         struct proc_dir_entry *parent);
     151             : 
     152             : static inline struct proc_dir_entry *proc_create(const char *name, mode_t mode,
     153             :         struct proc_dir_entry *parent, const struct file_operations *proc_fops)
     154             : {
     155             :         return proc_create_data(name, mode, parent, proc_fops, NULL);
     156             : }
     157             : 
     158             : static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
     159             :         mode_t mode, struct proc_dir_entry *base, 
     160             :         read_proc_t *read_proc, void * data)
     161             : {
     162             :         struct proc_dir_entry *res=create_proc_entry(name,mode,base);
     163             :         if (res) {
     164             :                 res->read_proc=read_proc;
     165             :                 res->data=data;
     166             :         }
     167             :         return res;
     168             : }
     169             :  
     170             : extern struct proc_dir_entry *proc_net_fops_create(struct net *net,
     171             :         const char *name, mode_t mode, const struct file_operations *fops);
     172             : extern void proc_net_remove(struct net *net, const char *name);
     173             : extern struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
     174             :         struct proc_dir_entry *parent);
     175             : 
     176             : /* While the {get|set|dup}_mm_exe_file functions are for mm_structs, they are
     177             :  * only needed to implement /proc/<pid>|self/exe so we define them here. */
     178             : extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
     179             : extern struct file *get_mm_exe_file(struct mm_struct *mm);
     180             : extern void dup_mm_exe_file(struct mm_struct *oldmm, struct mm_struct *newmm);
     181             : 
     182             : #else
     183             : 
     184             : #define proc_net_fops_create(net, name, mode, fops)  ({ (void)(mode), NULL; })
     185             : static inline void proc_net_remove(struct net *net, const char *name) {}
     186             : 
     187             : static inline void proc_flush_task(struct task_struct *task)
     188             : {
     189             : }
     190             : 
     191             : static inline struct proc_dir_entry *create_proc_entry(const char *name,
     192             :         mode_t mode, struct proc_dir_entry *parent) { return NULL; }
     193             : static inline struct proc_dir_entry *proc_create(const char *name,
     194             :         mode_t mode, struct proc_dir_entry *parent,
     195             :         const struct file_operations *proc_fops)
     196             : {
     197             :         return NULL;
     198             : }
     199             : static inline struct proc_dir_entry *proc_create_data(const char *name,
     200             :         mode_t mode, struct proc_dir_entry *parent,
     201             :         const struct file_operations *proc_fops, void *data)
     202             : {
     203             :         return NULL;
     204             : }
     205             : #define remove_proc_entry(name, parent) do {} while (0)
     206             : 
     207             : static inline struct proc_dir_entry *proc_symlink(const char *name,
     208             :                 struct proc_dir_entry *parent,const char *dest) {return NULL;}
     209             : static inline struct proc_dir_entry *proc_mkdir(const char *name,
     210             :         struct proc_dir_entry *parent) {return NULL;}
     211             : 
     212             : static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
     213             :         mode_t mode, struct proc_dir_entry *base, 
     214             :         read_proc_t *read_proc, void * data) { return NULL; }
     215             : 
     216             : struct tty_driver;
     217             : static inline void proc_tty_register_driver(struct tty_driver *driver) {};
     218             : static inline void proc_tty_unregister_driver(struct tty_driver *driver) {};
     219             : 
     220             : static inline int pid_ns_prepare_proc(struct pid_namespace *ns)
     221             : {
     222             :         return 0;
     223             : }
     224             : 
     225             : static inline void pid_ns_release_proc(struct pid_namespace *ns)
     226             : {
     227             : }
     228             : 
     229             : static inline void set_mm_exe_file(struct mm_struct *mm,
     230             :                                    struct file *new_exe_file)
     231             : {}
     232             : 
     233             : static inline struct file *get_mm_exe_file(struct mm_struct *mm)
     234             : {
     235             :         return NULL;
     236             : }
     237             : 
     238             : static inline void dup_mm_exe_file(struct mm_struct *oldmm,
     239             :                                    struct mm_struct *newmm)
     240             : {}
     241             : 
     242             : #endif /* CONFIG_PROC_FS */
     243             : 
     244             : #if !defined(CONFIG_PROC_KCORE)
     245             : static inline void
     246             : kclist_add(struct kcore_list *new, void *addr, size_t size, int type)
     247             : {
     248             : }
     249             : #else
     250             : extern void kclist_add(struct kcore_list *, void *, size_t, int type);
     251             : #endif
     252             : 
     253             : union proc_op {
     254             :         int (*proc_get_link)(struct inode *, struct path *);
     255             :         int (*proc_read)(struct task_struct *task, char *page);
     256             :         int (*proc_show)(struct seq_file *m,
     257             :                 struct pid_namespace *ns, struct pid *pid,
     258             :                 struct task_struct *task);
     259             : };
     260             : 
     261             : struct ctl_table_header;
     262             : struct ctl_table;
     263             : 
     264             : struct proc_inode {
     265             :         struct pid *pid;
     266             :         int fd;
     267             :         union proc_op op;
     268             :         struct proc_dir_entry *pde;
     269             :         struct ctl_table_header *sysctl;
     270             :         struct ctl_table *sysctl_entry;
     271             :         struct inode vfs_inode;
     272             : };
     273             : 
     274             : static inline struct proc_inode *PROC_I(const struct inode *inode)
     275             : {
     276             :         return container_of(inode, struct proc_inode, vfs_inode);
     277             : }
     278             : 
     279             : static inline struct proc_dir_entry *PDE(const struct inode *inode)
     280             : {
     281             :         return PROC_I(inode)->pde;
     282             : }
     283             : 
     284             : static inline struct net *PDE_NET(struct proc_dir_entry *pde)
     285             : {
     286             :         return pde->parent->data;
     287             : }
     288             : 
     289             : struct proc_maps_private {
     290             :         struct pid *pid;
     291             :         struct task_struct *task;
     292             : #ifdef CONFIG_MMU
     293             :         struct vm_area_struct *tail_vma;
     294             : #endif
     295             : };
     296             : 
     297             : #endif /* _LINUX_PROC_FS_H */

Generated by: LCOV version 1.10