1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/bio.h> 21 #include <linux/buffer_head.h> 22 #include <linux/file.h> 23 #include <linux/fs.h> 24 #include <linux/fsnotify.h> 25 #include <linux/pagemap.h> 26 #include <linux/highmem.h> 27 #include <linux/time.h> 28 #include <linux/init.h> 29 #include <linux/string.h> 30 #include <linux/backing-dev.h> 31 #include <linux/mount.h> 32 #include <linux/mpage.h> 33 #include <linux/namei.h> 34 #include <linux/swap.h> 35 #include <linux/writeback.h> 36 #include <linux/statfs.h> 37 #include <linux/compat.h> 38 #include <linux/bit_spinlock.h> 39 #include <linux/security.h> 40 #include <linux/xattr.h> 41 #include <linux/vmalloc.h> 42 #include <linux/slab.h> 43 #include <linux/blkdev.h> 44 #include <linux/uuid.h> 45 #include <linux/btrfs.h> 46 #include <linux/uaccess.h> 47 #include "ctree.h" 48 #include "disk-io.h" 49 #include "transaction.h" 50 #include "btrfs_inode.h" 51 #include "print-tree.h" 52 #include "volumes.h" 53 #include "locking.h" 54 #include "inode-map.h" 55 #include "backref.h" 56 #include "rcu-string.h" 57 #include "send.h" 58 #include "dev-replace.h" 59 #include "props.h" 60 #include "sysfs.h" 61 #include "qgroup.h" 62 63 #ifdef CONFIG_64BIT 64 /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI 65 * structures are incorrect, as the timespec structure from userspace 66 * is 4 bytes too small. We define these alternatives here to teach 67 * the kernel about the 32-bit struct packing. 68 */ 69 struct btrfs_ioctl_timespec_32 { 70 __u64 sec; 71 __u32 nsec; 72 } __attribute__ ((__packed__)); 73 74 struct btrfs_ioctl_received_subvol_args_32 { 75 char uuid[BTRFS_UUID_SIZE]; /* in */ 76 __u64 stransid; /* in */ 77 __u64 rtransid; /* out */ 78 struct btrfs_ioctl_timespec_32 stime; /* in */ 79 struct btrfs_ioctl_timespec_32 rtime; /* out */ 80 __u64 flags; /* in */ 81 __u64 reserved[16]; /* in */ 82 } __attribute__ ((__packed__)); 83 84 #define BTRFS_IOC_SET_RECEIVED_SUBVOL_32 _IOWR(BTRFS_IOCTL_MAGIC, 37, \ 85 struct btrfs_ioctl_received_subvol_args_32) 86 #endif 87 88 89 static int btrfs_clone(struct inode *src, struct inode *inode, 90 u64 off, u64 olen, u64 olen_aligned, u64 destoff); 91 92 /* Mask out flags that are inappropriate for the given type of inode. */ 93 static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags) 94 { 95 if (S_ISDIR(mode)) 96 return flags; 97 else if (S_ISREG(mode)) 98 return flags & ~FS_DIRSYNC_FL; 99 else 100 return flags & (FS_NODUMP_FL | FS_NOATIME_FL); 101 } 102 103 /* 104 * Export inode flags to the format expected by the FS_IOC_GETFLAGS ioctl. 105 */ 106 static unsigned int btrfs_flags_to_ioctl(unsigned int flags) 107 { 108 unsigned int iflags = 0; 109 110 if (flags & BTRFS_INODE_SYNC) 111 iflags |= FS_SYNC_FL; 112 if (flags & BTRFS_INODE_IMMUTABLE) 113 iflags |= FS_IMMUTABLE_FL; 114 if (flags & BTRFS_INODE_APPEND) 115 iflags |= FS_APPEND_FL; 116 if (flags & BTRFS_INODE_NODUMP) 117 iflags |= FS_NODUMP_FL; 118 if (flags & BTRFS_INODE_NOATIME) 119 iflags |= FS_NOATIME_FL; 120 if (flags & BTRFS_INODE_DIRSYNC) 121 iflags |= FS_DIRSYNC_FL; 122 if (flags & BTRFS_INODE_NODATACOW) 123 iflags |= FS_NOCOW_FL; 124 125 if ((flags & BTRFS_INODE_COMPRESS) && !(flags & BTRFS_INODE_NOCOMPRESS)) 126 iflags |= FS_COMPR_FL; 127 else if (flags & BTRFS_INODE_NOCOMPRESS) 128 iflags |= FS_NOCOMP_FL; 129 130 return iflags; 131 } 132 133 /* 134 * Update inode->i_flags based on the btrfs internal flags. 135 */ 136 void btrfs_update_iflags(struct inode *inode) 137 { 138 struct btrfs_inode *ip = BTRFS_I(inode); 139 unsigned int new_fl = 0; 140 141 if (ip->flags & BTRFS_INODE_SYNC) 142 new_fl |= S_SYNC; 143 if (ip->flags & BTRFS_INODE_IMMUTABLE) 144 new_fl |= S_IMMUTABLE; 145 if (ip->flags & BTRFS_INODE_APPEND) 146 new_fl |= S_APPEND; 147 if (ip->flags & BTRFS_INODE_NOATIME) 148 new_fl |= S_NOATIME; 149 if (ip->flags & BTRFS_INODE_DIRSYNC) 150 new_fl |= S_DIRSYNC; 151 152 set_mask_bits(&inode->i_flags, 153 S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | S_DIRSYNC, 154 new_fl); 155 } 156 157 /* 158 * Inherit flags from the parent inode. 159 * 160 * Currently only the compression flags and the cow flags are inherited. 161 */ 162 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir) 163 { 164 unsigned int flags; 165 166 if (!dir) 167 return; 168 169 flags = BTRFS_I(dir)->flags; 170 171 if (flags & BTRFS_INODE_NOCOMPRESS) { 172 BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS; 173 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; 174 } else if (flags & BTRFS_INODE_COMPRESS) { 175 BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS; 176 BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS; 177 } 178 179 if (flags & BTRFS_INODE_NODATACOW) { 180 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW; 181 if (S_ISREG(inode->i_mode)) 182 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; 183 } 184 185 btrfs_update_iflags(inode); 186 } 187 188 static int btrfs_ioctl_getflags(struct file *file, void __user *arg) 189 { 190 struct btrfs_inode *ip = BTRFS_I(file_inode(file)); 191 unsigned int flags = btrfs_flags_to_ioctl(ip->flags); 192 193 if (copy_to_user(arg, &flags, sizeof(flags))) 194 return -EFAULT; 195 return 0; 196 } 197 198 static int check_flags(unsigned int flags) 199 { 200 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \ 201 FS_NOATIME_FL | FS_NODUMP_FL | \ 202 FS_SYNC_FL | FS_DIRSYNC_FL | \ 203 FS_NOCOMP_FL | FS_COMPR_FL | 204 FS_NOCOW_FL)) 205 return -EOPNOTSUPP; 206 207 if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL)) 208 return -EINVAL; 209 210 return 0; 211 } 212 213 static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 214 { 215 struct inode *inode = file_inode(file); 216 struct btrfs_inode *ip = BTRFS_I(inode); 217 struct btrfs_root *root = ip->root; 218 struct btrfs_trans_handle *trans; 219 unsigned int flags, oldflags; 220 int ret; 221 u64 ip_oldflags; 222 unsigned int i_oldflags; 223 umode_t mode; 224 225 if (!inode_owner_or_capable(inode)) 226 return -EPERM; 227 228 if (btrfs_root_readonly(root)) 229 return -EROFS; 230 231 if (copy_from_user(&flags, arg, sizeof(flags))) 232 return -EFAULT; 233 234 ret = check_flags(flags); 235 if (ret) 236 return ret; 237 238 ret = mnt_want_write_file(file); 239 if (ret) 240 return ret; 241 242 mutex_lock(&inode->i_mutex); 243 244 ip_oldflags = ip->flags; 245 i_oldflags = inode->i_flags; 246 mode = inode->i_mode; 247 248 flags = btrfs_mask_flags(inode->i_mode, flags); 249 oldflags = btrfs_flags_to_ioctl(ip->flags); 250 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) { 251 if (!capable(CAP_LINUX_IMMUTABLE)) { 252 ret = -EPERM; 253 goto out_unlock; 254 } 255 } 256 257 if (flags & FS_SYNC_FL) 258 ip->flags |= BTRFS_INODE_SYNC; 259 else 260 ip->flags &= ~BTRFS_INODE_SYNC; 261 if (flags & FS_IMMUTABLE_FL) 262 ip->flags |= BTRFS_INODE_IMMUTABLE; 263 else 264 ip->flags &= ~BTRFS_INODE_IMMUTABLE; 265 if (flags & FS_APPEND_FL) 266 ip->flags |= BTRFS_INODE_APPEND; 267 else 268 ip->flags &= ~BTRFS_INODE_APPEND; 269 if (flags & FS_NODUMP_FL) 270 ip->flags |= BTRFS_INODE_NODUMP; 271 else 272 ip->flags &= ~BTRFS_INODE_NODUMP; 273 if (flags & FS_NOATIME_FL) 274 ip->flags |= BTRFS_INODE_NOATIME; 275 else 276 ip->flags &= ~BTRFS_INODE_NOATIME; 277 if (flags & FS_DIRSYNC_FL) 278 ip->flags |= BTRFS_INODE_DIRSYNC; 279 else 280 ip->flags &= ~BTRFS_INODE_DIRSYNC; 281 if (flags & FS_NOCOW_FL) { 282 if (S_ISREG(mode)) { 283 /* 284 * It's safe to turn csums off here, no extents exist. 285 * Otherwise we want the flag to reflect the real COW 286 * status of the file and will not set it. 287 */ 288 if (inode->i_size == 0) 289 ip->flags |= BTRFS_INODE_NODATACOW 290 | BTRFS_INODE_NODATASUM; 291 } else { 292 ip->flags |= BTRFS_INODE_NODATACOW; 293 } 294 } else { 295 /* 296 * Revert back under same assuptions as above 297 */ 298 if (S_ISREG(mode)) { 299 if (inode->i_size == 0) 300 ip->flags &= ~(BTRFS_INODE_NODATACOW 301 | BTRFS_INODE_NODATASUM); 302 } else { 303 ip->flags &= ~BTRFS_INODE_NODATACOW; 304 } 305 } 306 307 /* 308 * The COMPRESS flag can only be changed by users, while the NOCOMPRESS 309 * flag may be changed automatically if compression code won't make 310 * things smaller. 311 */ 312 if (flags & FS_NOCOMP_FL) { 313 ip->flags &= ~BTRFS_INODE_COMPRESS; 314 ip->flags |= BTRFS_INODE_NOCOMPRESS; 315 316 ret = btrfs_set_prop(inode, "btrfs.compression", NULL, 0, 0); 317 if (ret && ret != -ENODATA) 318 goto out_drop; 319 } else if (flags & FS_COMPR_FL) { 320 const char *comp; 321 322 ip->flags |= BTRFS_INODE_COMPRESS; 323 ip->flags &= ~BTRFS_INODE_NOCOMPRESS; 324 325 if (root->fs_info->compress_type == BTRFS_COMPRESS_LZO) 326 comp = "lzo"; 327 else 328 comp = "zlib"; 329 ret = btrfs_set_prop(inode, "btrfs.compression", 330 comp, strlen(comp), 0); 331 if (ret) 332 goto out_drop; 333 334 } else { 335 ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS); 336 } 337 338 trans = btrfs_start_transaction(root, 1); 339 if (IS_ERR(trans)) { 340 ret = PTR_ERR(trans); 341 goto out_drop; 342 } 343 344 btrfs_update_iflags(inode); 345 inode_inc_iversion(inode); 346 inode->i_ctime = CURRENT_TIME; 347 ret = btrfs_update_inode(trans, root, inode); 348 349 btrfs_end_transaction(trans, root); 350 out_drop: 351 if (ret) { 352 ip->flags = ip_oldflags; 353 inode->i_flags = i_oldflags; 354 } 355 356 out_unlock: 357 mutex_unlock(&inode->i_mutex); 358 mnt_drop_write_file(file); 359 return ret; 360 } 361 362 static int btrfs_ioctl_getversion(struct file *file, int __user *arg) 363 { 364 struct inode *inode = file_inode(file); 365 366 return put_user(inode->i_generation, arg); 367 } 368 369 static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg) 370 { 371 struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb); 372 struct btrfs_device *device; 373 struct request_queue *q; 374 struct fstrim_range range; 375 u64 minlen = ULLONG_MAX; 376 u64 num_devices = 0; 377 u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy); 378 int ret; 379 380 if (!capable(CAP_SYS_ADMIN)) 381 return -EPERM; 382 383 rcu_read_lock(); 384 list_for_each_entry_rcu(device, &fs_info->fs_devices->devices, 385 dev_list) { 386 if (!device->bdev) 387 continue; 388 q = bdev_get_queue(device->bdev); 389 if (blk_queue_discard(q)) { 390 num_devices++; 391 minlen = min((u64)q->limits.discard_granularity, 392 minlen); 393 } 394 } 395 rcu_read_unlock(); 396 397 if (!num_devices) 398 return -EOPNOTSUPP; 399 if (copy_from_user(&range, arg, sizeof(range))) 400 return -EFAULT; 401 if (range.start > total_bytes || 402 range.len < fs_info->sb->s_blocksize) 403 return -EINVAL; 404 405 range.len = min(range.len, total_bytes - range.start); 406 range.minlen = max(range.minlen, minlen); 407 ret = btrfs_trim_fs(fs_info->tree_root, &range); 408 if (ret < 0) 409 return ret; 410 411 if (copy_to_user(arg, &range, sizeof(range))) 412 return -EFAULT; 413 414 return 0; 415 } 416 417 int btrfs_is_empty_uuid(u8 *uuid) 418 { 419 int i; 420 421 for (i = 0; i < BTRFS_UUID_SIZE; i++) { 422 if (uuid[i]) 423 return 0; 424 } 425 return 1; 426 } 427 428 static noinline int create_subvol(struct inode *dir, 429 struct dentry *dentry, 430 char *name, int namelen, 431 u64 *async_transid, 432 struct btrfs_qgroup_inherit *inherit) 433 { 434 struct btrfs_trans_handle *trans; 435 struct btrfs_key key; 436 struct btrfs_root_item root_item; 437 struct btrfs_inode_item *inode_item; 438 struct extent_buffer *leaf; 439 struct btrfs_root *root = BTRFS_I(dir)->root; 440 struct btrfs_root *new_root; 441 struct btrfs_block_rsv block_rsv; 442 struct timespec cur_time = CURRENT_TIME; 443 struct inode *inode; 444 int ret; 445 int err; 446 u64 objectid; 447 u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID; 448 u64 index = 0; 449 u64 qgroup_reserved; 450 uuid_le new_uuid; 451 452 ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid); 453 if (ret) 454 return ret; 455 456 btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP); 457 /* 458 * The same as the snapshot creation, please see the comment 459 * of create_snapshot(). 460 */ 461 ret = btrfs_subvolume_reserve_metadata(root, &block_rsv, 462 8, &qgroup_reserved, false); 463 if (ret) 464 return ret; 465 466 trans = btrfs_start_transaction(root, 0); 467 if (IS_ERR(trans)) { 468 ret = PTR_ERR(trans); 469 btrfs_subvolume_release_metadata(root, &block_rsv, 470 qgroup_reserved); 471 return ret; 472 } 473 trans->block_rsv = &block_rsv; 474 trans->bytes_reserved = block_rsv.size; 475 476 ret = btrfs_qgroup_inherit(trans, root->fs_info, 0, objectid, inherit); 477 if (ret) 478 goto fail; 479 480 leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 481 0, objectid, NULL, 0, 0, 0); 482 if (IS_ERR(leaf)) { 483 ret = PTR_ERR(leaf); 484 goto fail; 485 } 486 487 memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header)); 488 btrfs_set_header_bytenr(leaf, leaf->start); 489 btrfs_set_header_generation(leaf, trans->transid); 490 btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV); 491 btrfs_set_header_owner(leaf, objectid); 492 493 write_extent_buffer(leaf, root->fs_info->fsid, btrfs_header_fsid(), 494 BTRFS_FSID_SIZE); 495 write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid, 496 btrfs_header_chunk_tree_uuid(leaf), 497 BTRFS_UUID_SIZE); 498 btrfs_mark_buffer_dirty(leaf); 499 500 memset(&root_item, 0, sizeof(root_item)); 501 502 inode_item = &root_item.inode; 503 btrfs_set_stack_inode_generation(inode_item, 1); 504 btrfs_set_stack_inode_size(inode_item, 3); 505 btrfs_set_stack_inode_nlink(inode_item, 1); 506 btrfs_set_stack_inode_nbytes(inode_item, root->leafsize); 507 btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755); 508 509 btrfs_set_root_flags(&root_item, 0); 510 btrfs_set_root_limit(&root_item, 0); 511 btrfs_set_stack_inode_flags(inode_item, BTRFS_INODE_ROOT_ITEM_INIT); 512 513 btrfs_set_root_bytenr(&root_item, leaf->start); 514 btrfs_set_root_generation(&root_item, trans->transid); 515 btrfs_set_root_level(&root_item, 0); 516 btrfs_set_root_refs(&root_item, 1); 517 btrfs_set_root_used(&root_item, leaf->len); 518 btrfs_set_root_last_snapshot(&root_item, 0); 519 520 btrfs_set_root_generation_v2(&root_item, 521 btrfs_root_generation(&root_item)); 522 uuid_le_gen(&new_uuid); 523 memcpy(root_item.uuid, new_uuid.b, BTRFS_UUID_SIZE); 524 btrfs_set_stack_timespec_sec(&root_item.otime, cur_time.tv_sec); 525 btrfs_set_stack_timespec_nsec(&root_item.otime, cur_time.tv_nsec); 526 root_item.ctime = root_item.otime; 527 btrfs_set_root_ctransid(&root_item, trans->transid); 528 btrfs_set_root_otransid(&root_item, trans->transid); 529 530 btrfs_tree_unlock(leaf); 531 free_extent_buffer(leaf); 532 leaf = NULL; 533 534 btrfs_set_root_dirid(&root_item, new_dirid); 535 536 key.objectid = objectid; 537 key.offset = 0; 538 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 539 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key, 540 &root_item); 541 if (ret) 542 goto fail; 543 544 key.offset = (u64)-1; 545 new_root = btrfs_read_fs_root_no_name(root->fs_info, &key); 546 if (IS_ERR(new_root)) { 547 btrfs_abort_transaction(trans, root, PTR_ERR(new_root)); 548 ret = PTR_ERR(new_root); 549 goto fail; 550 } 551 552 btrfs_record_root_in_trans(trans, new_root); 553 554 ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid); 555 if (ret) { 556 /* We potentially lose an unused inode item here */ 557 btrfs_abort_transaction(trans, root, ret); 558 goto fail; 559 } 560 561 /* 562 * insert the directory item 563 */ 564 ret = btrfs_set_inode_index(dir, &index); 565 if (ret) { 566 btrfs_abort_transaction(trans, root, ret); 567 goto fail; 568 } 569 570 ret = btrfs_insert_dir_item(trans, root, 571 name, namelen, dir, &key, 572 BTRFS_FT_DIR, index); 573 if (ret) { 574 btrfs_abort_transaction(trans, root, ret); 575 goto fail; 576 } 577 578 btrfs_i_size_write(dir, dir->i_size + namelen * 2); 579 ret = btrfs_update_inode(trans, root, dir); 580 BUG_ON(ret); 581 582 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root, 583 objectid, root->root_key.objectid, 584 btrfs_ino(dir), index, name, namelen); 585 BUG_ON(ret); 586 587 ret = btrfs_uuid_tree_add(trans, root->fs_info->uuid_root, 588 root_item.uuid, BTRFS_UUID_KEY_SUBVOL, 589 objectid); 590 if (ret) 591 btrfs_abort_transaction(trans, root, ret); 592 593 fail: 594 trans->block_rsv = NULL; 595 trans->bytes_reserved = 0; 596 btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved); 597 598 if (async_transid) { 599 *async_transid = trans->transid; 600 err = btrfs_commit_transaction_async(trans, root, 1); 601 if (err) 602 err = btrfs_commit_transaction(trans, root); 603 } else { 604 err = btrfs_commit_transaction(trans, root); 605 } 606 if (err && !ret) 607 ret = err; 608 609 if (!ret) { 610 inode = btrfs_lookup_dentry(dir, dentry); 611 if (IS_ERR(inode)) 612 return PTR_ERR(inode); 613 d_instantiate(dentry, inode); 614 } 615 return ret; 616 } 617 618 static void btrfs_wait_nocow_write(struct btrfs_root *root) 619 { 620 s64 writers; 621 DEFINE_WAIT(wait); 622 623 do { 624 prepare_to_wait(&root->subv_writers->wait, &wait, 625 TASK_UNINTERRUPTIBLE); 626 627 writers = percpu_counter_sum(&root->subv_writers->counter); 628 if (writers) 629 schedule(); 630 631 finish_wait(&root->subv_writers->wait, &wait); 632 } while (writers); 633 } 634 635 static int create_snapshot(struct btrfs_root *root, struct inode *dir, 636 struct dentry *dentry, char *name, int namelen, 637 u64 *async_transid, bool readonly, 638 struct btrfs_qgroup_inherit *inherit) 639 { 640 struct inode *inode; 641 struct btrfs_pending_snapshot *pending_snapshot; 642 struct btrfs_trans_handle *trans; 643 int ret; 644 645 if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state)) 646 return -EINVAL; 647 648 atomic_inc(&root->will_be_snapshoted); 649 smp_mb__after_atomic(); 650 btrfs_wait_nocow_write(root); 651 652 ret = btrfs_start_delalloc_inodes(root, 0); 653 if (ret) 654 goto out; 655 656 btrfs_wait_ordered_extents(root, -1); 657 658 pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS); 659 if (!pending_snapshot) { 660 ret = -ENOMEM; 661 goto out; 662 } 663 664 btrfs_init_block_rsv(&pending_snapshot->block_rsv, 665 BTRFS_BLOCK_RSV_TEMP); 666 /* 667 * 1 - parent dir inode 668 * 2 - dir entries 669 * 1 - root item 670 * 2 - root ref/backref 671 * 1 - root of snapshot 672 * 1 - UUID item 673 */ 674 ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root, 675 &pending_snapshot->block_rsv, 8, 676 &pending_snapshot->qgroup_reserved, 677 false); 678 if (ret) 679 goto free; 680 681 pending_snapshot->dentry = dentry; 682 pending_snapshot->root = root; 683 pending_snapshot->readonly = readonly; 684 pending_snapshot->dir = dir; 685 pending_snapshot->inherit = inherit; 686 687 trans = btrfs_start_transaction(root, 0); 688 if (IS_ERR(trans)) { 689 ret = PTR_ERR(trans); 690 goto fail; 691 } 692 693 spin_lock(&root->fs_info->trans_lock); 694 list_add(&pending_snapshot->list, 695 &trans->transaction->pending_snapshots); 696 spin_unlock(&root->fs_info->trans_lock); 697 if (async_transid) { 698 *async_transid = trans->transid; 699 ret = btrfs_commit_transaction_async(trans, 700 root->fs_info->extent_root, 1); 701 if (ret) 702 ret = btrfs_commit_transaction(trans, root); 703 } else { 704 ret = btrfs_commit_transaction(trans, 705 root->fs_info->extent_root); 706 } 707 if (ret) 708 goto fail; 709 710 ret = pending_snapshot->error; 711 if (ret) 712 goto fail; 713 714 ret = btrfs_orphan_cleanup(pending_snapshot->snap); 715 if (ret) 716 goto fail; 717 718 /* 719 * If orphan cleanup did remove any orphans, it means the tree was 720 * modified and therefore the commit root is not the same as the 721 * current root anymore. This is a problem, because send uses the 722 * commit root and therefore can see inode items that don't exist 723 * in the current root anymore, and for example make calls to 724 * btrfs_iget, which will do tree lookups based on the current root 725 * and not on the commit root. Those lookups will fail, returning a 726 * -ESTALE error, and making send fail with that error. So make sure 727 * a send does not see any orphans we have just removed, and that it 728 * will see the same inodes regardless of whether a transaction 729 * commit happened before it started (meaning that the commit root 730 * will be the same as the current root) or not. 731 */ 732 if (readonly && pending_snapshot->snap->node != 733 pending_snapshot->snap->commit_root) { 734 trans = btrfs_join_transaction(pending_snapshot->snap); 735 if (IS_ERR(trans) && PTR_ERR(trans) != -ENOENT) { 736 ret = PTR_ERR(trans); 737 goto fail; 738 } 739 if (!IS_ERR(trans)) { 740 ret = btrfs_commit_transaction(trans, 741 pending_snapshot->snap); 742 if (ret) 743 goto fail; 744 } 745 } 746 747 inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry); 748 if (IS_ERR(inode)) { 749 ret = PTR_ERR(inode); 750 goto fail; 751 } 752 753 d_instantiate(dentry, inode); 754 ret = 0; 755 fail: 756 btrfs_subvolume_release_metadata(BTRFS_I(dir)->root, 757 &pending_snapshot->block_rsv, 758 pending_snapshot->qgroup_reserved); 759 free: 760 kfree(pending_snapshot); 761 out: 762 atomic_dec(&root->will_be_snapshoted); 763 return ret; 764 } 765 766 /* copy of check_sticky in fs/namei.c() 767 * It's inline, so penalty for filesystems that don't use sticky bit is 768 * minimal. 769 */ 770 static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode) 771 { 772 kuid_t fsuid = current_fsuid(); 773 774 if (!(dir->i_mode & S_ISVTX)) 775 return 0; 776 if (uid_eq(inode->i_uid, fsuid)) 777 return 0; 778 if (uid_eq(dir->i_uid, fsuid)) 779 return 0; 780 return !capable(CAP_FOWNER); 781 } 782 783 /* copy of may_delete in fs/namei.c() 784 * Check whether we can remove a link victim from directory dir, check 785 * whether the type of victim is right. 786 * 1. We can't do it if dir is read-only (done in permission()) 787 * 2. We should have write and exec permissions on dir 788 * 3. We can't remove anything from append-only dir 789 * 4. We can't do anything with immutable dir (done in permission()) 790 * 5. If the sticky bit on dir is set we should either 791 * a. be owner of dir, or 792 * b. be owner of victim, or 793 * c. have CAP_FOWNER capability 794 * 6. If the victim is append-only or immutable we can't do antyhing with 795 * links pointing to it. 796 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. 797 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. 798 * 9. We can't remove a root or mountpoint. 799 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by 800 * nfs_async_unlink(). 801 */ 802 803 static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir) 804 { 805 int error; 806 807 if (!victim->d_inode) 808 return -ENOENT; 809 810 BUG_ON(victim->d_parent->d_inode != dir); 811 audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE); 812 813 error = inode_permission(dir, MAY_WRITE | MAY_EXEC); 814 if (error) 815 return error; 816 if (IS_APPEND(dir)) 817 return -EPERM; 818 if (btrfs_check_sticky(dir, victim->d_inode)|| 819 IS_APPEND(victim->d_inode)|| 820 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode)) 821 return -EPERM; 822 if (isdir) { 823 if (!S_ISDIR(victim->d_inode->i_mode)) 824 return -ENOTDIR; 825 if (IS_ROOT(victim)) 826 return -EBUSY; 827 } else if (S_ISDIR(victim->d_inode->i_mode)) 828 return -EISDIR; 829 if (IS_DEADDIR(dir)) 830 return -ENOENT; 831 if (victim->d_flags & DCACHE_NFSFS_RENAMED) 832 return -EBUSY; 833 return 0; 834 } 835 836 /* copy of may_create in fs/namei.c() */ 837 static inline int btrfs_may_create(struct inode *dir, struct dentry *child) 838 { 839 if (child->d_inode) 840 return -EEXIST; 841 if (IS_DEADDIR(dir)) 842 return -ENOENT; 843 return inode_permission(dir, MAY_WRITE | MAY_EXEC); 844 } 845 846 /* 847 * Create a new subvolume below @parent. This is largely modeled after 848 * sys_mkdirat and vfs_mkdir, but we only do a single component lookup 849 * inside this filesystem so it's quite a bit simpler. 850 */ 851 static noinline int btrfs_mksubvol(struct path *parent, 852 char *name, int namelen, 853 struct btrfs_root *snap_src, 854 u64 *async_transid, bool readonly, 855 struct btrfs_qgroup_inherit *inherit) 856 { 857 struct inode *dir = parent->dentry->d_inode; 858 struct dentry *dentry; 859 int error; 860 861 error = mutex_lock_killable_nested(&dir->i_mutex, I_MUTEX_PARENT); 862 if (error == -EINTR) 863 return error; 864 865 dentry = lookup_one_len(name, parent->dentry, namelen); 866 error = PTR_ERR(dentry); 867 if (IS_ERR(dentry)) 868 goto out_unlock; 869 870 error = -EEXIST; 871 if (dentry->d_inode) 872 goto out_dput; 873 874 error = btrfs_may_create(dir, dentry); 875 if (error) 876 goto out_dput; 877 878 /* 879 * even if this name doesn't exist, we may get hash collisions. 880 * check for them now when we can safely fail 881 */ 882 error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root, 883 dir->i_ino, name, 884 namelen); 885 if (error) 886 goto out_dput; 887 888 down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem); 889 890 if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0) 891 goto out_up_read; 892 893 if (snap_src) { 894 error = create_snapshot(snap_src, dir, dentry, name, namelen, 895 async_transid, readonly, inherit); 896 } else { 897 error = create_subvol(dir, dentry, name, namelen, 898 async_transid, inherit); 899 } 900 if (!error) 901 fsnotify_mkdir(dir, dentry); 902 out_up_read: 903 up_read(&BTRFS_I(dir)->root->fs_info->subvol_sem); 904 out_dput: 905 dput(dentry); 906 out_unlock: 907 mutex_unlock(&dir->i_mutex); 908 return error; 909 } 910 911 /* 912 * When we're defragging a range, we don't want to kick it off again 913 * if it is really just waiting for delalloc to send it down. 914 * If we find a nice big extent or delalloc range for the bytes in the 915 * file you want to defrag, we return 0 to let you know to skip this 916 * part of the file 917 */ 918 static int check_defrag_in_cache(struct inode *inode, u64 offset, int thresh) 919 { 920 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 921 struct extent_map *em = NULL; 922 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 923 u64 end; 924 925 read_lock(&em_tree->lock); 926 em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE); 927 read_unlock(&em_tree->lock); 928 929 if (em) { 930 end = extent_map_end(em); 931 free_extent_map(em); 932 if (end - offset > thresh) 933 return 0; 934 } 935 /* if we already have a nice delalloc here, just stop */ 936 thresh /= 2; 937 end = count_range_bits(io_tree, &offset, offset + thresh, 938 thresh, EXTENT_DELALLOC, 1); 939 if (end >= thresh) 940 return 0; 941 return 1; 942 } 943 944 /* 945 * helper function to walk through a file and find extents 946 * newer than a specific transid, and smaller than thresh. 947 * 948 * This is used by the defragging code to find new and small 949 * extents 950 */ 951 static int find_new_extents(struct btrfs_root *root, 952 struct inode *inode, u64 newer_than, 953 u64 *off, int thresh) 954 { 955 struct btrfs_path *path; 956 struct btrfs_key min_key; 957 struct extent_buffer *leaf; 958 struct btrfs_file_extent_item *extent; 959 int type; 960 int ret; 961 u64 ino = btrfs_ino(inode); 962 963 path = btrfs_alloc_path(); 964 if (!path) 965 return -ENOMEM; 966 967 min_key.objectid = ino; 968 min_key.type = BTRFS_EXTENT_DATA_KEY; 969 min_key.offset = *off; 970 971 while (1) { 972 path->keep_locks = 1; 973 ret = btrfs_search_forward(root, &min_key, path, newer_than); 974 if (ret != 0) 975 goto none; 976 path->keep_locks = 0; 977 btrfs_unlock_up_safe(path, 1); 978 process_slot: 979 if (min_key.objectid != ino) 980 goto none; 981 if (min_key.type != BTRFS_EXTENT_DATA_KEY) 982 goto none; 983 984 leaf = path->nodes[0]; 985 extent = btrfs_item_ptr(leaf, path->slots[0], 986 struct btrfs_file_extent_item); 987 988 type = btrfs_file_extent_type(leaf, extent); 989 if (type == BTRFS_FILE_EXTENT_REG && 990 btrfs_file_extent_num_bytes(leaf, extent) < thresh && 991 check_defrag_in_cache(inode, min_key.offset, thresh)) { 992 *off = min_key.offset; 993 btrfs_free_path(path); 994 return 0; 995 } 996 997 path->slots[0]++; 998 if (path->slots[0] < btrfs_header_nritems(leaf)) { 999 btrfs_item_key_to_cpu(leaf, &min_key, path->slots[0]); 1000 goto process_slot; 1001 } 1002 1003 if (min_key.offset == (u64)-1) 1004 goto none; 1005 1006 min_key.offset++; 1007 btrfs_release_path(path); 1008 } 1009 none: 1010 btrfs_free_path(path); 1011 return -ENOENT; 1012 } 1013 1014 static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start) 1015 { 1016 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 1017 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 1018 struct extent_map *em; 1019 u64 len = PAGE_CACHE_SIZE; 1020 1021 /* 1022 * hopefully we have this extent in the tree already, try without 1023 * the full extent lock 1024 */ 1025 read_lock(&em_tree->lock); 1026 em = lookup_extent_mapping(em_tree, start, len); 1027 read_unlock(&em_tree->lock); 1028 1029 if (!em) { 1030 struct extent_state *cached = NULL; 1031 u64 end = start + len - 1; 1032 1033 /* get the big lock and read metadata off disk */ 1034 lock_extent_bits(io_tree, start, end, 0, &cached); 1035 em = btrfs_get_extent(inode, NULL, 0, start, len, 0); 1036 unlock_extent_cached(io_tree, start, end, &cached, GFP_NOFS); 1037 1038 if (IS_ERR(em)) 1039 return NULL; 1040 } 1041 1042 return em; 1043 } 1044 1045 static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em) 1046 { 1047 struct extent_map *next; 1048 bool ret = true; 1049 1050 /* this is the last extent */ 1051 if (em->start + em->len >= i_size_read(inode)) 1052 return false; 1053 1054 next = defrag_lookup_extent(inode, em->start + em->len); 1055 if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE || 1056 (em->block_start + em->block_len == next->block_start)) 1057 ret = false; 1058 1059 free_extent_map(next); 1060 return ret; 1061 } 1062 1063 static int should_defrag_range(struct inode *inode, u64 start, int thresh, 1064 u64 *last_len, u64 *skip, u64 *defrag_end, 1065 int compress) 1066 { 1067 struct extent_map *em; 1068 int ret = 1; 1069 bool next_mergeable = true; 1070 1071 /* 1072 * make sure that once we start defragging an extent, we keep on 1073 * defragging it 1074 */ 1075 if (start < *defrag_end) 1076 return 1; 1077 1078 *skip = 0; 1079 1080 em = defrag_lookup_extent(inode, start); 1081 if (!em) 1082 return 0; 1083 1084 /* this will cover holes, and inline extents */ 1085 if (em->block_start >= EXTENT_MAP_LAST_BYTE) { 1086 ret = 0; 1087 goto out; 1088 } 1089 1090 next_mergeable = defrag_check_next_extent(inode, em); 1091 1092 /* 1093 * we hit a real extent, if it is big or the next extent is not a 1094 * real extent, don't bother defragging it 1095 */ 1096 if (!compress && (*last_len == 0 || *last_len >= thresh) && 1097 (em->len >= thresh || !next_mergeable)) 1098 ret = 0; 1099 out: 1100 /* 1101 * last_len ends up being a counter of how many bytes we've defragged. 1102 * every time we choose not to defrag an extent, we reset *last_len 1103 * so that the next tiny extent will force a defrag. 1104 * 1105 * The end result of this is that tiny extents before a single big 1106 * extent will force at least part of that big extent to be defragged. 1107 */ 1108 if (ret) { 1109 *defrag_end = extent_map_end(em); 1110 } else { 1111 *last_len = 0; 1112 *skip = extent_map_end(em); 1113 *defrag_end = 0; 1114 } 1115 1116 free_extent_map(em); 1117 return ret; 1118 } 1119 1120 /* 1121 * it doesn't do much good to defrag one or two pages 1122 * at a time. This pulls in a nice chunk of pages 1123 * to COW and defrag. 1124 * 1125 * It also makes sure the delalloc code has enough 1126 * dirty data to avoid making new small extents as part 1127 * of the defrag 1128 * 1129 * It's a good idea to start RA on this range 1130 * before calling this. 1131 */ 1132 static int cluster_pages_for_defrag(struct inode *inode, 1133 struct page **pages, 1134 unsigned long start_index, 1135 unsigned long num_pages) 1136 { 1137 unsigned long file_end; 1138 u64 isize = i_size_read(inode); 1139 u64 page_start; 1140 u64 page_end; 1141 u64 page_cnt; 1142 int ret; 1143 int i; 1144 int i_done; 1145 struct btrfs_ordered_extent *ordered; 1146 struct extent_state *cached_state = NULL; 1147 struct extent_io_tree *tree; 1148 gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping); 1149 1150 file_end = (isize - 1) >> PAGE_CACHE_SHIFT; 1151 if (!isize || start_index > file_end) 1152 return 0; 1153 1154 page_cnt = min_t(u64, (u64)num_pages, (u64)file_end - start_index + 1); 1155 1156 ret = btrfs_delalloc_reserve_space(inode, 1157 page_cnt << PAGE_CACHE_SHIFT); 1158 if (ret) 1159 return ret; 1160 i_done = 0; 1161 tree = &BTRFS_I(inode)->io_tree; 1162 1163 /* step one, lock all the pages */ 1164 for (i = 0; i < page_cnt; i++) { 1165 struct page *page; 1166 again: 1167 page = find_or_create_page(inode->i_mapping, 1168 start_index + i, mask); 1169 if (!page) 1170 break; 1171 1172 page_start = page_offset(page); 1173 page_end = page_start + PAGE_CACHE_SIZE - 1; 1174 while (1) { 1175 lock_extent_bits(tree, page_start, page_end, 1176 0, &cached_state); 1177 ordered = btrfs_lookup_ordered_extent(inode, 1178 page_start); 1179 unlock_extent_cached(tree, page_start, page_end, 1180 &cached_state, GFP_NOFS); 1181 if (!ordered) 1182 break; 1183 1184 unlock_page(page); 1185 btrfs_start_ordered_extent(inode, ordered, 1); 1186 btrfs_put_ordered_extent(ordered); 1187 lock_page(page); 1188 /* 1189 * we unlocked the page above, so we need check if 1190 * it was released or not. 1191 */ 1192 if (page->mapping != inode->i_mapping) { 1193 unlock_page(page); 1194 page_cache_release(page); 1195 goto again; 1196 } 1197 } 1198 1199 if (!PageUptodate(page)) { 1200 btrfs_readpage(NULL, page); 1201 lock_page(page); 1202 if (!PageUptodate(page)) { 1203 unlock_page(page); 1204 page_cache_release(page); 1205 ret = -EIO; 1206 break; 1207 } 1208 } 1209 1210 if (page->mapping != inode->i_mapping) { 1211 unlock_page(page); 1212 page_cache_release(page); 1213 goto again; 1214 } 1215 1216 pages[i] = page; 1217 i_done++; 1218 } 1219 if (!i_done || ret) 1220 goto out; 1221 1222 if (!(inode->i_sb->s_flags & MS_ACTIVE)) 1223 goto out; 1224 1225 /* 1226 * so now we have a nice long stream of locked 1227 * and up to date pages, lets wait on them 1228 */ 1229 for (i = 0; i < i_done; i++) 1230 wait_on_page_writeback(pages[i]); 1231 1232 page_start = page_offset(pages[0]); 1233 page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE; 1234 1235 lock_extent_bits(&BTRFS_I(inode)->io_tree, 1236 page_start, page_end - 1, 0, &cached_state); 1237 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, 1238 page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC | 1239 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0, 1240 &cached_state, GFP_NOFS); 1241 1242 if (i_done != page_cnt) { 1243 spin_lock(&BTRFS_I(inode)->lock); 1244 BTRFS_I(inode)->outstanding_extents++; 1245 spin_unlock(&BTRFS_I(inode)->lock); 1246 btrfs_delalloc_release_space(inode, 1247 (page_cnt - i_done) << PAGE_CACHE_SHIFT); 1248 } 1249 1250 1251 set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1, 1252 &cached_state, GFP_NOFS); 1253 1254 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 1255 page_start, page_end - 1, &cached_state, 1256 GFP_NOFS); 1257 1258 for (i = 0; i < i_done; i++) { 1259 clear_page_dirty_for_io(pages[i]); 1260 ClearPageChecked(pages[i]); 1261 set_page_extent_mapped(pages[i]); 1262 set_page_dirty(pages[i]); 1263 unlock_page(pages[i]); 1264 page_cache_release(pages[i]); 1265 } 1266 return i_done; 1267 out: 1268 for (i = 0; i < i_done; i++) { 1269 unlock_page(pages[i]); 1270 page_cache_release(pages[i]); 1271 } 1272 btrfs_delalloc_release_space(inode, page_cnt << PAGE_CACHE_SHIFT); 1273 return ret; 1274 1275 } 1276 1277 int btrfs_defrag_file(struct inode *inode, struct file *file, 1278 struct btrfs_ioctl_defrag_range_args *range, 1279 u64 newer_than, unsigned long max_to_defrag) 1280 { 1281 struct btrfs_root *root = BTRFS_I(inode)->root; 1282 struct file_ra_state *ra = NULL; 1283 unsigned long last_index; 1284 u64 isize = i_size_read(inode); 1285 u64 last_len = 0; 1286 u64 skip = 0; 1287 u64 defrag_end = 0; 1288 u64 newer_off = range->start; 1289 unsigned long i; 1290 unsigned long ra_index = 0; 1291 int ret; 1292 int defrag_count = 0; 1293 int compress_type = BTRFS_COMPRESS_ZLIB; 1294 int extent_thresh = range->extent_thresh; 1295 unsigned long max_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT; 1296 unsigned long cluster = max_cluster; 1297 u64 new_align = ~((u64)128 * 1024 - 1); 1298 struct page **pages = NULL; 1299 1300 if (isize == 0) 1301 return 0; 1302 1303 if (range->start >= isize) 1304 return -EINVAL; 1305 1306 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) { 1307 if (range->compress_type > BTRFS_COMPRESS_TYPES) 1308 return -EINVAL; 1309 if (range->compress_type) 1310 compress_type = range->compress_type; 1311 } 1312 1313 if (extent_thresh == 0) 1314 extent_thresh = 256 * 1024; 1315 1316 /* 1317 * if we were not given a file, allocate a readahead 1318 * context 1319 */ 1320 if (!file) { 1321 ra = kzalloc(sizeof(*ra), GFP_NOFS); 1322 if (!ra) 1323 return -ENOMEM; 1324 file_ra_state_init(ra, inode->i_mapping); 1325 } else { 1326 ra = &file->f_ra; 1327 } 1328 1329 pages = kmalloc_array(max_cluster, sizeof(struct page *), 1330 GFP_NOFS); 1331 if (!pages) { 1332 ret = -ENOMEM; 1333 goto out_ra; 1334 } 1335 1336 /* find the last page to defrag */ 1337 if (range->start + range->len > range->start) { 1338 last_index = min_t(u64, isize - 1, 1339 range->start + range->len - 1) >> PAGE_CACHE_SHIFT; 1340 } else { 1341 last_index = (isize - 1) >> PAGE_CACHE_SHIFT; 1342 } 1343 1344 if (newer_than) { 1345 ret = find_new_extents(root, inode, newer_than, 1346 &newer_off, 64 * 1024); 1347 if (!ret) { 1348 range->start = newer_off; 1349 /* 1350 * we always align our defrag to help keep 1351 * the extents in the file evenly spaced 1352 */ 1353 i = (newer_off & new_align) >> PAGE_CACHE_SHIFT; 1354 } else 1355 goto out_ra; 1356 } else { 1357 i = range->start >> PAGE_CACHE_SHIFT; 1358 } 1359 if (!max_to_defrag) 1360 max_to_defrag = last_index + 1; 1361 1362 /* 1363 * make writeback starts from i, so the defrag range can be 1364 * written sequentially. 1365 */ 1366 if (i < inode->i_mapping->writeback_index) 1367 inode->i_mapping->writeback_index = i; 1368 1369 while (i <= last_index && defrag_count < max_to_defrag && 1370 (i < (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> 1371 PAGE_CACHE_SHIFT)) { 1372 /* 1373 * make sure we stop running if someone unmounts 1374 * the FS 1375 */ 1376 if (!(inode->i_sb->s_flags & MS_ACTIVE)) 1377 break; 1378 1379 if (btrfs_defrag_cancelled(root->fs_info)) { 1380 printk(KERN_DEBUG "BTRFS: defrag_file cancelled\n"); 1381 ret = -EAGAIN; 1382 break; 1383 } 1384 1385 if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT, 1386 extent_thresh, &last_len, &skip, 1387 &defrag_end, range->flags & 1388 BTRFS_DEFRAG_RANGE_COMPRESS)) { 1389 unsigned long next; 1390 /* 1391 * the should_defrag function tells us how much to skip 1392 * bump our counter by the suggested amount 1393 */ 1394 next = (skip + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; 1395 i = max(i + 1, next); 1396 continue; 1397 } 1398 1399 if (!newer_than) { 1400 cluster = (PAGE_CACHE_ALIGN(defrag_end) >> 1401 PAGE_CACHE_SHIFT) - i; 1402 cluster = min(cluster, max_cluster); 1403 } else { 1404 cluster = max_cluster; 1405 } 1406 1407 if (i + cluster > ra_index) { 1408 ra_index = max(i, ra_index); 1409 btrfs_force_ra(inode->i_mapping, ra, file, ra_index, 1410 cluster); 1411 ra_index += max_cluster; 1412 } 1413 1414 mutex_lock(&inode->i_mutex); 1415 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) 1416 BTRFS_I(inode)->force_compress = compress_type; 1417 ret = cluster_pages_for_defrag(inode, pages, i, cluster); 1418 if (ret < 0) { 1419 mutex_unlock(&inode->i_mutex); 1420 goto out_ra; 1421 } 1422 1423 defrag_count += ret; 1424 balance_dirty_pages_ratelimited(inode->i_mapping); 1425 mutex_unlock(&inode->i_mutex); 1426 1427 if (newer_than) { 1428 if (newer_off == (u64)-1) 1429 break; 1430 1431 if (ret > 0) 1432 i += ret; 1433 1434 newer_off = max(newer_off + 1, 1435 (u64)i << PAGE_CACHE_SHIFT); 1436 1437 ret = find_new_extents(root, inode, 1438 newer_than, &newer_off, 1439 64 * 1024); 1440 if (!ret) { 1441 range->start = newer_off; 1442 i = (newer_off & new_align) >> PAGE_CACHE_SHIFT; 1443 } else { 1444 break; 1445 } 1446 } else { 1447 if (ret > 0) { 1448 i += ret; 1449 last_len += ret << PAGE_CACHE_SHIFT; 1450 } else { 1451 i++; 1452 last_len = 0; 1453 } 1454 } 1455 } 1456 1457 if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO)) { 1458 filemap_flush(inode->i_mapping); 1459 if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, 1460 &BTRFS_I(inode)->runtime_flags)) 1461 filemap_flush(inode->i_mapping); 1462 } 1463 1464 if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) { 1465 /* the filemap_flush will queue IO into the worker threads, but 1466 * we have to make sure the IO is actually started and that 1467 * ordered extents get created before we return 1468 */ 1469 atomic_inc(&root->fs_info->async_submit_draining); 1470 while (atomic_read(&root->fs_info->nr_async_submits) || 1471 atomic_read(&root->fs_info->async_delalloc_pages)) { 1472 wait_event(root->fs_info->async_submit_wait, 1473 (atomic_read(&root->fs_info->nr_async_submits) == 0 && 1474 atomic_read(&root->fs_info->async_delalloc_pages) == 0)); 1475 } 1476 atomic_dec(&root->fs_info->async_submit_draining); 1477 } 1478 1479 if (range->compress_type == BTRFS_COMPRESS_LZO) { 1480 btrfs_set_fs_incompat(root->fs_info, COMPRESS_LZO); 1481 } 1482 1483 ret = defrag_count; 1484 1485 out_ra: 1486 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) { 1487 mutex_lock(&inode->i_mutex); 1488 BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE; 1489 mutex_unlock(&inode->i_mutex); 1490 } 1491 if (!file) 1492 kfree(ra); 1493 kfree(pages); 1494 return ret; 1495 } 1496 1497 static noinline int btrfs_ioctl_resize(struct file *file, 1498 void __user *arg) 1499 { 1500 u64 new_size; 1501 u64 old_size; 1502 u64 devid = 1; 1503 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 1504 struct btrfs_ioctl_vol_args *vol_args; 1505 struct btrfs_trans_handle *trans; 1506 struct btrfs_device *device = NULL; 1507 char *sizestr; 1508 char *retptr; 1509 char *devstr = NULL; 1510 int ret = 0; 1511 int mod = 0; 1512 1513 if (!capable(CAP_SYS_ADMIN)) 1514 return -EPERM; 1515 1516 ret = mnt_want_write_file(file); 1517 if (ret) 1518 return ret; 1519 1520 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running, 1521 1)) { 1522 mnt_drop_write_file(file); 1523 return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 1524 } 1525 1526 mutex_lock(&root->fs_info->volume_mutex); 1527 vol_args = memdup_user(arg, sizeof(*vol_args)); 1528 if (IS_ERR(vol_args)) { 1529 ret = PTR_ERR(vol_args); 1530 goto out; 1531 } 1532 1533 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 1534 1535 sizestr = vol_args->name; 1536 devstr = strchr(sizestr, ':'); 1537 if (devstr) { 1538 sizestr = devstr + 1; 1539 *devstr = '\0'; 1540 devstr = vol_args->name; 1541 ret = kstrtoull(devstr, 10, &devid); 1542 if (ret) 1543 goto out_free; 1544 if (!devid) { 1545 ret = -EINVAL; 1546 goto out_free; 1547 } 1548 btrfs_info(root->fs_info, "resizing devid %llu", devid); 1549 } 1550 1551 device = btrfs_find_device(root->fs_info, devid, NULL, NULL); 1552 if (!device) { 1553 btrfs_info(root->fs_info, "resizer unable to find device %llu", 1554 devid); 1555 ret = -ENODEV; 1556 goto out_free; 1557 } 1558 1559 if (!device->writeable) { 1560 btrfs_info(root->fs_info, 1561 "resizer unable to apply on readonly device %llu", 1562 devid); 1563 ret = -EPERM; 1564 goto out_free; 1565 } 1566 1567 if (!strcmp(sizestr, "max")) 1568 new_size = device->bdev->bd_inode->i_size; 1569 else { 1570 if (sizestr[0] == '-') { 1571 mod = -1; 1572 sizestr++; 1573 } else if (sizestr[0] == '+') { 1574 mod = 1; 1575 sizestr++; 1576 } 1577 new_size = memparse(sizestr, &retptr); 1578 if (*retptr != '\0' || new_size == 0) { 1579 ret = -EINVAL; 1580 goto out_free; 1581 } 1582 } 1583 1584 if (device->is_tgtdev_for_dev_replace) { 1585 ret = -EPERM; 1586 goto out_free; 1587 } 1588 1589 old_size = device->total_bytes; 1590 1591 if (mod < 0) { 1592 if (new_size > old_size) { 1593 ret = -EINVAL; 1594 goto out_free; 1595 } 1596 new_size = old_size - new_size; 1597 } else if (mod > 0) { 1598 if (new_size > ULLONG_MAX - old_size) { 1599 ret = -ERANGE; 1600 goto out_free; 1601 } 1602 new_size = old_size + new_size; 1603 } 1604 1605 if (new_size < 256 * 1024 * 1024) { 1606 ret = -EINVAL; 1607 goto out_free; 1608 } 1609 if (new_size > device->bdev->bd_inode->i_size) { 1610 ret = -EFBIG; 1611 goto out_free; 1612 } 1613 1614 do_div(new_size, root->sectorsize); 1615 new_size *= root->sectorsize; 1616 1617 printk_in_rcu(KERN_INFO "BTRFS: new size for %s is %llu\n", 1618 rcu_str_deref(device->name), new_size); 1619 1620 if (new_size > old_size) { 1621 trans = btrfs_start_transaction(root, 0); 1622 if (IS_ERR(trans)) { 1623 ret = PTR_ERR(trans); 1624 goto out_free; 1625 } 1626 ret = btrfs_grow_device(trans, device, new_size); 1627 btrfs_commit_transaction(trans, root); 1628 } else if (new_size < old_size) { 1629 ret = btrfs_shrink_device(device, new_size); 1630 } /* equal, nothing need to do */ 1631 1632 out_free: 1633 kfree(vol_args); 1634 out: 1635 mutex_unlock(&root->fs_info->volume_mutex); 1636 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0); 1637 mnt_drop_write_file(file); 1638 return ret; 1639 } 1640 1641 static noinline int btrfs_ioctl_snap_create_transid(struct file *file, 1642 char *name, unsigned long fd, int subvol, 1643 u64 *transid, bool readonly, 1644 struct btrfs_qgroup_inherit *inherit) 1645 { 1646 int namelen; 1647 int ret = 0; 1648 1649 ret = mnt_want_write_file(file); 1650 if (ret) 1651 goto out; 1652 1653 namelen = strlen(name); 1654 if (strchr(name, '/')) { 1655 ret = -EINVAL; 1656 goto out_drop_write; 1657 } 1658 1659 if (name[0] == '.' && 1660 (namelen == 1 || (name[1] == '.' && namelen == 2))) { 1661 ret = -EEXIST; 1662 goto out_drop_write; 1663 } 1664 1665 if (subvol) { 1666 ret = btrfs_mksubvol(&file->f_path, name, namelen, 1667 NULL, transid, readonly, inherit); 1668 } else { 1669 struct fd src = fdget(fd); 1670 struct inode *src_inode; 1671 if (!src.file) { 1672 ret = -EINVAL; 1673 goto out_drop_write; 1674 } 1675 1676 src_inode = file_inode(src.file); 1677 if (src_inode->i_sb != file_inode(file)->i_sb) { 1678 btrfs_info(BTRFS_I(src_inode)->root->fs_info, 1679 "Snapshot src from another FS"); 1680 ret = -EXDEV; 1681 } else if (!inode_owner_or_capable(src_inode)) { 1682 /* 1683 * Subvolume creation is not restricted, but snapshots 1684 * are limited to own subvolumes only 1685 */ 1686 ret = -EPERM; 1687 } else { 1688 ret = btrfs_mksubvol(&file->f_path, name, namelen, 1689 BTRFS_I(src_inode)->root, 1690 transid, readonly, inherit); 1691 } 1692 fdput(src); 1693 } 1694 out_drop_write: 1695 mnt_drop_write_file(file); 1696 out: 1697 return ret; 1698 } 1699 1700 static noinline int btrfs_ioctl_snap_create(struct file *file, 1701 void __user *arg, int subvol) 1702 { 1703 struct btrfs_ioctl_vol_args *vol_args; 1704 int ret; 1705 1706 vol_args = memdup_user(arg, sizeof(*vol_args)); 1707 if (IS_ERR(vol_args)) 1708 return PTR_ERR(vol_args); 1709 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 1710 1711 ret = btrfs_ioctl_snap_create_transid(file, vol_args->name, 1712 vol_args->fd, subvol, 1713 NULL, false, NULL); 1714 1715 kfree(vol_args); 1716 return ret; 1717 } 1718 1719 static noinline int btrfs_ioctl_snap_create_v2(struct file *file, 1720 void __user *arg, int subvol) 1721 { 1722 struct btrfs_ioctl_vol_args_v2 *vol_args; 1723 int ret; 1724 u64 transid = 0; 1725 u64 *ptr = NULL; 1726 bool readonly = false; 1727 struct btrfs_qgroup_inherit *inherit = NULL; 1728 1729 vol_args = memdup_user(arg, sizeof(*vol_args)); 1730 if (IS_ERR(vol_args)) 1731 return PTR_ERR(vol_args); 1732 vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0'; 1733 1734 if (vol_args->flags & 1735 ~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY | 1736 BTRFS_SUBVOL_QGROUP_INHERIT)) { 1737 ret = -EOPNOTSUPP; 1738 goto out; 1739 } 1740 1741 if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC) 1742 ptr = &transid; 1743 if (vol_args->flags & BTRFS_SUBVOL_RDONLY) 1744 readonly = true; 1745 if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) { 1746 if (vol_args->size > PAGE_CACHE_SIZE) { 1747 ret = -EINVAL; 1748 goto out; 1749 } 1750 inherit = memdup_user(vol_args->qgroup_inherit, vol_args->size); 1751 if (IS_ERR(inherit)) { 1752 ret = PTR_ERR(inherit); 1753 goto out; 1754 } 1755 } 1756 1757 ret = btrfs_ioctl_snap_create_transid(file, vol_args->name, 1758 vol_args->fd, subvol, ptr, 1759 readonly, inherit); 1760 1761 if (ret == 0 && ptr && 1762 copy_to_user(arg + 1763 offsetof(struct btrfs_ioctl_vol_args_v2, 1764 transid), ptr, sizeof(*ptr))) 1765 ret = -EFAULT; 1766 out: 1767 kfree(vol_args); 1768 kfree(inherit); 1769 return ret; 1770 } 1771 1772 static noinline int btrfs_ioctl_subvol_getflags(struct file *file, 1773 void __user *arg) 1774 { 1775 struct inode *inode = file_inode(file); 1776 struct btrfs_root *root = BTRFS_I(inode)->root; 1777 int ret = 0; 1778 u64 flags = 0; 1779 1780 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) 1781 return -EINVAL; 1782 1783 down_read(&root->fs_info->subvol_sem); 1784 if (btrfs_root_readonly(root)) 1785 flags |= BTRFS_SUBVOL_RDONLY; 1786 up_read(&root->fs_info->subvol_sem); 1787 1788 if (copy_to_user(arg, &flags, sizeof(flags))) 1789 ret = -EFAULT; 1790 1791 return ret; 1792 } 1793 1794 static noinline int btrfs_ioctl_subvol_setflags(struct file *file, 1795 void __user *arg) 1796 { 1797 struct inode *inode = file_inode(file); 1798 struct btrfs_root *root = BTRFS_I(inode)->root; 1799 struct btrfs_trans_handle *trans; 1800 u64 root_flags; 1801 u64 flags; 1802 int ret = 0; 1803 1804 if (!inode_owner_or_capable(inode)) 1805 return -EPERM; 1806 1807 ret = mnt_want_write_file(file); 1808 if (ret) 1809 goto out; 1810 1811 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) { 1812 ret = -EINVAL; 1813 goto out_drop_write; 1814 } 1815 1816 if (copy_from_user(&flags, arg, sizeof(flags))) { 1817 ret = -EFAULT; 1818 goto out_drop_write; 1819 } 1820 1821 if (flags & BTRFS_SUBVOL_CREATE_ASYNC) { 1822 ret = -EINVAL; 1823 goto out_drop_write; 1824 } 1825 1826 if (flags & ~BTRFS_SUBVOL_RDONLY) { 1827 ret = -EOPNOTSUPP; 1828 goto out_drop_write; 1829 } 1830 1831 down_write(&root->fs_info->subvol_sem); 1832 1833 /* nothing to do */ 1834 if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root)) 1835 goto out_drop_sem; 1836 1837 root_flags = btrfs_root_flags(&root->root_item); 1838 if (flags & BTRFS_SUBVOL_RDONLY) { 1839 btrfs_set_root_flags(&root->root_item, 1840 root_flags | BTRFS_ROOT_SUBVOL_RDONLY); 1841 } else { 1842 /* 1843 * Block RO -> RW transition if this subvolume is involved in 1844 * send 1845 */ 1846 spin_lock(&root->root_item_lock); 1847 if (root->send_in_progress == 0) { 1848 btrfs_set_root_flags(&root->root_item, 1849 root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY); 1850 spin_unlock(&root->root_item_lock); 1851 } else { 1852 spin_unlock(&root->root_item_lock); 1853 btrfs_warn(root->fs_info, 1854 "Attempt to set subvolume %llu read-write during send", 1855 root->root_key.objectid); 1856 ret = -EPERM; 1857 goto out_drop_sem; 1858 } 1859 } 1860 1861 trans = btrfs_start_transaction(root, 1); 1862 if (IS_ERR(trans)) { 1863 ret = PTR_ERR(trans); 1864 goto out_reset; 1865 } 1866 1867 ret = btrfs_update_root(trans, root->fs_info->tree_root, 1868 &root->root_key, &root->root_item); 1869 1870 btrfs_commit_transaction(trans, root); 1871 out_reset: 1872 if (ret) 1873 btrfs_set_root_flags(&root->root_item, root_flags); 1874 out_drop_sem: 1875 up_write(&root->fs_info->subvol_sem); 1876 out_drop_write: 1877 mnt_drop_write_file(file); 1878 out: 1879 return ret; 1880 } 1881 1882 /* 1883 * helper to check if the subvolume references other subvolumes 1884 */ 1885 static noinline int may_destroy_subvol(struct btrfs_root *root) 1886 { 1887 struct btrfs_path *path; 1888 struct btrfs_dir_item *di; 1889 struct btrfs_key key; 1890 u64 dir_id; 1891 int ret; 1892 1893 path = btrfs_alloc_path(); 1894 if (!path) 1895 return -ENOMEM; 1896 1897 /* Make sure this root isn't set as the default subvol */ 1898 dir_id = btrfs_super_root_dir(root->fs_info->super_copy); 1899 di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root, path, 1900 dir_id, "default", 7, 0); 1901 if (di && !IS_ERR(di)) { 1902 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key); 1903 if (key.objectid == root->root_key.objectid) { 1904 ret = -EPERM; 1905 btrfs_err(root->fs_info, "deleting default subvolume " 1906 "%llu is not allowed", key.objectid); 1907 goto out; 1908 } 1909 btrfs_release_path(path); 1910 } 1911 1912 key.objectid = root->root_key.objectid; 1913 key.type = BTRFS_ROOT_REF_KEY; 1914 key.offset = (u64)-1; 1915 1916 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, 1917 &key, path, 0, 0); 1918 if (ret < 0) 1919 goto out; 1920 BUG_ON(ret == 0); 1921 1922 ret = 0; 1923 if (path->slots[0] > 0) { 1924 path->slots[0]--; 1925 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 1926 if (key.objectid == root->root_key.objectid && 1927 key.type == BTRFS_ROOT_REF_KEY) 1928 ret = -ENOTEMPTY; 1929 } 1930 out: 1931 btrfs_free_path(path); 1932 return ret; 1933 } 1934 1935 static noinline int key_in_sk(struct btrfs_key *key, 1936 struct btrfs_ioctl_search_key *sk) 1937 { 1938 struct btrfs_key test; 1939 int ret; 1940 1941 test.objectid = sk->min_objectid; 1942 test.type = sk->min_type; 1943 test.offset = sk->min_offset; 1944 1945 ret = btrfs_comp_cpu_keys(key, &test); 1946 if (ret < 0) 1947 return 0; 1948 1949 test.objectid = sk->max_objectid; 1950 test.type = sk->max_type; 1951 test.offset = sk->max_offset; 1952 1953 ret = btrfs_comp_cpu_keys(key, &test); 1954 if (ret > 0) 1955 return 0; 1956 return 1; 1957 } 1958 1959 static noinline int copy_to_sk(struct btrfs_root *root, 1960 struct btrfs_path *path, 1961 struct btrfs_key *key, 1962 struct btrfs_ioctl_search_key *sk, 1963 size_t *buf_size, 1964 char __user *ubuf, 1965 unsigned long *sk_offset, 1966 int *num_found) 1967 { 1968 u64 found_transid; 1969 struct extent_buffer *leaf; 1970 struct btrfs_ioctl_search_header sh; 1971 unsigned long item_off; 1972 unsigned long item_len; 1973 int nritems; 1974 int i; 1975 int slot; 1976 int ret = 0; 1977 1978 leaf = path->nodes[0]; 1979 slot = path->slots[0]; 1980 nritems = btrfs_header_nritems(leaf); 1981 1982 if (btrfs_header_generation(leaf) > sk->max_transid) { 1983 i = nritems; 1984 goto advance_key; 1985 } 1986 found_transid = btrfs_header_generation(leaf); 1987 1988 for (i = slot; i < nritems; i++) { 1989 item_off = btrfs_item_ptr_offset(leaf, i); 1990 item_len = btrfs_item_size_nr(leaf, i); 1991 1992 btrfs_item_key_to_cpu(leaf, key, i); 1993 if (!key_in_sk(key, sk)) 1994 continue; 1995 1996 if (sizeof(sh) + item_len > *buf_size) { 1997 if (*num_found) { 1998 ret = 1; 1999 goto out; 2000 } 2001 2002 /* 2003 * return one empty item back for v1, which does not 2004 * handle -EOVERFLOW 2005 */ 2006 2007 *buf_size = sizeof(sh) + item_len; 2008 item_len = 0; 2009 ret = -EOVERFLOW; 2010 } 2011 2012 if (sizeof(sh) + item_len + *sk_offset > *buf_size) { 2013 ret = 1; 2014 goto out; 2015 } 2016 2017 sh.objectid = key->objectid; 2018 sh.offset = key->offset; 2019 sh.type = key->type; 2020 sh.len = item_len; 2021 sh.transid = found_transid; 2022 2023 /* copy search result header */ 2024 if (copy_to_user(ubuf + *sk_offset, &sh, sizeof(sh))) { 2025 ret = -EFAULT; 2026 goto out; 2027 } 2028 2029 *sk_offset += sizeof(sh); 2030 2031 if (item_len) { 2032 char __user *up = ubuf + *sk_offset; 2033 /* copy the item */ 2034 if (read_extent_buffer_to_user(leaf, up, 2035 item_off, item_len)) { 2036 ret = -EFAULT; 2037 goto out; 2038 } 2039 2040 *sk_offset += item_len; 2041 } 2042 (*num_found)++; 2043 2044 if (ret) /* -EOVERFLOW from above */ 2045 goto out; 2046 2047 if (*num_found >= sk->nr_items) { 2048 ret = 1; 2049 goto out; 2050 } 2051 } 2052 advance_key: 2053 ret = 0; 2054 if (key->offset < (u64)-1 && key->offset < sk->max_offset) 2055 key->offset++; 2056 else if (key->type < (u8)-1 && key->type < sk->max_type) { 2057 key->offset = 0; 2058 key->type++; 2059 } else if (key->objectid < (u64)-1 && key->objectid < sk->max_objectid) { 2060 key->offset = 0; 2061 key->type = 0; 2062 key->objectid++; 2063 } else 2064 ret = 1; 2065 out: 2066 /* 2067 * 0: all items from this leaf copied, continue with next 2068 * 1: * more items can be copied, but unused buffer is too small 2069 * * all items were found 2070 * Either way, it will stops the loop which iterates to the next 2071 * leaf 2072 * -EOVERFLOW: item was to large for buffer 2073 * -EFAULT: could not copy extent buffer back to userspace 2074 */ 2075 return ret; 2076 } 2077 2078 static noinline int search_ioctl(struct inode *inode, 2079 struct btrfs_ioctl_search_key *sk, 2080 size_t *buf_size, 2081 char __user *ubuf) 2082 { 2083 struct btrfs_root *root; 2084 struct btrfs_key key; 2085 struct btrfs_path *path; 2086 struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info; 2087 int ret; 2088 int num_found = 0; 2089 unsigned long sk_offset = 0; 2090 2091 if (*buf_size < sizeof(struct btrfs_ioctl_search_header)) { 2092 *buf_size = sizeof(struct btrfs_ioctl_search_header); 2093 return -EOVERFLOW; 2094 } 2095 2096 path = btrfs_alloc_path(); 2097 if (!path) 2098 return -ENOMEM; 2099 2100 if (sk->tree_id == 0) { 2101 /* search the root of the inode that was passed */ 2102 root = BTRFS_I(inode)->root; 2103 } else { 2104 key.objectid = sk->tree_id; 2105 key.type = BTRFS_ROOT_ITEM_KEY; 2106 key.offset = (u64)-1; 2107 root = btrfs_read_fs_root_no_name(info, &key); 2108 if (IS_ERR(root)) { 2109 printk(KERN_ERR "BTRFS: could not find root %llu\n", 2110 sk->tree_id); 2111 btrfs_free_path(path); 2112 return -ENOENT; 2113 } 2114 } 2115 2116 key.objectid = sk->min_objectid; 2117 key.type = sk->min_type; 2118 key.offset = sk->min_offset; 2119 2120 path->keep_locks = 1; 2121 2122 while (1) { 2123 ret = btrfs_search_forward(root, &key, path, sk->min_transid); 2124 if (ret != 0) { 2125 if (ret > 0) 2126 ret = 0; 2127 goto err; 2128 } 2129 ret = copy_to_sk(root, path, &key, sk, buf_size, ubuf, 2130 &sk_offset, &num_found); 2131 btrfs_release_path(path); 2132 if (ret) 2133 break; 2134 2135 } 2136 if (ret > 0) 2137 ret = 0; 2138 err: 2139 sk->nr_items = num_found; 2140 btrfs_free_path(path); 2141 return ret; 2142 } 2143 2144 static noinline int btrfs_ioctl_tree_search(struct file *file, 2145 void __user *argp) 2146 { 2147 struct btrfs_ioctl_search_args __user *uargs; 2148 struct btrfs_ioctl_search_key sk; 2149 struct inode *inode; 2150 int ret; 2151 size_t buf_size; 2152 2153 if (!capable(CAP_SYS_ADMIN)) 2154 return -EPERM; 2155 2156 uargs = (struct btrfs_ioctl_search_args __user *)argp; 2157 2158 if (copy_from_user(&sk, &uargs->key, sizeof(sk))) 2159 return -EFAULT; 2160 2161 buf_size = sizeof(uargs->buf); 2162 2163 inode = file_inode(file); 2164 ret = search_ioctl(inode, &sk, &buf_size, uargs->buf); 2165 2166 /* 2167 * In the origin implementation an overflow is handled by returning a 2168 * search header with a len of zero, so reset ret. 2169 */ 2170 if (ret == -EOVERFLOW) 2171 ret = 0; 2172 2173 if (ret == 0 && copy_to_user(&uargs->key, &sk, sizeof(sk))) 2174 ret = -EFAULT; 2175 return ret; 2176 } 2177 2178 static noinline int btrfs_ioctl_tree_search_v2(struct file *file, 2179 void __user *argp) 2180 { 2181 struct btrfs_ioctl_search_args_v2 __user *uarg; 2182 struct btrfs_ioctl_search_args_v2 args; 2183 struct inode *inode; 2184 int ret; 2185 size_t buf_size; 2186 const size_t buf_limit = 16 * 1024 * 1024; 2187 2188 if (!capable(CAP_SYS_ADMIN)) 2189 return -EPERM; 2190 2191 /* copy search header and buffer size */ 2192 uarg = (struct btrfs_ioctl_search_args_v2 __user *)argp; 2193 if (copy_from_user(&args, uarg, sizeof(args))) 2194 return -EFAULT; 2195 2196 buf_size = args.buf_size; 2197 2198 if (buf_size < sizeof(struct btrfs_ioctl_search_header)) 2199 return -EOVERFLOW; 2200 2201 /* limit result size to 16MB */ 2202 if (buf_size > buf_limit) 2203 buf_size = buf_limit; 2204 2205 inode = file_inode(file); 2206 ret = search_ioctl(inode, &args.key, &buf_size, 2207 (char *)(&uarg->buf[0])); 2208 if (ret == 0 && copy_to_user(&uarg->key, &args.key, sizeof(args.key))) 2209 ret = -EFAULT; 2210 else if (ret == -EOVERFLOW && 2211 copy_to_user(&uarg->buf_size, &buf_size, sizeof(buf_size))) 2212 ret = -EFAULT; 2213 2214 return ret; 2215 } 2216 2217 /* 2218 * Search INODE_REFs to identify path name of 'dirid' directory 2219 * in a 'tree_id' tree. and sets path name to 'name'. 2220 */ 2221 static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, 2222 u64 tree_id, u64 dirid, char *name) 2223 { 2224 struct btrfs_root *root; 2225 struct btrfs_key key; 2226 char *ptr; 2227 int ret = -1; 2228 int slot; 2229 int len; 2230 int total_len = 0; 2231 struct btrfs_inode_ref *iref; 2232 struct extent_buffer *l; 2233 struct btrfs_path *path; 2234 2235 if (dirid == BTRFS_FIRST_FREE_OBJECTID) { 2236 name[0]='\0'; 2237 return 0; 2238 } 2239 2240 path = btrfs_alloc_path(); 2241 if (!path) 2242 return -ENOMEM; 2243 2244 ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX]; 2245 2246 key.objectid = tree_id; 2247 key.type = BTRFS_ROOT_ITEM_KEY; 2248 key.offset = (u64)-1; 2249 root = btrfs_read_fs_root_no_name(info, &key); 2250 if (IS_ERR(root)) { 2251 printk(KERN_ERR "BTRFS: could not find root %llu\n", tree_id); 2252 ret = -ENOENT; 2253 goto out; 2254 } 2255 2256 key.objectid = dirid; 2257 key.type = BTRFS_INODE_REF_KEY; 2258 key.offset = (u64)-1; 2259 2260 while (1) { 2261 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 2262 if (ret < 0) 2263 goto out; 2264 else if (ret > 0) { 2265 ret = btrfs_previous_item(root, path, dirid, 2266 BTRFS_INODE_REF_KEY); 2267 if (ret < 0) 2268 goto out; 2269 else if (ret > 0) { 2270 ret = -ENOENT; 2271 goto out; 2272 } 2273 } 2274 2275 l = path->nodes[0]; 2276 slot = path->slots[0]; 2277 btrfs_item_key_to_cpu(l, &key, slot); 2278 2279 iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref); 2280 len = btrfs_inode_ref_name_len(l, iref); 2281 ptr -= len + 1; 2282 total_len += len + 1; 2283 if (ptr < name) { 2284 ret = -ENAMETOOLONG; 2285 goto out; 2286 } 2287 2288 *(ptr + len) = '/'; 2289 read_extent_buffer(l, ptr, (unsigned long)(iref + 1), len); 2290 2291 if (key.offset == BTRFS_FIRST_FREE_OBJECTID) 2292 break; 2293 2294 btrfs_release_path(path); 2295 key.objectid = key.offset; 2296 key.offset = (u64)-1; 2297 dirid = key.objectid; 2298 } 2299 memmove(name, ptr, total_len); 2300 name[total_len] = '\0'; 2301 ret = 0; 2302 out: 2303 btrfs_free_path(path); 2304 return ret; 2305 } 2306 2307 static noinline int btrfs_ioctl_ino_lookup(struct file *file, 2308 void __user *argp) 2309 { 2310 struct btrfs_ioctl_ino_lookup_args *args; 2311 struct inode *inode; 2312 int ret; 2313 2314 if (!capable(CAP_SYS_ADMIN)) 2315 return -EPERM; 2316 2317 args = memdup_user(argp, sizeof(*args)); 2318 if (IS_ERR(args)) 2319 return PTR_ERR(args); 2320 2321 inode = file_inode(file); 2322 2323 if (args->treeid == 0) 2324 args->treeid = BTRFS_I(inode)->root->root_key.objectid; 2325 2326 ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info, 2327 args->treeid, args->objectid, 2328 args->name); 2329 2330 if (ret == 0 && copy_to_user(argp, args, sizeof(*args))) 2331 ret = -EFAULT; 2332 2333 kfree(args); 2334 return ret; 2335 } 2336 2337 static noinline int btrfs_ioctl_snap_destroy(struct file *file, 2338 void __user *arg) 2339 { 2340 struct dentry *parent = file->f_path.dentry; 2341 struct dentry *dentry; 2342 struct inode *dir = parent->d_inode; 2343 struct inode *inode; 2344 struct btrfs_root *root = BTRFS_I(dir)->root; 2345 struct btrfs_root *dest = NULL; 2346 struct btrfs_ioctl_vol_args *vol_args; 2347 struct btrfs_trans_handle *trans; 2348 struct btrfs_block_rsv block_rsv; 2349 u64 root_flags; 2350 u64 qgroup_reserved; 2351 int namelen; 2352 int ret; 2353 int err = 0; 2354 2355 vol_args = memdup_user(arg, sizeof(*vol_args)); 2356 if (IS_ERR(vol_args)) 2357 return PTR_ERR(vol_args); 2358 2359 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 2360 namelen = strlen(vol_args->name); 2361 if (strchr(vol_args->name, '/') || 2362 strncmp(vol_args->name, "..", namelen) == 0) { 2363 err = -EINVAL; 2364 goto out; 2365 } 2366 2367 err = mnt_want_write_file(file); 2368 if (err) 2369 goto out; 2370 2371 2372 err = mutex_lock_killable_nested(&dir->i_mutex, I_MUTEX_PARENT); 2373 if (err == -EINTR) 2374 goto out_drop_write; 2375 dentry = lookup_one_len(vol_args->name, parent, namelen); 2376 if (IS_ERR(dentry)) { 2377 err = PTR_ERR(dentry); 2378 goto out_unlock_dir; 2379 } 2380 2381 if (!dentry->d_inode) { 2382 err = -ENOENT; 2383 goto out_dput; 2384 } 2385 2386 inode = dentry->d_inode; 2387 dest = BTRFS_I(inode)->root; 2388 if (!capable(CAP_SYS_ADMIN)) { 2389 /* 2390 * Regular user. Only allow this with a special mount 2391 * option, when the user has write+exec access to the 2392 * subvol root, and when rmdir(2) would have been 2393 * allowed. 2394 * 2395 * Note that this is _not_ check that the subvol is 2396 * empty or doesn't contain data that we wouldn't 2397 * otherwise be able to delete. 2398 * 2399 * Users who want to delete empty subvols should try 2400 * rmdir(2). 2401 */ 2402 err = -EPERM; 2403 if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED)) 2404 goto out_dput; 2405 2406 /* 2407 * Do not allow deletion if the parent dir is the same 2408 * as the dir to be deleted. That means the ioctl 2409 * must be called on the dentry referencing the root 2410 * of the subvol, not a random directory contained 2411 * within it. 2412 */ 2413 err = -EINVAL; 2414 if (root == dest) 2415 goto out_dput; 2416 2417 err = inode_permission(inode, MAY_WRITE | MAY_EXEC); 2418 if (err) 2419 goto out_dput; 2420 } 2421 2422 /* check if subvolume may be deleted by a user */ 2423 err = btrfs_may_delete(dir, dentry, 1); 2424 if (err) 2425 goto out_dput; 2426 2427 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) { 2428 err = -EINVAL; 2429 goto out_dput; 2430 } 2431 2432 mutex_lock(&inode->i_mutex); 2433 2434 /* 2435 * Don't allow to delete a subvolume with send in progress. This is 2436 * inside the i_mutex so the error handling that has to drop the bit 2437 * again is not run concurrently. 2438 */ 2439 spin_lock(&dest->root_item_lock); 2440 root_flags = btrfs_root_flags(&dest->root_item); 2441 if (dest->send_in_progress == 0) { 2442 btrfs_set_root_flags(&dest->root_item, 2443 root_flags | BTRFS_ROOT_SUBVOL_DEAD); 2444 spin_unlock(&dest->root_item_lock); 2445 } else { 2446 spin_unlock(&dest->root_item_lock); 2447 btrfs_warn(root->fs_info, 2448 "Attempt to delete subvolume %llu during send", 2449 dest->root_key.objectid); 2450 err = -EPERM; 2451 goto out_dput; 2452 } 2453 2454 err = d_invalidate(dentry); 2455 if (err) 2456 goto out_unlock; 2457 2458 down_write(&root->fs_info->subvol_sem); 2459 2460 err = may_destroy_subvol(dest); 2461 if (err) 2462 goto out_up_write; 2463 2464 btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP); 2465 /* 2466 * One for dir inode, two for dir entries, two for root 2467 * ref/backref. 2468 */ 2469 err = btrfs_subvolume_reserve_metadata(root, &block_rsv, 2470 5, &qgroup_reserved, true); 2471 if (err) 2472 goto out_up_write; 2473 2474 trans = btrfs_start_transaction(root, 0); 2475 if (IS_ERR(trans)) { 2476 err = PTR_ERR(trans); 2477 goto out_release; 2478 } 2479 trans->block_rsv = &block_rsv; 2480 trans->bytes_reserved = block_rsv.size; 2481 2482 ret = btrfs_unlink_subvol(trans, root, dir, 2483 dest->root_key.objectid, 2484 dentry->d_name.name, 2485 dentry->d_name.len); 2486 if (ret) { 2487 err = ret; 2488 btrfs_abort_transaction(trans, root, ret); 2489 goto out_end_trans; 2490 } 2491 2492 btrfs_record_root_in_trans(trans, dest); 2493 2494 memset(&dest->root_item.drop_progress, 0, 2495 sizeof(dest->root_item.drop_progress)); 2496 dest->root_item.drop_level = 0; 2497 btrfs_set_root_refs(&dest->root_item, 0); 2498 2499 if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) { 2500 ret = btrfs_insert_orphan_item(trans, 2501 root->fs_info->tree_root, 2502 dest->root_key.objectid); 2503 if (ret) { 2504 btrfs_abort_transaction(trans, root, ret); 2505 err = ret; 2506 goto out_end_trans; 2507 } 2508 } 2509 2510 ret = btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root, 2511 dest->root_item.uuid, BTRFS_UUID_KEY_SUBVOL, 2512 dest->root_key.objectid); 2513 if (ret && ret != -ENOENT) { 2514 btrfs_abort_transaction(trans, root, ret); 2515 err = ret; 2516 goto out_end_trans; 2517 } 2518 if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) { 2519 ret = btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root, 2520 dest->root_item.received_uuid, 2521 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 2522 dest->root_key.objectid); 2523 if (ret && ret != -ENOENT) { 2524 btrfs_abort_transaction(trans, root, ret); 2525 err = ret; 2526 goto out_end_trans; 2527 } 2528 } 2529 2530 out_end_trans: 2531 trans->block_rsv = NULL; 2532 trans->bytes_reserved = 0; 2533 ret = btrfs_end_transaction(trans, root); 2534 if (ret && !err) 2535 err = ret; 2536 inode->i_flags |= S_DEAD; 2537 out_release: 2538 btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved); 2539 out_up_write: 2540 up_write(&root->fs_info->subvol_sem); 2541 out_unlock: 2542 if (err) { 2543 spin_lock(&dest->root_item_lock); 2544 root_flags = btrfs_root_flags(&dest->root_item); 2545 btrfs_set_root_flags(&dest->root_item, 2546 root_flags & ~BTRFS_ROOT_SUBVOL_DEAD); 2547 spin_unlock(&dest->root_item_lock); 2548 } 2549 mutex_unlock(&inode->i_mutex); 2550 if (!err) { 2551 shrink_dcache_sb(root->fs_info->sb); 2552 btrfs_invalidate_inodes(dest); 2553 d_delete(dentry); 2554 ASSERT(dest->send_in_progress == 0); 2555 2556 /* the last ref */ 2557 if (dest->cache_inode) { 2558 iput(dest->cache_inode); 2559 dest->cache_inode = NULL; 2560 } 2561 } 2562 out_dput: 2563 dput(dentry); 2564 out_unlock_dir: 2565 mutex_unlock(&dir->i_mutex); 2566 out_drop_write: 2567 mnt_drop_write_file(file); 2568 out: 2569 kfree(vol_args); 2570 return err; 2571 } 2572 2573 static int btrfs_ioctl_defrag(struct file *file, void __user *argp) 2574 { 2575 struct inode *inode = file_inode(file); 2576 struct btrfs_root *root = BTRFS_I(inode)->root; 2577 struct btrfs_ioctl_defrag_range_args *range; 2578 int ret; 2579 2580 ret = mnt_want_write_file(file); 2581 if (ret) 2582 return ret; 2583 2584 if (btrfs_root_readonly(root)) { 2585 ret = -EROFS; 2586 goto out; 2587 } 2588 2589 switch (inode->i_mode & S_IFMT) { 2590 case S_IFDIR: 2591 if (!capable(CAP_SYS_ADMIN)) { 2592 ret = -EPERM; 2593 goto out; 2594 } 2595 ret = btrfs_defrag_root(root); 2596 if (ret) 2597 goto out; 2598 ret = btrfs_defrag_root(root->fs_info->extent_root); 2599 break; 2600 case S_IFREG: 2601 if (!(file->f_mode & FMODE_WRITE)) { 2602 ret = -EINVAL; 2603 goto out; 2604 } 2605 2606 range = kzalloc(sizeof(*range), GFP_KERNEL); 2607 if (!range) { 2608 ret = -ENOMEM; 2609 goto out; 2610 } 2611 2612 if (argp) { 2613 if (copy_from_user(range, argp, 2614 sizeof(*range))) { 2615 ret = -EFAULT; 2616 kfree(range); 2617 goto out; 2618 } 2619 /* compression requires us to start the IO */ 2620 if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) { 2621 range->flags |= BTRFS_DEFRAG_RANGE_START_IO; 2622 range->extent_thresh = (u32)-1; 2623 } 2624 } else { 2625 /* the rest are all set to zero by kzalloc */ 2626 range->len = (u64)-1; 2627 } 2628 ret = btrfs_defrag_file(file_inode(file), file, 2629 range, 0, 0); 2630 if (ret > 0) 2631 ret = 0; 2632 kfree(range); 2633 break; 2634 default: 2635 ret = -EINVAL; 2636 } 2637 out: 2638 mnt_drop_write_file(file); 2639 return ret; 2640 } 2641 2642 static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg) 2643 { 2644 struct btrfs_ioctl_vol_args *vol_args; 2645 int ret; 2646 2647 if (!capable(CAP_SYS_ADMIN)) 2648 return -EPERM; 2649 2650 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running, 2651 1)) { 2652 return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 2653 } 2654 2655 mutex_lock(&root->fs_info->volume_mutex); 2656 vol_args = memdup_user(arg, sizeof(*vol_args)); 2657 if (IS_ERR(vol_args)) { 2658 ret = PTR_ERR(vol_args); 2659 goto out; 2660 } 2661 2662 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 2663 ret = btrfs_init_new_device(root, vol_args->name); 2664 2665 kfree(vol_args); 2666 out: 2667 mutex_unlock(&root->fs_info->volume_mutex); 2668 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0); 2669 return ret; 2670 } 2671 2672 static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg) 2673 { 2674 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 2675 struct btrfs_ioctl_vol_args *vol_args; 2676 int ret; 2677 2678 if (!capable(CAP_SYS_ADMIN)) 2679 return -EPERM; 2680 2681 ret = mnt_want_write_file(file); 2682 if (ret) 2683 return ret; 2684 2685 vol_args = memdup_user(arg, sizeof(*vol_args)); 2686 if (IS_ERR(vol_args)) { 2687 ret = PTR_ERR(vol_args); 2688 goto out; 2689 } 2690 2691 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 2692 2693 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running, 2694 1)) { 2695 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 2696 goto out; 2697 } 2698 2699 mutex_lock(&root->fs_info->volume_mutex); 2700 ret = btrfs_rm_device(root, vol_args->name); 2701 mutex_unlock(&root->fs_info->volume_mutex); 2702 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0); 2703 2704 out: 2705 kfree(vol_args); 2706 mnt_drop_write_file(file); 2707 return ret; 2708 } 2709 2710 static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg) 2711 { 2712 struct btrfs_ioctl_fs_info_args *fi_args; 2713 struct btrfs_device *device; 2714 struct btrfs_device *next; 2715 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices; 2716 int ret = 0; 2717 2718 fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL); 2719 if (!fi_args) 2720 return -ENOMEM; 2721 2722 mutex_lock(&fs_devices->device_list_mutex); 2723 fi_args->num_devices = fs_devices->num_devices; 2724 memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid)); 2725 2726 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { 2727 if (device->devid > fi_args->max_id) 2728 fi_args->max_id = device->devid; 2729 } 2730 mutex_unlock(&fs_devices->device_list_mutex); 2731 2732 fi_args->nodesize = root->fs_info->super_copy->nodesize; 2733 fi_args->sectorsize = root->fs_info->super_copy->sectorsize; 2734 fi_args->clone_alignment = root->fs_info->super_copy->sectorsize; 2735 2736 if (copy_to_user(arg, fi_args, sizeof(*fi_args))) 2737 ret = -EFAULT; 2738 2739 kfree(fi_args); 2740 return ret; 2741 } 2742 2743 static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg) 2744 { 2745 struct btrfs_ioctl_dev_info_args *di_args; 2746 struct btrfs_device *dev; 2747 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices; 2748 int ret = 0; 2749 char *s_uuid = NULL; 2750 2751 di_args = memdup_user(arg, sizeof(*di_args)); 2752 if (IS_ERR(di_args)) 2753 return PTR_ERR(di_args); 2754 2755 if (!btrfs_is_empty_uuid(di_args->uuid)) 2756 s_uuid = di_args->uuid; 2757 2758 mutex_lock(&fs_devices->device_list_mutex); 2759 dev = btrfs_find_device(root->fs_info, di_args->devid, s_uuid, NULL); 2760 2761 if (!dev) { 2762 ret = -ENODEV; 2763 goto out; 2764 } 2765 2766 di_args->devid = dev->devid; 2767 di_args->bytes_used = dev->bytes_used; 2768 di_args->total_bytes = dev->total_bytes; 2769 memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid)); 2770 if (dev->name) { 2771 struct rcu_string *name; 2772 2773 rcu_read_lock(); 2774 name = rcu_dereference(dev->name); 2775 strncpy(di_args->path, name->str, sizeof(di_args->path)); 2776 rcu_read_unlock(); 2777 di_args->path[sizeof(di_args->path) - 1] = 0; 2778 } else { 2779 di_args->path[0] = '\0'; 2780 } 2781 2782 out: 2783 mutex_unlock(&fs_devices->device_list_mutex); 2784 if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args))) 2785 ret = -EFAULT; 2786 2787 kfree(di_args); 2788 return ret; 2789 } 2790 2791 static struct page *extent_same_get_page(struct inode *inode, u64 off) 2792 { 2793 struct page *page; 2794 pgoff_t index; 2795 struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree; 2796 2797 index = off >> PAGE_CACHE_SHIFT; 2798 2799 page = grab_cache_page(inode->i_mapping, index); 2800 if (!page) 2801 return NULL; 2802 2803 if (!PageUptodate(page)) { 2804 if (extent_read_full_page_nolock(tree, page, btrfs_get_extent, 2805 0)) 2806 return NULL; 2807 lock_page(page); 2808 if (!PageUptodate(page)) { 2809 unlock_page(page); 2810 page_cache_release(page); 2811 return NULL; 2812 } 2813 } 2814 unlock_page(page); 2815 2816 return page; 2817 } 2818 2819 static inline void lock_extent_range(struct inode *inode, u64 off, u64 len) 2820 { 2821 /* do any pending delalloc/csum calc on src, one way or 2822 another, and lock file content */ 2823 while (1) { 2824 struct btrfs_ordered_extent *ordered; 2825 lock_extent(&BTRFS_I(inode)->io_tree, off, off + len - 1); 2826 ordered = btrfs_lookup_first_ordered_extent(inode, 2827 off + len - 1); 2828 if ((!ordered || 2829 ordered->file_offset + ordered->len <= off || 2830 ordered->file_offset >= off + len) && 2831 !test_range_bit(&BTRFS_I(inode)->io_tree, off, 2832 off + len - 1, EXTENT_DELALLOC, 0, NULL)) { 2833 if (ordered) 2834 btrfs_put_ordered_extent(ordered); 2835 break; 2836 } 2837 unlock_extent(&BTRFS_I(inode)->io_tree, off, off + len - 1); 2838 if (ordered) 2839 btrfs_put_ordered_extent(ordered); 2840 btrfs_wait_ordered_range(inode, off, len); 2841 } 2842 } 2843 2844 static void btrfs_double_unlock(struct inode *inode1, u64 loff1, 2845 struct inode *inode2, u64 loff2, u64 len) 2846 { 2847 unlock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1); 2848 unlock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1); 2849 2850 mutex_unlock(&inode1->i_mutex); 2851 mutex_unlock(&inode2->i_mutex); 2852 } 2853 2854 static void btrfs_double_lock(struct inode *inode1, u64 loff1, 2855 struct inode *inode2, u64 loff2, u64 len) 2856 { 2857 if (inode1 < inode2) { 2858 swap(inode1, inode2); 2859 swap(loff1, loff2); 2860 } 2861 2862 mutex_lock_nested(&inode1->i_mutex, I_MUTEX_PARENT); 2863 lock_extent_range(inode1, loff1, len); 2864 if (inode1 != inode2) { 2865 mutex_lock_nested(&inode2->i_mutex, I_MUTEX_CHILD); 2866 lock_extent_range(inode2, loff2, len); 2867 } 2868 } 2869 2870 static int btrfs_cmp_data(struct inode *src, u64 loff, struct inode *dst, 2871 u64 dst_loff, u64 len) 2872 { 2873 int ret = 0; 2874 struct page *src_page, *dst_page; 2875 unsigned int cmp_len = PAGE_CACHE_SIZE; 2876 void *addr, *dst_addr; 2877 2878 while (len) { 2879 if (len < PAGE_CACHE_SIZE) 2880 cmp_len = len; 2881 2882 src_page = extent_same_get_page(src, loff); 2883 if (!src_page) 2884 return -EINVAL; 2885 dst_page = extent_same_get_page(dst, dst_loff); 2886 if (!dst_page) { 2887 page_cache_release(src_page); 2888 return -EINVAL; 2889 } 2890 addr = kmap_atomic(src_page); 2891 dst_addr = kmap_atomic(dst_page); 2892 2893 flush_dcache_page(src_page); 2894 flush_dcache_page(dst_page); 2895 2896 if (memcmp(addr, dst_addr, cmp_len)) 2897 ret = BTRFS_SAME_DATA_DIFFERS; 2898 2899 kunmap_atomic(addr); 2900 kunmap_atomic(dst_addr); 2901 page_cache_release(src_page); 2902 page_cache_release(dst_page); 2903 2904 if (ret) 2905 break; 2906 2907 loff += cmp_len; 2908 dst_loff += cmp_len; 2909 len -= cmp_len; 2910 } 2911 2912 return ret; 2913 } 2914 2915 static int extent_same_check_offsets(struct inode *inode, u64 off, u64 len) 2916 { 2917 u64 bs = BTRFS_I(inode)->root->fs_info->sb->s_blocksize; 2918 2919 if (off + len > inode->i_size || off + len < off) 2920 return -EINVAL; 2921 /* Check that we are block aligned - btrfs_clone() requires this */ 2922 if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs)) 2923 return -EINVAL; 2924 2925 return 0; 2926 } 2927 2928 static int btrfs_extent_same(struct inode *src, u64 loff, u64 len, 2929 struct inode *dst, u64 dst_loff) 2930 { 2931 int ret; 2932 2933 /* 2934 * btrfs_clone() can't handle extents in the same file 2935 * yet. Once that works, we can drop this check and replace it 2936 * with a check for the same inode, but overlapping extents. 2937 */ 2938 if (src == dst) 2939 return -EINVAL; 2940 2941 btrfs_double_lock(src, loff, dst, dst_loff, len); 2942 2943 ret = extent_same_check_offsets(src, loff, len); 2944 if (ret) 2945 goto out_unlock; 2946 2947 ret = extent_same_check_offsets(dst, dst_loff, len); 2948 if (ret) 2949 goto out_unlock; 2950 2951 /* don't make the dst file partly checksummed */ 2952 if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) != 2953 (BTRFS_I(dst)->flags & BTRFS_INODE_NODATASUM)) { 2954 ret = -EINVAL; 2955 goto out_unlock; 2956 } 2957 2958 ret = btrfs_cmp_data(src, loff, dst, dst_loff, len); 2959 if (ret == 0) 2960 ret = btrfs_clone(src, dst, loff, len, len, dst_loff); 2961 2962 out_unlock: 2963 btrfs_double_unlock(src, loff, dst, dst_loff, len); 2964 2965 return ret; 2966 } 2967 2968 #define BTRFS_MAX_DEDUPE_LEN (16 * 1024 * 1024) 2969 2970 static long btrfs_ioctl_file_extent_same(struct file *file, 2971 struct btrfs_ioctl_same_args __user *argp) 2972 { 2973 struct btrfs_ioctl_same_args *same; 2974 struct btrfs_ioctl_same_extent_info *info; 2975 struct inode *src = file_inode(file); 2976 u64 off; 2977 u64 len; 2978 int i; 2979 int ret; 2980 unsigned long size; 2981 u64 bs = BTRFS_I(src)->root->fs_info->sb->s_blocksize; 2982 bool is_admin = capable(CAP_SYS_ADMIN); 2983 u16 count; 2984 2985 if (!(file->f_mode & FMODE_READ)) 2986 return -EINVAL; 2987 2988 ret = mnt_want_write_file(file); 2989 if (ret) 2990 return ret; 2991 2992 if (get_user(count, &argp->dest_count)) { 2993 ret = -EFAULT; 2994 goto out; 2995 } 2996 2997 size = offsetof(struct btrfs_ioctl_same_args __user, info[count]); 2998 2999 same = memdup_user(argp, size); 3000 3001 if (IS_ERR(same)) { 3002 ret = PTR_ERR(same); 3003 goto out; 3004 } 3005 3006 off = same->logical_offset; 3007 len = same->length; 3008 3009 /* 3010 * Limit the total length we will dedupe for each operation. 3011 * This is intended to bound the total time spent in this 3012 * ioctl to something sane. 3013 */ 3014 if (len > BTRFS_MAX_DEDUPE_LEN) 3015 len = BTRFS_MAX_DEDUPE_LEN; 3016 3017 if (WARN_ON_ONCE(bs < PAGE_CACHE_SIZE)) { 3018 /* 3019 * Btrfs does not support blocksize < page_size. As a 3020 * result, btrfs_cmp_data() won't correctly handle 3021 * this situation without an update. 3022 */ 3023 ret = -EINVAL; 3024 goto out; 3025 } 3026 3027 ret = -EISDIR; 3028 if (S_ISDIR(src->i_mode)) 3029 goto out; 3030 3031 ret = -EACCES; 3032 if (!S_ISREG(src->i_mode)) 3033 goto out; 3034 3035 /* pre-format output fields to sane values */ 3036 for (i = 0; i < count; i++) { 3037 same->info[i].bytes_deduped = 0ULL; 3038 same->info[i].status = 0; 3039 } 3040 3041 for (i = 0, info = same->info; i < count; i++, info++) { 3042 struct inode *dst; 3043 struct fd dst_file = fdget(info->fd); 3044 if (!dst_file.file) { 3045 info->status = -EBADF; 3046 continue; 3047 } 3048 dst = file_inode(dst_file.file); 3049 3050 if (!(is_admin || (dst_file.file->f_mode & FMODE_WRITE))) { 3051 info->status = -EINVAL; 3052 } else if (file->f_path.mnt != dst_file.file->f_path.mnt) { 3053 info->status = -EXDEV; 3054 } else if (S_ISDIR(dst->i_mode)) { 3055 info->status = -EISDIR; 3056 } else if (!S_ISREG(dst->i_mode)) { 3057 info->status = -EACCES; 3058 } else { 3059 info->status = btrfs_extent_same(src, off, len, dst, 3060 info->logical_offset); 3061 if (info->status == 0) 3062 info->bytes_deduped += len; 3063 } 3064 fdput(dst_file); 3065 } 3066 3067 ret = copy_to_user(argp, same, size); 3068 if (ret) 3069 ret = -EFAULT; 3070 3071 out: 3072 mnt_drop_write_file(file); 3073 return ret; 3074 } 3075 3076 /* Helper to check and see if this root currently has a ref on the given disk 3077 * bytenr. If it does then we need to update the quota for this root. This 3078 * doesn't do anything if quotas aren't enabled. 3079 */ 3080 static int check_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 3081 u64 disko) 3082 { 3083 struct seq_list tree_mod_seq_elem = {}; 3084 struct ulist *roots; 3085 struct ulist_iterator uiter; 3086 struct ulist_node *root_node = NULL; 3087 int ret; 3088 3089 if (!root->fs_info->quota_enabled) 3090 return 1; 3091 3092 btrfs_get_tree_mod_seq(root->fs_info, &tree_mod_seq_elem); 3093 ret = btrfs_find_all_roots(trans, root->fs_info, disko, 3094 tree_mod_seq_elem.seq, &roots); 3095 if (ret < 0) 3096 goto out; 3097 ret = 0; 3098 ULIST_ITER_INIT(&uiter); 3099 while ((root_node = ulist_next(roots, &uiter))) { 3100 if (root_node->val == root->objectid) { 3101 ret = 1; 3102 break; 3103 } 3104 } 3105 ulist_free(roots); 3106 out: 3107 btrfs_put_tree_mod_seq(root->fs_info, &tree_mod_seq_elem); 3108 return ret; 3109 } 3110 3111 static int clone_finish_inode_update(struct btrfs_trans_handle *trans, 3112 struct inode *inode, 3113 u64 endoff, 3114 const u64 destoff, 3115 const u64 olen) 3116 { 3117 struct btrfs_root *root = BTRFS_I(inode)->root; 3118 int ret; 3119 3120 inode_inc_iversion(inode); 3121 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 3122 /* 3123 * We round up to the block size at eof when determining which 3124 * extents to clone above, but shouldn't round up the file size. 3125 */ 3126 if (endoff > destoff + olen) 3127 endoff = destoff + olen; 3128 if (endoff > inode->i_size) 3129 btrfs_i_size_write(inode, endoff); 3130 3131 ret = btrfs_update_inode(trans, root, inode); 3132 if (ret) { 3133 btrfs_abort_transaction(trans, root, ret); 3134 btrfs_end_transaction(trans, root); 3135 goto out; 3136 } 3137 ret = btrfs_end_transaction(trans, root); 3138 out: 3139 return ret; 3140 } 3141 3142 static void clone_update_extent_map(struct inode *inode, 3143 const struct btrfs_trans_handle *trans, 3144 const struct btrfs_path *path, 3145 const u64 hole_offset, 3146 const u64 hole_len) 3147 { 3148 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 3149 struct extent_map *em; 3150 int ret; 3151 3152 em = alloc_extent_map(); 3153 if (!em) { 3154 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3155 &BTRFS_I(inode)->runtime_flags); 3156 return; 3157 } 3158 3159 if (path) { 3160 struct btrfs_file_extent_item *fi; 3161 3162 fi = btrfs_item_ptr(path->nodes[0], path->slots[0], 3163 struct btrfs_file_extent_item); 3164 btrfs_extent_item_to_extent_map(inode, path, fi, false, em); 3165 em->generation = -1; 3166 if (btrfs_file_extent_type(path->nodes[0], fi) == 3167 BTRFS_FILE_EXTENT_INLINE) 3168 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3169 &BTRFS_I(inode)->runtime_flags); 3170 } else { 3171 em->start = hole_offset; 3172 em->len = hole_len; 3173 em->ram_bytes = em->len; 3174 em->orig_start = hole_offset; 3175 em->block_start = EXTENT_MAP_HOLE; 3176 em->block_len = 0; 3177 em->orig_block_len = 0; 3178 em->compress_type = BTRFS_COMPRESS_NONE; 3179 em->generation = trans->transid; 3180 } 3181 3182 while (1) { 3183 write_lock(&em_tree->lock); 3184 ret = add_extent_mapping(em_tree, em, 1); 3185 write_unlock(&em_tree->lock); 3186 if (ret != -EEXIST) { 3187 free_extent_map(em); 3188 break; 3189 } 3190 btrfs_drop_extent_cache(inode, em->start, 3191 em->start + em->len - 1, 0); 3192 } 3193 3194 if (unlikely(ret)) 3195 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3196 &BTRFS_I(inode)->runtime_flags); 3197 } 3198 3199 /** 3200 * btrfs_clone() - clone a range from inode file to another 3201 * 3202 * @src: Inode to clone from 3203 * @inode: Inode to clone to 3204 * @off: Offset within source to start clone from 3205 * @olen: Original length, passed by user, of range to clone 3206 * @olen_aligned: Block-aligned value of olen, extent_same uses 3207 * identical values here 3208 * @destoff: Offset within @inode to start clone 3209 */ 3210 static int btrfs_clone(struct inode *src, struct inode *inode, 3211 const u64 off, const u64 olen, const u64 olen_aligned, 3212 const u64 destoff) 3213 { 3214 struct btrfs_root *root = BTRFS_I(inode)->root; 3215 struct btrfs_path *path = NULL; 3216 struct extent_buffer *leaf; 3217 struct btrfs_trans_handle *trans; 3218 char *buf = NULL; 3219 struct btrfs_key key; 3220 u32 nritems; 3221 int slot; 3222 int ret; 3223 int no_quota; 3224 const u64 len = olen_aligned; 3225 u64 last_disko = 0; 3226 u64 last_dest_end = destoff; 3227 3228 ret = -ENOMEM; 3229 buf = vmalloc(btrfs_level_size(root, 0)); 3230 if (!buf) 3231 return ret; 3232 3233 path = btrfs_alloc_path(); 3234 if (!path) { 3235 vfree(buf); 3236 return ret; 3237 } 3238 3239 path->reada = 2; 3240 /* clone data */ 3241 key.objectid = btrfs_ino(src); 3242 key.type = BTRFS_EXTENT_DATA_KEY; 3243 key.offset = off; 3244 3245 while (1) { 3246 /* 3247 * note the key will change type as we walk through the 3248 * tree. 3249 */ 3250 path->leave_spinning = 1; 3251 ret = btrfs_search_slot(NULL, BTRFS_I(src)->root, &key, path, 3252 0, 0); 3253 if (ret < 0) 3254 goto out; 3255 /* 3256 * First search, if no extent item that starts at offset off was 3257 * found but the previous item is an extent item, it's possible 3258 * it might overlap our target range, therefore process it. 3259 */ 3260 if (key.offset == off && ret > 0 && path->slots[0] > 0) { 3261 btrfs_item_key_to_cpu(path->nodes[0], &key, 3262 path->slots[0] - 1); 3263 if (key.type == BTRFS_EXTENT_DATA_KEY) 3264 path->slots[0]--; 3265 } 3266 3267 nritems = btrfs_header_nritems(path->nodes[0]); 3268 process_slot: 3269 no_quota = 1; 3270 if (path->slots[0] >= nritems) { 3271 ret = btrfs_next_leaf(BTRFS_I(src)->root, path); 3272 if (ret < 0) 3273 goto out; 3274 if (ret > 0) 3275 break; 3276 nritems = btrfs_header_nritems(path->nodes[0]); 3277 } 3278 leaf = path->nodes[0]; 3279 slot = path->slots[0]; 3280 3281 btrfs_item_key_to_cpu(leaf, &key, slot); 3282 if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY || 3283 key.objectid != btrfs_ino(src)) 3284 break; 3285 3286 if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) { 3287 struct btrfs_file_extent_item *extent; 3288 int type; 3289 u32 size; 3290 struct btrfs_key new_key; 3291 u64 disko = 0, diskl = 0; 3292 u64 datao = 0, datal = 0; 3293 u8 comp; 3294 u64 drop_start; 3295 3296 extent = btrfs_item_ptr(leaf, slot, 3297 struct btrfs_file_extent_item); 3298 comp = btrfs_file_extent_compression(leaf, extent); 3299 type = btrfs_file_extent_type(leaf, extent); 3300 if (type == BTRFS_FILE_EXTENT_REG || 3301 type == BTRFS_FILE_EXTENT_PREALLOC) { 3302 disko = btrfs_file_extent_disk_bytenr(leaf, 3303 extent); 3304 diskl = btrfs_file_extent_disk_num_bytes(leaf, 3305 extent); 3306 datao = btrfs_file_extent_offset(leaf, extent); 3307 datal = btrfs_file_extent_num_bytes(leaf, 3308 extent); 3309 } else if (type == BTRFS_FILE_EXTENT_INLINE) { 3310 /* take upper bound, may be compressed */ 3311 datal = btrfs_file_extent_ram_bytes(leaf, 3312 extent); 3313 } 3314 3315 /* 3316 * The first search might have left us at an extent 3317 * item that ends before our target range's start, can 3318 * happen if we have holes and NO_HOLES feature enabled. 3319 */ 3320 if (key.offset + datal <= off) { 3321 path->slots[0]++; 3322 goto process_slot; 3323 } else if (key.offset >= off + len) { 3324 break; 3325 } 3326 3327 size = btrfs_item_size_nr(leaf, slot); 3328 read_extent_buffer(leaf, buf, 3329 btrfs_item_ptr_offset(leaf, slot), 3330 size); 3331 3332 btrfs_release_path(path); 3333 path->leave_spinning = 0; 3334 3335 memcpy(&new_key, &key, sizeof(new_key)); 3336 new_key.objectid = btrfs_ino(inode); 3337 if (off <= key.offset) 3338 new_key.offset = key.offset + destoff - off; 3339 else 3340 new_key.offset = destoff; 3341 3342 /* 3343 * Deal with a hole that doesn't have an extent item 3344 * that represents it (NO_HOLES feature enabled). 3345 * This hole is either in the middle of the cloning 3346 * range or at the beginning (fully overlaps it or 3347 * partially overlaps it). 3348 */ 3349 if (new_key.offset != last_dest_end) 3350 drop_start = last_dest_end; 3351 else 3352 drop_start = new_key.offset; 3353 3354 /* 3355 * 1 - adjusting old extent (we may have to split it) 3356 * 1 - add new extent 3357 * 1 - inode update 3358 */ 3359 trans = btrfs_start_transaction(root, 3); 3360 if (IS_ERR(trans)) { 3361 ret = PTR_ERR(trans); 3362 goto out; 3363 } 3364 3365 if (type == BTRFS_FILE_EXTENT_REG || 3366 type == BTRFS_FILE_EXTENT_PREALLOC) { 3367 /* 3368 * a | --- range to clone ---| b 3369 * | ------------- extent ------------- | 3370 */ 3371 3372 /* subtract range b */ 3373 if (key.offset + datal > off + len) 3374 datal = off + len - key.offset; 3375 3376 /* subtract range a */ 3377 if (off > key.offset) { 3378 datao += off - key.offset; 3379 datal -= off - key.offset; 3380 } 3381 3382 ret = btrfs_drop_extents(trans, root, inode, 3383 drop_start, 3384 new_key.offset + datal, 3385 1); 3386 if (ret) { 3387 if (ret != -EOPNOTSUPP) 3388 btrfs_abort_transaction(trans, 3389 root, ret); 3390 btrfs_end_transaction(trans, root); 3391 goto out; 3392 } 3393 3394 ret = btrfs_insert_empty_item(trans, root, path, 3395 &new_key, size); 3396 if (ret) { 3397 btrfs_abort_transaction(trans, root, 3398 ret); 3399 btrfs_end_transaction(trans, root); 3400 goto out; 3401 } 3402 3403 leaf = path->nodes[0]; 3404 slot = path->slots[0]; 3405 write_extent_buffer(leaf, buf, 3406 btrfs_item_ptr_offset(leaf, slot), 3407 size); 3408 3409 extent = btrfs_item_ptr(leaf, slot, 3410 struct btrfs_file_extent_item); 3411 3412 /* disko == 0 means it's a hole */ 3413 if (!disko) 3414 datao = 0; 3415 3416 btrfs_set_file_extent_offset(leaf, extent, 3417 datao); 3418 btrfs_set_file_extent_num_bytes(leaf, extent, 3419 datal); 3420 3421 /* 3422 * We need to look up the roots that point at 3423 * this bytenr and see if the new root does. If 3424 * it does not we need to make sure we update 3425 * quotas appropriately. 3426 */ 3427 if (disko && root != BTRFS_I(src)->root && 3428 disko != last_disko) { 3429 no_quota = check_ref(trans, root, 3430 disko); 3431 if (no_quota < 0) { 3432 btrfs_abort_transaction(trans, 3433 root, 3434 ret); 3435 btrfs_end_transaction(trans, 3436 root); 3437 ret = no_quota; 3438 goto out; 3439 } 3440 } 3441 3442 if (disko) { 3443 inode_add_bytes(inode, datal); 3444 ret = btrfs_inc_extent_ref(trans, root, 3445 disko, diskl, 0, 3446 root->root_key.objectid, 3447 btrfs_ino(inode), 3448 new_key.offset - datao, 3449 no_quota); 3450 if (ret) { 3451 btrfs_abort_transaction(trans, 3452 root, 3453 ret); 3454 btrfs_end_transaction(trans, 3455 root); 3456 goto out; 3457 3458 } 3459 } 3460 } else if (type == BTRFS_FILE_EXTENT_INLINE) { 3461 u64 skip = 0; 3462 u64 trim = 0; 3463 u64 aligned_end = 0; 3464 3465 if (off > key.offset) { 3466 skip = off - key.offset; 3467 new_key.offset += skip; 3468 } 3469 3470 if (key.offset + datal > off + len) 3471 trim = key.offset + datal - (off + len); 3472 3473 if (comp && (skip || trim)) { 3474 ret = -EINVAL; 3475 btrfs_end_transaction(trans, root); 3476 goto out; 3477 } 3478 size -= skip + trim; 3479 datal -= skip + trim; 3480 3481 aligned_end = ALIGN(new_key.offset + datal, 3482 root->sectorsize); 3483 ret = btrfs_drop_extents(trans, root, inode, 3484 drop_start, 3485 aligned_end, 3486 1); 3487 if (ret) { 3488 if (ret != -EOPNOTSUPP) 3489 btrfs_abort_transaction(trans, 3490 root, ret); 3491 btrfs_end_transaction(trans, root); 3492 goto out; 3493 } 3494 3495 ret = btrfs_insert_empty_item(trans, root, path, 3496 &new_key, size); 3497 if (ret) { 3498 btrfs_abort_transaction(trans, root, 3499 ret); 3500 btrfs_end_transaction(trans, root); 3501 goto out; 3502 } 3503 3504 if (skip) { 3505 u32 start = 3506 btrfs_file_extent_calc_inline_size(0); 3507 memmove(buf+start, buf+start+skip, 3508 datal); 3509 } 3510 3511 leaf = path->nodes[0]; 3512 slot = path->slots[0]; 3513 write_extent_buffer(leaf, buf, 3514 btrfs_item_ptr_offset(leaf, slot), 3515 size); 3516 inode_add_bytes(inode, datal); 3517 } 3518 3519 /* If we have an implicit hole (NO_HOLES feature). */ 3520 if (drop_start < new_key.offset) 3521 clone_update_extent_map(inode, trans, 3522 NULL, drop_start, 3523 new_key.offset - drop_start); 3524 3525 clone_update_extent_map(inode, trans, path, 0, 0); 3526 3527 btrfs_mark_buffer_dirty(leaf); 3528 btrfs_release_path(path); 3529 3530 last_dest_end = new_key.offset + datal; 3531 ret = clone_finish_inode_update(trans, inode, 3532 last_dest_end, 3533 destoff, olen); 3534 if (ret) 3535 goto out; 3536 if (new_key.offset + datal >= destoff + len) 3537 break; 3538 } 3539 btrfs_release_path(path); 3540 key.offset++; 3541 } 3542 ret = 0; 3543 3544 if (last_dest_end < destoff + len) { 3545 /* 3546 * We have an implicit hole (NO_HOLES feature is enabled) that 3547 * fully or partially overlaps our cloning range at its end. 3548 */ 3549 btrfs_release_path(path); 3550 3551 /* 3552 * 1 - remove extent(s) 3553 * 1 - inode update 3554 */ 3555 trans = btrfs_start_transaction(root, 2); 3556 if (IS_ERR(trans)) { 3557 ret = PTR_ERR(trans); 3558 goto out; 3559 } 3560 ret = btrfs_drop_extents(trans, root, inode, 3561 last_dest_end, destoff + len, 1); 3562 if (ret) { 3563 if (ret != -EOPNOTSUPP) 3564 btrfs_abort_transaction(trans, root, ret); 3565 btrfs_end_transaction(trans, root); 3566 goto out; 3567 } 3568 clone_update_extent_map(inode, trans, NULL, last_dest_end, 3569 destoff + len - last_dest_end); 3570 ret = clone_finish_inode_update(trans, inode, destoff + len, 3571 destoff, olen); 3572 } 3573 3574 out: 3575 btrfs_free_path(path); 3576 vfree(buf); 3577 return ret; 3578 } 3579 3580 static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, 3581 u64 off, u64 olen, u64 destoff) 3582 { 3583 struct inode *inode = file_inode(file); 3584 struct btrfs_root *root = BTRFS_I(inode)->root; 3585 struct fd src_file; 3586 struct inode *src; 3587 int ret; 3588 u64 len = olen; 3589 u64 bs = root->fs_info->sb->s_blocksize; 3590 int same_inode = 0; 3591 3592 /* 3593 * TODO: 3594 * - split compressed inline extents. annoying: we need to 3595 * decompress into destination's address_space (the file offset 3596 * may change, so source mapping won't do), then recompress (or 3597 * otherwise reinsert) a subrange. 3598 * 3599 * - split destination inode's inline extents. The inline extents can 3600 * be either compressed or non-compressed. 3601 */ 3602 3603 /* the destination must be opened for writing */ 3604 if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND)) 3605 return -EINVAL; 3606 3607 if (btrfs_root_readonly(root)) 3608 return -EROFS; 3609 3610 ret = mnt_want_write_file(file); 3611 if (ret) 3612 return ret; 3613 3614 src_file = fdget(srcfd); 3615 if (!src_file.file) { 3616 ret = -EBADF; 3617 goto out_drop_write; 3618 } 3619 3620 ret = -EXDEV; 3621 if (src_file.file->f_path.mnt != file->f_path.mnt) 3622 goto out_fput; 3623 3624 src = file_inode(src_file.file); 3625 3626 ret = -EINVAL; 3627 if (src == inode) 3628 same_inode = 1; 3629 3630 /* the src must be open for reading */ 3631 if (!(src_file.file->f_mode & FMODE_READ)) 3632 goto out_fput; 3633 3634 /* don't make the dst file partly checksummed */ 3635 if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) != 3636 (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) 3637 goto out_fput; 3638 3639 ret = -EISDIR; 3640 if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode)) 3641 goto out_fput; 3642 3643 ret = -EXDEV; 3644 if (src->i_sb != inode->i_sb) 3645 goto out_fput; 3646 3647 if (!same_inode) { 3648 if (inode < src) { 3649 mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT); 3650 mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD); 3651 } else { 3652 mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT); 3653 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD); 3654 } 3655 } else { 3656 mutex_lock(&src->i_mutex); 3657 } 3658 3659 /* determine range to clone */ 3660 ret = -EINVAL; 3661 if (off + len > src->i_size || off + len < off) 3662 goto out_unlock; 3663 if (len == 0) 3664 olen = len = src->i_size - off; 3665 /* if we extend to eof, continue to block boundary */ 3666 if (off + len == src->i_size) 3667 len = ALIGN(src->i_size, bs) - off; 3668 3669 /* verify the end result is block aligned */ 3670 if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) || 3671 !IS_ALIGNED(destoff, bs)) 3672 goto out_unlock; 3673 3674 /* verify if ranges are overlapped within the same file */ 3675 if (same_inode) { 3676 if (destoff + len > off && destoff < off + len) 3677 goto out_unlock; 3678 } 3679 3680 if (destoff > inode->i_size) { 3681 ret = btrfs_cont_expand(inode, inode->i_size, destoff); 3682 if (ret) 3683 goto out_unlock; 3684 } 3685 3686 /* 3687 * Lock the target range too. Right after we replace the file extent 3688 * items in the fs tree (which now point to the cloned data), we might 3689 * have a worker replace them with extent items relative to a write 3690 * operation that was issued before this clone operation (i.e. confront 3691 * with inode.c:btrfs_finish_ordered_io). 3692 */ 3693 if (same_inode) { 3694 u64 lock_start = min_t(u64, off, destoff); 3695 u64 lock_len = max_t(u64, off, destoff) + len - lock_start; 3696 3697 lock_extent_range(src, lock_start, lock_len); 3698 } else { 3699 lock_extent_range(src, off, len); 3700 lock_extent_range(inode, destoff, len); 3701 } 3702 3703 ret = btrfs_clone(src, inode, off, olen, len, destoff); 3704 3705 if (same_inode) { 3706 u64 lock_start = min_t(u64, off, destoff); 3707 u64 lock_end = max_t(u64, off, destoff) + len - 1; 3708 3709 unlock_extent(&BTRFS_I(src)->io_tree, lock_start, lock_end); 3710 } else { 3711 unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1); 3712 unlock_extent(&BTRFS_I(inode)->io_tree, destoff, 3713 destoff + len - 1); 3714 } 3715 /* 3716 * Truncate page cache pages so that future reads will see the cloned 3717 * data immediately and not the previous data. 3718 */ 3719 truncate_inode_pages_range(&inode->i_data, destoff, 3720 PAGE_CACHE_ALIGN(destoff + len) - 1); 3721 out_unlock: 3722 if (!same_inode) { 3723 if (inode < src) { 3724 mutex_unlock(&src->i_mutex); 3725 mutex_unlock(&inode->i_mutex); 3726 } else { 3727 mutex_unlock(&inode->i_mutex); 3728 mutex_unlock(&src->i_mutex); 3729 } 3730 } else { 3731 mutex_unlock(&src->i_mutex); 3732 } 3733 out_fput: 3734 fdput(src_file); 3735 out_drop_write: 3736 mnt_drop_write_file(file); 3737 return ret; 3738 } 3739 3740 static long btrfs_ioctl_clone_range(struct file *file, void __user *argp) 3741 { 3742 struct btrfs_ioctl_clone_range_args args; 3743 3744 if (copy_from_user(&args, argp, sizeof(args))) 3745 return -EFAULT; 3746 return btrfs_ioctl_clone(file, args.src_fd, args.src_offset, 3747 args.src_length, args.dest_offset); 3748 } 3749 3750 /* 3751 * there are many ways the trans_start and trans_end ioctls can lead 3752 * to deadlocks. They should only be used by applications that 3753 * basically own the machine, and have a very in depth understanding 3754 * of all the possible deadlocks and enospc problems. 3755 */ 3756 static long btrfs_ioctl_trans_start(struct file *file) 3757 { 3758 struct inode *inode = file_inode(file); 3759 struct btrfs_root *root = BTRFS_I(inode)->root; 3760 struct btrfs_trans_handle *trans; 3761 int ret; 3762 3763 ret = -EPERM; 3764 if (!capable(CAP_SYS_ADMIN)) 3765 goto out; 3766 3767 ret = -EINPROGRESS; 3768 if (file->private_data) 3769 goto out; 3770 3771 ret = -EROFS; 3772 if (btrfs_root_readonly(root)) 3773 goto out; 3774 3775 ret = mnt_want_write_file(file); 3776 if (ret) 3777 goto out; 3778 3779 atomic_inc(&root->fs_info->open_ioctl_trans); 3780 3781 ret = -ENOMEM; 3782 trans = btrfs_start_ioctl_transaction(root); 3783 if (IS_ERR(trans)) 3784 goto out_drop; 3785 3786 file->private_data = trans; 3787 return 0; 3788 3789 out_drop: 3790 atomic_dec(&root->fs_info->open_ioctl_trans); 3791 mnt_drop_write_file(file); 3792 out: 3793 return ret; 3794 } 3795 3796 static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) 3797 { 3798 struct inode *inode = file_inode(file); 3799 struct btrfs_root *root = BTRFS_I(inode)->root; 3800 struct btrfs_root *new_root; 3801 struct btrfs_dir_item *di; 3802 struct btrfs_trans_handle *trans; 3803 struct btrfs_path *path; 3804 struct btrfs_key location; 3805 struct btrfs_disk_key disk_key; 3806 u64 objectid = 0; 3807 u64 dir_id; 3808 int ret; 3809 3810 if (!capable(CAP_SYS_ADMIN)) 3811 return -EPERM; 3812 3813 ret = mnt_want_write_file(file); 3814 if (ret) 3815 return ret; 3816 3817 if (copy_from_user(&objectid, argp, sizeof(objectid))) { 3818 ret = -EFAULT; 3819 goto out; 3820 } 3821 3822 if (!objectid) 3823 objectid = BTRFS_FS_TREE_OBJECTID; 3824 3825 location.objectid = objectid; 3826 location.type = BTRFS_ROOT_ITEM_KEY; 3827 location.offset = (u64)-1; 3828 3829 new_root = btrfs_read_fs_root_no_name(root->fs_info, &location); 3830 if (IS_ERR(new_root)) { 3831 ret = PTR_ERR(new_root); 3832 goto out; 3833 } 3834 3835 path = btrfs_alloc_path(); 3836 if (!path) { 3837 ret = -ENOMEM; 3838 goto out; 3839 } 3840 path->leave_spinning = 1; 3841 3842 trans = btrfs_start_transaction(root, 1); 3843 if (IS_ERR(trans)) { 3844 btrfs_free_path(path); 3845 ret = PTR_ERR(trans); 3846 goto out; 3847 } 3848 3849 dir_id = btrfs_super_root_dir(root->fs_info->super_copy); 3850 di = btrfs_lookup_dir_item(trans, root->fs_info->tree_root, path, 3851 dir_id, "default", 7, 1); 3852 if (IS_ERR_OR_NULL(di)) { 3853 btrfs_free_path(path); 3854 btrfs_end_transaction(trans, root); 3855 btrfs_err(new_root->fs_info, "Umm, you don't have the default dir" 3856 "item, this isn't going to work"); 3857 ret = -ENOENT; 3858 goto out; 3859 } 3860 3861 btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key); 3862 btrfs_set_dir_item_key(path->nodes[0], di, &disk_key); 3863 btrfs_mark_buffer_dirty(path->nodes[0]); 3864 btrfs_free_path(path); 3865 3866 btrfs_set_fs_incompat(root->fs_info, DEFAULT_SUBVOL); 3867 btrfs_end_transaction(trans, root); 3868 out: 3869 mnt_drop_write_file(file); 3870 return ret; 3871 } 3872 3873 void btrfs_get_block_group_info(struct list_head *groups_list, 3874 struct btrfs_ioctl_space_info *space) 3875 { 3876 struct btrfs_block_group_cache *block_group; 3877 3878 space->total_bytes = 0; 3879 space->used_bytes = 0; 3880 space->flags = 0; 3881 list_for_each_entry(block_group, groups_list, list) { 3882 space->flags = block_group->flags; 3883 space->total_bytes += block_group->key.offset; 3884 space->used_bytes += 3885 btrfs_block_group_used(&block_group->item); 3886 } 3887 } 3888 3889 static long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg) 3890 { 3891 struct btrfs_ioctl_space_args space_args; 3892 struct btrfs_ioctl_space_info space; 3893 struct btrfs_ioctl_space_info *dest; 3894 struct btrfs_ioctl_space_info *dest_orig; 3895 struct btrfs_ioctl_space_info __user *user_dest; 3896 struct btrfs_space_info *info; 3897 u64 types[] = {BTRFS_BLOCK_GROUP_DATA, 3898 BTRFS_BLOCK_GROUP_SYSTEM, 3899 BTRFS_BLOCK_GROUP_METADATA, 3900 BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA}; 3901 int num_types = 4; 3902 int alloc_size; 3903 int ret = 0; 3904 u64 slot_count = 0; 3905 int i, c; 3906 3907 if (copy_from_user(&space_args, 3908 (struct btrfs_ioctl_space_args __user *)arg, 3909 sizeof(space_args))) 3910 return -EFAULT; 3911 3912 for (i = 0; i < num_types; i++) { 3913 struct btrfs_space_info *tmp; 3914 3915 info = NULL; 3916 rcu_read_lock(); 3917 list_for_each_entry_rcu(tmp, &root->fs_info->space_info, 3918 list) { 3919 if (tmp->flags == types[i]) { 3920 info = tmp; 3921 break; 3922 } 3923 } 3924 rcu_read_unlock(); 3925 3926 if (!info) 3927 continue; 3928 3929 down_read(&info->groups_sem); 3930 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) { 3931 if (!list_empty(&info->block_groups[c])) 3932 slot_count++; 3933 } 3934 up_read(&info->groups_sem); 3935 } 3936 3937 /* 3938 * Global block reserve, exported as a space_info 3939 */ 3940 slot_count++; 3941 3942 /* space_slots == 0 means they are asking for a count */ 3943 if (space_args.space_slots == 0) { 3944 space_args.total_spaces = slot_count; 3945 goto out; 3946 } 3947 3948 slot_count = min_t(u64, space_args.space_slots, slot_count); 3949 3950 alloc_size = sizeof(*dest) * slot_count; 3951 3952 /* we generally have at most 6 or so space infos, one for each raid 3953 * level. So, a whole page should be more than enough for everyone 3954 */ 3955 if (alloc_size > PAGE_CACHE_SIZE) 3956 return -ENOMEM; 3957 3958 space_args.total_spaces = 0; 3959 dest = kmalloc(alloc_size, GFP_NOFS); 3960 if (!dest) 3961 return -ENOMEM; 3962 dest_orig = dest; 3963 3964 /* now we have a buffer to copy into */ 3965 for (i = 0; i < num_types; i++) { 3966 struct btrfs_space_info *tmp; 3967 3968 if (!slot_count) 3969 break; 3970 3971 info = NULL; 3972 rcu_read_lock(); 3973 list_for_each_entry_rcu(tmp, &root->fs_info->space_info, 3974 list) { 3975 if (tmp->flags == types[i]) { 3976 info = tmp; 3977 break; 3978 } 3979 } 3980 rcu_read_unlock(); 3981 3982 if (!info) 3983 continue; 3984 down_read(&info->groups_sem); 3985 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) { 3986 if (!list_empty(&info->block_groups[c])) { 3987 btrfs_get_block_group_info( 3988 &info->block_groups[c], &space); 3989 memcpy(dest, &space, sizeof(space)); 3990 dest++; 3991 space_args.total_spaces++; 3992 slot_count--; 3993 } 3994 if (!slot_count) 3995 break; 3996 } 3997 up_read(&info->groups_sem); 3998 } 3999 4000 /* 4001 * Add global block reserve 4002 */ 4003 if (slot_count) { 4004 struct btrfs_block_rsv *block_rsv = &root->fs_info->global_block_rsv; 4005 4006 spin_lock(&block_rsv->lock); 4007 space.total_bytes = block_rsv->size; 4008 space.used_bytes = block_rsv->size - block_rsv->reserved; 4009 spin_unlock(&block_rsv->lock); 4010 space.flags = BTRFS_SPACE_INFO_GLOBAL_RSV; 4011 memcpy(dest, &space, sizeof(space)); 4012 space_args.total_spaces++; 4013 } 4014 4015 user_dest = (struct btrfs_ioctl_space_info __user *) 4016 (arg + sizeof(struct btrfs_ioctl_space_args)); 4017 4018 if (copy_to_user(user_dest, dest_orig, alloc_size)) 4019 ret = -EFAULT; 4020 4021 kfree(dest_orig); 4022 out: 4023 if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args))) 4024 ret = -EFAULT; 4025 4026 return ret; 4027 } 4028 4029 /* 4030 * there are many ways the trans_start and trans_end ioctls can lead 4031 * to deadlocks. They should only be used by applications that 4032 * basically own the machine, and have a very in depth understanding 4033 * of all the possible deadlocks and enospc problems. 4034 */ 4035 long btrfs_ioctl_trans_end(struct file *file) 4036 { 4037 struct inode *inode = file_inode(file); 4038 struct btrfs_root *root = BTRFS_I(inode)->root; 4039 struct btrfs_trans_handle *trans; 4040 4041 trans = file->private_data; 4042 if (!trans) 4043 return -EINVAL; 4044 file->private_data = NULL; 4045 4046 btrfs_end_transaction(trans, root); 4047 4048 atomic_dec(&root->fs_info->open_ioctl_trans); 4049 4050 mnt_drop_write_file(file); 4051 return 0; 4052 } 4053 4054 static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root, 4055 void __user *argp) 4056 { 4057 struct btrfs_trans_handle *trans; 4058 u64 transid; 4059 int ret; 4060 4061 trans = btrfs_attach_transaction_barrier(root); 4062 if (IS_ERR(trans)) { 4063 if (PTR_ERR(trans) != -ENOENT) 4064 return PTR_ERR(trans); 4065 4066 /* No running transaction, don't bother */ 4067 transid = root->fs_info->last_trans_committed; 4068 goto out; 4069 } 4070 transid = trans->transid; 4071 ret = btrfs_commit_transaction_async(trans, root, 0); 4072 if (ret) { 4073 btrfs_end_transaction(trans, root); 4074 return ret; 4075 } 4076 out: 4077 if (argp) 4078 if (copy_to_user(argp, &transid, sizeof(transid))) 4079 return -EFAULT; 4080 return 0; 4081 } 4082 4083 static noinline long btrfs_ioctl_wait_sync(struct btrfs_root *root, 4084 void __user *argp) 4085 { 4086 u64 transid; 4087 4088 if (argp) { 4089 if (copy_from_user(&transid, argp, sizeof(transid))) 4090 return -EFAULT; 4091 } else { 4092 transid = 0; /* current trans */ 4093 } 4094 return btrfs_wait_for_commit(root, transid); 4095 } 4096 4097 static long btrfs_ioctl_scrub(struct file *file, void __user *arg) 4098 { 4099 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4100 struct btrfs_ioctl_scrub_args *sa; 4101 int ret; 4102 4103 if (!capable(CAP_SYS_ADMIN)) 4104 return -EPERM; 4105 4106 sa = memdup_user(arg, sizeof(*sa)); 4107 if (IS_ERR(sa)) 4108 return PTR_ERR(sa); 4109 4110 if (!(sa->flags & BTRFS_SCRUB_READONLY)) { 4111 ret = mnt_want_write_file(file); 4112 if (ret) 4113 goto out; 4114 } 4115 4116 ret = btrfs_scrub_dev(root->fs_info, sa->devid, sa->start, sa->end, 4117 &sa->progress, sa->flags & BTRFS_SCRUB_READONLY, 4118 0); 4119 4120 if (copy_to_user(arg, sa, sizeof(*sa))) 4121 ret = -EFAULT; 4122 4123 if (!(sa->flags & BTRFS_SCRUB_READONLY)) 4124 mnt_drop_write_file(file); 4125 out: 4126 kfree(sa); 4127 return ret; 4128 } 4129 4130 static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg) 4131 { 4132 if (!capable(CAP_SYS_ADMIN)) 4133 return -EPERM; 4134 4135 return btrfs_scrub_cancel(root->fs_info); 4136 } 4137 4138 static long btrfs_ioctl_scrub_progress(struct btrfs_root *root, 4139 void __user *arg) 4140 { 4141 struct btrfs_ioctl_scrub_args *sa; 4142 int ret; 4143 4144 if (!capable(CAP_SYS_ADMIN)) 4145 return -EPERM; 4146 4147 sa = memdup_user(arg, sizeof(*sa)); 4148 if (IS_ERR(sa)) 4149 return PTR_ERR(sa); 4150 4151 ret = btrfs_scrub_progress(root, sa->devid, &sa->progress); 4152 4153 if (copy_to_user(arg, sa, sizeof(*sa))) 4154 ret = -EFAULT; 4155 4156 kfree(sa); 4157 return ret; 4158 } 4159 4160 static long btrfs_ioctl_get_dev_stats(struct btrfs_root *root, 4161 void __user *arg) 4162 { 4163 struct btrfs_ioctl_get_dev_stats *sa; 4164 int ret; 4165 4166 sa = memdup_user(arg, sizeof(*sa)); 4167 if (IS_ERR(sa)) 4168 return PTR_ERR(sa); 4169 4170 if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) { 4171 kfree(sa); 4172 return -EPERM; 4173 } 4174 4175 ret = btrfs_get_dev_stats(root, sa); 4176 4177 if (copy_to_user(arg, sa, sizeof(*sa))) 4178 ret = -EFAULT; 4179 4180 kfree(sa); 4181 return ret; 4182 } 4183 4184 static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg) 4185 { 4186 struct btrfs_ioctl_dev_replace_args *p; 4187 int ret; 4188 4189 if (!capable(CAP_SYS_ADMIN)) 4190 return -EPERM; 4191 4192 p = memdup_user(arg, sizeof(*p)); 4193 if (IS_ERR(p)) 4194 return PTR_ERR(p); 4195 4196 switch (p->cmd) { 4197 case BTRFS_IOCTL_DEV_REPLACE_CMD_START: 4198 if (root->fs_info->sb->s_flags & MS_RDONLY) { 4199 ret = -EROFS; 4200 goto out; 4201 } 4202 if (atomic_xchg( 4203 &root->fs_info->mutually_exclusive_operation_running, 4204 1)) { 4205 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 4206 } else { 4207 ret = btrfs_dev_replace_start(root, p); 4208 atomic_set( 4209 &root->fs_info->mutually_exclusive_operation_running, 4210 0); 4211 } 4212 break; 4213 case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS: 4214 btrfs_dev_replace_status(root->fs_info, p); 4215 ret = 0; 4216 break; 4217 case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL: 4218 ret = btrfs_dev_replace_cancel(root->fs_info, p); 4219 break; 4220 default: 4221 ret = -EINVAL; 4222 break; 4223 } 4224 4225 if (copy_to_user(arg, p, sizeof(*p))) 4226 ret = -EFAULT; 4227 out: 4228 kfree(p); 4229 return ret; 4230 } 4231 4232 static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg) 4233 { 4234 int ret = 0; 4235 int i; 4236 u64 rel_ptr; 4237 int size; 4238 struct btrfs_ioctl_ino_path_args *ipa = NULL; 4239 struct inode_fs_paths *ipath = NULL; 4240 struct btrfs_path *path; 4241 4242 if (!capable(CAP_DAC_READ_SEARCH)) 4243 return -EPERM; 4244 4245 path = btrfs_alloc_path(); 4246 if (!path) { 4247 ret = -ENOMEM; 4248 goto out; 4249 } 4250 4251 ipa = memdup_user(arg, sizeof(*ipa)); 4252 if (IS_ERR(ipa)) { 4253 ret = PTR_ERR(ipa); 4254 ipa = NULL; 4255 goto out; 4256 } 4257 4258 size = min_t(u32, ipa->size, 4096); 4259 ipath = init_ipath(size, root, path); 4260 if (IS_ERR(ipath)) { 4261 ret = PTR_ERR(ipath); 4262 ipath = NULL; 4263 goto out; 4264 } 4265 4266 ret = paths_from_inode(ipa->inum, ipath); 4267 if (ret < 0) 4268 goto out; 4269 4270 for (i = 0; i < ipath->fspath->elem_cnt; ++i) { 4271 rel_ptr = ipath->fspath->val[i] - 4272 (u64)(unsigned long)ipath->fspath->val; 4273 ipath->fspath->val[i] = rel_ptr; 4274 } 4275 4276 ret = copy_to_user((void *)(unsigned long)ipa->fspath, 4277 (void *)(unsigned long)ipath->fspath, size); 4278 if (ret) { 4279 ret = -EFAULT; 4280 goto out; 4281 } 4282 4283 out: 4284 btrfs_free_path(path); 4285 free_ipath(ipath); 4286 kfree(ipa); 4287 4288 return ret; 4289 } 4290 4291 static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx) 4292 { 4293 struct btrfs_data_container *inodes = ctx; 4294 const size_t c = 3 * sizeof(u64); 4295 4296 if (inodes->bytes_left >= c) { 4297 inodes->bytes_left -= c; 4298 inodes->val[inodes->elem_cnt] = inum; 4299 inodes->val[inodes->elem_cnt + 1] = offset; 4300 inodes->val[inodes->elem_cnt + 2] = root; 4301 inodes->elem_cnt += 3; 4302 } else { 4303 inodes->bytes_missing += c - inodes->bytes_left; 4304 inodes->bytes_left = 0; 4305 inodes->elem_missed += 3; 4306 } 4307 4308 return 0; 4309 } 4310 4311 static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root, 4312 void __user *arg) 4313 { 4314 int ret = 0; 4315 int size; 4316 struct btrfs_ioctl_logical_ino_args *loi; 4317 struct btrfs_data_container *inodes = NULL; 4318 struct btrfs_path *path = NULL; 4319 4320 if (!capable(CAP_SYS_ADMIN)) 4321 return -EPERM; 4322 4323 loi = memdup_user(arg, sizeof(*loi)); 4324 if (IS_ERR(loi)) { 4325 ret = PTR_ERR(loi); 4326 loi = NULL; 4327 goto out; 4328 } 4329 4330 path = btrfs_alloc_path(); 4331 if (!path) { 4332 ret = -ENOMEM; 4333 goto out; 4334 } 4335 4336 size = min_t(u32, loi->size, 64 * 1024); 4337 inodes = init_data_container(size); 4338 if (IS_ERR(inodes)) { 4339 ret = PTR_ERR(inodes); 4340 inodes = NULL; 4341 goto out; 4342 } 4343 4344 ret = iterate_inodes_from_logical(loi->logical, root->fs_info, path, 4345 build_ino_list, inodes); 4346 if (ret == -EINVAL) 4347 ret = -ENOENT; 4348 if (ret < 0) 4349 goto out; 4350 4351 ret = copy_to_user((void *)(unsigned long)loi->inodes, 4352 (void *)(unsigned long)inodes, size); 4353 if (ret) 4354 ret = -EFAULT; 4355 4356 out: 4357 btrfs_free_path(path); 4358 vfree(inodes); 4359 kfree(loi); 4360 4361 return ret; 4362 } 4363 4364 void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock, 4365 struct btrfs_ioctl_balance_args *bargs) 4366 { 4367 struct btrfs_balance_control *bctl = fs_info->balance_ctl; 4368 4369 bargs->flags = bctl->flags; 4370 4371 if (atomic_read(&fs_info->balance_running)) 4372 bargs->state |= BTRFS_BALANCE_STATE_RUNNING; 4373 if (atomic_read(&fs_info->balance_pause_req)) 4374 bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ; 4375 if (atomic_read(&fs_info->balance_cancel_req)) 4376 bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ; 4377 4378 memcpy(&bargs->data, &bctl->data, sizeof(bargs->data)); 4379 memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta)); 4380 memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys)); 4381 4382 if (lock) { 4383 spin_lock(&fs_info->balance_lock); 4384 memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat)); 4385 spin_unlock(&fs_info->balance_lock); 4386 } else { 4387 memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat)); 4388 } 4389 } 4390 4391 static long btrfs_ioctl_balance(struct file *file, void __user *arg) 4392 { 4393 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4394 struct btrfs_fs_info *fs_info = root->fs_info; 4395 struct btrfs_ioctl_balance_args *bargs; 4396 struct btrfs_balance_control *bctl; 4397 bool need_unlock; /* for mut. excl. ops lock */ 4398 int ret; 4399 4400 if (!capable(CAP_SYS_ADMIN)) 4401 return -EPERM; 4402 4403 ret = mnt_want_write_file(file); 4404 if (ret) 4405 return ret; 4406 4407 again: 4408 if (!atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1)) { 4409 mutex_lock(&fs_info->volume_mutex); 4410 mutex_lock(&fs_info->balance_mutex); 4411 need_unlock = true; 4412 goto locked; 4413 } 4414 4415 /* 4416 * mut. excl. ops lock is locked. Three possibilites: 4417 * (1) some other op is running 4418 * (2) balance is running 4419 * (3) balance is paused -- special case (think resume) 4420 */ 4421 mutex_lock(&fs_info->balance_mutex); 4422 if (fs_info->balance_ctl) { 4423 /* this is either (2) or (3) */ 4424 if (!atomic_read(&fs_info->balance_running)) { 4425 mutex_unlock(&fs_info->balance_mutex); 4426 if (!mutex_trylock(&fs_info->volume_mutex)) 4427 goto again; 4428 mutex_lock(&fs_info->balance_mutex); 4429 4430 if (fs_info->balance_ctl && 4431 !atomic_read(&fs_info->balance_running)) { 4432 /* this is (3) */ 4433 need_unlock = false; 4434 goto locked; 4435 } 4436 4437 mutex_unlock(&fs_info->balance_mutex); 4438 mutex_unlock(&fs_info->volume_mutex); 4439 goto again; 4440 } else { 4441 /* this is (2) */ 4442 mutex_unlock(&fs_info->balance_mutex); 4443 ret = -EINPROGRESS; 4444 goto out; 4445 } 4446 } else { 4447 /* this is (1) */ 4448 mutex_unlock(&fs_info->balance_mutex); 4449 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 4450 goto out; 4451 } 4452 4453 locked: 4454 BUG_ON(!atomic_read(&fs_info->mutually_exclusive_operation_running)); 4455 4456 if (arg) { 4457 bargs = memdup_user(arg, sizeof(*bargs)); 4458 if (IS_ERR(bargs)) { 4459 ret = PTR_ERR(bargs); 4460 goto out_unlock; 4461 } 4462 4463 if (bargs->flags & BTRFS_BALANCE_RESUME) { 4464 if (!fs_info->balance_ctl) { 4465 ret = -ENOTCONN; 4466 goto out_bargs; 4467 } 4468 4469 bctl = fs_info->balance_ctl; 4470 spin_lock(&fs_info->balance_lock); 4471 bctl->flags |= BTRFS_BALANCE_RESUME; 4472 spin_unlock(&fs_info->balance_lock); 4473 4474 goto do_balance; 4475 } 4476 } else { 4477 bargs = NULL; 4478 } 4479 4480 if (fs_info->balance_ctl) { 4481 ret = -EINPROGRESS; 4482 goto out_bargs; 4483 } 4484 4485 bctl = kzalloc(sizeof(*bctl), GFP_NOFS); 4486 if (!bctl) { 4487 ret = -ENOMEM; 4488 goto out_bargs; 4489 } 4490 4491 bctl->fs_info = fs_info; 4492 if (arg) { 4493 memcpy(&bctl->data, &bargs->data, sizeof(bctl->data)); 4494 memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta)); 4495 memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys)); 4496 4497 bctl->flags = bargs->flags; 4498 } else { 4499 /* balance everything - no filters */ 4500 bctl->flags |= BTRFS_BALANCE_TYPE_MASK; 4501 } 4502 4503 do_balance: 4504 /* 4505 * Ownership of bctl and mutually_exclusive_operation_running 4506 * goes to to btrfs_balance. bctl is freed in __cancel_balance, 4507 * or, if restriper was paused all the way until unmount, in 4508 * free_fs_info. mutually_exclusive_operation_running is 4509 * cleared in __cancel_balance. 4510 */ 4511 need_unlock = false; 4512 4513 ret = btrfs_balance(bctl, bargs); 4514 4515 if (arg) { 4516 if (copy_to_user(arg, bargs, sizeof(*bargs))) 4517 ret = -EFAULT; 4518 } 4519 4520 out_bargs: 4521 kfree(bargs); 4522 out_unlock: 4523 mutex_unlock(&fs_info->balance_mutex); 4524 mutex_unlock(&fs_info->volume_mutex); 4525 if (need_unlock) 4526 atomic_set(&fs_info->mutually_exclusive_operation_running, 0); 4527 out: 4528 mnt_drop_write_file(file); 4529 return ret; 4530 } 4531 4532 static long btrfs_ioctl_balance_ctl(struct btrfs_root *root, int cmd) 4533 { 4534 if (!capable(CAP_SYS_ADMIN)) 4535 return -EPERM; 4536 4537 switch (cmd) { 4538 case BTRFS_BALANCE_CTL_PAUSE: 4539 return btrfs_pause_balance(root->fs_info); 4540 case BTRFS_BALANCE_CTL_CANCEL: 4541 return btrfs_cancel_balance(root->fs_info); 4542 } 4543 4544 return -EINVAL; 4545 } 4546 4547 static long btrfs_ioctl_balance_progress(struct btrfs_root *root, 4548 void __user *arg) 4549 { 4550 struct btrfs_fs_info *fs_info = root->fs_info; 4551 struct btrfs_ioctl_balance_args *bargs; 4552 int ret = 0; 4553 4554 if (!capable(CAP_SYS_ADMIN)) 4555 return -EPERM; 4556 4557 mutex_lock(&fs_info->balance_mutex); 4558 if (!fs_info->balance_ctl) { 4559 ret = -ENOTCONN; 4560 goto out; 4561 } 4562 4563 bargs = kzalloc(sizeof(*bargs), GFP_NOFS); 4564 if (!bargs) { 4565 ret = -ENOMEM; 4566 goto out; 4567 } 4568 4569 update_ioctl_balance_args(fs_info, 1, bargs); 4570 4571 if (copy_to_user(arg, bargs, sizeof(*bargs))) 4572 ret = -EFAULT; 4573 4574 kfree(bargs); 4575 out: 4576 mutex_unlock(&fs_info->balance_mutex); 4577 return ret; 4578 } 4579 4580 static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg) 4581 { 4582 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4583 struct btrfs_ioctl_quota_ctl_args *sa; 4584 struct btrfs_trans_handle *trans = NULL; 4585 int ret; 4586 int err; 4587 4588 if (!capable(CAP_SYS_ADMIN)) 4589 return -EPERM; 4590 4591 ret = mnt_want_write_file(file); 4592 if (ret) 4593 return ret; 4594 4595 sa = memdup_user(arg, sizeof(*sa)); 4596 if (IS_ERR(sa)) { 4597 ret = PTR_ERR(sa); 4598 goto drop_write; 4599 } 4600 4601 down_write(&root->fs_info->subvol_sem); 4602 trans = btrfs_start_transaction(root->fs_info->tree_root, 2); 4603 if (IS_ERR(trans)) { 4604 ret = PTR_ERR(trans); 4605 goto out; 4606 } 4607 4608 switch (sa->cmd) { 4609 case BTRFS_QUOTA_CTL_ENABLE: 4610 ret = btrfs_quota_enable(trans, root->fs_info); 4611 break; 4612 case BTRFS_QUOTA_CTL_DISABLE: 4613 ret = btrfs_quota_disable(trans, root->fs_info); 4614 break; 4615 default: 4616 ret = -EINVAL; 4617 break; 4618 } 4619 4620 err = btrfs_commit_transaction(trans, root->fs_info->tree_root); 4621 if (err && !ret) 4622 ret = err; 4623 out: 4624 kfree(sa); 4625 up_write(&root->fs_info->subvol_sem); 4626 drop_write: 4627 mnt_drop_write_file(file); 4628 return ret; 4629 } 4630 4631 static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg) 4632 { 4633 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4634 struct btrfs_ioctl_qgroup_assign_args *sa; 4635 struct btrfs_trans_handle *trans; 4636 int ret; 4637 int err; 4638 4639 if (!capable(CAP_SYS_ADMIN)) 4640 return -EPERM; 4641 4642 ret = mnt_want_write_file(file); 4643 if (ret) 4644 return ret; 4645 4646 sa = memdup_user(arg, sizeof(*sa)); 4647 if (IS_ERR(sa)) { 4648 ret = PTR_ERR(sa); 4649 goto drop_write; 4650 } 4651 4652 trans = btrfs_join_transaction(root); 4653 if (IS_ERR(trans)) { 4654 ret = PTR_ERR(trans); 4655 goto out; 4656 } 4657 4658 /* FIXME: check if the IDs really exist */ 4659 if (sa->assign) { 4660 ret = btrfs_add_qgroup_relation(trans, root->fs_info, 4661 sa->src, sa->dst); 4662 } else { 4663 ret = btrfs_del_qgroup_relation(trans, root->fs_info, 4664 sa->src, sa->dst); 4665 } 4666 4667 err = btrfs_end_transaction(trans, root); 4668 if (err && !ret) 4669 ret = err; 4670 4671 out: 4672 kfree(sa); 4673 drop_write: 4674 mnt_drop_write_file(file); 4675 return ret; 4676 } 4677 4678 static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg) 4679 { 4680 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4681 struct btrfs_ioctl_qgroup_create_args *sa; 4682 struct btrfs_trans_handle *trans; 4683 int ret; 4684 int err; 4685 4686 if (!capable(CAP_SYS_ADMIN)) 4687 return -EPERM; 4688 4689 ret = mnt_want_write_file(file); 4690 if (ret) 4691 return ret; 4692 4693 sa = memdup_user(arg, sizeof(*sa)); 4694 if (IS_ERR(sa)) { 4695 ret = PTR_ERR(sa); 4696 goto drop_write; 4697 } 4698 4699 if (!sa->qgroupid) { 4700 ret = -EINVAL; 4701 goto out; 4702 } 4703 4704 trans = btrfs_join_transaction(root); 4705 if (IS_ERR(trans)) { 4706 ret = PTR_ERR(trans); 4707 goto out; 4708 } 4709 4710 /* FIXME: check if the IDs really exist */ 4711 if (sa->create) { 4712 ret = btrfs_create_qgroup(trans, root->fs_info, sa->qgroupid, 4713 NULL); 4714 } else { 4715 ret = btrfs_remove_qgroup(trans, root->fs_info, sa->qgroupid); 4716 } 4717 4718 err = btrfs_end_transaction(trans, root); 4719 if (err && !ret) 4720 ret = err; 4721 4722 out: 4723 kfree(sa); 4724 drop_write: 4725 mnt_drop_write_file(file); 4726 return ret; 4727 } 4728 4729 static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg) 4730 { 4731 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4732 struct btrfs_ioctl_qgroup_limit_args *sa; 4733 struct btrfs_trans_handle *trans; 4734 int ret; 4735 int err; 4736 u64 qgroupid; 4737 4738 if (!capable(CAP_SYS_ADMIN)) 4739 return -EPERM; 4740 4741 ret = mnt_want_write_file(file); 4742 if (ret) 4743 return ret; 4744 4745 sa = memdup_user(arg, sizeof(*sa)); 4746 if (IS_ERR(sa)) { 4747 ret = PTR_ERR(sa); 4748 goto drop_write; 4749 } 4750 4751 trans = btrfs_join_transaction(root); 4752 if (IS_ERR(trans)) { 4753 ret = PTR_ERR(trans); 4754 goto out; 4755 } 4756 4757 qgroupid = sa->qgroupid; 4758 if (!qgroupid) { 4759 /* take the current subvol as qgroup */ 4760 qgroupid = root->root_key.objectid; 4761 } 4762 4763 /* FIXME: check if the IDs really exist */ 4764 ret = btrfs_limit_qgroup(trans, root->fs_info, qgroupid, &sa->lim); 4765 4766 err = btrfs_end_transaction(trans, root); 4767 if (err && !ret) 4768 ret = err; 4769 4770 out: 4771 kfree(sa); 4772 drop_write: 4773 mnt_drop_write_file(file); 4774 return ret; 4775 } 4776 4777 static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg) 4778 { 4779 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4780 struct btrfs_ioctl_quota_rescan_args *qsa; 4781 int ret; 4782 4783 if (!capable(CAP_SYS_ADMIN)) 4784 return -EPERM; 4785 4786 ret = mnt_want_write_file(file); 4787 if (ret) 4788 return ret; 4789 4790 qsa = memdup_user(arg, sizeof(*qsa)); 4791 if (IS_ERR(qsa)) { 4792 ret = PTR_ERR(qsa); 4793 goto drop_write; 4794 } 4795 4796 if (qsa->flags) { 4797 ret = -EINVAL; 4798 goto out; 4799 } 4800 4801 ret = btrfs_qgroup_rescan(root->fs_info); 4802 4803 out: 4804 kfree(qsa); 4805 drop_write: 4806 mnt_drop_write_file(file); 4807 return ret; 4808 } 4809 4810 static long btrfs_ioctl_quota_rescan_status(struct file *file, void __user *arg) 4811 { 4812 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4813 struct btrfs_ioctl_quota_rescan_args *qsa; 4814 int ret = 0; 4815 4816 if (!capable(CAP_SYS_ADMIN)) 4817 return -EPERM; 4818 4819 qsa = kzalloc(sizeof(*qsa), GFP_NOFS); 4820 if (!qsa) 4821 return -ENOMEM; 4822 4823 if (root->fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) { 4824 qsa->flags = 1; 4825 qsa->progress = root->fs_info->qgroup_rescan_progress.objectid; 4826 } 4827 4828 if (copy_to_user(arg, qsa, sizeof(*qsa))) 4829 ret = -EFAULT; 4830 4831 kfree(qsa); 4832 return ret; 4833 } 4834 4835 static long btrfs_ioctl_quota_rescan_wait(struct file *file, void __user *arg) 4836 { 4837 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4838 4839 if (!capable(CAP_SYS_ADMIN)) 4840 return -EPERM; 4841 4842 return btrfs_qgroup_wait_for_completion(root->fs_info); 4843 } 4844 4845 static long _btrfs_ioctl_set_received_subvol(struct file *file, 4846 struct btrfs_ioctl_received_subvol_args *sa) 4847 { 4848 struct inode *inode = file_inode(file); 4849 struct btrfs_root *root = BTRFS_I(inode)->root; 4850 struct btrfs_root_item *root_item = &root->root_item; 4851 struct btrfs_trans_handle *trans; 4852 struct timespec ct = CURRENT_TIME; 4853 int ret = 0; 4854 int received_uuid_changed; 4855 4856 if (!inode_owner_or_capable(inode)) 4857 return -EPERM; 4858 4859 ret = mnt_want_write_file(file); 4860 if (ret < 0) 4861 return ret; 4862 4863 down_write(&root->fs_info->subvol_sem); 4864 4865 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) { 4866 ret = -EINVAL; 4867 goto out; 4868 } 4869 4870 if (btrfs_root_readonly(root)) { 4871 ret = -EROFS; 4872 goto out; 4873 } 4874 4875 /* 4876 * 1 - root item 4877 * 2 - uuid items (received uuid + subvol uuid) 4878 */ 4879 trans = btrfs_start_transaction(root, 3); 4880 if (IS_ERR(trans)) { 4881 ret = PTR_ERR(trans); 4882 trans = NULL; 4883 goto out; 4884 } 4885 4886 sa->rtransid = trans->transid; 4887 sa->rtime.sec = ct.tv_sec; 4888 sa->rtime.nsec = ct.tv_nsec; 4889 4890 received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid, 4891 BTRFS_UUID_SIZE); 4892 if (received_uuid_changed && 4893 !btrfs_is_empty_uuid(root_item->received_uuid)) 4894 btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root, 4895 root_item->received_uuid, 4896 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 4897 root->root_key.objectid); 4898 memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE); 4899 btrfs_set_root_stransid(root_item, sa->stransid); 4900 btrfs_set_root_rtransid(root_item, sa->rtransid); 4901 btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec); 4902 btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec); 4903 btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec); 4904 btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec); 4905 4906 ret = btrfs_update_root(trans, root->fs_info->tree_root, 4907 &root->root_key, &root->root_item); 4908 if (ret < 0) { 4909 btrfs_end_transaction(trans, root); 4910 goto out; 4911 } 4912 if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) { 4913 ret = btrfs_uuid_tree_add(trans, root->fs_info->uuid_root, 4914 sa->uuid, 4915 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 4916 root->root_key.objectid); 4917 if (ret < 0 && ret != -EEXIST) { 4918 btrfs_abort_transaction(trans, root, ret); 4919 goto out; 4920 } 4921 } 4922 ret = btrfs_commit_transaction(trans, root); 4923 if (ret < 0) { 4924 btrfs_abort_transaction(trans, root, ret); 4925 goto out; 4926 } 4927 4928 out: 4929 up_write(&root->fs_info->subvol_sem); 4930 mnt_drop_write_file(file); 4931 return ret; 4932 } 4933 4934 #ifdef CONFIG_64BIT 4935 static long btrfs_ioctl_set_received_subvol_32(struct file *file, 4936 void __user *arg) 4937 { 4938 struct btrfs_ioctl_received_subvol_args_32 *args32 = NULL; 4939 struct btrfs_ioctl_received_subvol_args *args64 = NULL; 4940 int ret = 0; 4941 4942 args32 = memdup_user(arg, sizeof(*args32)); 4943 if (IS_ERR(args32)) { 4944 ret = PTR_ERR(args32); 4945 args32 = NULL; 4946 goto out; 4947 } 4948 4949 args64 = kmalloc(sizeof(*args64), GFP_NOFS); 4950 if (!args64) { 4951 ret = -ENOMEM; 4952 goto out; 4953 } 4954 4955 memcpy(args64->uuid, args32->uuid, BTRFS_UUID_SIZE); 4956 args64->stransid = args32->stransid; 4957 args64->rtransid = args32->rtransid; 4958 args64->stime.sec = args32->stime.sec; 4959 args64->stime.nsec = args32->stime.nsec; 4960 args64->rtime.sec = args32->rtime.sec; 4961 args64->rtime.nsec = args32->rtime.nsec; 4962 args64->flags = args32->flags; 4963 4964 ret = _btrfs_ioctl_set_received_subvol(file, args64); 4965 if (ret) 4966 goto out; 4967 4968 memcpy(args32->uuid, args64->uuid, BTRFS_UUID_SIZE); 4969 args32->stransid = args64->stransid; 4970 args32->rtransid = args64->rtransid; 4971 args32->stime.sec = args64->stime.sec; 4972 args32->stime.nsec = args64->stime.nsec; 4973 args32->rtime.sec = args64->rtime.sec; 4974 args32->rtime.nsec = args64->rtime.nsec; 4975 args32->flags = args64->flags; 4976 4977 ret = copy_to_user(arg, args32, sizeof(*args32)); 4978 if (ret) 4979 ret = -EFAULT; 4980 4981 out: 4982 kfree(args32); 4983 kfree(args64); 4984 return ret; 4985 } 4986 #endif 4987 4988 static long btrfs_ioctl_set_received_subvol(struct file *file, 4989 void __user *arg) 4990 { 4991 struct btrfs_ioctl_received_subvol_args *sa = NULL; 4992 int ret = 0; 4993 4994 sa = memdup_user(arg, sizeof(*sa)); 4995 if (IS_ERR(sa)) { 4996 ret = PTR_ERR(sa); 4997 sa = NULL; 4998 goto out; 4999 } 5000 5001 ret = _btrfs_ioctl_set_received_subvol(file, sa); 5002 5003 if (ret) 5004 goto out; 5005 5006 ret = copy_to_user(arg, sa, sizeof(*sa)); 5007 if (ret) 5008 ret = -EFAULT; 5009 5010 out: 5011 kfree(sa); 5012 return ret; 5013 } 5014 5015 static int btrfs_ioctl_get_fslabel(struct file *file, void __user *arg) 5016 { 5017 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 5018 size_t len; 5019 int ret; 5020 char label[BTRFS_LABEL_SIZE]; 5021 5022 spin_lock(&root->fs_info->super_lock); 5023 memcpy(label, root->fs_info->super_copy->label, BTRFS_LABEL_SIZE); 5024 spin_unlock(&root->fs_info->super_lock); 5025 5026 len = strnlen(label, BTRFS_LABEL_SIZE); 5027 5028 if (len == BTRFS_LABEL_SIZE) { 5029 btrfs_warn(root->fs_info, 5030 "label is too long, return the first %zu bytes", --len); 5031 } 5032 5033 ret = copy_to_user(arg, label, len); 5034 5035 return ret ? -EFAULT : 0; 5036 } 5037 5038 static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg) 5039 { 5040 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 5041 struct btrfs_super_block *super_block = root->fs_info->super_copy; 5042 struct btrfs_trans_handle *trans; 5043 char label[BTRFS_LABEL_SIZE]; 5044 int ret; 5045 5046 if (!capable(CAP_SYS_ADMIN)) 5047 return -EPERM; 5048 5049 if (copy_from_user(label, arg, sizeof(label))) 5050 return -EFAULT; 5051 5052 if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) { 5053 btrfs_err(root->fs_info, "unable to set label with more than %d bytes", 5054 BTRFS_LABEL_SIZE - 1); 5055 return -EINVAL; 5056 } 5057 5058 ret = mnt_want_write_file(file); 5059 if (ret) 5060 return ret; 5061 5062 trans = btrfs_start_transaction(root, 0); 5063 if (IS_ERR(trans)) { 5064 ret = PTR_ERR(trans); 5065 goto out_unlock; 5066 } 5067 5068 spin_lock(&root->fs_info->super_lock); 5069 strcpy(super_block->label, label); 5070 spin_unlock(&root->fs_info->super_lock); 5071 ret = btrfs_commit_transaction(trans, root); 5072 5073 out_unlock: 5074 mnt_drop_write_file(file); 5075 return ret; 5076 } 5077 5078 #define INIT_FEATURE_FLAGS(suffix) \ 5079 { .compat_flags = BTRFS_FEATURE_COMPAT_##suffix, \ 5080 .compat_ro_flags = BTRFS_FEATURE_COMPAT_RO_##suffix, \ 5081 .incompat_flags = BTRFS_FEATURE_INCOMPAT_##suffix } 5082 5083 static int btrfs_ioctl_get_supported_features(struct file *file, 5084 void __user *arg) 5085 { 5086 static struct btrfs_ioctl_feature_flags features[3] = { 5087 INIT_FEATURE_FLAGS(SUPP), 5088 INIT_FEATURE_FLAGS(SAFE_SET), 5089 INIT_FEATURE_FLAGS(SAFE_CLEAR) 5090 }; 5091 5092 if (copy_to_user(arg, &features, sizeof(features))) 5093 return -EFAULT; 5094 5095 return 0; 5096 } 5097 5098 static int btrfs_ioctl_get_features(struct file *file, void __user *arg) 5099 { 5100 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 5101 struct btrfs_super_block *super_block = root->fs_info->super_copy; 5102 struct btrfs_ioctl_feature_flags features; 5103 5104 features.compat_flags = btrfs_super_compat_flags(super_block); 5105 features.compat_ro_flags = btrfs_super_compat_ro_flags(super_block); 5106 features.incompat_flags = btrfs_super_incompat_flags(super_block); 5107 5108 if (copy_to_user(arg, &features, sizeof(features))) 5109 return -EFAULT; 5110 5111 return 0; 5112 } 5113 5114 static int check_feature_bits(struct btrfs_root *root, 5115 enum btrfs_feature_set set, 5116 u64 change_mask, u64 flags, u64 supported_flags, 5117 u64 safe_set, u64 safe_clear) 5118 { 5119 const char *type = btrfs_feature_set_names[set]; 5120 char *names; 5121 u64 disallowed, unsupported; 5122 u64 set_mask = flags & change_mask; 5123 u64 clear_mask = ~flags & change_mask; 5124 5125 unsupported = set_mask & ~supported_flags; 5126 if (unsupported) { 5127 names = btrfs_printable_features(set, unsupported); 5128 if (names) { 5129 btrfs_warn(root->fs_info, 5130 "this kernel does not support the %s feature bit%s", 5131 names, strchr(names, ',') ? "s" : ""); 5132 kfree(names); 5133 } else 5134 btrfs_warn(root->fs_info, 5135 "this kernel does not support %s bits 0x%llx", 5136 type, unsupported); 5137 return -EOPNOTSUPP; 5138 } 5139 5140 disallowed = set_mask & ~safe_set; 5141 if (disallowed) { 5142 names = btrfs_printable_features(set, disallowed); 5143 if (names) { 5144 btrfs_warn(root->fs_info, 5145 "can't set the %s feature bit%s while mounted", 5146 names, strchr(names, ',') ? "s" : ""); 5147 kfree(names); 5148 } else 5149 btrfs_warn(root->fs_info, 5150 "can't set %s bits 0x%llx while mounted", 5151 type, disallowed); 5152 return -EPERM; 5153 } 5154 5155 disallowed = clear_mask & ~safe_clear; 5156 if (disallowed) { 5157 names = btrfs_printable_features(set, disallowed); 5158 if (names) { 5159 btrfs_warn(root->fs_info, 5160 "can't clear the %s feature bit%s while mounted", 5161 names, strchr(names, ',') ? "s" : ""); 5162 kfree(names); 5163 } else 5164 btrfs_warn(root->fs_info, 5165 "can't clear %s bits 0x%llx while mounted", 5166 type, disallowed); 5167 return -EPERM; 5168 } 5169 5170 return 0; 5171 } 5172 5173 #define check_feature(root, change_mask, flags, mask_base) \ 5174 check_feature_bits(root, FEAT_##mask_base, change_mask, flags, \ 5175 BTRFS_FEATURE_ ## mask_base ## _SUPP, \ 5176 BTRFS_FEATURE_ ## mask_base ## _SAFE_SET, \ 5177 BTRFS_FEATURE_ ## mask_base ## _SAFE_CLEAR) 5178 5179 static int btrfs_ioctl_set_features(struct file *file, void __user *arg) 5180 { 5181 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 5182 struct btrfs_super_block *super_block = root->fs_info->super_copy; 5183 struct btrfs_ioctl_feature_flags flags[2]; 5184 struct btrfs_trans_handle *trans; 5185 u64 newflags; 5186 int ret; 5187 5188 if (!capable(CAP_SYS_ADMIN)) 5189 return -EPERM; 5190 5191 if (copy_from_user(flags, arg, sizeof(flags))) 5192 return -EFAULT; 5193 5194 /* Nothing to do */ 5195 if (!flags[0].compat_flags && !flags[0].compat_ro_flags && 5196 !flags[0].incompat_flags) 5197 return 0; 5198 5199 ret = check_feature(root, flags[0].compat_flags, 5200 flags[1].compat_flags, COMPAT); 5201 if (ret) 5202 return ret; 5203 5204 ret = check_feature(root, flags[0].compat_ro_flags, 5205 flags[1].compat_ro_flags, COMPAT_RO); 5206 if (ret) 5207 return ret; 5208 5209 ret = check_feature(root, flags[0].incompat_flags, 5210 flags[1].incompat_flags, INCOMPAT); 5211 if (ret) 5212 return ret; 5213 5214 trans = btrfs_start_transaction(root, 0); 5215 if (IS_ERR(trans)) 5216 return PTR_ERR(trans); 5217 5218 spin_lock(&root->fs_info->super_lock); 5219 newflags = btrfs_super_compat_flags(super_block); 5220 newflags |= flags[0].compat_flags & flags[1].compat_flags; 5221 newflags &= ~(flags[0].compat_flags & ~flags[1].compat_flags); 5222 btrfs_set_super_compat_flags(super_block, newflags); 5223 5224 newflags = btrfs_super_compat_ro_flags(super_block); 5225 newflags |= flags[0].compat_ro_flags & flags[1].compat_ro_flags; 5226 newflags &= ~(flags[0].compat_ro_flags & ~flags[1].compat_ro_flags); 5227 btrfs_set_super_compat_ro_flags(super_block, newflags); 5228 5229 newflags = btrfs_super_incompat_flags(super_block); 5230 newflags |= flags[0].incompat_flags & flags[1].incompat_flags; 5231 newflags &= ~(flags[0].incompat_flags & ~flags[1].incompat_flags); 5232 btrfs_set_super_incompat_flags(super_block, newflags); 5233 spin_unlock(&root->fs_info->super_lock); 5234 5235 return btrfs_commit_transaction(trans, root); 5236 } 5237 5238 long btrfs_ioctl(struct file *file, unsigned int 5239 cmd, unsigned long arg) 5240 { 5241 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 5242 void __user *argp = (void __user *)arg; 5243 5244 switch (cmd) { 5245 case FS_IOC_GETFLAGS: 5246 return btrfs_ioctl_getflags(file, argp); 5247 case FS_IOC_SETFLAGS: 5248 return btrfs_ioctl_setflags(file, argp); 5249 case FS_IOC_GETVERSION: 5250 return btrfs_ioctl_getversion(file, argp); 5251 case FITRIM: 5252 return btrfs_ioctl_fitrim(file, argp); 5253 case BTRFS_IOC_SNAP_CREATE: 5254 return btrfs_ioctl_snap_create(file, argp, 0); 5255 case BTRFS_IOC_SNAP_CREATE_V2: 5256 return btrfs_ioctl_snap_create_v2(file, argp, 0); 5257 case BTRFS_IOC_SUBVOL_CREATE: 5258 return btrfs_ioctl_snap_create(file, argp, 1); 5259 case BTRFS_IOC_SUBVOL_CREATE_V2: 5260 return btrfs_ioctl_snap_create_v2(file, argp, 1); 5261 case BTRFS_IOC_SNAP_DESTROY: 5262 return btrfs_ioctl_snap_destroy(file, argp); 5263 case BTRFS_IOC_SUBVOL_GETFLAGS: 5264 return btrfs_ioctl_subvol_getflags(file, argp); 5265 case BTRFS_IOC_SUBVOL_SETFLAGS: 5266 return btrfs_ioctl_subvol_setflags(file, argp); 5267 case BTRFS_IOC_DEFAULT_SUBVOL: 5268 return btrfs_ioctl_default_subvol(file, argp); 5269 case BTRFS_IOC_DEFRAG: 5270 return btrfs_ioctl_defrag(file, NULL); 5271 case BTRFS_IOC_DEFRAG_RANGE: 5272 return btrfs_ioctl_defrag(file, argp); 5273 case BTRFS_IOC_RESIZE: 5274 return btrfs_ioctl_resize(file, argp); 5275 case BTRFS_IOC_ADD_DEV: 5276 return btrfs_ioctl_add_dev(root, argp); 5277 case BTRFS_IOC_RM_DEV: 5278 return btrfs_ioctl_rm_dev(file, argp); 5279 case BTRFS_IOC_FS_INFO: 5280 return btrfs_ioctl_fs_info(root, argp); 5281 case BTRFS_IOC_DEV_INFO: 5282 return btrfs_ioctl_dev_info(root, argp); 5283 case BTRFS_IOC_BALANCE: 5284 return btrfs_ioctl_balance(file, NULL); 5285 case BTRFS_IOC_CLONE: 5286 return btrfs_ioctl_clone(file, arg, 0, 0, 0); 5287 case BTRFS_IOC_CLONE_RANGE: 5288 return btrfs_ioctl_clone_range(file, argp); 5289 case BTRFS_IOC_TRANS_START: 5290 return btrfs_ioctl_trans_start(file); 5291 case BTRFS_IOC_TRANS_END: 5292 return btrfs_ioctl_trans_end(file); 5293 case BTRFS_IOC_TREE_SEARCH: 5294 return btrfs_ioctl_tree_search(file, argp); 5295 case BTRFS_IOC_TREE_SEARCH_V2: 5296 return btrfs_ioctl_tree_search_v2(file, argp); 5297 case BTRFS_IOC_INO_LOOKUP: 5298 return btrfs_ioctl_ino_lookup(file, argp); 5299 case BTRFS_IOC_INO_PATHS: 5300 return btrfs_ioctl_ino_to_path(root, argp); 5301 case BTRFS_IOC_LOGICAL_INO: 5302 return btrfs_ioctl_logical_to_ino(root, argp); 5303 case BTRFS_IOC_SPACE_INFO: 5304 return btrfs_ioctl_space_info(root, argp); 5305 case BTRFS_IOC_SYNC: { 5306 int ret; 5307 5308 ret = btrfs_start_delalloc_roots(root->fs_info, 0, -1); 5309 if (ret) 5310 return ret; 5311 ret = btrfs_sync_fs(file->f_dentry->d_sb, 1); 5312 return ret; 5313 } 5314 case BTRFS_IOC_START_SYNC: 5315 return btrfs_ioctl_start_sync(root, argp); 5316 case BTRFS_IOC_WAIT_SYNC: 5317 return btrfs_ioctl_wait_sync(root, argp); 5318 case BTRFS_IOC_SCRUB: 5319 return btrfs_ioctl_scrub(file, argp); 5320 case BTRFS_IOC_SCRUB_CANCEL: 5321 return btrfs_ioctl_scrub_cancel(root, argp); 5322 case BTRFS_IOC_SCRUB_PROGRESS: 5323 return btrfs_ioctl_scrub_progress(root, argp); 5324 case BTRFS_IOC_BALANCE_V2: 5325 return btrfs_ioctl_balance(file, argp); 5326 case BTRFS_IOC_BALANCE_CTL: 5327 return btrfs_ioctl_balance_ctl(root, arg); 5328 case BTRFS_IOC_BALANCE_PROGRESS: 5329 return btrfs_ioctl_balance_progress(root, argp); 5330 case BTRFS_IOC_SET_RECEIVED_SUBVOL: 5331 return btrfs_ioctl_set_received_subvol(file, argp); 5332 #ifdef CONFIG_64BIT 5333 case BTRFS_IOC_SET_RECEIVED_SUBVOL_32: 5334 return btrfs_ioctl_set_received_subvol_32(file, argp); 5335 #endif 5336 case BTRFS_IOC_SEND: 5337 return btrfs_ioctl_send(file, argp); 5338 case BTRFS_IOC_GET_DEV_STATS: 5339 return btrfs_ioctl_get_dev_stats(root, argp); 5340 case BTRFS_IOC_QUOTA_CTL: 5341 return btrfs_ioctl_quota_ctl(file, argp); 5342 case BTRFS_IOC_QGROUP_ASSIGN: 5343 return btrfs_ioctl_qgroup_assign(file, argp); 5344 case BTRFS_IOC_QGROUP_CREATE: 5345 return btrfs_ioctl_qgroup_create(file, argp); 5346 case BTRFS_IOC_QGROUP_LIMIT: 5347 return btrfs_ioctl_qgroup_limit(file, argp); 5348 case BTRFS_IOC_QUOTA_RESCAN: 5349 return btrfs_ioctl_quota_rescan(file, argp); 5350 case BTRFS_IOC_QUOTA_RESCAN_STATUS: 5351 return btrfs_ioctl_quota_rescan_status(file, argp); 5352 case BTRFS_IOC_QUOTA_RESCAN_WAIT: 5353 return btrfs_ioctl_quota_rescan_wait(file, argp); 5354 case BTRFS_IOC_DEV_REPLACE: 5355 return btrfs_ioctl_dev_replace(root, argp); 5356 case BTRFS_IOC_GET_FSLABEL: 5357 return btrfs_ioctl_get_fslabel(file, argp); 5358 case BTRFS_IOC_SET_FSLABEL: 5359 return btrfs_ioctl_set_fslabel(file, argp); 5360 case BTRFS_IOC_FILE_EXTENT_SAME: 5361 return btrfs_ioctl_file_extent_same(file, argp); 5362 case BTRFS_IOC_GET_SUPPORTED_FEATURES: 5363 return btrfs_ioctl_get_supported_features(file, argp); 5364 case BTRFS_IOC_GET_FEATURES: 5365 return btrfs_ioctl_get_features(file, argp); 5366 case BTRFS_IOC_SET_FEATURES: 5367 return btrfs_ioctl_set_features(file, argp); 5368 } 5369 5370 return -ENOTTY; 5371 } 5372