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