fs: do not assign default i_ino in new_inode
[linux-2.6.git] / fs / statfs.c
1 #include <linux/syscalls.h>
2 #include <linux/module.h>
3 #include <linux/fs.h>
4 #include <linux/file.h>
5 #include <linux/mount.h>
6 #include <linux/namei.h>
7 #include <linux/statfs.h>
8 #include <linux/security.h>
9 #include <linux/uaccess.h>
10
11 static int flags_by_mnt(int mnt_flags)
12 {
13         int flags = 0;
14
15         if (mnt_flags & MNT_READONLY)
16                 flags |= ST_RDONLY;
17         if (mnt_flags & MNT_NOSUID)
18                 flags |= ST_NOSUID;
19         if (mnt_flags & MNT_NODEV)
20                 flags |= ST_NODEV;
21         if (mnt_flags & MNT_NOEXEC)
22                 flags |= ST_NOEXEC;
23         if (mnt_flags & MNT_NOATIME)
24                 flags |= ST_NOATIME;
25         if (mnt_flags & MNT_NODIRATIME)
26                 flags |= ST_NODIRATIME;
27         if (mnt_flags & MNT_RELATIME)
28                 flags |= ST_RELATIME;
29         return flags;
30 }
31
32 static int flags_by_sb(int s_flags)
33 {
34         int flags = 0;
35         if (s_flags & MS_SYNCHRONOUS)
36                 flags |= ST_SYNCHRONOUS;
37         if (s_flags & MS_MANDLOCK)
38                 flags |= ST_MANDLOCK;
39         return flags;
40 }
41
42 static int calculate_f_flags(struct vfsmount *mnt)
43 {
44         return ST_VALID | flags_by_mnt(mnt->mnt_flags) |
45                 flags_by_sb(mnt->mnt_sb->s_flags);
46 }
47
48 int statfs_by_dentry(struct dentry *dentry, struct kstatfs *buf)
49 {
50         int retval;
51
52         if (!dentry->d_sb->s_op->statfs)
53                 return -ENOSYS;
54
55         memset(buf, 0, sizeof(*buf));
56         retval = security_sb_statfs(dentry);
57         if (retval)
58                 return retval;
59         retval = dentry->d_sb->s_op->statfs(dentry, buf);
60         if (retval == 0 && buf->f_frsize == 0)
61                 buf->f_frsize = buf->f_bsize;
62         return retval;
63 }
64
65 int vfs_statfs(struct path *path, struct kstatfs *buf)
66 {
67         int error;
68
69         error = statfs_by_dentry(path->dentry, buf);
70         if (!error)
71                 buf->f_flags = calculate_f_flags(path->mnt);
72         return error;
73 }
74 EXPORT_SYMBOL(vfs_statfs);
75
76 static int do_statfs_native(struct path *path, struct statfs *buf)
77 {
78         struct kstatfs st;
79         int retval;
80
81         retval = vfs_statfs(path, &st);
82         if (retval)
83                 return retval;
84
85         if (sizeof(*buf) == sizeof(st))
86                 memcpy(buf, &st, sizeof(st));
87         else {
88                 if (sizeof buf->f_blocks == 4) {
89                         if ((st.f_blocks | st.f_bfree | st.f_bavail |
90                              st.f_bsize | st.f_frsize) &
91                             0xffffffff00000000ULL)
92                                 return -EOVERFLOW;
93                         /*
94                          * f_files and f_ffree may be -1; it's okay to stuff
95                          * that into 32 bits
96                          */
97                         if (st.f_files != -1 &&
98                             (st.f_files & 0xffffffff00000000ULL))
99                                 return -EOVERFLOW;
100                         if (st.f_ffree != -1 &&
101                             (st.f_ffree & 0xffffffff00000000ULL))
102                                 return -EOVERFLOW;
103                 }
104
105                 buf->f_type = st.f_type;
106                 buf->f_bsize = st.f_bsize;
107                 buf->f_blocks = st.f_blocks;
108                 buf->f_bfree = st.f_bfree;
109                 buf->f_bavail = st.f_bavail;
110                 buf->f_files = st.f_files;
111                 buf->f_ffree = st.f_ffree;
112                 buf->f_fsid = st.f_fsid;
113                 buf->f_namelen = st.f_namelen;
114                 buf->f_frsize = st.f_frsize;
115                 buf->f_flags = st.f_flags;
116                 memset(buf->f_spare, 0, sizeof(buf->f_spare));
117         }
118         return 0;
119 }
120
121 static int do_statfs64(struct path *path, struct statfs64 *buf)
122 {
123         struct kstatfs st;
124         int retval;
125
126         retval = vfs_statfs(path, &st);
127         if (retval)
128                 return retval;
129
130         if (sizeof(*buf) == sizeof(st))
131                 memcpy(buf, &st, sizeof(st));
132         else {
133                 buf->f_type = st.f_type;
134                 buf->f_bsize = st.f_bsize;
135                 buf->f_blocks = st.f_blocks;
136                 buf->f_bfree = st.f_bfree;
137                 buf->f_bavail = st.f_bavail;
138                 buf->f_files = st.f_files;
139                 buf->f_ffree = st.f_ffree;
140                 buf->f_fsid = st.f_fsid;
141                 buf->f_namelen = st.f_namelen;
142                 buf->f_frsize = st.f_frsize;
143                 buf->f_flags = st.f_flags;
144                 memset(buf->f_spare, 0, sizeof(buf->f_spare));
145         }
146         return 0;
147 }
148
149 SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct statfs __user *, buf)
150 {
151         struct path path;
152         int error;
153
154         error = user_path(pathname, &path);
155         if (!error) {
156                 struct statfs tmp;
157                 error = do_statfs_native(&path, &tmp);
158                 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
159                         error = -EFAULT;
160                 path_put(&path);
161         }
162         return error;
163 }
164
165 SYSCALL_DEFINE3(statfs64, const char __user *, pathname, size_t, sz, struct statfs64 __user *, buf)
166 {
167         struct path path;
168         long error;
169
170         if (sz != sizeof(*buf))
171                 return -EINVAL;
172         error = user_path(pathname, &path);
173         if (!error) {
174                 struct statfs64 tmp;
175                 error = do_statfs64(&path, &tmp);
176                 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
177                         error = -EFAULT;
178                 path_put(&path);
179         }
180         return error;
181 }
182
183 SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct statfs __user *, buf)
184 {
185         struct file *file;
186         struct statfs tmp;
187         int error;
188
189         error = -EBADF;
190         file = fget(fd);
191         if (!file)
192                 goto out;
193         error = do_statfs_native(&file->f_path, &tmp);
194         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
195                 error = -EFAULT;
196         fput(file);
197 out:
198         return error;
199 }
200
201 SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, size_t, sz, struct statfs64 __user *, buf)
202 {
203         struct file *file;
204         struct statfs64 tmp;
205         int error;
206
207         if (sz != sizeof(*buf))
208                 return -EINVAL;
209
210         error = -EBADF;
211         file = fget(fd);
212         if (!file)
213                 goto out;
214         error = do_statfs64(&file->f_path, &tmp);
215         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
216                 error = -EFAULT;
217         fput(file);
218 out:
219         return error;
220 }
221
222 SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
223 {
224         struct super_block *s;
225         struct ustat tmp;
226         struct kstatfs sbuf;
227         int err;
228
229         s = user_get_super(new_decode_dev(dev));
230         if (!s)
231                 return -EINVAL;
232
233         err = statfs_by_dentry(s->s_root, &sbuf);
234         drop_super(s);
235         if (err)
236                 return err;
237
238         memset(&tmp,0,sizeof(struct ustat));
239         tmp.f_tfree = sbuf.f_bfree;
240         tmp.f_tinode = sbuf.f_ffree;
241
242         return copy_to_user(ubuf, &tmp, sizeof(struct ustat)) ? -EFAULT : 0;
243 }