1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/syscalls.h> 3 #include <linux/export.h> 4 #include <linux/fs.h> 5 #include <linux/file.h> 6 #include <linux/mount.h> 7 #include <linux/namei.h> 8 #include <linux/statfs.h> 9 #include <linux/security.h> 10 #include <linux/uaccess.h> 11 #include <linux/compat.h> 12 #include "internal.h" 13 14 static int flags_by_mnt(int mnt_flags) 15 { 16 int flags = 0; 17 18 if (mnt_flags & MNT_READONLY) 19 flags |= ST_RDONLY; 20 if (mnt_flags & MNT_NOSUID) 21 flags |= ST_NOSUID; 22 if (mnt_flags & MNT_NODEV) 23 flags |= ST_NODEV; 24 if (mnt_flags & MNT_NOEXEC) 25 flags |= ST_NOEXEC; 26 if (mnt_flags & MNT_NOATIME) 27 flags |= ST_NOATIME; 28 if (mnt_flags & MNT_NODIRATIME) 29 flags |= ST_NODIRATIME; 30 if (mnt_flags & MNT_RELATIME) 31 flags |= ST_RELATIME; 32 return flags; 33 } 34 35 static int flags_by_sb(int s_flags) 36 { 37 int flags = 0; 38 if (s_flags & SB_SYNCHRONOUS) 39 flags |= ST_SYNCHRONOUS; 40 if (s_flags & SB_MANDLOCK) 41 flags |= ST_MANDLOCK; 42 if (s_flags & SB_RDONLY) 43 flags |= ST_RDONLY; 44 return flags; 45 } 46 47 static int calculate_f_flags(struct vfsmount *mnt) 48 { 49 return ST_VALID | flags_by_mnt(mnt->mnt_flags) | 50 flags_by_sb(mnt->mnt_sb->s_flags); 51 } 52 53 static int statfs_by_dentry(struct dentry *dentry, struct kstatfs *buf) 54 { 55 int retval; 56 57 if (!dentry->d_sb->s_op->statfs) 58 return -ENOSYS; 59 60 memset(buf, 0, sizeof(*buf)); 61 retval = security_sb_statfs(dentry); 62 if (retval) 63 return retval; 64 retval = dentry->d_sb->s_op->statfs(dentry, buf); 65 if (retval == 0 && buf->f_frsize == 0) 66 buf->f_frsize = buf->f_bsize; 67 return retval; 68 } 69 70 int vfs_get_fsid(struct dentry *dentry, __kernel_fsid_t *fsid) 71 { 72 struct kstatfs st; 73 int error; 74 75 error = statfs_by_dentry(dentry, &st); 76 if (error) 77 return error; 78 79 *fsid = st.f_fsid; 80 return 0; 81 } 82 EXPORT_SYMBOL(vfs_get_fsid); 83 84 int vfs_statfs(const struct path *path, struct kstatfs *buf) 85 { 86 int error; 87 88 error = statfs_by_dentry(path->dentry, buf); 89 if (!error) 90 buf->f_flags = calculate_f_flags(path->mnt); 91 return error; 92 } 93 EXPORT_SYMBOL(vfs_statfs); 94 95 int user_statfs(const char __user *pathname, struct kstatfs *st) 96 { 97 struct path path; 98 int error; 99 unsigned int lookup_flags = LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT; 100 retry: 101 error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); 102 if (!error) { 103 error = vfs_statfs(&path, st); 104 path_put(&path); 105 if (retry_estale(error, lookup_flags)) { 106 lookup_flags |= LOOKUP_REVAL; 107 goto retry; 108 } 109 } 110 return error; 111 } 112 113 int fd_statfs(int fd, struct kstatfs *st) 114 { 115 struct fd f = fdget_raw(fd); 116 int error = -EBADF; 117 if (f.file) { 118 error = vfs_statfs(&f.file->f_path, st); 119 fdput(f); 120 } 121 return error; 122 } 123 124 static int do_statfs_native(struct kstatfs *st, struct statfs __user *p) 125 { 126 struct statfs buf; 127 128 if (sizeof(buf) == sizeof(*st)) 129 memcpy(&buf, st, sizeof(*st)); 130 else { 131 if (sizeof buf.f_blocks == 4) { 132 if ((st->f_blocks | st->f_bfree | st->f_bavail | 133 st->f_bsize | st->f_frsize) & 134 0xffffffff00000000ULL) 135 return -EOVERFLOW; 136 /* 137 * f_files and f_ffree may be -1; it's okay to stuff 138 * that into 32 bits 139 */ 140 if (st->f_files != -1 && 141 (st->f_files & 0xffffffff00000000ULL)) 142 return -EOVERFLOW; 143 if (st->f_ffree != -1 && 144 (st->f_ffree & 0xffffffff00000000ULL)) 145 return -EOVERFLOW; 146 } 147 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 static int do_statfs64(struct kstatfs *st, struct statfs64 __user *p) 167 { 168 struct statfs64 buf; 169 if (sizeof(buf) == sizeof(*st)) 170 memcpy(&buf, st, sizeof(*st)); 171 else { 172 buf.f_type = st->f_type; 173 buf.f_bsize = st->f_bsize; 174 buf.f_blocks = st->f_blocks; 175 buf.f_bfree = st->f_bfree; 176 buf.f_bavail = st->f_bavail; 177 buf.f_files = st->f_files; 178 buf.f_ffree = st->f_ffree; 179 buf.f_fsid = st->f_fsid; 180 buf.f_namelen = st->f_namelen; 181 buf.f_frsize = st->f_frsize; 182 buf.f_flags = st->f_flags; 183 memset(buf.f_spare, 0, sizeof(buf.f_spare)); 184 } 185 if (copy_to_user(p, &buf, sizeof(buf))) 186 return -EFAULT; 187 return 0; 188 } 189 190 SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct statfs __user *, buf) 191 { 192 struct kstatfs st; 193 int error = user_statfs(pathname, &st); 194 if (!error) 195 error = do_statfs_native(&st, buf); 196 return error; 197 } 198 199 SYSCALL_DEFINE3(statfs64, const char __user *, pathname, size_t, sz, struct statfs64 __user *, buf) 200 { 201 struct kstatfs st; 202 int error; 203 if (sz != sizeof(*buf)) 204 return -EINVAL; 205 error = user_statfs(pathname, &st); 206 if (!error) 207 error = do_statfs64(&st, buf); 208 return error; 209 } 210 211 SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct statfs __user *, buf) 212 { 213 struct kstatfs st; 214 int error = fd_statfs(fd, &st); 215 if (!error) 216 error = do_statfs_native(&st, buf); 217 return error; 218 } 219 220 SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, size_t, sz, struct statfs64 __user *, buf) 221 { 222 struct kstatfs st; 223 int error; 224 225 if (sz != sizeof(*buf)) 226 return -EINVAL; 227 228 error = fd_statfs(fd, &st); 229 if (!error) 230 error = do_statfs64(&st, buf); 231 return error; 232 } 233 234 static int vfs_ustat(dev_t dev, struct kstatfs *sbuf) 235 { 236 struct super_block *s = user_get_super(dev); 237 int err; 238 if (!s) 239 return -EINVAL; 240 241 err = statfs_by_dentry(s->s_root, sbuf); 242 drop_super(s); 243 return err; 244 } 245 246 SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf) 247 { 248 struct ustat tmp; 249 struct kstatfs sbuf; 250 int err = vfs_ustat(new_decode_dev(dev), &sbuf); 251 if (err) 252 return err; 253 254 memset(&tmp,0,sizeof(struct ustat)); 255 tmp.f_tfree = sbuf.f_bfree; 256 tmp.f_tinode = sbuf.f_ffree; 257 258 return copy_to_user(ubuf, &tmp, sizeof(struct ustat)) ? -EFAULT : 0; 259 } 260 261 #ifdef CONFIG_COMPAT 262 static int put_compat_statfs(struct compat_statfs __user *ubuf, struct kstatfs *kbuf) 263 { 264 struct compat_statfs buf; 265 if (sizeof ubuf->f_blocks == 4) { 266 if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail | 267 kbuf->f_bsize | kbuf->f_frsize) & 0xffffffff00000000ULL) 268 return -EOVERFLOW; 269 /* f_files and f_ffree may be -1; it's okay 270 * to stuff that into 32 bits */ 271 if (kbuf->f_files != 0xffffffffffffffffULL 272 && (kbuf->f_files & 0xffffffff00000000ULL)) 273 return -EOVERFLOW; 274 if (kbuf->f_ffree != 0xffffffffffffffffULL 275 && (kbuf->f_ffree & 0xffffffff00000000ULL)) 276 return -EOVERFLOW; 277 } 278 memset(&buf, 0, sizeof(struct compat_statfs)); 279 buf.f_type = kbuf->f_type; 280 buf.f_bsize = kbuf->f_bsize; 281 buf.f_blocks = kbuf->f_blocks; 282 buf.f_bfree = kbuf->f_bfree; 283 buf.f_bavail = kbuf->f_bavail; 284 buf.f_files = kbuf->f_files; 285 buf.f_ffree = kbuf->f_ffree; 286 buf.f_namelen = kbuf->f_namelen; 287 buf.f_fsid.val[0] = kbuf->f_fsid.val[0]; 288 buf.f_fsid.val[1] = kbuf->f_fsid.val[1]; 289 buf.f_frsize = kbuf->f_frsize; 290 buf.f_flags = kbuf->f_flags; 291 if (copy_to_user(ubuf, &buf, sizeof(struct compat_statfs))) 292 return -EFAULT; 293 return 0; 294 } 295 296 /* 297 * The following statfs calls are copies of code from fs/statfs.c and 298 * should be checked against those from time to time 299 */ 300 COMPAT_SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct compat_statfs __user *, buf) 301 { 302 struct kstatfs tmp; 303 int error = user_statfs(pathname, &tmp); 304 if (!error) 305 error = put_compat_statfs(buf, &tmp); 306 return error; 307 } 308 309 COMPAT_SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct compat_statfs __user *, buf) 310 { 311 struct kstatfs tmp; 312 int error = fd_statfs(fd, &tmp); 313 if (!error) 314 error = put_compat_statfs(buf, &tmp); 315 return error; 316 } 317 318 static int put_compat_statfs64(struct compat_statfs64 __user *ubuf, struct kstatfs *kbuf) 319 { 320 struct compat_statfs64 buf; 321 if (sizeof(ubuf->f_bsize) == 4) { 322 if ((kbuf->f_type | kbuf->f_bsize | kbuf->f_namelen | 323 kbuf->f_frsize | kbuf->f_flags) & 0xffffffff00000000ULL) 324 return -EOVERFLOW; 325 /* f_files and f_ffree may be -1; it's okay 326 * to stuff that into 32 bits */ 327 if (kbuf->f_files != 0xffffffffffffffffULL 328 && (kbuf->f_files & 0xffffffff00000000ULL)) 329 return -EOVERFLOW; 330 if (kbuf->f_ffree != 0xffffffffffffffffULL 331 && (kbuf->f_ffree & 0xffffffff00000000ULL)) 332 return -EOVERFLOW; 333 } 334 memset(&buf, 0, sizeof(struct compat_statfs64)); 335 buf.f_type = kbuf->f_type; 336 buf.f_bsize = kbuf->f_bsize; 337 buf.f_blocks = kbuf->f_blocks; 338 buf.f_bfree = kbuf->f_bfree; 339 buf.f_bavail = kbuf->f_bavail; 340 buf.f_files = kbuf->f_files; 341 buf.f_ffree = kbuf->f_ffree; 342 buf.f_namelen = kbuf->f_namelen; 343 buf.f_fsid.val[0] = kbuf->f_fsid.val[0]; 344 buf.f_fsid.val[1] = kbuf->f_fsid.val[1]; 345 buf.f_frsize = kbuf->f_frsize; 346 buf.f_flags = kbuf->f_flags; 347 if (copy_to_user(ubuf, &buf, sizeof(struct compat_statfs64))) 348 return -EFAULT; 349 return 0; 350 } 351 352 int kcompat_sys_statfs64(const char __user * pathname, compat_size_t sz, struct compat_statfs64 __user * buf) 353 { 354 struct kstatfs tmp; 355 int error; 356 357 if (sz != sizeof(*buf)) 358 return -EINVAL; 359 360 error = user_statfs(pathname, &tmp); 361 if (!error) 362 error = put_compat_statfs64(buf, &tmp); 363 return error; 364 } 365 366 COMPAT_SYSCALL_DEFINE3(statfs64, const char __user *, pathname, compat_size_t, sz, struct compat_statfs64 __user *, buf) 367 { 368 return kcompat_sys_statfs64(pathname, sz, buf); 369 } 370 371 int kcompat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user * buf) 372 { 373 struct kstatfs tmp; 374 int error; 375 376 if (sz != sizeof(*buf)) 377 return -EINVAL; 378 379 error = fd_statfs(fd, &tmp); 380 if (!error) 381 error = put_compat_statfs64(buf, &tmp); 382 return error; 383 } 384 385 COMPAT_SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, compat_size_t, sz, struct compat_statfs64 __user *, buf) 386 { 387 return kcompat_sys_fstatfs64(fd, sz, buf); 388 } 389 390 /* 391 * This is a copy of sys_ustat, just dealing with a structure layout. 392 * Given how simple this syscall is that apporach is more maintainable 393 * than the various conversion hacks. 394 */ 395 COMPAT_SYSCALL_DEFINE2(ustat, unsigned, dev, struct compat_ustat __user *, u) 396 { 397 struct compat_ustat tmp; 398 struct kstatfs sbuf; 399 int err = vfs_ustat(new_decode_dev(dev), &sbuf); 400 if (err) 401 return err; 402 403 memset(&tmp, 0, sizeof(struct compat_ustat)); 404 tmp.f_tfree = sbuf.f_bfree; 405 tmp.f_tinode = sbuf.f_ffree; 406 if (copy_to_user(u, &tmp, sizeof(struct compat_ustat))) 407 return -EFAULT; 408 return 0; 409 } 410 #endif 411