home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / proc_fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  9.2 KB  |  316 lines
  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.  * "owner" is used to protect module
  46.  * from unloading while proc_dir_entry is in use
  47.  */
  48.  
  49. typedef    int (read_proc_t)(char *page, char **start, off_t off,
  50.               int count, int *eof, void *data);
  51. typedef    int (write_proc_t)(struct file *file, const char __user *buffer,
  52.                unsigned long count, void *data);
  53.  
  54. struct proc_dir_entry {
  55.     unsigned int low_ino;
  56.     unsigned short namelen;
  57.     const char *name;
  58.     mode_t mode;
  59.     nlink_t nlink;
  60.     uid_t uid;
  61.     gid_t gid;
  62.     loff_t size;
  63.     const struct inode_operations *proc_iops;
  64.     /*
  65.      * NULL ->proc_fops means "PDE is going away RSN" or
  66.      * "PDE is just created". In either case, e.g. ->read_proc won't be
  67.      * called because it's too late or too early, respectively.
  68.      *
  69.      * If you're allocating ->proc_fops dynamically, save a pointer
  70.      * somewhere.
  71.      */
  72.     const struct file_operations *proc_fops;
  73.     struct module *owner;
  74.     struct proc_dir_entry *next, *parent, *subdir;
  75.     void *data;
  76.     read_proc_t *read_proc;
  77.     write_proc_t *write_proc;
  78.     atomic_t count;        /* use count */
  79.     int pde_users;    /* number of callers into module in progress */
  80.     spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
  81.     struct completion *pde_unload_completion;
  82.     struct list_head pde_openers;    /* who did ->open, but not ->release */
  83. };
  84.  
  85. struct kcore_list {
  86.     struct kcore_list *next;
  87.     unsigned long addr;
  88.     size_t size;
  89. };
  90.  
  91. struct vmcore {
  92.     struct list_head list;
  93.     unsigned long long paddr;
  94.     unsigned long long size;
  95.     loff_t offset;
  96. };
  97.  
  98. #ifdef CONFIG_PROC_FS
  99.  
  100. extern spinlock_t proc_subdir_lock;
  101.  
  102. extern void proc_root_init(void);
  103.  
  104. void proc_flush_task(struct task_struct *task);
  105. struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *);
  106. int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir);
  107. unsigned long task_vsize(struct mm_struct *);
  108. int task_statm(struct mm_struct *, int *, int *, int *, int *);
  109. void task_mem(struct seq_file *, struct mm_struct *);
  110. void clear_refs_smap(struct mm_struct *mm);
  111.  
  112. struct proc_dir_entry *de_get(struct proc_dir_entry *de);
  113. void de_put(struct proc_dir_entry *de);
  114.  
  115. extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
  116.                         struct proc_dir_entry *parent);
  117. struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
  118.                 struct proc_dir_entry *parent,
  119.                 const struct file_operations *proc_fops,
  120.                 void *data);
  121. extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
  122.  
  123. extern struct vfsmount *proc_mnt;
  124. struct pid_namespace;
  125. extern int proc_fill_super(struct super_block *);
  126. extern struct inode *proc_get_inode(struct super_block *, unsigned int, struct proc_dir_entry *);
  127.  
  128. /*
  129.  * These are generic /proc routines that use the internal
  130.  * "struct proc_dir_entry" tree to traverse the filesystem.
  131.  *
  132.  * The /proc root directory has extended versions to take care
  133.  * of the /proc/<pid> subdirectories.
  134.  */
  135. extern int proc_readdir(struct file *, void *, filldir_t);
  136. extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *);
  137.  
  138. extern int pid_ns_prepare_proc(struct pid_namespace *ns);
  139. extern void pid_ns_release_proc(struct pid_namespace *ns);
  140.  
  141. /*
  142.  * proc_tty.c
  143.  */
  144. struct tty_driver;
  145. extern void proc_tty_init(void);
  146. extern void proc_tty_register_driver(struct tty_driver *driver);
  147. extern void proc_tty_unregister_driver(struct tty_driver *driver);
  148.  
  149. /*
  150.  * proc_devtree.c
  151.  */
  152. #ifdef CONFIG_PROC_DEVICETREE
  153. struct device_node;
  154. struct property;
  155. extern void proc_device_tree_init(void);
  156. extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
  157. extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
  158. extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
  159.                      struct property *prop);
  160. extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
  161.                      struct property *newprop,
  162.                      struct property *oldprop);
  163. #endif /* CONFIG_PROC_DEVICETREE */
  164.  
  165. extern struct proc_dir_entry *proc_symlink(const char *,
  166.         struct proc_dir_entry *, const char *);
  167. extern struct proc_dir_entry *proc_mkdir(const char *,struct proc_dir_entry *);
  168. extern struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
  169.             struct proc_dir_entry *parent);
  170.  
  171. static inline struct proc_dir_entry *proc_create(const char *name, mode_t mode,
  172.     struct proc_dir_entry *parent, const struct file_operations *proc_fops)
  173. {
  174.     return proc_create_data(name, mode, parent, proc_fops, NULL);
  175. }
  176.  
  177. static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
  178.     mode_t mode, struct proc_dir_entry *base, 
  179.     read_proc_t *read_proc, void * data)
  180. {
  181.     struct proc_dir_entry *res=create_proc_entry(name,mode,base);
  182.     if (res) {
  183.         res->read_proc=read_proc;
  184.         res->data=data;
  185.     }
  186.     return res;
  187. }
  188.  
  189. extern struct proc_dir_entry *proc_net_fops_create(struct net *net,
  190.     const char *name, mode_t mode, const struct file_operations *fops);
  191. extern void proc_net_remove(struct net *net, const char *name);
  192. extern struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
  193.     struct proc_dir_entry *parent);
  194.  
  195. /* While the {get|set|dup}_mm_exe_file functions are for mm_structs, they are
  196.  * only needed to implement /proc/<pid>|self/exe so we define them here. */
  197. extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
  198. extern struct file *get_mm_exe_file(struct mm_struct *mm);
  199. extern void dup_mm_exe_file(struct mm_struct *oldmm, struct mm_struct *newmm);
  200.  
  201. #else
  202.  
  203. #define proc_net_fops_create(net, name, mode, fops)  ({ (void)(mode), NULL; })
  204. static inline void proc_net_remove(struct net *net, const char *name) {}
  205.  
  206. static inline void proc_flush_task(struct task_struct *task)
  207. {
  208. }
  209.  
  210. static inline struct proc_dir_entry *create_proc_entry(const char *name,
  211.     mode_t mode, struct proc_dir_entry *parent) { return NULL; }
  212. static inline struct proc_dir_entry *proc_create(const char *name,
  213.     mode_t mode, struct proc_dir_entry *parent,
  214.     const struct file_operations *proc_fops)
  215. {
  216.     return NULL;
  217. }
  218. static inline struct proc_dir_entry *proc_create_data(const char *name,
  219.     mode_t mode, struct proc_dir_entry *parent,
  220.     const struct file_operations *proc_fops, void *data)
  221. {
  222.     return NULL;
  223. }
  224. #define remove_proc_entry(name, parent) do {} while (0)
  225.  
  226. static inline struct proc_dir_entry *proc_symlink(const char *name,
  227.         struct proc_dir_entry *parent,const char *dest) {return NULL;}
  228. static inline struct proc_dir_entry *proc_mkdir(const char *name,
  229.     struct proc_dir_entry *parent) {return NULL;}
  230.  
  231. static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
  232.     mode_t mode, struct proc_dir_entry *base, 
  233.     read_proc_t *read_proc, void * data) { return NULL; }
  234.  
  235. struct tty_driver;
  236. static inline void proc_tty_register_driver(struct tty_driver *driver) {};
  237. static inline void proc_tty_unregister_driver(struct tty_driver *driver) {};
  238.  
  239. static inline int pid_ns_prepare_proc(struct pid_namespace *ns)
  240. {
  241.     return 0;
  242. }
  243.  
  244. static inline void pid_ns_release_proc(struct pid_namespace *ns)
  245. {
  246. }
  247.  
  248. static inline void set_mm_exe_file(struct mm_struct *mm,
  249.                    struct file *new_exe_file)
  250. {}
  251.  
  252. static inline struct file *get_mm_exe_file(struct mm_struct *mm)
  253. {
  254.     return NULL;
  255. }
  256.  
  257. static inline void dup_mm_exe_file(struct mm_struct *oldmm,
  258.                           struct mm_struct *newmm)
  259. {}
  260.  
  261. #endif /* CONFIG_PROC_FS */
  262.  
  263. #if !defined(CONFIG_PROC_KCORE)
  264. static inline void kclist_add(struct kcore_list *new, void *addr, size_t size)
  265. {
  266. }
  267. #else
  268. extern void kclist_add(struct kcore_list *, void *, size_t);
  269. #endif
  270.  
  271. union proc_op {
  272.     int (*proc_get_link)(struct inode *, struct path *);
  273.     int (*proc_read)(struct task_struct *task, char *page);
  274.     int (*proc_show)(struct seq_file *m,
  275.         struct pid_namespace *ns, struct pid *pid,
  276.         struct task_struct *task);
  277. };
  278.  
  279. struct ctl_table_header;
  280. struct ctl_table;
  281.  
  282. struct proc_inode {
  283.     struct pid *pid;
  284.     int fd;
  285.     union proc_op op;
  286.     struct proc_dir_entry *pde;
  287.     struct ctl_table_header *sysctl;
  288.     struct ctl_table *sysctl_entry;
  289.     struct inode vfs_inode;
  290. };
  291.  
  292. static inline struct proc_inode *PROC_I(const struct inode *inode)
  293. {
  294.     return container_of(inode, struct proc_inode, vfs_inode);
  295. }
  296.  
  297. static inline struct proc_dir_entry *PDE(const struct inode *inode)
  298. {
  299.     return PROC_I(inode)->pde;
  300. }
  301.  
  302. static inline struct net *PDE_NET(struct proc_dir_entry *pde)
  303. {
  304.     return pde->parent->data;
  305. }
  306.  
  307. struct proc_maps_private {
  308.     struct pid *pid;
  309.     struct task_struct *task;
  310. #ifdef CONFIG_MMU
  311.     struct vm_area_struct *tail_vma;
  312. #endif
  313. };
  314.  
  315. #endif /* _LINUX_PROC_FS_H */
  316.