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 "compat.h" 44 #include "ctree.h" 45 #include "disk-io.h" 46 #include "transaction.h" 47 #include "btrfs_inode.h" 48 #include "ioctl.h" 49 #include "print-tree.h" 50 #include "volumes.h" 51 #include "locking.h" 52 53 /* Mask out flags that are inappropriate for the given type of inode. */ 54 static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags) 55 { 56 if (S_ISDIR(mode)) 57 return flags; 58 else if (S_ISREG(mode)) 59 return flags & ~FS_DIRSYNC_FL; 60 else 61 return flags & (FS_NODUMP_FL | FS_NOATIME_FL); 62 } 63 64 /* 65 * Export inode flags to the format expected by the FS_IOC_GETFLAGS ioctl. 66 */ 67 static unsigned int btrfs_flags_to_ioctl(unsigned int flags) 68 { 69 unsigned int iflags = 0; 70 71 if (flags & BTRFS_INODE_SYNC) 72 iflags |= FS_SYNC_FL; 73 if (flags & BTRFS_INODE_IMMUTABLE) 74 iflags |= FS_IMMUTABLE_FL; 75 if (flags & BTRFS_INODE_APPEND) 76 iflags |= FS_APPEND_FL; 77 if (flags & BTRFS_INODE_NODUMP) 78 iflags |= FS_NODUMP_FL; 79 if (flags & BTRFS_INODE_NOATIME) 80 iflags |= FS_NOATIME_FL; 81 if (flags & BTRFS_INODE_DIRSYNC) 82 iflags |= FS_DIRSYNC_FL; 83 84 return iflags; 85 } 86 87 /* 88 * Update inode->i_flags based on the btrfs internal flags. 89 */ 90 void btrfs_update_iflags(struct inode *inode) 91 { 92 struct btrfs_inode *ip = BTRFS_I(inode); 93 94 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC); 95 96 if (ip->flags & BTRFS_INODE_SYNC) 97 inode->i_flags |= S_SYNC; 98 if (ip->flags & BTRFS_INODE_IMMUTABLE) 99 inode->i_flags |= S_IMMUTABLE; 100 if (ip->flags & BTRFS_INODE_APPEND) 101 inode->i_flags |= S_APPEND; 102 if (ip->flags & BTRFS_INODE_NOATIME) 103 inode->i_flags |= S_NOATIME; 104 if (ip->flags & BTRFS_INODE_DIRSYNC) 105 inode->i_flags |= S_DIRSYNC; 106 } 107 108 /* 109 * Inherit flags from the parent inode. 110 * 111 * Unlike extN we don't have any flags we don't want to inherit currently. 112 */ 113 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir) 114 { 115 unsigned int flags; 116 117 if (!dir) 118 return; 119 120 flags = BTRFS_I(dir)->flags; 121 122 if (S_ISREG(inode->i_mode)) 123 flags &= ~BTRFS_INODE_DIRSYNC; 124 else if (!S_ISDIR(inode->i_mode)) 125 flags &= (BTRFS_INODE_NODUMP | BTRFS_INODE_NOATIME); 126 127 BTRFS_I(inode)->flags = flags; 128 btrfs_update_iflags(inode); 129 } 130 131 static int btrfs_ioctl_getflags(struct file *file, void __user *arg) 132 { 133 struct btrfs_inode *ip = BTRFS_I(file->f_path.dentry->d_inode); 134 unsigned int flags = btrfs_flags_to_ioctl(ip->flags); 135 136 if (copy_to_user(arg, &flags, sizeof(flags))) 137 return -EFAULT; 138 return 0; 139 } 140 141 static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 142 { 143 struct inode *inode = file->f_path.dentry->d_inode; 144 struct btrfs_inode *ip = BTRFS_I(inode); 145 struct btrfs_root *root = ip->root; 146 struct btrfs_trans_handle *trans; 147 unsigned int flags, oldflags; 148 int ret; 149 150 if (btrfs_root_readonly(root)) 151 return -EROFS; 152 153 if (copy_from_user(&flags, arg, sizeof(flags))) 154 return -EFAULT; 155 156 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \ 157 FS_NOATIME_FL | FS_NODUMP_FL | \ 158 FS_SYNC_FL | FS_DIRSYNC_FL)) 159 return -EOPNOTSUPP; 160 161 if (!is_owner_or_cap(inode)) 162 return -EACCES; 163 164 mutex_lock(&inode->i_mutex); 165 166 flags = btrfs_mask_flags(inode->i_mode, flags); 167 oldflags = btrfs_flags_to_ioctl(ip->flags); 168 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) { 169 if (!capable(CAP_LINUX_IMMUTABLE)) { 170 ret = -EPERM; 171 goto out_unlock; 172 } 173 } 174 175 ret = mnt_want_write(file->f_path.mnt); 176 if (ret) 177 goto out_unlock; 178 179 if (flags & FS_SYNC_FL) 180 ip->flags |= BTRFS_INODE_SYNC; 181 else 182 ip->flags &= ~BTRFS_INODE_SYNC; 183 if (flags & FS_IMMUTABLE_FL) 184 ip->flags |= BTRFS_INODE_IMMUTABLE; 185 else 186 ip->flags &= ~BTRFS_INODE_IMMUTABLE; 187 if (flags & FS_APPEND_FL) 188 ip->flags |= BTRFS_INODE_APPEND; 189 else 190 ip->flags &= ~BTRFS_INODE_APPEND; 191 if (flags & FS_NODUMP_FL) 192 ip->flags |= BTRFS_INODE_NODUMP; 193 else 194 ip->flags &= ~BTRFS_INODE_NODUMP; 195 if (flags & FS_NOATIME_FL) 196 ip->flags |= BTRFS_INODE_NOATIME; 197 else 198 ip->flags &= ~BTRFS_INODE_NOATIME; 199 if (flags & FS_DIRSYNC_FL) 200 ip->flags |= BTRFS_INODE_DIRSYNC; 201 else 202 ip->flags &= ~BTRFS_INODE_DIRSYNC; 203 204 205 trans = btrfs_join_transaction(root, 1); 206 BUG_ON(!trans); 207 208 ret = btrfs_update_inode(trans, root, inode); 209 BUG_ON(ret); 210 211 btrfs_update_iflags(inode); 212 inode->i_ctime = CURRENT_TIME; 213 btrfs_end_transaction(trans, root); 214 215 mnt_drop_write(file->f_path.mnt); 216 out_unlock: 217 mutex_unlock(&inode->i_mutex); 218 return 0; 219 } 220 221 static int btrfs_ioctl_getversion(struct file *file, int __user *arg) 222 { 223 struct inode *inode = file->f_path.dentry->d_inode; 224 225 return put_user(inode->i_generation, arg); 226 } 227 228 static noinline int create_subvol(struct btrfs_root *root, 229 struct dentry *dentry, 230 char *name, int namelen, 231 u64 *async_transid) 232 { 233 struct btrfs_trans_handle *trans; 234 struct btrfs_key key; 235 struct btrfs_root_item root_item; 236 struct btrfs_inode_item *inode_item; 237 struct extent_buffer *leaf; 238 struct btrfs_root *new_root; 239 struct dentry *parent = dget_parent(dentry); 240 struct inode *dir; 241 int ret; 242 int err; 243 u64 objectid; 244 u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID; 245 u64 index = 0; 246 247 ret = btrfs_find_free_objectid(NULL, root->fs_info->tree_root, 248 0, &objectid); 249 if (ret) { 250 dput(parent); 251 return ret; 252 } 253 254 dir = parent->d_inode; 255 256 /* 257 * 1 - inode item 258 * 2 - refs 259 * 1 - root item 260 * 2 - dir items 261 */ 262 trans = btrfs_start_transaction(root, 6); 263 if (IS_ERR(trans)) { 264 dput(parent); 265 return PTR_ERR(trans); 266 } 267 268 leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 269 0, objectid, NULL, 0, 0, 0); 270 if (IS_ERR(leaf)) { 271 ret = PTR_ERR(leaf); 272 goto fail; 273 } 274 275 memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header)); 276 btrfs_set_header_bytenr(leaf, leaf->start); 277 btrfs_set_header_generation(leaf, trans->transid); 278 btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV); 279 btrfs_set_header_owner(leaf, objectid); 280 281 write_extent_buffer(leaf, root->fs_info->fsid, 282 (unsigned long)btrfs_header_fsid(leaf), 283 BTRFS_FSID_SIZE); 284 write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid, 285 (unsigned long)btrfs_header_chunk_tree_uuid(leaf), 286 BTRFS_UUID_SIZE); 287 btrfs_mark_buffer_dirty(leaf); 288 289 inode_item = &root_item.inode; 290 memset(inode_item, 0, sizeof(*inode_item)); 291 inode_item->generation = cpu_to_le64(1); 292 inode_item->size = cpu_to_le64(3); 293 inode_item->nlink = cpu_to_le32(1); 294 inode_item->nbytes = cpu_to_le64(root->leafsize); 295 inode_item->mode = cpu_to_le32(S_IFDIR | 0755); 296 297 btrfs_set_root_bytenr(&root_item, leaf->start); 298 btrfs_set_root_generation(&root_item, trans->transid); 299 btrfs_set_root_level(&root_item, 0); 300 btrfs_set_root_refs(&root_item, 1); 301 btrfs_set_root_used(&root_item, leaf->len); 302 btrfs_set_root_last_snapshot(&root_item, 0); 303 304 memset(&root_item.drop_progress, 0, sizeof(root_item.drop_progress)); 305 root_item.drop_level = 0; 306 307 btrfs_tree_unlock(leaf); 308 free_extent_buffer(leaf); 309 leaf = NULL; 310 311 btrfs_set_root_dirid(&root_item, new_dirid); 312 313 key.objectid = objectid; 314 key.offset = 0; 315 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 316 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key, 317 &root_item); 318 if (ret) 319 goto fail; 320 321 key.offset = (u64)-1; 322 new_root = btrfs_read_fs_root_no_name(root->fs_info, &key); 323 BUG_ON(IS_ERR(new_root)); 324 325 btrfs_record_root_in_trans(trans, new_root); 326 327 ret = btrfs_create_subvol_root(trans, new_root, new_dirid, 328 BTRFS_I(dir)->block_group); 329 /* 330 * insert the directory item 331 */ 332 ret = btrfs_set_inode_index(dir, &index); 333 BUG_ON(ret); 334 335 ret = btrfs_insert_dir_item(trans, root, 336 name, namelen, dir->i_ino, &key, 337 BTRFS_FT_DIR, index); 338 if (ret) 339 goto fail; 340 341 btrfs_i_size_write(dir, dir->i_size + namelen * 2); 342 ret = btrfs_update_inode(trans, root, dir); 343 BUG_ON(ret); 344 345 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root, 346 objectid, root->root_key.objectid, 347 dir->i_ino, index, name, namelen); 348 349 BUG_ON(ret); 350 351 d_instantiate(dentry, btrfs_lookup_dentry(dir, dentry)); 352 fail: 353 dput(parent); 354 if (async_transid) { 355 *async_transid = trans->transid; 356 err = btrfs_commit_transaction_async(trans, root, 1); 357 } else { 358 err = btrfs_commit_transaction(trans, root); 359 } 360 if (err && !ret) 361 ret = err; 362 return ret; 363 } 364 365 static int create_snapshot(struct btrfs_root *root, struct dentry *dentry, 366 char *name, int namelen, u64 *async_transid, 367 bool readonly) 368 { 369 struct inode *inode; 370 struct dentry *parent; 371 struct btrfs_pending_snapshot *pending_snapshot; 372 struct btrfs_trans_handle *trans; 373 int ret; 374 375 if (!root->ref_cows) 376 return -EINVAL; 377 378 pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS); 379 if (!pending_snapshot) 380 return -ENOMEM; 381 382 btrfs_init_block_rsv(&pending_snapshot->block_rsv); 383 pending_snapshot->dentry = dentry; 384 pending_snapshot->root = root; 385 pending_snapshot->readonly = readonly; 386 387 trans = btrfs_start_transaction(root->fs_info->extent_root, 5); 388 if (IS_ERR(trans)) { 389 ret = PTR_ERR(trans); 390 goto fail; 391 } 392 393 ret = btrfs_snap_reserve_metadata(trans, pending_snapshot); 394 BUG_ON(ret); 395 396 list_add(&pending_snapshot->list, 397 &trans->transaction->pending_snapshots); 398 if (async_transid) { 399 *async_transid = trans->transid; 400 ret = btrfs_commit_transaction_async(trans, 401 root->fs_info->extent_root, 1); 402 } else { 403 ret = btrfs_commit_transaction(trans, 404 root->fs_info->extent_root); 405 } 406 BUG_ON(ret); 407 408 ret = pending_snapshot->error; 409 if (ret) 410 goto fail; 411 412 btrfs_orphan_cleanup(pending_snapshot->snap); 413 414 parent = dget_parent(dentry); 415 inode = btrfs_lookup_dentry(parent->d_inode, dentry); 416 dput(parent); 417 if (IS_ERR(inode)) { 418 ret = PTR_ERR(inode); 419 goto fail; 420 } 421 BUG_ON(!inode); 422 d_instantiate(dentry, inode); 423 ret = 0; 424 fail: 425 kfree(pending_snapshot); 426 return ret; 427 } 428 429 /* copy of check_sticky in fs/namei.c() 430 * It's inline, so penalty for filesystems that don't use sticky bit is 431 * minimal. 432 */ 433 static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode) 434 { 435 uid_t fsuid = current_fsuid(); 436 437 if (!(dir->i_mode & S_ISVTX)) 438 return 0; 439 if (inode->i_uid == fsuid) 440 return 0; 441 if (dir->i_uid == fsuid) 442 return 0; 443 return !capable(CAP_FOWNER); 444 } 445 446 /* copy of may_delete in fs/namei.c() 447 * Check whether we can remove a link victim from directory dir, check 448 * whether the type of victim is right. 449 * 1. We can't do it if dir is read-only (done in permission()) 450 * 2. We should have write and exec permissions on dir 451 * 3. We can't remove anything from append-only dir 452 * 4. We can't do anything with immutable dir (done in permission()) 453 * 5. If the sticky bit on dir is set we should either 454 * a. be owner of dir, or 455 * b. be owner of victim, or 456 * c. have CAP_FOWNER capability 457 * 6. If the victim is append-only or immutable we can't do antyhing with 458 * links pointing to it. 459 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. 460 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. 461 * 9. We can't remove a root or mountpoint. 462 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by 463 * nfs_async_unlink(). 464 */ 465 466 static int btrfs_may_delete(struct inode *dir,struct dentry *victim,int isdir) 467 { 468 int error; 469 470 if (!victim->d_inode) 471 return -ENOENT; 472 473 BUG_ON(victim->d_parent->d_inode != dir); 474 audit_inode_child(victim, dir); 475 476 error = inode_permission(dir, MAY_WRITE | MAY_EXEC); 477 if (error) 478 return error; 479 if (IS_APPEND(dir)) 480 return -EPERM; 481 if (btrfs_check_sticky(dir, victim->d_inode)|| 482 IS_APPEND(victim->d_inode)|| 483 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode)) 484 return -EPERM; 485 if (isdir) { 486 if (!S_ISDIR(victim->d_inode->i_mode)) 487 return -ENOTDIR; 488 if (IS_ROOT(victim)) 489 return -EBUSY; 490 } else if (S_ISDIR(victim->d_inode->i_mode)) 491 return -EISDIR; 492 if (IS_DEADDIR(dir)) 493 return -ENOENT; 494 if (victim->d_flags & DCACHE_NFSFS_RENAMED) 495 return -EBUSY; 496 return 0; 497 } 498 499 /* copy of may_create in fs/namei.c() */ 500 static inline int btrfs_may_create(struct inode *dir, struct dentry *child) 501 { 502 if (child->d_inode) 503 return -EEXIST; 504 if (IS_DEADDIR(dir)) 505 return -ENOENT; 506 return inode_permission(dir, MAY_WRITE | MAY_EXEC); 507 } 508 509 /* 510 * Create a new subvolume below @parent. This is largely modeled after 511 * sys_mkdirat and vfs_mkdir, but we only do a single component lookup 512 * inside this filesystem so it's quite a bit simpler. 513 */ 514 static noinline int btrfs_mksubvol(struct path *parent, 515 char *name, int namelen, 516 struct btrfs_root *snap_src, 517 u64 *async_transid, bool readonly) 518 { 519 struct inode *dir = parent->dentry->d_inode; 520 struct dentry *dentry; 521 int error; 522 523 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 524 525 dentry = lookup_one_len(name, parent->dentry, namelen); 526 error = PTR_ERR(dentry); 527 if (IS_ERR(dentry)) 528 goto out_unlock; 529 530 error = -EEXIST; 531 if (dentry->d_inode) 532 goto out_dput; 533 534 error = mnt_want_write(parent->mnt); 535 if (error) 536 goto out_dput; 537 538 error = btrfs_may_create(dir, dentry); 539 if (error) 540 goto out_drop_write; 541 542 down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem); 543 544 if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0) 545 goto out_up_read; 546 547 if (snap_src) { 548 error = create_snapshot(snap_src, dentry, 549 name, namelen, async_transid, readonly); 550 } else { 551 error = create_subvol(BTRFS_I(dir)->root, dentry, 552 name, namelen, async_transid); 553 } 554 if (!error) 555 fsnotify_mkdir(dir, dentry); 556 out_up_read: 557 up_read(&BTRFS_I(dir)->root->fs_info->subvol_sem); 558 out_drop_write: 559 mnt_drop_write(parent->mnt); 560 out_dput: 561 dput(dentry); 562 out_unlock: 563 mutex_unlock(&dir->i_mutex); 564 return error; 565 } 566 567 static int should_defrag_range(struct inode *inode, u64 start, u64 len, 568 int thresh, u64 *last_len, u64 *skip, 569 u64 *defrag_end) 570 { 571 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 572 struct extent_map *em = NULL; 573 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 574 int ret = 1; 575 576 577 if (thresh == 0) 578 thresh = 256 * 1024; 579 580 /* 581 * make sure that once we start defragging and extent, we keep on 582 * defragging it 583 */ 584 if (start < *defrag_end) 585 return 1; 586 587 *skip = 0; 588 589 /* 590 * hopefully we have this extent in the tree already, try without 591 * the full extent lock 592 */ 593 read_lock(&em_tree->lock); 594 em = lookup_extent_mapping(em_tree, start, len); 595 read_unlock(&em_tree->lock); 596 597 if (!em) { 598 /* get the big lock and read metadata off disk */ 599 lock_extent(io_tree, start, start + len - 1, GFP_NOFS); 600 em = btrfs_get_extent(inode, NULL, 0, start, len, 0); 601 unlock_extent(io_tree, start, start + len - 1, GFP_NOFS); 602 603 if (IS_ERR(em)) 604 return 0; 605 } 606 607 /* this will cover holes, and inline extents */ 608 if (em->block_start >= EXTENT_MAP_LAST_BYTE) 609 ret = 0; 610 611 /* 612 * we hit a real extent, if it is big don't bother defragging it again 613 */ 614 if ((*last_len == 0 || *last_len >= thresh) && em->len >= thresh) 615 ret = 0; 616 617 /* 618 * last_len ends up being a counter of how many bytes we've defragged. 619 * every time we choose not to defrag an extent, we reset *last_len 620 * so that the next tiny extent will force a defrag. 621 * 622 * The end result of this is that tiny extents before a single big 623 * extent will force at least part of that big extent to be defragged. 624 */ 625 if (ret) { 626 *last_len += len; 627 *defrag_end = extent_map_end(em); 628 } else { 629 *last_len = 0; 630 *skip = extent_map_end(em); 631 *defrag_end = 0; 632 } 633 634 free_extent_map(em); 635 return ret; 636 } 637 638 static int btrfs_defrag_file(struct file *file, 639 struct btrfs_ioctl_defrag_range_args *range) 640 { 641 struct inode *inode = fdentry(file)->d_inode; 642 struct btrfs_root *root = BTRFS_I(inode)->root; 643 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 644 struct btrfs_ordered_extent *ordered; 645 struct page *page; 646 struct btrfs_super_block *disk_super; 647 unsigned long last_index; 648 unsigned long ra_pages = root->fs_info->bdi.ra_pages; 649 unsigned long total_read = 0; 650 u64 features; 651 u64 page_start; 652 u64 page_end; 653 u64 last_len = 0; 654 u64 skip = 0; 655 u64 defrag_end = 0; 656 unsigned long i; 657 int ret; 658 int compress_type = BTRFS_COMPRESS_ZLIB; 659 660 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) { 661 if (range->compress_type > BTRFS_COMPRESS_TYPES) 662 return -EINVAL; 663 if (range->compress_type) 664 compress_type = range->compress_type; 665 } 666 667 if (inode->i_size == 0) 668 return 0; 669 670 if (range->start + range->len > range->start) { 671 last_index = min_t(u64, inode->i_size - 1, 672 range->start + range->len - 1) >> PAGE_CACHE_SHIFT; 673 } else { 674 last_index = (inode->i_size - 1) >> PAGE_CACHE_SHIFT; 675 } 676 677 i = range->start >> PAGE_CACHE_SHIFT; 678 while (i <= last_index) { 679 if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT, 680 PAGE_CACHE_SIZE, 681 range->extent_thresh, 682 &last_len, &skip, 683 &defrag_end)) { 684 unsigned long next; 685 /* 686 * the should_defrag function tells us how much to skip 687 * bump our counter by the suggested amount 688 */ 689 next = (skip + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; 690 i = max(i + 1, next); 691 continue; 692 } 693 694 if (total_read % ra_pages == 0) { 695 btrfs_force_ra(inode->i_mapping, &file->f_ra, file, i, 696 min(last_index, i + ra_pages - 1)); 697 } 698 total_read++; 699 mutex_lock(&inode->i_mutex); 700 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) 701 BTRFS_I(inode)->force_compress = compress_type; 702 703 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE); 704 if (ret) 705 goto err_unlock; 706 again: 707 if (inode->i_size == 0 || 708 i > ((inode->i_size - 1) >> PAGE_CACHE_SHIFT)) { 709 ret = 0; 710 goto err_reservations; 711 } 712 713 page = grab_cache_page(inode->i_mapping, i); 714 if (!page) { 715 ret = -ENOMEM; 716 goto err_reservations; 717 } 718 719 if (!PageUptodate(page)) { 720 btrfs_readpage(NULL, page); 721 lock_page(page); 722 if (!PageUptodate(page)) { 723 unlock_page(page); 724 page_cache_release(page); 725 ret = -EIO; 726 goto err_reservations; 727 } 728 } 729 730 if (page->mapping != inode->i_mapping) { 731 unlock_page(page); 732 page_cache_release(page); 733 goto again; 734 } 735 736 wait_on_page_writeback(page); 737 738 if (PageDirty(page)) { 739 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE); 740 goto loop_unlock; 741 } 742 743 page_start = (u64)page->index << PAGE_CACHE_SHIFT; 744 page_end = page_start + PAGE_CACHE_SIZE - 1; 745 lock_extent(io_tree, page_start, page_end, GFP_NOFS); 746 747 ordered = btrfs_lookup_ordered_extent(inode, page_start); 748 if (ordered) { 749 unlock_extent(io_tree, page_start, page_end, GFP_NOFS); 750 unlock_page(page); 751 page_cache_release(page); 752 btrfs_start_ordered_extent(inode, ordered, 1); 753 btrfs_put_ordered_extent(ordered); 754 goto again; 755 } 756 set_page_extent_mapped(page); 757 758 /* 759 * this makes sure page_mkwrite is called on the 760 * page if it is dirtied again later 761 */ 762 clear_page_dirty_for_io(page); 763 clear_extent_bits(&BTRFS_I(inode)->io_tree, page_start, 764 page_end, EXTENT_DIRTY | EXTENT_DELALLOC | 765 EXTENT_DO_ACCOUNTING, GFP_NOFS); 766 767 btrfs_set_extent_delalloc(inode, page_start, page_end, NULL); 768 ClearPageChecked(page); 769 set_page_dirty(page); 770 unlock_extent(io_tree, page_start, page_end, GFP_NOFS); 771 772 loop_unlock: 773 unlock_page(page); 774 page_cache_release(page); 775 mutex_unlock(&inode->i_mutex); 776 777 balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1); 778 i++; 779 } 780 781 if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO)) 782 filemap_flush(inode->i_mapping); 783 784 if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) { 785 /* the filemap_flush will queue IO into the worker threads, but 786 * we have to make sure the IO is actually started and that 787 * ordered extents get created before we return 788 */ 789 atomic_inc(&root->fs_info->async_submit_draining); 790 while (atomic_read(&root->fs_info->nr_async_submits) || 791 atomic_read(&root->fs_info->async_delalloc_pages)) { 792 wait_event(root->fs_info->async_submit_wait, 793 (atomic_read(&root->fs_info->nr_async_submits) == 0 && 794 atomic_read(&root->fs_info->async_delalloc_pages) == 0)); 795 } 796 atomic_dec(&root->fs_info->async_submit_draining); 797 798 mutex_lock(&inode->i_mutex); 799 BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE; 800 mutex_unlock(&inode->i_mutex); 801 } 802 803 disk_super = &root->fs_info->super_copy; 804 features = btrfs_super_incompat_flags(disk_super); 805 if (range->compress_type == BTRFS_COMPRESS_LZO) { 806 features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO; 807 btrfs_set_super_incompat_flags(disk_super, features); 808 } 809 810 return 0; 811 812 err_reservations: 813 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE); 814 err_unlock: 815 mutex_unlock(&inode->i_mutex); 816 return ret; 817 } 818 819 static noinline int btrfs_ioctl_resize(struct btrfs_root *root, 820 void __user *arg) 821 { 822 u64 new_size; 823 u64 old_size; 824 u64 devid = 1; 825 struct btrfs_ioctl_vol_args *vol_args; 826 struct btrfs_trans_handle *trans; 827 struct btrfs_device *device = NULL; 828 char *sizestr; 829 char *devstr = NULL; 830 int ret = 0; 831 int mod = 0; 832 833 if (root->fs_info->sb->s_flags & MS_RDONLY) 834 return -EROFS; 835 836 if (!capable(CAP_SYS_ADMIN)) 837 return -EPERM; 838 839 vol_args = memdup_user(arg, sizeof(*vol_args)); 840 if (IS_ERR(vol_args)) 841 return PTR_ERR(vol_args); 842 843 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 844 845 mutex_lock(&root->fs_info->volume_mutex); 846 sizestr = vol_args->name; 847 devstr = strchr(sizestr, ':'); 848 if (devstr) { 849 char *end; 850 sizestr = devstr + 1; 851 *devstr = '\0'; 852 devstr = vol_args->name; 853 devid = simple_strtoull(devstr, &end, 10); 854 printk(KERN_INFO "resizing devid %llu\n", 855 (unsigned long long)devid); 856 } 857 device = btrfs_find_device(root, devid, NULL, NULL); 858 if (!device) { 859 printk(KERN_INFO "resizer unable to find device %llu\n", 860 (unsigned long long)devid); 861 ret = -EINVAL; 862 goto out_unlock; 863 } 864 if (!strcmp(sizestr, "max")) 865 new_size = device->bdev->bd_inode->i_size; 866 else { 867 if (sizestr[0] == '-') { 868 mod = -1; 869 sizestr++; 870 } else if (sizestr[0] == '+') { 871 mod = 1; 872 sizestr++; 873 } 874 new_size = memparse(sizestr, NULL); 875 if (new_size == 0) { 876 ret = -EINVAL; 877 goto out_unlock; 878 } 879 } 880 881 old_size = device->total_bytes; 882 883 if (mod < 0) { 884 if (new_size > old_size) { 885 ret = -EINVAL; 886 goto out_unlock; 887 } 888 new_size = old_size - new_size; 889 } else if (mod > 0) { 890 new_size = old_size + new_size; 891 } 892 893 if (new_size < 256 * 1024 * 1024) { 894 ret = -EINVAL; 895 goto out_unlock; 896 } 897 if (new_size > device->bdev->bd_inode->i_size) { 898 ret = -EFBIG; 899 goto out_unlock; 900 } 901 902 do_div(new_size, root->sectorsize); 903 new_size *= root->sectorsize; 904 905 printk(KERN_INFO "new size for %s is %llu\n", 906 device->name, (unsigned long long)new_size); 907 908 if (new_size > old_size) { 909 trans = btrfs_start_transaction(root, 0); 910 ret = btrfs_grow_device(trans, device, new_size); 911 btrfs_commit_transaction(trans, root); 912 } else { 913 ret = btrfs_shrink_device(device, new_size); 914 } 915 916 out_unlock: 917 mutex_unlock(&root->fs_info->volume_mutex); 918 kfree(vol_args); 919 return ret; 920 } 921 922 static noinline int btrfs_ioctl_snap_create_transid(struct file *file, 923 char *name, 924 unsigned long fd, 925 int subvol, 926 u64 *transid, 927 bool readonly) 928 { 929 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root; 930 struct file *src_file; 931 int namelen; 932 int ret = 0; 933 934 if (root->fs_info->sb->s_flags & MS_RDONLY) 935 return -EROFS; 936 937 namelen = strlen(name); 938 if (strchr(name, '/')) { 939 ret = -EINVAL; 940 goto out; 941 } 942 943 if (subvol) { 944 ret = btrfs_mksubvol(&file->f_path, name, namelen, 945 NULL, transid, readonly); 946 } else { 947 struct inode *src_inode; 948 src_file = fget(fd); 949 if (!src_file) { 950 ret = -EINVAL; 951 goto out; 952 } 953 954 src_inode = src_file->f_path.dentry->d_inode; 955 if (src_inode->i_sb != file->f_path.dentry->d_inode->i_sb) { 956 printk(KERN_INFO "btrfs: Snapshot src from " 957 "another FS\n"); 958 ret = -EINVAL; 959 fput(src_file); 960 goto out; 961 } 962 ret = btrfs_mksubvol(&file->f_path, name, namelen, 963 BTRFS_I(src_inode)->root, 964 transid, readonly); 965 fput(src_file); 966 } 967 out: 968 return ret; 969 } 970 971 static noinline int btrfs_ioctl_snap_create(struct file *file, 972 void __user *arg, int subvol) 973 { 974 struct btrfs_ioctl_vol_args *vol_args; 975 int ret; 976 977 vol_args = memdup_user(arg, sizeof(*vol_args)); 978 if (IS_ERR(vol_args)) 979 return PTR_ERR(vol_args); 980 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 981 982 ret = btrfs_ioctl_snap_create_transid(file, vol_args->name, 983 vol_args->fd, subvol, 984 NULL, false); 985 986 kfree(vol_args); 987 return ret; 988 } 989 990 static noinline int btrfs_ioctl_snap_create_v2(struct file *file, 991 void __user *arg, int subvol) 992 { 993 struct btrfs_ioctl_vol_args_v2 *vol_args; 994 int ret; 995 u64 transid = 0; 996 u64 *ptr = NULL; 997 bool readonly = false; 998 999 vol_args = memdup_user(arg, sizeof(*vol_args)); 1000 if (IS_ERR(vol_args)) 1001 return PTR_ERR(vol_args); 1002 vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0'; 1003 1004 if (vol_args->flags & 1005 ~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY)) { 1006 ret = -EOPNOTSUPP; 1007 goto out; 1008 } 1009 1010 if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC) 1011 ptr = &transid; 1012 if (vol_args->flags & BTRFS_SUBVOL_RDONLY) 1013 readonly = true; 1014 1015 ret = btrfs_ioctl_snap_create_transid(file, vol_args->name, 1016 vol_args->fd, subvol, 1017 ptr, readonly); 1018 1019 if (ret == 0 && ptr && 1020 copy_to_user(arg + 1021 offsetof(struct btrfs_ioctl_vol_args_v2, 1022 transid), ptr, sizeof(*ptr))) 1023 ret = -EFAULT; 1024 out: 1025 kfree(vol_args); 1026 return ret; 1027 } 1028 1029 static noinline int btrfs_ioctl_subvol_getflags(struct file *file, 1030 void __user *arg) 1031 { 1032 struct inode *inode = fdentry(file)->d_inode; 1033 struct btrfs_root *root = BTRFS_I(inode)->root; 1034 int ret = 0; 1035 u64 flags = 0; 1036 1037 if (inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) 1038 return -EINVAL; 1039 1040 down_read(&root->fs_info->subvol_sem); 1041 if (btrfs_root_readonly(root)) 1042 flags |= BTRFS_SUBVOL_RDONLY; 1043 up_read(&root->fs_info->subvol_sem); 1044 1045 if (copy_to_user(arg, &flags, sizeof(flags))) 1046 ret = -EFAULT; 1047 1048 return ret; 1049 } 1050 1051 static noinline int btrfs_ioctl_subvol_setflags(struct file *file, 1052 void __user *arg) 1053 { 1054 struct inode *inode = fdentry(file)->d_inode; 1055 struct btrfs_root *root = BTRFS_I(inode)->root; 1056 struct btrfs_trans_handle *trans; 1057 u64 root_flags; 1058 u64 flags; 1059 int ret = 0; 1060 1061 if (root->fs_info->sb->s_flags & MS_RDONLY) 1062 return -EROFS; 1063 1064 if (inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) 1065 return -EINVAL; 1066 1067 if (copy_from_user(&flags, arg, sizeof(flags))) 1068 return -EFAULT; 1069 1070 if (flags & ~BTRFS_SUBVOL_CREATE_ASYNC) 1071 return -EINVAL; 1072 1073 if (flags & ~BTRFS_SUBVOL_RDONLY) 1074 return -EOPNOTSUPP; 1075 1076 down_write(&root->fs_info->subvol_sem); 1077 1078 /* nothing to do */ 1079 if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root)) 1080 goto out; 1081 1082 root_flags = btrfs_root_flags(&root->root_item); 1083 if (flags & BTRFS_SUBVOL_RDONLY) 1084 btrfs_set_root_flags(&root->root_item, 1085 root_flags | BTRFS_ROOT_SUBVOL_RDONLY); 1086 else 1087 btrfs_set_root_flags(&root->root_item, 1088 root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY); 1089 1090 trans = btrfs_start_transaction(root, 1); 1091 if (IS_ERR(trans)) { 1092 ret = PTR_ERR(trans); 1093 goto out_reset; 1094 } 1095 1096 ret = btrfs_update_root(trans, root, 1097 &root->root_key, &root->root_item); 1098 1099 btrfs_commit_transaction(trans, root); 1100 out_reset: 1101 if (ret) 1102 btrfs_set_root_flags(&root->root_item, root_flags); 1103 out: 1104 up_write(&root->fs_info->subvol_sem); 1105 return ret; 1106 } 1107 1108 /* 1109 * helper to check if the subvolume references other subvolumes 1110 */ 1111 static noinline int may_destroy_subvol(struct btrfs_root *root) 1112 { 1113 struct btrfs_path *path; 1114 struct btrfs_key key; 1115 int ret; 1116 1117 path = btrfs_alloc_path(); 1118 if (!path) 1119 return -ENOMEM; 1120 1121 key.objectid = root->root_key.objectid; 1122 key.type = BTRFS_ROOT_REF_KEY; 1123 key.offset = (u64)-1; 1124 1125 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, 1126 &key, path, 0, 0); 1127 if (ret < 0) 1128 goto out; 1129 BUG_ON(ret == 0); 1130 1131 ret = 0; 1132 if (path->slots[0] > 0) { 1133 path->slots[0]--; 1134 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 1135 if (key.objectid == root->root_key.objectid && 1136 key.type == BTRFS_ROOT_REF_KEY) 1137 ret = -ENOTEMPTY; 1138 } 1139 out: 1140 btrfs_free_path(path); 1141 return ret; 1142 } 1143 1144 static noinline int key_in_sk(struct btrfs_key *key, 1145 struct btrfs_ioctl_search_key *sk) 1146 { 1147 struct btrfs_key test; 1148 int ret; 1149 1150 test.objectid = sk->min_objectid; 1151 test.type = sk->min_type; 1152 test.offset = sk->min_offset; 1153 1154 ret = btrfs_comp_cpu_keys(key, &test); 1155 if (ret < 0) 1156 return 0; 1157 1158 test.objectid = sk->max_objectid; 1159 test.type = sk->max_type; 1160 test.offset = sk->max_offset; 1161 1162 ret = btrfs_comp_cpu_keys(key, &test); 1163 if (ret > 0) 1164 return 0; 1165 return 1; 1166 } 1167 1168 static noinline int copy_to_sk(struct btrfs_root *root, 1169 struct btrfs_path *path, 1170 struct btrfs_key *key, 1171 struct btrfs_ioctl_search_key *sk, 1172 char *buf, 1173 unsigned long *sk_offset, 1174 int *num_found) 1175 { 1176 u64 found_transid; 1177 struct extent_buffer *leaf; 1178 struct btrfs_ioctl_search_header sh; 1179 unsigned long item_off; 1180 unsigned long item_len; 1181 int nritems; 1182 int i; 1183 int slot; 1184 int found = 0; 1185 int ret = 0; 1186 1187 leaf = path->nodes[0]; 1188 slot = path->slots[0]; 1189 nritems = btrfs_header_nritems(leaf); 1190 1191 if (btrfs_header_generation(leaf) > sk->max_transid) { 1192 i = nritems; 1193 goto advance_key; 1194 } 1195 found_transid = btrfs_header_generation(leaf); 1196 1197 for (i = slot; i < nritems; i++) { 1198 item_off = btrfs_item_ptr_offset(leaf, i); 1199 item_len = btrfs_item_size_nr(leaf, i); 1200 1201 if (item_len > BTRFS_SEARCH_ARGS_BUFSIZE) 1202 item_len = 0; 1203 1204 if (sizeof(sh) + item_len + *sk_offset > 1205 BTRFS_SEARCH_ARGS_BUFSIZE) { 1206 ret = 1; 1207 goto overflow; 1208 } 1209 1210 btrfs_item_key_to_cpu(leaf, key, i); 1211 if (!key_in_sk(key, sk)) 1212 continue; 1213 1214 sh.objectid = key->objectid; 1215 sh.offset = key->offset; 1216 sh.type = key->type; 1217 sh.len = item_len; 1218 sh.transid = found_transid; 1219 1220 /* copy search result header */ 1221 memcpy(buf + *sk_offset, &sh, sizeof(sh)); 1222 *sk_offset += sizeof(sh); 1223 1224 if (item_len) { 1225 char *p = buf + *sk_offset; 1226 /* copy the item */ 1227 read_extent_buffer(leaf, p, 1228 item_off, item_len); 1229 *sk_offset += item_len; 1230 } 1231 found++; 1232 1233 if (*num_found >= sk->nr_items) 1234 break; 1235 } 1236 advance_key: 1237 ret = 0; 1238 if (key->offset < (u64)-1 && key->offset < sk->max_offset) 1239 key->offset++; 1240 else if (key->type < (u8)-1 && key->type < sk->max_type) { 1241 key->offset = 0; 1242 key->type++; 1243 } else if (key->objectid < (u64)-1 && key->objectid < sk->max_objectid) { 1244 key->offset = 0; 1245 key->type = 0; 1246 key->objectid++; 1247 } else 1248 ret = 1; 1249 overflow: 1250 *num_found += found; 1251 return ret; 1252 } 1253 1254 static noinline int search_ioctl(struct inode *inode, 1255 struct btrfs_ioctl_search_args *args) 1256 { 1257 struct btrfs_root *root; 1258 struct btrfs_key key; 1259 struct btrfs_key max_key; 1260 struct btrfs_path *path; 1261 struct btrfs_ioctl_search_key *sk = &args->key; 1262 struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info; 1263 int ret; 1264 int num_found = 0; 1265 unsigned long sk_offset = 0; 1266 1267 path = btrfs_alloc_path(); 1268 if (!path) 1269 return -ENOMEM; 1270 1271 if (sk->tree_id == 0) { 1272 /* search the root of the inode that was passed */ 1273 root = BTRFS_I(inode)->root; 1274 } else { 1275 key.objectid = sk->tree_id; 1276 key.type = BTRFS_ROOT_ITEM_KEY; 1277 key.offset = (u64)-1; 1278 root = btrfs_read_fs_root_no_name(info, &key); 1279 if (IS_ERR(root)) { 1280 printk(KERN_ERR "could not find root %llu\n", 1281 sk->tree_id); 1282 btrfs_free_path(path); 1283 return -ENOENT; 1284 } 1285 } 1286 1287 key.objectid = sk->min_objectid; 1288 key.type = sk->min_type; 1289 key.offset = sk->min_offset; 1290 1291 max_key.objectid = sk->max_objectid; 1292 max_key.type = sk->max_type; 1293 max_key.offset = sk->max_offset; 1294 1295 path->keep_locks = 1; 1296 1297 while(1) { 1298 ret = btrfs_search_forward(root, &key, &max_key, path, 0, 1299 sk->min_transid); 1300 if (ret != 0) { 1301 if (ret > 0) 1302 ret = 0; 1303 goto err; 1304 } 1305 ret = copy_to_sk(root, path, &key, sk, args->buf, 1306 &sk_offset, &num_found); 1307 btrfs_release_path(root, path); 1308 if (ret || num_found >= sk->nr_items) 1309 break; 1310 1311 } 1312 ret = 0; 1313 err: 1314 sk->nr_items = num_found; 1315 btrfs_free_path(path); 1316 return ret; 1317 } 1318 1319 static noinline int btrfs_ioctl_tree_search(struct file *file, 1320 void __user *argp) 1321 { 1322 struct btrfs_ioctl_search_args *args; 1323 struct inode *inode; 1324 int ret; 1325 1326 if (!capable(CAP_SYS_ADMIN)) 1327 return -EPERM; 1328 1329 args = memdup_user(argp, sizeof(*args)); 1330 if (IS_ERR(args)) 1331 return PTR_ERR(args); 1332 1333 inode = fdentry(file)->d_inode; 1334 ret = search_ioctl(inode, args); 1335 if (ret == 0 && copy_to_user(argp, args, sizeof(*args))) 1336 ret = -EFAULT; 1337 kfree(args); 1338 return ret; 1339 } 1340 1341 /* 1342 * Search INODE_REFs to identify path name of 'dirid' directory 1343 * in a 'tree_id' tree. and sets path name to 'name'. 1344 */ 1345 static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, 1346 u64 tree_id, u64 dirid, char *name) 1347 { 1348 struct btrfs_root *root; 1349 struct btrfs_key key; 1350 char *ptr; 1351 int ret = -1; 1352 int slot; 1353 int len; 1354 int total_len = 0; 1355 struct btrfs_inode_ref *iref; 1356 struct extent_buffer *l; 1357 struct btrfs_path *path; 1358 1359 if (dirid == BTRFS_FIRST_FREE_OBJECTID) { 1360 name[0]='\0'; 1361 return 0; 1362 } 1363 1364 path = btrfs_alloc_path(); 1365 if (!path) 1366 return -ENOMEM; 1367 1368 ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX]; 1369 1370 key.objectid = tree_id; 1371 key.type = BTRFS_ROOT_ITEM_KEY; 1372 key.offset = (u64)-1; 1373 root = btrfs_read_fs_root_no_name(info, &key); 1374 if (IS_ERR(root)) { 1375 printk(KERN_ERR "could not find root %llu\n", tree_id); 1376 ret = -ENOENT; 1377 goto out; 1378 } 1379 1380 key.objectid = dirid; 1381 key.type = BTRFS_INODE_REF_KEY; 1382 key.offset = (u64)-1; 1383 1384 while(1) { 1385 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 1386 if (ret < 0) 1387 goto out; 1388 1389 l = path->nodes[0]; 1390 slot = path->slots[0]; 1391 if (ret > 0 && slot > 0) 1392 slot--; 1393 btrfs_item_key_to_cpu(l, &key, slot); 1394 1395 if (ret > 0 && (key.objectid != dirid || 1396 key.type != BTRFS_INODE_REF_KEY)) { 1397 ret = -ENOENT; 1398 goto out; 1399 } 1400 1401 iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref); 1402 len = btrfs_inode_ref_name_len(l, iref); 1403 ptr -= len + 1; 1404 total_len += len + 1; 1405 if (ptr < name) 1406 goto out; 1407 1408 *(ptr + len) = '/'; 1409 read_extent_buffer(l, ptr,(unsigned long)(iref + 1), len); 1410 1411 if (key.offset == BTRFS_FIRST_FREE_OBJECTID) 1412 break; 1413 1414 btrfs_release_path(root, path); 1415 key.objectid = key.offset; 1416 key.offset = (u64)-1; 1417 dirid = key.objectid; 1418 1419 } 1420 if (ptr < name) 1421 goto out; 1422 memcpy(name, ptr, total_len); 1423 name[total_len]='\0'; 1424 ret = 0; 1425 out: 1426 btrfs_free_path(path); 1427 return ret; 1428 } 1429 1430 static noinline int btrfs_ioctl_ino_lookup(struct file *file, 1431 void __user *argp) 1432 { 1433 struct btrfs_ioctl_ino_lookup_args *args; 1434 struct inode *inode; 1435 int ret; 1436 1437 if (!capable(CAP_SYS_ADMIN)) 1438 return -EPERM; 1439 1440 args = memdup_user(argp, sizeof(*args)); 1441 if (IS_ERR(args)) 1442 return PTR_ERR(args); 1443 1444 inode = fdentry(file)->d_inode; 1445 1446 if (args->treeid == 0) 1447 args->treeid = BTRFS_I(inode)->root->root_key.objectid; 1448 1449 ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info, 1450 args->treeid, args->objectid, 1451 args->name); 1452 1453 if (ret == 0 && copy_to_user(argp, args, sizeof(*args))) 1454 ret = -EFAULT; 1455 1456 kfree(args); 1457 return ret; 1458 } 1459 1460 static noinline int btrfs_ioctl_snap_destroy(struct file *file, 1461 void __user *arg) 1462 { 1463 struct dentry *parent = fdentry(file); 1464 struct dentry *dentry; 1465 struct inode *dir = parent->d_inode; 1466 struct inode *inode; 1467 struct btrfs_root *root = BTRFS_I(dir)->root; 1468 struct btrfs_root *dest = NULL; 1469 struct btrfs_ioctl_vol_args *vol_args; 1470 struct btrfs_trans_handle *trans; 1471 int namelen; 1472 int ret; 1473 int err = 0; 1474 1475 vol_args = memdup_user(arg, sizeof(*vol_args)); 1476 if (IS_ERR(vol_args)) 1477 return PTR_ERR(vol_args); 1478 1479 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 1480 namelen = strlen(vol_args->name); 1481 if (strchr(vol_args->name, '/') || 1482 strncmp(vol_args->name, "..", namelen) == 0) { 1483 err = -EINVAL; 1484 goto out; 1485 } 1486 1487 err = mnt_want_write(file->f_path.mnt); 1488 if (err) 1489 goto out; 1490 1491 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 1492 dentry = lookup_one_len(vol_args->name, parent, namelen); 1493 if (IS_ERR(dentry)) { 1494 err = PTR_ERR(dentry); 1495 goto out_unlock_dir; 1496 } 1497 1498 if (!dentry->d_inode) { 1499 err = -ENOENT; 1500 goto out_dput; 1501 } 1502 1503 inode = dentry->d_inode; 1504 dest = BTRFS_I(inode)->root; 1505 if (!capable(CAP_SYS_ADMIN)){ 1506 /* 1507 * Regular user. Only allow this with a special mount 1508 * option, when the user has write+exec access to the 1509 * subvol root, and when rmdir(2) would have been 1510 * allowed. 1511 * 1512 * Note that this is _not_ check that the subvol is 1513 * empty or doesn't contain data that we wouldn't 1514 * otherwise be able to delete. 1515 * 1516 * Users who want to delete empty subvols should try 1517 * rmdir(2). 1518 */ 1519 err = -EPERM; 1520 if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED)) 1521 goto out_dput; 1522 1523 /* 1524 * Do not allow deletion if the parent dir is the same 1525 * as the dir to be deleted. That means the ioctl 1526 * must be called on the dentry referencing the root 1527 * of the subvol, not a random directory contained 1528 * within it. 1529 */ 1530 err = -EINVAL; 1531 if (root == dest) 1532 goto out_dput; 1533 1534 err = inode_permission(inode, MAY_WRITE | MAY_EXEC); 1535 if (err) 1536 goto out_dput; 1537 1538 /* check if subvolume may be deleted by a non-root user */ 1539 err = btrfs_may_delete(dir, dentry, 1); 1540 if (err) 1541 goto out_dput; 1542 } 1543 1544 if (inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) { 1545 err = -EINVAL; 1546 goto out_dput; 1547 } 1548 1549 mutex_lock(&inode->i_mutex); 1550 err = d_invalidate(dentry); 1551 if (err) 1552 goto out_unlock; 1553 1554 down_write(&root->fs_info->subvol_sem); 1555 1556 err = may_destroy_subvol(dest); 1557 if (err) 1558 goto out_up_write; 1559 1560 trans = btrfs_start_transaction(root, 0); 1561 if (IS_ERR(trans)) { 1562 err = PTR_ERR(trans); 1563 goto out_up_write; 1564 } 1565 trans->block_rsv = &root->fs_info->global_block_rsv; 1566 1567 ret = btrfs_unlink_subvol(trans, root, dir, 1568 dest->root_key.objectid, 1569 dentry->d_name.name, 1570 dentry->d_name.len); 1571 BUG_ON(ret); 1572 1573 btrfs_record_root_in_trans(trans, dest); 1574 1575 memset(&dest->root_item.drop_progress, 0, 1576 sizeof(dest->root_item.drop_progress)); 1577 dest->root_item.drop_level = 0; 1578 btrfs_set_root_refs(&dest->root_item, 0); 1579 1580 if (!xchg(&dest->orphan_item_inserted, 1)) { 1581 ret = btrfs_insert_orphan_item(trans, 1582 root->fs_info->tree_root, 1583 dest->root_key.objectid); 1584 BUG_ON(ret); 1585 } 1586 1587 ret = btrfs_end_transaction(trans, root); 1588 BUG_ON(ret); 1589 inode->i_flags |= S_DEAD; 1590 out_up_write: 1591 up_write(&root->fs_info->subvol_sem); 1592 out_unlock: 1593 mutex_unlock(&inode->i_mutex); 1594 if (!err) { 1595 shrink_dcache_sb(root->fs_info->sb); 1596 btrfs_invalidate_inodes(dest); 1597 d_delete(dentry); 1598 } 1599 out_dput: 1600 dput(dentry); 1601 out_unlock_dir: 1602 mutex_unlock(&dir->i_mutex); 1603 mnt_drop_write(file->f_path.mnt); 1604 out: 1605 kfree(vol_args); 1606 return err; 1607 } 1608 1609 static int btrfs_ioctl_defrag(struct file *file, void __user *argp) 1610 { 1611 struct inode *inode = fdentry(file)->d_inode; 1612 struct btrfs_root *root = BTRFS_I(inode)->root; 1613 struct btrfs_ioctl_defrag_range_args *range; 1614 int ret; 1615 1616 if (btrfs_root_readonly(root)) 1617 return -EROFS; 1618 1619 ret = mnt_want_write(file->f_path.mnt); 1620 if (ret) 1621 return ret; 1622 1623 switch (inode->i_mode & S_IFMT) { 1624 case S_IFDIR: 1625 if (!capable(CAP_SYS_ADMIN)) { 1626 ret = -EPERM; 1627 goto out; 1628 } 1629 ret = btrfs_defrag_root(root, 0); 1630 if (ret) 1631 goto out; 1632 ret = btrfs_defrag_root(root->fs_info->extent_root, 0); 1633 break; 1634 case S_IFREG: 1635 if (!(file->f_mode & FMODE_WRITE)) { 1636 ret = -EINVAL; 1637 goto out; 1638 } 1639 1640 range = kzalloc(sizeof(*range), GFP_KERNEL); 1641 if (!range) { 1642 ret = -ENOMEM; 1643 goto out; 1644 } 1645 1646 if (argp) { 1647 if (copy_from_user(range, argp, 1648 sizeof(*range))) { 1649 ret = -EFAULT; 1650 kfree(range); 1651 goto out; 1652 } 1653 /* compression requires us to start the IO */ 1654 if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) { 1655 range->flags |= BTRFS_DEFRAG_RANGE_START_IO; 1656 range->extent_thresh = (u32)-1; 1657 } 1658 } else { 1659 /* the rest are all set to zero by kzalloc */ 1660 range->len = (u64)-1; 1661 } 1662 ret = btrfs_defrag_file(file, range); 1663 kfree(range); 1664 break; 1665 default: 1666 ret = -EINVAL; 1667 } 1668 out: 1669 mnt_drop_write(file->f_path.mnt); 1670 return ret; 1671 } 1672 1673 static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg) 1674 { 1675 struct btrfs_ioctl_vol_args *vol_args; 1676 int ret; 1677 1678 if (!capable(CAP_SYS_ADMIN)) 1679 return -EPERM; 1680 1681 vol_args = memdup_user(arg, sizeof(*vol_args)); 1682 if (IS_ERR(vol_args)) 1683 return PTR_ERR(vol_args); 1684 1685 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 1686 ret = btrfs_init_new_device(root, vol_args->name); 1687 1688 kfree(vol_args); 1689 return ret; 1690 } 1691 1692 static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg) 1693 { 1694 struct btrfs_ioctl_vol_args *vol_args; 1695 int ret; 1696 1697 if (!capable(CAP_SYS_ADMIN)) 1698 return -EPERM; 1699 1700 if (root->fs_info->sb->s_flags & MS_RDONLY) 1701 return -EROFS; 1702 1703 vol_args = memdup_user(arg, sizeof(*vol_args)); 1704 if (IS_ERR(vol_args)) 1705 return PTR_ERR(vol_args); 1706 1707 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0'; 1708 ret = btrfs_rm_device(root, vol_args->name); 1709 1710 kfree(vol_args); 1711 return ret; 1712 } 1713 1714 static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, 1715 u64 off, u64 olen, u64 destoff) 1716 { 1717 struct inode *inode = fdentry(file)->d_inode; 1718 struct btrfs_root *root = BTRFS_I(inode)->root; 1719 struct file *src_file; 1720 struct inode *src; 1721 struct btrfs_trans_handle *trans; 1722 struct btrfs_path *path; 1723 struct extent_buffer *leaf; 1724 char *buf; 1725 struct btrfs_key key; 1726 u32 nritems; 1727 int slot; 1728 int ret; 1729 u64 len = olen; 1730 u64 bs = root->fs_info->sb->s_blocksize; 1731 u64 hint_byte; 1732 1733 /* 1734 * TODO: 1735 * - split compressed inline extents. annoying: we need to 1736 * decompress into destination's address_space (the file offset 1737 * may change, so source mapping won't do), then recompress (or 1738 * otherwise reinsert) a subrange. 1739 * - allow ranges within the same file to be cloned (provided 1740 * they don't overlap)? 1741 */ 1742 1743 /* the destination must be opened for writing */ 1744 if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND)) 1745 return -EINVAL; 1746 1747 if (btrfs_root_readonly(root)) 1748 return -EROFS; 1749 1750 ret = mnt_want_write(file->f_path.mnt); 1751 if (ret) 1752 return ret; 1753 1754 src_file = fget(srcfd); 1755 if (!src_file) { 1756 ret = -EBADF; 1757 goto out_drop_write; 1758 } 1759 1760 src = src_file->f_dentry->d_inode; 1761 1762 ret = -EINVAL; 1763 if (src == inode) 1764 goto out_fput; 1765 1766 /* the src must be open for reading */ 1767 if (!(src_file->f_mode & FMODE_READ)) 1768 goto out_fput; 1769 1770 ret = -EISDIR; 1771 if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode)) 1772 goto out_fput; 1773 1774 ret = -EXDEV; 1775 if (src->i_sb != inode->i_sb || BTRFS_I(src)->root != root) 1776 goto out_fput; 1777 1778 ret = -ENOMEM; 1779 buf = vmalloc(btrfs_level_size(root, 0)); 1780 if (!buf) 1781 goto out_fput; 1782 1783 path = btrfs_alloc_path(); 1784 if (!path) { 1785 vfree(buf); 1786 goto out_fput; 1787 } 1788 path->reada = 2; 1789 1790 if (inode < src) { 1791 mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT); 1792 mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD); 1793 } else { 1794 mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT); 1795 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD); 1796 } 1797 1798 /* determine range to clone */ 1799 ret = -EINVAL; 1800 if (off + len > src->i_size || off + len < off) 1801 goto out_unlock; 1802 if (len == 0) 1803 olen = len = src->i_size - off; 1804 /* if we extend to eof, continue to block boundary */ 1805 if (off + len == src->i_size) 1806 len = ALIGN(src->i_size, bs) - off; 1807 1808 /* verify the end result is block aligned */ 1809 if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) || 1810 !IS_ALIGNED(destoff, bs)) 1811 goto out_unlock; 1812 1813 /* do any pending delalloc/csum calc on src, one way or 1814 another, and lock file content */ 1815 while (1) { 1816 struct btrfs_ordered_extent *ordered; 1817 lock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS); 1818 ordered = btrfs_lookup_first_ordered_extent(src, off+len); 1819 if (!ordered && 1820 !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len, 1821 EXTENT_DELALLOC, 0, NULL)) 1822 break; 1823 unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS); 1824 if (ordered) 1825 btrfs_put_ordered_extent(ordered); 1826 btrfs_wait_ordered_range(src, off, len); 1827 } 1828 1829 /* clone data */ 1830 key.objectid = src->i_ino; 1831 key.type = BTRFS_EXTENT_DATA_KEY; 1832 key.offset = 0; 1833 1834 while (1) { 1835 /* 1836 * note the key will change type as we walk through the 1837 * tree. 1838 */ 1839 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 1840 if (ret < 0) 1841 goto out; 1842 1843 nritems = btrfs_header_nritems(path->nodes[0]); 1844 if (path->slots[0] >= nritems) { 1845 ret = btrfs_next_leaf(root, path); 1846 if (ret < 0) 1847 goto out; 1848 if (ret > 0) 1849 break; 1850 nritems = btrfs_header_nritems(path->nodes[0]); 1851 } 1852 leaf = path->nodes[0]; 1853 slot = path->slots[0]; 1854 1855 btrfs_item_key_to_cpu(leaf, &key, slot); 1856 if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY || 1857 key.objectid != src->i_ino) 1858 break; 1859 1860 if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) { 1861 struct btrfs_file_extent_item *extent; 1862 int type; 1863 u32 size; 1864 struct btrfs_key new_key; 1865 u64 disko = 0, diskl = 0; 1866 u64 datao = 0, datal = 0; 1867 u8 comp; 1868 u64 endoff; 1869 1870 size = btrfs_item_size_nr(leaf, slot); 1871 read_extent_buffer(leaf, buf, 1872 btrfs_item_ptr_offset(leaf, slot), 1873 size); 1874 1875 extent = btrfs_item_ptr(leaf, slot, 1876 struct btrfs_file_extent_item); 1877 comp = btrfs_file_extent_compression(leaf, extent); 1878 type = btrfs_file_extent_type(leaf, extent); 1879 if (type == BTRFS_FILE_EXTENT_REG || 1880 type == BTRFS_FILE_EXTENT_PREALLOC) { 1881 disko = btrfs_file_extent_disk_bytenr(leaf, 1882 extent); 1883 diskl = btrfs_file_extent_disk_num_bytes(leaf, 1884 extent); 1885 datao = btrfs_file_extent_offset(leaf, extent); 1886 datal = btrfs_file_extent_num_bytes(leaf, 1887 extent); 1888 } else if (type == BTRFS_FILE_EXTENT_INLINE) { 1889 /* take upper bound, may be compressed */ 1890 datal = btrfs_file_extent_ram_bytes(leaf, 1891 extent); 1892 } 1893 btrfs_release_path(root, path); 1894 1895 if (key.offset + datal <= off || 1896 key.offset >= off+len) 1897 goto next; 1898 1899 memcpy(&new_key, &key, sizeof(new_key)); 1900 new_key.objectid = inode->i_ino; 1901 new_key.offset = key.offset + destoff - off; 1902 1903 trans = btrfs_start_transaction(root, 1); 1904 if (IS_ERR(trans)) { 1905 ret = PTR_ERR(trans); 1906 goto out; 1907 } 1908 1909 if (type == BTRFS_FILE_EXTENT_REG || 1910 type == BTRFS_FILE_EXTENT_PREALLOC) { 1911 if (off > key.offset) { 1912 datao += off - key.offset; 1913 datal -= off - key.offset; 1914 } 1915 1916 if (key.offset + datal > off + len) 1917 datal = off + len - key.offset; 1918 1919 ret = btrfs_drop_extents(trans, inode, 1920 new_key.offset, 1921 new_key.offset + datal, 1922 &hint_byte, 1); 1923 BUG_ON(ret); 1924 1925 ret = btrfs_insert_empty_item(trans, root, path, 1926 &new_key, size); 1927 BUG_ON(ret); 1928 1929 leaf = path->nodes[0]; 1930 slot = path->slots[0]; 1931 write_extent_buffer(leaf, buf, 1932 btrfs_item_ptr_offset(leaf, slot), 1933 size); 1934 1935 extent = btrfs_item_ptr(leaf, slot, 1936 struct btrfs_file_extent_item); 1937 1938 /* disko == 0 means it's a hole */ 1939 if (!disko) 1940 datao = 0; 1941 1942 btrfs_set_file_extent_offset(leaf, extent, 1943 datao); 1944 btrfs_set_file_extent_num_bytes(leaf, extent, 1945 datal); 1946 if (disko) { 1947 inode_add_bytes(inode, datal); 1948 ret = btrfs_inc_extent_ref(trans, root, 1949 disko, diskl, 0, 1950 root->root_key.objectid, 1951 inode->i_ino, 1952 new_key.offset - datao); 1953 BUG_ON(ret); 1954 } 1955 } else if (type == BTRFS_FILE_EXTENT_INLINE) { 1956 u64 skip = 0; 1957 u64 trim = 0; 1958 if (off > key.offset) { 1959 skip = off - key.offset; 1960 new_key.offset += skip; 1961 } 1962 1963 if (key.offset + datal > off+len) 1964 trim = key.offset + datal - (off+len); 1965 1966 if (comp && (skip || trim)) { 1967 ret = -EINVAL; 1968 btrfs_end_transaction(trans, root); 1969 goto out; 1970 } 1971 size -= skip + trim; 1972 datal -= skip + trim; 1973 1974 ret = btrfs_drop_extents(trans, inode, 1975 new_key.offset, 1976 new_key.offset + datal, 1977 &hint_byte, 1); 1978 BUG_ON(ret); 1979 1980 ret = btrfs_insert_empty_item(trans, root, path, 1981 &new_key, size); 1982 BUG_ON(ret); 1983 1984 if (skip) { 1985 u32 start = 1986 btrfs_file_extent_calc_inline_size(0); 1987 memmove(buf+start, buf+start+skip, 1988 datal); 1989 } 1990 1991 leaf = path->nodes[0]; 1992 slot = path->slots[0]; 1993 write_extent_buffer(leaf, buf, 1994 btrfs_item_ptr_offset(leaf, slot), 1995 size); 1996 inode_add_bytes(inode, datal); 1997 } 1998 1999 btrfs_mark_buffer_dirty(leaf); 2000 btrfs_release_path(root, path); 2001 2002 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 2003 2004 /* 2005 * we round up to the block size at eof when 2006 * determining which extents to clone above, 2007 * but shouldn't round up the file size 2008 */ 2009 endoff = new_key.offset + datal; 2010 if (endoff > destoff+olen) 2011 endoff = destoff+olen; 2012 if (endoff > inode->i_size) 2013 btrfs_i_size_write(inode, endoff); 2014 2015 BTRFS_I(inode)->flags = BTRFS_I(src)->flags; 2016 ret = btrfs_update_inode(trans, root, inode); 2017 BUG_ON(ret); 2018 btrfs_end_transaction(trans, root); 2019 } 2020 next: 2021 btrfs_release_path(root, path); 2022 key.offset++; 2023 } 2024 ret = 0; 2025 out: 2026 btrfs_release_path(root, path); 2027 unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS); 2028 out_unlock: 2029 mutex_unlock(&src->i_mutex); 2030 mutex_unlock(&inode->i_mutex); 2031 vfree(buf); 2032 btrfs_free_path(path); 2033 out_fput: 2034 fput(src_file); 2035 out_drop_write: 2036 mnt_drop_write(file->f_path.mnt); 2037 return ret; 2038 } 2039 2040 static long btrfs_ioctl_clone_range(struct file *file, void __user *argp) 2041 { 2042 struct btrfs_ioctl_clone_range_args args; 2043 2044 if (copy_from_user(&args, argp, sizeof(args))) 2045 return -EFAULT; 2046 return btrfs_ioctl_clone(file, args.src_fd, args.src_offset, 2047 args.src_length, args.dest_offset); 2048 } 2049 2050 /* 2051 * there are many ways the trans_start and trans_end ioctls can lead 2052 * to deadlocks. They should only be used by applications that 2053 * basically own the machine, and have a very in depth understanding 2054 * of all the possible deadlocks and enospc problems. 2055 */ 2056 static long btrfs_ioctl_trans_start(struct file *file) 2057 { 2058 struct inode *inode = fdentry(file)->d_inode; 2059 struct btrfs_root *root = BTRFS_I(inode)->root; 2060 struct btrfs_trans_handle *trans; 2061 int ret; 2062 2063 ret = -EPERM; 2064 if (!capable(CAP_SYS_ADMIN)) 2065 goto out; 2066 2067 ret = -EINPROGRESS; 2068 if (file->private_data) 2069 goto out; 2070 2071 ret = -EROFS; 2072 if (btrfs_root_readonly(root)) 2073 goto out; 2074 2075 ret = mnt_want_write(file->f_path.mnt); 2076 if (ret) 2077 goto out; 2078 2079 mutex_lock(&root->fs_info->trans_mutex); 2080 root->fs_info->open_ioctl_trans++; 2081 mutex_unlock(&root->fs_info->trans_mutex); 2082 2083 ret = -ENOMEM; 2084 trans = btrfs_start_ioctl_transaction(root, 0); 2085 if (!trans) 2086 goto out_drop; 2087 2088 file->private_data = trans; 2089 return 0; 2090 2091 out_drop: 2092 mutex_lock(&root->fs_info->trans_mutex); 2093 root->fs_info->open_ioctl_trans--; 2094 mutex_unlock(&root->fs_info->trans_mutex); 2095 mnt_drop_write(file->f_path.mnt); 2096 out: 2097 return ret; 2098 } 2099 2100 static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) 2101 { 2102 struct inode *inode = fdentry(file)->d_inode; 2103 struct btrfs_root *root = BTRFS_I(inode)->root; 2104 struct btrfs_root *new_root; 2105 struct btrfs_dir_item *di; 2106 struct btrfs_trans_handle *trans; 2107 struct btrfs_path *path; 2108 struct btrfs_key location; 2109 struct btrfs_disk_key disk_key; 2110 struct btrfs_super_block *disk_super; 2111 u64 features; 2112 u64 objectid = 0; 2113 u64 dir_id; 2114 2115 if (!capable(CAP_SYS_ADMIN)) 2116 return -EPERM; 2117 2118 if (copy_from_user(&objectid, argp, sizeof(objectid))) 2119 return -EFAULT; 2120 2121 if (!objectid) 2122 objectid = root->root_key.objectid; 2123 2124 location.objectid = objectid; 2125 location.type = BTRFS_ROOT_ITEM_KEY; 2126 location.offset = (u64)-1; 2127 2128 new_root = btrfs_read_fs_root_no_name(root->fs_info, &location); 2129 if (IS_ERR(new_root)) 2130 return PTR_ERR(new_root); 2131 2132 if (btrfs_root_refs(&new_root->root_item) == 0) 2133 return -ENOENT; 2134 2135 path = btrfs_alloc_path(); 2136 if (!path) 2137 return -ENOMEM; 2138 path->leave_spinning = 1; 2139 2140 trans = btrfs_start_transaction(root, 1); 2141 if (!trans) { 2142 btrfs_free_path(path); 2143 return -ENOMEM; 2144 } 2145 2146 dir_id = btrfs_super_root_dir(&root->fs_info->super_copy); 2147 di = btrfs_lookup_dir_item(trans, root->fs_info->tree_root, path, 2148 dir_id, "default", 7, 1); 2149 if (IS_ERR_OR_NULL(di)) { 2150 btrfs_free_path(path); 2151 btrfs_end_transaction(trans, root); 2152 printk(KERN_ERR "Umm, you don't have the default dir item, " 2153 "this isn't going to work\n"); 2154 return -ENOENT; 2155 } 2156 2157 btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key); 2158 btrfs_set_dir_item_key(path->nodes[0], di, &disk_key); 2159 btrfs_mark_buffer_dirty(path->nodes[0]); 2160 btrfs_free_path(path); 2161 2162 disk_super = &root->fs_info->super_copy; 2163 features = btrfs_super_incompat_flags(disk_super); 2164 if (!(features & BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL)) { 2165 features |= BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL; 2166 btrfs_set_super_incompat_flags(disk_super, features); 2167 } 2168 btrfs_end_transaction(trans, root); 2169 2170 return 0; 2171 } 2172 2173 static void get_block_group_info(struct list_head *groups_list, 2174 struct btrfs_ioctl_space_info *space) 2175 { 2176 struct btrfs_block_group_cache *block_group; 2177 2178 space->total_bytes = 0; 2179 space->used_bytes = 0; 2180 space->flags = 0; 2181 list_for_each_entry(block_group, groups_list, list) { 2182 space->flags = block_group->flags; 2183 space->total_bytes += block_group->key.offset; 2184 space->used_bytes += 2185 btrfs_block_group_used(&block_group->item); 2186 } 2187 } 2188 2189 long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg) 2190 { 2191 struct btrfs_ioctl_space_args space_args; 2192 struct btrfs_ioctl_space_info space; 2193 struct btrfs_ioctl_space_info *dest; 2194 struct btrfs_ioctl_space_info *dest_orig; 2195 struct btrfs_ioctl_space_info *user_dest; 2196 struct btrfs_space_info *info; 2197 u64 types[] = {BTRFS_BLOCK_GROUP_DATA, 2198 BTRFS_BLOCK_GROUP_SYSTEM, 2199 BTRFS_BLOCK_GROUP_METADATA, 2200 BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA}; 2201 int num_types = 4; 2202 int alloc_size; 2203 int ret = 0; 2204 int slot_count = 0; 2205 int i, c; 2206 2207 if (copy_from_user(&space_args, 2208 (struct btrfs_ioctl_space_args __user *)arg, 2209 sizeof(space_args))) 2210 return -EFAULT; 2211 2212 for (i = 0; i < num_types; i++) { 2213 struct btrfs_space_info *tmp; 2214 2215 info = NULL; 2216 rcu_read_lock(); 2217 list_for_each_entry_rcu(tmp, &root->fs_info->space_info, 2218 list) { 2219 if (tmp->flags == types[i]) { 2220 info = tmp; 2221 break; 2222 } 2223 } 2224 rcu_read_unlock(); 2225 2226 if (!info) 2227 continue; 2228 2229 down_read(&info->groups_sem); 2230 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) { 2231 if (!list_empty(&info->block_groups[c])) 2232 slot_count++; 2233 } 2234 up_read(&info->groups_sem); 2235 } 2236 2237 /* space_slots == 0 means they are asking for a count */ 2238 if (space_args.space_slots == 0) { 2239 space_args.total_spaces = slot_count; 2240 goto out; 2241 } 2242 2243 slot_count = min_t(int, space_args.space_slots, slot_count); 2244 2245 alloc_size = sizeof(*dest) * slot_count; 2246 2247 /* we generally have at most 6 or so space infos, one for each raid 2248 * level. So, a whole page should be more than enough for everyone 2249 */ 2250 if (alloc_size > PAGE_CACHE_SIZE) 2251 return -ENOMEM; 2252 2253 space_args.total_spaces = 0; 2254 dest = kmalloc(alloc_size, GFP_NOFS); 2255 if (!dest) 2256 return -ENOMEM; 2257 dest_orig = dest; 2258 2259 /* now we have a buffer to copy into */ 2260 for (i = 0; i < num_types; i++) { 2261 struct btrfs_space_info *tmp; 2262 2263 info = NULL; 2264 rcu_read_lock(); 2265 list_for_each_entry_rcu(tmp, &root->fs_info->space_info, 2266 list) { 2267 if (tmp->flags == types[i]) { 2268 info = tmp; 2269 break; 2270 } 2271 } 2272 rcu_read_unlock(); 2273 2274 if (!info) 2275 continue; 2276 down_read(&info->groups_sem); 2277 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) { 2278 if (!list_empty(&info->block_groups[c])) { 2279 get_block_group_info(&info->block_groups[c], 2280 &space); 2281 memcpy(dest, &space, sizeof(space)); 2282 dest++; 2283 space_args.total_spaces++; 2284 } 2285 } 2286 up_read(&info->groups_sem); 2287 } 2288 2289 user_dest = (struct btrfs_ioctl_space_info *) 2290 (arg + sizeof(struct btrfs_ioctl_space_args)); 2291 2292 if (copy_to_user(user_dest, dest_orig, alloc_size)) 2293 ret = -EFAULT; 2294 2295 kfree(dest_orig); 2296 out: 2297 if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args))) 2298 ret = -EFAULT; 2299 2300 return ret; 2301 } 2302 2303 /* 2304 * there are many ways the trans_start and trans_end ioctls can lead 2305 * to deadlocks. They should only be used by applications that 2306 * basically own the machine, and have a very in depth understanding 2307 * of all the possible deadlocks and enospc problems. 2308 */ 2309 long btrfs_ioctl_trans_end(struct file *file) 2310 { 2311 struct inode *inode = fdentry(file)->d_inode; 2312 struct btrfs_root *root = BTRFS_I(inode)->root; 2313 struct btrfs_trans_handle *trans; 2314 2315 trans = file->private_data; 2316 if (!trans) 2317 return -EINVAL; 2318 file->private_data = NULL; 2319 2320 btrfs_end_transaction(trans, root); 2321 2322 mutex_lock(&root->fs_info->trans_mutex); 2323 root->fs_info->open_ioctl_trans--; 2324 mutex_unlock(&root->fs_info->trans_mutex); 2325 2326 mnt_drop_write(file->f_path.mnt); 2327 return 0; 2328 } 2329 2330 static noinline long btrfs_ioctl_start_sync(struct file *file, void __user *argp) 2331 { 2332 struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root; 2333 struct btrfs_trans_handle *trans; 2334 u64 transid; 2335 2336 trans = btrfs_start_transaction(root, 0); 2337 transid = trans->transid; 2338 btrfs_commit_transaction_async(trans, root, 0); 2339 2340 if (argp) 2341 if (copy_to_user(argp, &transid, sizeof(transid))) 2342 return -EFAULT; 2343 return 0; 2344 } 2345 2346 static noinline long btrfs_ioctl_wait_sync(struct file *file, void __user *argp) 2347 { 2348 struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root; 2349 u64 transid; 2350 2351 if (argp) { 2352 if (copy_from_user(&transid, argp, sizeof(transid))) 2353 return -EFAULT; 2354 } else { 2355 transid = 0; /* current trans */ 2356 } 2357 return btrfs_wait_for_commit(root, transid); 2358 } 2359 2360 long btrfs_ioctl(struct file *file, unsigned int 2361 cmd, unsigned long arg) 2362 { 2363 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root; 2364 void __user *argp = (void __user *)arg; 2365 2366 switch (cmd) { 2367 case FS_IOC_GETFLAGS: 2368 return btrfs_ioctl_getflags(file, argp); 2369 case FS_IOC_SETFLAGS: 2370 return btrfs_ioctl_setflags(file, argp); 2371 case FS_IOC_GETVERSION: 2372 return btrfs_ioctl_getversion(file, argp); 2373 case BTRFS_IOC_SNAP_CREATE: 2374 return btrfs_ioctl_snap_create(file, argp, 0); 2375 case BTRFS_IOC_SNAP_CREATE_V2: 2376 return btrfs_ioctl_snap_create_v2(file, argp, 0); 2377 case BTRFS_IOC_SUBVOL_CREATE: 2378 return btrfs_ioctl_snap_create(file, argp, 1); 2379 case BTRFS_IOC_SNAP_DESTROY: 2380 return btrfs_ioctl_snap_destroy(file, argp); 2381 case BTRFS_IOC_SUBVOL_GETFLAGS: 2382 return btrfs_ioctl_subvol_getflags(file, argp); 2383 case BTRFS_IOC_SUBVOL_SETFLAGS: 2384 return btrfs_ioctl_subvol_setflags(file, argp); 2385 case BTRFS_IOC_DEFAULT_SUBVOL: 2386 return btrfs_ioctl_default_subvol(file, argp); 2387 case BTRFS_IOC_DEFRAG: 2388 return btrfs_ioctl_defrag(file, NULL); 2389 case BTRFS_IOC_DEFRAG_RANGE: 2390 return btrfs_ioctl_defrag(file, argp); 2391 case BTRFS_IOC_RESIZE: 2392 return btrfs_ioctl_resize(root, argp); 2393 case BTRFS_IOC_ADD_DEV: 2394 return btrfs_ioctl_add_dev(root, argp); 2395 case BTRFS_IOC_RM_DEV: 2396 return btrfs_ioctl_rm_dev(root, argp); 2397 case BTRFS_IOC_BALANCE: 2398 return btrfs_balance(root->fs_info->dev_root); 2399 case BTRFS_IOC_CLONE: 2400 return btrfs_ioctl_clone(file, arg, 0, 0, 0); 2401 case BTRFS_IOC_CLONE_RANGE: 2402 return btrfs_ioctl_clone_range(file, argp); 2403 case BTRFS_IOC_TRANS_START: 2404 return btrfs_ioctl_trans_start(file); 2405 case BTRFS_IOC_TRANS_END: 2406 return btrfs_ioctl_trans_end(file); 2407 case BTRFS_IOC_TREE_SEARCH: 2408 return btrfs_ioctl_tree_search(file, argp); 2409 case BTRFS_IOC_INO_LOOKUP: 2410 return btrfs_ioctl_ino_lookup(file, argp); 2411 case BTRFS_IOC_SPACE_INFO: 2412 return btrfs_ioctl_space_info(root, argp); 2413 case BTRFS_IOC_SYNC: 2414 btrfs_sync_fs(file->f_dentry->d_sb, 1); 2415 return 0; 2416 case BTRFS_IOC_START_SYNC: 2417 return btrfs_ioctl_start_sync(file, argp); 2418 case BTRFS_IOC_WAIT_SYNC: 2419 return btrfs_ioctl_wait_sync(file, argp); 2420 } 2421 2422 return -ENOTTY; 2423 } 2424