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