fat: Remove FAT Directory Bread message
[linux-2.6.git] / fs / proc / root.c
1 /*
2  *  linux/fs/proc/root.c
3  *
4  *  Copyright (C) 1991, 1992 Linus Torvalds
5  *
6  *  proc root directory handling functions
7  */
8
9 #include <asm/uaccess.h>
10
11 #include <linux/errno.h>
12 #include <linux/time.h>
13 #include <linux/proc_fs.h>
14 #include <linux/stat.h>
15 #include <linux/init.h>
16 #include <linux/sched.h>
17 #include <linux/module.h>
18 #include <linux/bitops.h>
19 #include <linux/mount.h>
20 #include <linux/pid_namespace.h>
21
22 #include "internal.h"
23
24 static int proc_test_super(struct super_block *sb, void *data)
25 {
26         return sb->s_fs_info == data;
27 }
28
29 static int proc_set_super(struct super_block *sb, void *data)
30 {
31         int err = set_anon_super(sb, NULL);
32         if (!err) {
33                 struct pid_namespace *ns = (struct pid_namespace *)data;
34                 sb->s_fs_info = get_pid_ns(ns);
35         }
36         return err;
37 }
38
39 static struct dentry *proc_mount(struct file_system_type *fs_type,
40         int flags, const char *dev_name, void *data)
41 {
42         int err;
43         struct super_block *sb;
44         struct pid_namespace *ns;
45         struct proc_inode *ei;
46
47         if (flags & MS_KERNMOUNT)
48                 ns = (struct pid_namespace *)data;
49         else
50                 ns = current->nsproxy->pid_ns;
51
52         sb = sget(fs_type, proc_test_super, proc_set_super, ns);
53         if (IS_ERR(sb))
54                 return ERR_CAST(sb);
55
56         if (!sb->s_root) {
57                 sb->s_flags = flags;
58                 err = proc_fill_super(sb);
59                 if (err) {
60                         deactivate_locked_super(sb);
61                         return ERR_PTR(err);
62                 }
63
64                 sb->s_flags |= MS_ACTIVE;
65         }
66
67         ei = PROC_I(sb->s_root->d_inode);
68         if (!ei->pid) {
69                 rcu_read_lock();
70                 ei->pid = get_pid(find_pid_ns(1, ns));
71                 rcu_read_unlock();
72         }
73
74         return dget(sb->s_root);
75 }
76
77 static void proc_kill_sb(struct super_block *sb)
78 {
79         struct pid_namespace *ns;
80
81         ns = (struct pid_namespace *)sb->s_fs_info;
82         kill_anon_super(sb);
83         put_pid_ns(ns);
84 }
85
86 static struct file_system_type proc_fs_type = {
87         .name           = "proc",
88         .mount          = proc_mount,
89         .kill_sb        = proc_kill_sb,
90 };
91
92 void __init proc_root_init(void)
93 {
94         struct vfsmount *mnt;
95         int err;
96
97         proc_init_inodecache();
98         err = register_filesystem(&proc_fs_type);
99         if (err)
100                 return;
101         mnt = kern_mount_data(&proc_fs_type, &init_pid_ns);
102         if (IS_ERR(mnt)) {
103                 unregister_filesystem(&proc_fs_type);
104                 return;
105         }
106
107         init_pid_ns.proc_mnt = mnt;
108         proc_symlink("mounts", NULL, "self/mounts");
109
110         proc_net_init();
111
112 #ifdef CONFIG_SYSVIPC
113         proc_mkdir("sysvipc", NULL);
114 #endif
115         proc_mkdir("fs", NULL);
116         proc_mkdir("driver", NULL);
117         proc_mkdir("fs/nfsd", NULL); /* somewhere for the nfsd filesystem to be mounted */
118 #if defined(CONFIG_SUN_OPENPROMFS) || defined(CONFIG_SUN_OPENPROMFS_MODULE)
119         /* just give it a mountpoint */
120         proc_mkdir("openprom", NULL);
121 #endif
122         proc_tty_init();
123 #ifdef CONFIG_PROC_DEVICETREE
124         proc_device_tree_init();
125 #endif
126         proc_mkdir("bus", NULL);
127         proc_sys_init();
128 }
129
130 static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat
131 )
132 {
133         generic_fillattr(dentry->d_inode, stat);
134         stat->nlink = proc_root.nlink + nr_processes();
135         return 0;
136 }
137
138 static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
139 {
140         if (!proc_lookup(dir, dentry, nd)) {
141                 return NULL;
142         }
143         
144         return proc_pid_lookup(dir, dentry, nd);
145 }
146
147 static int proc_root_readdir(struct file * filp,
148         void * dirent, filldir_t filldir)
149 {
150         unsigned int nr = filp->f_pos;
151         int ret;
152
153         if (nr < FIRST_PROCESS_ENTRY) {
154                 int error = proc_readdir(filp, dirent, filldir);
155                 if (error <= 0)
156                         return error;
157                 filp->f_pos = FIRST_PROCESS_ENTRY;
158         }
159
160         ret = proc_pid_readdir(filp, dirent, filldir);
161         return ret;
162 }
163
164 /*
165  * The root /proc directory is special, as it has the
166  * <pid> directories. Thus we don't use the generic
167  * directory handling functions for that..
168  */
169 static const struct file_operations proc_root_operations = {
170         .read            = generic_read_dir,
171         .readdir         = proc_root_readdir,
172         .llseek         = default_llseek,
173 };
174
175 /*
176  * proc root can do almost nothing..
177  */
178 static const struct inode_operations proc_root_inode_operations = {
179         .lookup         = proc_root_lookup,
180         .getattr        = proc_root_getattr,
181 };
182
183 /*
184  * This is the root "inode" in the /proc tree..
185  */
186 struct proc_dir_entry proc_root = {
187         .low_ino        = PROC_ROOT_INO, 
188         .namelen        = 5, 
189         .mode           = S_IFDIR | S_IRUGO | S_IXUGO, 
190         .nlink          = 2, 
191         .count          = ATOMIC_INIT(1),
192         .proc_iops      = &proc_root_inode_operations, 
193         .proc_fops      = &proc_root_operations,
194         .parent         = &proc_root,
195         .name           = "/proc",
196 };
197
198 int pid_ns_prepare_proc(struct pid_namespace *ns)
199 {
200         struct vfsmount *mnt;
201
202         mnt = kern_mount_data(&proc_fs_type, ns);
203         if (IS_ERR(mnt))
204                 return PTR_ERR(mnt);
205
206         ns->proc_mnt = mnt;
207         return 0;
208 }
209
210 void pid_ns_release_proc(struct pid_namespace *ns)
211 {
212         mntput(ns->proc_mnt);
213 }