1 // SPDX-License-Identifier: GPL-2.0 2 #ifndef NO_BCACHEFS_FS 3 4 #include "bcachefs.h" 5 #include "chardev.h" 6 #include "dirent.h" 7 #include "fs.h" 8 #include "fs-common.h" 9 #include "fs-ioctl.h" 10 #include "quota.h" 11 12 #include <linux/compat.h> 13 #include <linux/fsnotify.h> 14 #include <linux/mount.h> 15 #include <linux/namei.h> 16 #include <linux/security.h> 17 #include <linux/writeback.h> 18 19 #define FS_IOC_GOINGDOWN _IOR('X', 125, __u32) 20 #define FSOP_GOING_FLAGS_DEFAULT 0x0 /* going down */ 21 #define FSOP_GOING_FLAGS_LOGFLUSH 0x1 /* flush log but not data */ 22 #define FSOP_GOING_FLAGS_NOLOGFLUSH 0x2 /* don't flush log nor data */ 23 24 struct flags_set { 25 unsigned mask; 26 unsigned flags; 27 28 unsigned projid; 29 30 bool set_projinherit; 31 bool projinherit; 32 }; 33 34 static int bch2_inode_flags_set(struct btree_trans *trans, 35 struct bch_inode_info *inode, 36 struct bch_inode_unpacked *bi, 37 void *p) 38 { 39 struct bch_fs *c = inode->v.i_sb->s_fs_info; 40 /* 41 * We're relying on btree locking here for exclusion with other ioctl 42 * calls - use the flags in the btree (@bi), not inode->i_flags: 43 */ 44 struct flags_set *s = p; 45 unsigned newflags = s->flags; 46 unsigned oldflags = bi->bi_flags & s->mask; 47 48 if (((newflags ^ oldflags) & (BCH_INODE_append|BCH_INODE_immutable)) && 49 !capable(CAP_LINUX_IMMUTABLE)) 50 return -EPERM; 51 52 if (!S_ISREG(bi->bi_mode) && 53 !S_ISDIR(bi->bi_mode) && 54 (newflags & (BCH_INODE_nodump|BCH_INODE_noatime)) != newflags) 55 return -EINVAL; 56 57 if (s->set_projinherit) { 58 bi->bi_fields_set &= ~(1 << Inode_opt_project); 59 bi->bi_fields_set |= ((int) s->projinherit << Inode_opt_project); 60 } 61 62 bi->bi_flags &= ~s->mask; 63 bi->bi_flags |= newflags; 64 65 bi->bi_ctime = timespec_to_bch2_time(c, current_time(&inode->v)); 66 return 0; 67 } 68 69 static int bch2_ioc_getflags(struct bch_inode_info *inode, int __user *arg) 70 { 71 unsigned flags = map_flags(bch_flags_to_uflags, inode->ei_inode.bi_flags); 72 73 return put_user(flags, arg); 74 } 75 76 static int bch2_ioc_setflags(struct bch_fs *c, 77 struct file *file, 78 struct bch_inode_info *inode, 79 void __user *arg) 80 { 81 struct flags_set s = { .mask = map_defined(bch_flags_to_uflags) }; 82 unsigned uflags; 83 int ret; 84 85 if (get_user(uflags, (int __user *) arg)) 86 return -EFAULT; 87 88 s.flags = map_flags_rev(bch_flags_to_uflags, uflags); 89 if (uflags) 90 return -EOPNOTSUPP; 91 92 ret = mnt_want_write_file(file); 93 if (ret) 94 return ret; 95 96 inode_lock(&inode->v); 97 if (!inode_owner_or_capable(file_mnt_idmap(file), &inode->v)) { 98 ret = -EACCES; 99 goto setflags_out; 100 } 101 102 mutex_lock(&inode->ei_update_lock); 103 ret = bch2_subvol_is_ro(c, inode->ei_subvol) ?: 104 bch2_write_inode(c, inode, bch2_inode_flags_set, &s, 105 ATTR_CTIME); 106 mutex_unlock(&inode->ei_update_lock); 107 108 setflags_out: 109 inode_unlock(&inode->v); 110 mnt_drop_write_file(file); 111 return ret; 112 } 113 114 static int bch2_ioc_fsgetxattr(struct bch_inode_info *inode, 115 struct fsxattr __user *arg) 116 { 117 struct fsxattr fa = { 0 }; 118 119 fa.fsx_xflags = map_flags(bch_flags_to_xflags, inode->ei_inode.bi_flags); 120 121 if (inode->ei_inode.bi_fields_set & (1 << Inode_opt_project)) 122 fa.fsx_xflags |= FS_XFLAG_PROJINHERIT; 123 124 fa.fsx_projid = inode->ei_qid.q[QTYP_PRJ]; 125 126 if (copy_to_user(arg, &fa, sizeof(fa))) 127 return -EFAULT; 128 129 return 0; 130 } 131 132 static int fssetxattr_inode_update_fn(struct btree_trans *trans, 133 struct bch_inode_info *inode, 134 struct bch_inode_unpacked *bi, 135 void *p) 136 { 137 struct flags_set *s = p; 138 139 if (s->projid != bi->bi_project) { 140 bi->bi_fields_set |= 1U << Inode_opt_project; 141 bi->bi_project = s->projid; 142 } 143 144 return bch2_inode_flags_set(trans, inode, bi, p); 145 } 146 147 static int bch2_ioc_fssetxattr(struct bch_fs *c, 148 struct file *file, 149 struct bch_inode_info *inode, 150 struct fsxattr __user *arg) 151 { 152 struct flags_set s = { .mask = map_defined(bch_flags_to_xflags) }; 153 struct fsxattr fa; 154 int ret; 155 156 if (copy_from_user(&fa, arg, sizeof(fa))) 157 return -EFAULT; 158 159 s.set_projinherit = true; 160 s.projinherit = (fa.fsx_xflags & FS_XFLAG_PROJINHERIT) != 0; 161 fa.fsx_xflags &= ~FS_XFLAG_PROJINHERIT; 162 163 s.flags = map_flags_rev(bch_flags_to_xflags, fa.fsx_xflags); 164 if (fa.fsx_xflags) 165 return -EOPNOTSUPP; 166 167 if (fa.fsx_projid >= U32_MAX) 168 return -EINVAL; 169 170 /* 171 * inode fields accessible via the xattr interface are stored with a +1 172 * bias, so that 0 means unset: 173 */ 174 s.projid = fa.fsx_projid + 1; 175 176 ret = mnt_want_write_file(file); 177 if (ret) 178 return ret; 179 180 inode_lock(&inode->v); 181 if (!inode_owner_or_capable(file_mnt_idmap(file), &inode->v)) { 182 ret = -EACCES; 183 goto err; 184 } 185 186 mutex_lock(&inode->ei_update_lock); 187 ret = bch2_subvol_is_ro(c, inode->ei_subvol) ?: 188 bch2_set_projid(c, inode, fa.fsx_projid) ?: 189 bch2_write_inode(c, inode, fssetxattr_inode_update_fn, &s, 190 ATTR_CTIME); 191 mutex_unlock(&inode->ei_update_lock); 192 err: 193 inode_unlock(&inode->v); 194 mnt_drop_write_file(file); 195 return ret; 196 } 197 198 static int bch2_reinherit_attrs_fn(struct btree_trans *trans, 199 struct bch_inode_info *inode, 200 struct bch_inode_unpacked *bi, 201 void *p) 202 { 203 struct bch_inode_info *dir = p; 204 205 return !bch2_reinherit_attrs(bi, &dir->ei_inode); 206 } 207 208 static int bch2_ioc_reinherit_attrs(struct bch_fs *c, 209 struct file *file, 210 struct bch_inode_info *src, 211 const char __user *name) 212 { 213 struct bch_hash_info hash = bch2_hash_info_init(c, &src->ei_inode); 214 struct bch_inode_info *dst; 215 struct inode *vinode = NULL; 216 char *kname = NULL; 217 struct qstr qstr; 218 int ret = 0; 219 subvol_inum inum; 220 221 kname = kmalloc(BCH_NAME_MAX + 1, GFP_KERNEL); 222 if (!kname) 223 return -ENOMEM; 224 225 ret = strncpy_from_user(kname, name, BCH_NAME_MAX); 226 if (unlikely(ret < 0)) 227 goto err1; 228 229 qstr.len = ret; 230 qstr.name = kname; 231 232 ret = bch2_dirent_lookup(c, inode_inum(src), &hash, &qstr, &inum); 233 if (ret) 234 goto err1; 235 236 vinode = bch2_vfs_inode_get(c, inum); 237 ret = PTR_ERR_OR_ZERO(vinode); 238 if (ret) 239 goto err1; 240 241 dst = to_bch_ei(vinode); 242 243 ret = mnt_want_write_file(file); 244 if (ret) 245 goto err2; 246 247 bch2_lock_inodes(INODE_UPDATE_LOCK, src, dst); 248 249 if (inode_attr_changing(src, dst, Inode_opt_project)) { 250 ret = bch2_fs_quota_transfer(c, dst, 251 src->ei_qid, 252 1 << QTYP_PRJ, 253 KEY_TYPE_QUOTA_PREALLOC); 254 if (ret) 255 goto err3; 256 } 257 258 ret = bch2_write_inode(c, dst, bch2_reinherit_attrs_fn, src, 0); 259 err3: 260 bch2_unlock_inodes(INODE_UPDATE_LOCK, src, dst); 261 262 /* return true if we did work */ 263 if (ret >= 0) 264 ret = !ret; 265 266 mnt_drop_write_file(file); 267 err2: 268 iput(vinode); 269 err1: 270 kfree(kname); 271 272 return ret; 273 } 274 275 static int bch2_ioc_goingdown(struct bch_fs *c, u32 __user *arg) 276 { 277 u32 flags; 278 int ret = 0; 279 280 if (!capable(CAP_SYS_ADMIN)) 281 return -EPERM; 282 283 if (get_user(flags, arg)) 284 return -EFAULT; 285 286 bch_notice(c, "shutdown by ioctl type %u", flags); 287 288 down_write(&c->vfs_sb->s_umount); 289 290 switch (flags) { 291 case FSOP_GOING_FLAGS_DEFAULT: 292 ret = freeze_bdev(c->vfs_sb->s_bdev); 293 if (ret) 294 goto err; 295 296 bch2_journal_flush(&c->journal); 297 c->vfs_sb->s_flags |= SB_RDONLY; 298 bch2_fs_emergency_read_only(c); 299 thaw_bdev(c->vfs_sb->s_bdev); 300 break; 301 302 case FSOP_GOING_FLAGS_LOGFLUSH: 303 bch2_journal_flush(&c->journal); 304 fallthrough; 305 306 case FSOP_GOING_FLAGS_NOLOGFLUSH: 307 c->vfs_sb->s_flags |= SB_RDONLY; 308 bch2_fs_emergency_read_only(c); 309 break; 310 default: 311 ret = -EINVAL; 312 break; 313 } 314 err: 315 up_write(&c->vfs_sb->s_umount); 316 return ret; 317 } 318 319 static long __bch2_ioctl_subvolume_create(struct bch_fs *c, struct file *filp, 320 struct bch_ioctl_subvolume arg) 321 { 322 struct inode *dir; 323 struct bch_inode_info *inode; 324 struct user_namespace *s_user_ns; 325 struct dentry *dst_dentry; 326 struct path src_path, dst_path; 327 int how = LOOKUP_FOLLOW; 328 int error; 329 subvol_inum snapshot_src = { 0 }; 330 unsigned lookup_flags = 0; 331 unsigned create_flags = BCH_CREATE_SUBVOL; 332 333 if (arg.flags & ~(BCH_SUBVOL_SNAPSHOT_CREATE| 334 BCH_SUBVOL_SNAPSHOT_RO)) 335 return -EINVAL; 336 337 if (!(arg.flags & BCH_SUBVOL_SNAPSHOT_CREATE) && 338 (arg.src_ptr || 339 (arg.flags & BCH_SUBVOL_SNAPSHOT_RO))) 340 return -EINVAL; 341 342 if (arg.flags & BCH_SUBVOL_SNAPSHOT_CREATE) 343 create_flags |= BCH_CREATE_SNAPSHOT; 344 345 if (arg.flags & BCH_SUBVOL_SNAPSHOT_RO) 346 create_flags |= BCH_CREATE_SNAPSHOT_RO; 347 348 /* why do we need this lock? */ 349 down_read(&c->vfs_sb->s_umount); 350 351 if (arg.flags & BCH_SUBVOL_SNAPSHOT_CREATE) 352 sync_inodes_sb(c->vfs_sb); 353 retry: 354 if (arg.src_ptr) { 355 error = user_path_at(arg.dirfd, 356 (const char __user *)(unsigned long)arg.src_ptr, 357 how, &src_path); 358 if (error) 359 goto err1; 360 361 if (src_path.dentry->d_sb->s_fs_info != c) { 362 path_put(&src_path); 363 error = -EXDEV; 364 goto err1; 365 } 366 367 snapshot_src = inode_inum(to_bch_ei(src_path.dentry->d_inode)); 368 } 369 370 dst_dentry = user_path_create(arg.dirfd, 371 (const char __user *)(unsigned long)arg.dst_ptr, 372 &dst_path, lookup_flags); 373 error = PTR_ERR_OR_ZERO(dst_dentry); 374 if (error) 375 goto err2; 376 377 if (dst_dentry->d_sb->s_fs_info != c) { 378 error = -EXDEV; 379 goto err3; 380 } 381 382 if (dst_dentry->d_inode) { 383 error = -EEXIST; 384 goto err3; 385 } 386 387 dir = dst_path.dentry->d_inode; 388 if (IS_DEADDIR(dir)) { 389 error = -BCH_ERR_ENOENT_directory_dead; 390 goto err3; 391 } 392 393 s_user_ns = dir->i_sb->s_user_ns; 394 if (!kuid_has_mapping(s_user_ns, current_fsuid()) || 395 !kgid_has_mapping(s_user_ns, current_fsgid())) { 396 error = -EOVERFLOW; 397 goto err3; 398 } 399 400 error = inode_permission(file_mnt_idmap(filp), 401 dir, MAY_WRITE | MAY_EXEC); 402 if (error) 403 goto err3; 404 405 if (!IS_POSIXACL(dir)) 406 arg.mode &= ~current_umask(); 407 408 error = security_path_mkdir(&dst_path, dst_dentry, arg.mode); 409 if (error) 410 goto err3; 411 412 if ((arg.flags & BCH_SUBVOL_SNAPSHOT_CREATE) && 413 !arg.src_ptr) 414 snapshot_src.subvol = inode_inum(to_bch_ei(dir)).subvol; 415 416 inode = __bch2_create(file_mnt_idmap(filp), to_bch_ei(dir), 417 dst_dentry, arg.mode|S_IFDIR, 418 0, snapshot_src, create_flags); 419 error = PTR_ERR_OR_ZERO(inode); 420 if (error) 421 goto err3; 422 423 d_instantiate(dst_dentry, &inode->v); 424 fsnotify_mkdir(dir, dst_dentry); 425 err3: 426 done_path_create(&dst_path, dst_dentry); 427 err2: 428 if (arg.src_ptr) 429 path_put(&src_path); 430 431 if (retry_estale(error, lookup_flags)) { 432 lookup_flags |= LOOKUP_REVAL; 433 goto retry; 434 } 435 err1: 436 up_read(&c->vfs_sb->s_umount); 437 438 return error; 439 } 440 441 static long bch2_ioctl_subvolume_create(struct bch_fs *c, struct file *filp, 442 struct bch_ioctl_subvolume arg) 443 { 444 down_write(&c->snapshot_create_lock); 445 long ret = __bch2_ioctl_subvolume_create(c, filp, arg); 446 up_write(&c->snapshot_create_lock); 447 448 return ret; 449 } 450 451 static long bch2_ioctl_subvolume_destroy(struct bch_fs *c, struct file *filp, 452 struct bch_ioctl_subvolume arg) 453 { 454 struct path path; 455 struct inode *dir; 456 int ret = 0; 457 458 if (arg.flags) 459 return -EINVAL; 460 461 ret = user_path_at(arg.dirfd, 462 (const char __user *)(unsigned long)arg.dst_ptr, 463 LOOKUP_FOLLOW, &path); 464 if (ret) 465 return ret; 466 467 if (path.dentry->d_sb->s_fs_info != c) { 468 ret = -EXDEV; 469 goto err; 470 } 471 472 dir = path.dentry->d_parent->d_inode; 473 474 ret = __bch2_unlink(dir, path.dentry, true); 475 if (ret) 476 goto err; 477 478 fsnotify_rmdir(dir, path.dentry); 479 d_delete(path.dentry); 480 err: 481 path_put(&path); 482 return ret; 483 } 484 485 long bch2_fs_file_ioctl(struct file *file, unsigned cmd, unsigned long arg) 486 { 487 struct bch_inode_info *inode = file_bch_inode(file); 488 struct bch_fs *c = inode->v.i_sb->s_fs_info; 489 long ret; 490 491 switch (cmd) { 492 case FS_IOC_GETFLAGS: 493 ret = bch2_ioc_getflags(inode, (int __user *) arg); 494 break; 495 496 case FS_IOC_SETFLAGS: 497 ret = bch2_ioc_setflags(c, file, inode, (int __user *) arg); 498 break; 499 500 case FS_IOC_FSGETXATTR: 501 ret = bch2_ioc_fsgetxattr(inode, (void __user *) arg); 502 break; 503 504 case FS_IOC_FSSETXATTR: 505 ret = bch2_ioc_fssetxattr(c, file, inode, 506 (void __user *) arg); 507 break; 508 509 case BCHFS_IOC_REINHERIT_ATTRS: 510 ret = bch2_ioc_reinherit_attrs(c, file, inode, 511 (void __user *) arg); 512 break; 513 514 case FS_IOC_GETVERSION: 515 ret = -ENOTTY; 516 break; 517 518 case FS_IOC_SETVERSION: 519 ret = -ENOTTY; 520 break; 521 522 case FS_IOC_GOINGDOWN: 523 ret = bch2_ioc_goingdown(c, (u32 __user *) arg); 524 break; 525 526 case BCH_IOCTL_SUBVOLUME_CREATE: { 527 struct bch_ioctl_subvolume i; 528 529 ret = copy_from_user(&i, (void __user *) arg, sizeof(i)) 530 ? -EFAULT 531 : bch2_ioctl_subvolume_create(c, file, i); 532 break; 533 } 534 535 case BCH_IOCTL_SUBVOLUME_DESTROY: { 536 struct bch_ioctl_subvolume i; 537 538 ret = copy_from_user(&i, (void __user *) arg, sizeof(i)) 539 ? -EFAULT 540 : bch2_ioctl_subvolume_destroy(c, file, i); 541 break; 542 } 543 544 default: 545 ret = bch2_fs_ioctl(c, cmd, (void __user *) arg); 546 break; 547 } 548 549 return bch2_err_class(ret); 550 } 551 552 #ifdef CONFIG_COMPAT 553 long bch2_compat_fs_ioctl(struct file *file, unsigned cmd, unsigned long arg) 554 { 555 /* These are just misnamed, they actually get/put from/to user an int */ 556 switch (cmd) { 557 case FS_IOC_GETFLAGS: 558 cmd = FS_IOC_GETFLAGS; 559 break; 560 case FS_IOC32_SETFLAGS: 561 cmd = FS_IOC_SETFLAGS; 562 break; 563 default: 564 return -ENOIOCTLCMD; 565 } 566 return bch2_fs_file_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 567 } 568 #endif 569 570 #endif /* NO_BCACHEFS_FS */ 571