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