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