1 // SPDX-License-Identifier: GPL-2.0
8 #include "disk-io.h"
13 #include "delalloc-space.h"
16 #include "file-item.h"
41 	 * This value is different for compressed/non-compressed extents, thus
51 	if (defrag1->root > defrag2->root)  in compare_inode_defrag()
53 	else if (defrag1->root < defrag2->root)  in compare_inode_defrag()
54 		return -1;  in compare_inode_defrag()
55 	else if (defrag1->ino > defrag2->ino)  in compare_inode_defrag()
57 	else if (defrag1->ino < defrag2->ino)  in compare_inode_defrag()
58 		return -1;  in compare_inode_defrag()
81 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_insert_inode_defrag()
84 	node = rb_find_add(&defrag->rb_node, &fs_info->defrag_inodes, inode_defrag_cmp);  in btrfs_insert_inode_defrag()
93 		if (defrag->transid < entry->transid)  in btrfs_insert_inode_defrag()
94 			entry->transid = defrag->transid;  in btrfs_insert_inode_defrag()
95 		entry->extent_thresh = min(defrag->extent_thresh, entry->extent_thresh);  in btrfs_insert_inode_defrag()
96 		return -EEXIST;  in btrfs_insert_inode_defrag()
98 	set_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags);  in btrfs_insert_inode_defrag()
119 	struct btrfs_root *root = inode->root;  in btrfs_add_inode_defrag()
120 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_add_inode_defrag()
127 	if (test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags))  in btrfs_add_inode_defrag()
134 	defrag->ino = btrfs_ino(inode);  in btrfs_add_inode_defrag()
135 	defrag->transid = btrfs_get_root_last_trans(root);  in btrfs_add_inode_defrag()
136 	defrag->root = btrfs_root_id(root);  in btrfs_add_inode_defrag()
137 	defrag->extent_thresh = extent_thresh;  in btrfs_add_inode_defrag()
139 	spin_lock(&fs_info->defrag_inodes_lock);  in btrfs_add_inode_defrag()
140 	if (!test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags)) {  in btrfs_add_inode_defrag()
143 		 * and then re-read this inode, this new inode doesn't have  in btrfs_add_inode_defrag()
152 	spin_unlock(&fs_info->defrag_inodes_lock);  in btrfs_add_inode_defrag()
165 	struct rb_node *parent = NULL;  in btrfs_pick_defrag_inode()  local
171 	spin_lock(&fs_info->defrag_inodes_lock);  in btrfs_pick_defrag_inode()
172 	p = fs_info->defrag_inodes.rb_node;  in btrfs_pick_defrag_inode()
174 		parent = p;  in btrfs_pick_defrag_inode()
175 		entry = rb_entry(parent, struct inode_defrag, rb_node);  in btrfs_pick_defrag_inode()
179 			p = parent->rb_left;  in btrfs_pick_defrag_inode()
181 			p = parent->rb_right;  in btrfs_pick_defrag_inode()
186 	if (parent && compare_inode_defrag(&tmp, entry) > 0) {  in btrfs_pick_defrag_inode()
187 		parent = rb_next(parent);  in btrfs_pick_defrag_inode()
188 		entry = rb_entry_safe(parent, struct inode_defrag, rb_node);  in btrfs_pick_defrag_inode()
192 		rb_erase(parent, &fs_info->defrag_inodes);  in btrfs_pick_defrag_inode()
193 	spin_unlock(&fs_info->defrag_inodes_lock);  in btrfs_pick_defrag_inode()
201 	spin_lock(&fs_info->defrag_inodes_lock);  in btrfs_cleanup_defrag_inodes()
204 					     &fs_info->defrag_inodes, rb_node)  in btrfs_cleanup_defrag_inodes()
207 	fs_info->defrag_inodes = RB_ROOT;  in btrfs_cleanup_defrag_inodes()
209 	spin_unlock(&fs_info->defrag_inodes_lock);  in btrfs_cleanup_defrag_inodes()
225 	if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))  in btrfs_run_defrag_inode()
231 	inode_root = btrfs_get_fs_root(fs_info, defrag->root, true);  in btrfs_run_defrag_inode()
237 	inode = btrfs_iget(defrag->ino, inode_root);  in btrfs_run_defrag_inode()
244 	if (cur >= i_size_read(&inode->vfs_inode)) {  in btrfs_run_defrag_inode()
245 		iput(&inode->vfs_inode);  in btrfs_run_defrag_inode()
250 	clear_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags);  in btrfs_run_defrag_inode()
252 	range.len = (u64)-1;  in btrfs_run_defrag_inode()
254 	range.extent_thresh = defrag->extent_thresh;  in btrfs_run_defrag_inode()
255 	file_ra_state_init(ra, inode->vfs_inode.i_mapping);  in btrfs_run_defrag_inode()
257 	sb_start_write(fs_info->sb);  in btrfs_run_defrag_inode()
258 	ret = btrfs_defrag_file(inode, ra, &range, defrag->transid,  in btrfs_run_defrag_inode()
260 	sb_end_write(fs_info->sb);  in btrfs_run_defrag_inode()
261 	iput(&inode->vfs_inode);  in btrfs_run_defrag_inode()
266 	cur = max(cur + fs_info->sectorsize, range.start);  in btrfs_run_defrag_inode()
283 	atomic_inc(&fs_info->defrag_running);  in btrfs_run_defrag_inodes()
288 		if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))  in btrfs_run_defrag_inodes()
306 		first_ino = defrag->ino + 1;  in btrfs_run_defrag_inodes()
307 		root_objectid = defrag->root;  in btrfs_run_defrag_inodes()
311 	atomic_dec(&fs_info->defrag_running);  in btrfs_run_defrag_inodes()
317 	wake_up(&fs_info->transaction_wait);  in btrfs_run_defrag_inodes()
326 	if (blocknr < other && other - (blocknr + blocksize) < SZ_32K)  in close_blocks()
328 	if (blocknr > other && blocknr - (other + blocksize) < SZ_32K)  in close_blocks()
339 			      struct extent_buffer *parent,  in btrfs_realloc_node()  argument
343 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_realloc_node()
344 	const u32 blocksize = fs_info->nodesize;  in btrfs_realloc_node()
345 	const int end_slot = btrfs_header_nritems(parent) - 1;  in btrfs_realloc_node()
357 	if (unlikely(trans->transaction != fs_info->running_transaction ||  in btrfs_realloc_node()
358 		     trans->transid != fs_info->generation)) {  in btrfs_realloc_node()
359 		btrfs_abort_transaction(trans, -EUCLEAN);  in btrfs_realloc_node()
361 "unexpected transaction when attempting to reallocate parent %llu for root %llu, transaction %llu r…  in btrfs_realloc_node()
362 			   parent->start, btrfs_root_id(root), trans->transid,  in btrfs_realloc_node()
363 			   fs_info->running_transaction->transid,  in btrfs_realloc_node()
364 			   fs_info->generation);  in btrfs_realloc_node()
365 		return -EUCLEAN;  in btrfs_realloc_node()
368 	if (btrfs_header_nritems(parent) <= 1)  in btrfs_realloc_node()
378 		btrfs_node_key(parent, &disk_key, i);  in btrfs_realloc_node()
383 		blocknr = btrfs_node_blockptr(parent, i);  in btrfs_realloc_node()
388 			other = btrfs_node_blockptr(parent, i - 1);  in btrfs_realloc_node()
392 			other = btrfs_node_blockptr(parent, i + 1);  in btrfs_realloc_node()
400 		cur = btrfs_read_node_slot(parent, i);  in btrfs_realloc_node()
407 		ret = btrfs_force_cow_block(trans, root, cur, parent, i,  in btrfs_realloc_node()
410 						(end_slot - i) * blocksize),  in btrfs_realloc_node()
417 		search_start = cur->start;  in btrfs_realloc_node()
418 		last_block = cur->start;  in btrfs_realloc_node()
443 	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))  in btrfs_defrag_leaves()
448 		ret = -ENOMEM;  in btrfs_defrag_leaves()
452 	level = btrfs_header_level(root->node);  in btrfs_defrag_leaves()
457 	if (root->defrag_progress.objectid == 0) {  in btrfs_defrag_leaves()
463 		root->defrag_max.objectid = 0;  in btrfs_defrag_leaves()
465 		btrfs_node_key_to_cpu(root_node, &root->defrag_max,  in btrfs_defrag_leaves()
466 				      nritems - 1);  in btrfs_defrag_leaves()
471 		memcpy(&key, &root->defrag_progress, sizeof(key));  in btrfs_defrag_leaves()
474 	path->keep_locks = 1;  in btrfs_defrag_leaves()
486 	 * leafs from path->nodes[1], so set lowest_level to 1 to avoid later  in btrfs_defrag_leaves()
487 	 * a deadlock (attempting to write lock an already write locked leaf).  in btrfs_defrag_leaves()
489 	path->lowest_level = 1;  in btrfs_defrag_leaves()
496 	if (!path->nodes[1]) {  in btrfs_defrag_leaves()
501 	 * The node at level 1 must always be locked when our path has  in btrfs_defrag_leaves()
503 	 * path->slots[1].  in btrfs_defrag_leaves()
505 	ASSERT(path->locks[1] != 0);  in btrfs_defrag_leaves()
507 				 path->nodes[1], 0,  in btrfs_defrag_leaves()
509 				 &root->defrag_progress);  in btrfs_defrag_leaves()
511 		WARN_ON(ret == -EAGAIN);  in btrfs_defrag_leaves()
517 	 * without COWing, this is because even with path->keep_locks = 1,  in btrfs_defrag_leaves()
519 	 * node when path->slots[node_level - 1] does not point to the last  in btrfs_defrag_leaves()
523 	path->slots[1] = btrfs_header_nritems(path->nodes[1]);  in btrfs_defrag_leaves()
527 		memcpy(&root->defrag_progress, &key, sizeof(key));  in btrfs_defrag_leaves()
528 		ret = -EAGAIN;  in btrfs_defrag_leaves()
532 	if (ret == -EAGAIN) {  in btrfs_defrag_leaves()
533 		if (root->defrag_max.objectid > root->defrag_progress.objectid)  in btrfs_defrag_leaves()
535 		if (root->defrag_max.type > root->defrag_progress.type)  in btrfs_defrag_leaves()
537 		if (root->defrag_max.offset > root->defrag_progress.offset)  in btrfs_defrag_leaves()
542 	if (ret != -EAGAIN)  in btrfs_defrag_leaves()
543 		memset(&root->defrag_progress, 0,  in btrfs_defrag_leaves()
544 		       sizeof(root->defrag_progress));  in btrfs_defrag_leaves()
554 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_defrag_root()
557 	if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state))  in btrfs_defrag_root()
575 		if (btrfs_fs_closing(fs_info) || ret != -EAGAIN)  in btrfs_defrag_root()
580 			ret = -EAGAIN;  in btrfs_defrag_root()
584 	clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state);  in btrfs_defrag_root()
593  * - No extent_map will be added to inode->extent_tree
596  * - Extra optimization to skip file extents older than @newer_than
610 	struct btrfs_root *root = inode->root;  in defrag_get_extent()
620 		ret = -ENOMEM;  in defrag_get_extent()
647 		path.slots[0] = btrfs_header_nritems(path.nodes[0]) - 1;  in defrag_get_extent()
659 			path.slots[0]--;  in defrag_get_extent()
685 		 *	|	|<- File extent ->|  in defrag_get_extent()
686 		 *	\- start  in defrag_get_extent()
691 			em->start = start;  in defrag_get_extent()
692 			em->disk_bytenr = EXTENT_MAP_HOLE;  in defrag_get_extent()
693 			em->disk_num_bytes = 0;  in defrag_get_extent()
694 			em->ram_bytes = 0;  in defrag_get_extent()
695 			em->offset = 0;  in defrag_get_extent()
696 			em->len = key.offset - start;  in defrag_get_extent()
705 		 *	|<- file extent ->|	|  in defrag_get_extent()
706 		 *				\- start  in defrag_get_extent()
738 					       u64 newer_than, bool locked)  in defrag_lookup_extent()  argument
740 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;  in defrag_lookup_extent()
741 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in defrag_lookup_extent()
743 	const u32 sectorsize = BTRFS_I(inode)->root->fs_info->sectorsize;  in defrag_lookup_extent()
749 	read_lock(&em_tree->lock);  in defrag_lookup_extent()
751 	read_unlock(&em_tree->lock);  in defrag_lookup_extent()
754 	 * We can get a merged extent, in that case, we need to re-search  in defrag_lookup_extent()
762 	if (em && (em->flags & EXTENT_FLAG_MERGED)) {  in defrag_lookup_extent()
769 		u64 end = start + sectorsize - 1;  in defrag_lookup_extent()
772 		if (!locked)  in defrag_lookup_extent()
775 		if (!locked)  in defrag_lookup_extent()
790 	return fs_info->max_extent_size;  in get_extent_max_capacity()
794 				     u32 extent_thresh, u64 newer_than, bool locked)  in defrag_check_next_extent()  argument
801 	if (em->start + em->len >= i_size_read(inode))  in defrag_check_next_extent()
810 	next = defrag_lookup_extent(inode, em->start + em->len, newer_than, locked);  in defrag_check_next_extent()
812 	if (!next || next->disk_bytenr >= EXTENT_MAP_LAST_BYTE)  in defrag_check_next_extent()
814 	if (next->flags & EXTENT_FLAG_PREALLOC)  in defrag_check_next_extent()
820 	if (next->len >= get_extent_max_capacity(fs_info, em))  in defrag_check_next_extent()
823 	if (next->generation < newer_than)  in defrag_check_next_extent()
826 	if (next->len >= extent_thresh)  in defrag_check_next_extent()
840  * - Returned page is locked and has been set up properly.
841  * - No ordered extent exists in the page.
842  * - The page is uptodate.
849 	struct address_space *mapping = inode->vfs_inode.i_mapping;  in defrag_prepare_one_folio()
865 	 * Since we can defragment files opened read-only, we can encounter  in defrag_prepare_one_folio()
878 		return ERR_PTR(-ETXTBSY);  in defrag_prepare_one_folio()
889 	lock_end = folio_end(folio) - 1;  in defrag_prepare_one_folio()
894 		btrfs_lock_extent(&inode->io_tree, lock_start, lock_end, &cached_state);  in defrag_prepare_one_folio()
896 		btrfs_unlock_extent(&inode->io_tree, lock_start, lock_end, &cached_state);  in defrag_prepare_one_folio()
908 		if (folio->mapping != mapping || !folio->private) {  in defrag_prepare_one_folio()
922 		if (folio->mapping != mapping || !folio->private) {  in defrag_prepare_one_folio()
930 			return ERR_PTR(-EIO);  in defrag_prepare_one_folio()
950  * @do_compress:   whether the defrag is doing compression or no-compression
953  * @locked:	   if the range has already held extent lock
959 				  bool locked, struct list_head *target_list,  in defrag_collect_targets()  argument
962 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in defrag_collect_targets()
974 		em = defrag_lookup_extent(&inode->vfs_inode, cur, newer_than, locked);  in defrag_collect_targets()
984 		if (em->disk_bytenr == EXTENT_MAP_INLINE &&  in defrag_collect_targets()
985 		    em->len <= inode->root->fs_info->max_inline)  in defrag_collect_targets()
989 		if (em->disk_bytenr == EXTENT_MAP_HOLE ||  in defrag_collect_targets()
990 		    (em->flags & EXTENT_FLAG_PREALLOC))  in defrag_collect_targets()
994 		if (em->generation < newer_than)  in defrag_collect_targets()
998 		if (em->generation == (u64)-1)  in defrag_collect_targets()
1005 		range_len = em->len - (cur - em->start);  in defrag_collect_targets()
1015 		 *    locked, and starting writeback, or finishing an ordered  in defrag_collect_targets()
1026 		if (btrfs_test_range_bit_exists(&inode->io_tree, cur, cur + range_len - 1,  in defrag_collect_targets()
1038 		if (em->len >= extent_thresh)  in defrag_collect_targets()
1045 		if (em->len >= get_extent_max_capacity(fs_info, em))  in defrag_collect_targets()
1054 		if (em->disk_bytenr == EXTENT_MAP_INLINE)  in defrag_collect_targets()
1057 		next_mergeable = defrag_check_next_extent(&inode->vfs_inode, em,  in defrag_collect_targets()
1058 						extent_thresh, newer_than, locked);  in defrag_collect_targets()
1068 			if (last->start + last->len != cur)  in defrag_collect_targets()
1076 		range_len = min(btrfs_extent_map_end(em), start + len) - cur;  in defrag_collect_targets()
1086 			ASSERT(last->start + last->len <= cur);  in defrag_collect_targets()
1087 			if (last->start + last->len == cur) {  in defrag_collect_targets()
1089 				last->len += range_len;  in defrag_collect_targets()
1099 			ret = -ENOMEM;  in defrag_collect_targets()
1102 		new->start = cur;  in defrag_collect_targets()
1103 		new->len = range_len;  in defrag_collect_targets()
1104 		list_add_tail(&new->list, target_list);  in defrag_collect_targets()
1115 			list_del_init(&entry->list);  in defrag_collect_targets()
1141  * @pages:	locked pages covering the defrag range
1142  * @nr_pages:	number of locked pages
1146  * - Pages are prepared
1147  *   Pages should be locked, no ordered extent in the pages range,
1150  * - Extent bits are locked
1157 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in defrag_one_locked_target()
1159 	const u64 start = target->start;  in defrag_one_locked_target()
1160 	const u64 len = target->len;  in defrag_one_locked_target()
1166 	btrfs_clear_extent_bit(&inode->io_tree, start, start + len - 1,  in defrag_one_locked_target()
1169 	btrfs_set_extent_bit(&inode->io_tree, start, start + len - 1,  in defrag_one_locked_target()
1201 	const u32 sectorsize = inode->root->fs_info->sectorsize;  in defrag_one_range()
1203 	const unsigned int nr_pages = ((start + len - 1) >> PAGE_SHIFT) -  in defrag_one_range()
1212 		return -ENOMEM;  in defrag_one_range()
1233 	btrfs_lock_extent(&inode->io_tree, folio_pos(folios[0]), cur - 1, &cached_state);  in defrag_one_range()
1235 	 * Now we have a consistent view about the extent map, re-check  in defrag_one_range()
1238 	 * And this time we have extent locked already, pass @locked = true  in defrag_one_range()
1255 		list_del_init(&entry->list);  in defrag_one_range()
1259 	btrfs_unlock_extent(&inode->io_tree, folio_pos(folios[0]), cur - 1, &cached_state);  in defrag_one_range()
1279 	const u32 sectorsize = inode->root->fs_info->sectorsize;  in defrag_one_cluster()
1292 		u32 range_len = entry->len;  in defrag_one_cluster()
1302 				(max_sectors - *sectors_defragged) * sectorsize);  in defrag_one_cluster()
1310 		if (entry->start + range_len <= *last_scanned_ret)  in defrag_one_cluster()
1313 		page_cache_sync_readahead(inode->vfs_inode.i_mapping,  in defrag_one_cluster()
1314 				ra, NULL, entry->start >> PAGE_SHIFT,  in defrag_one_cluster()
1315 				((entry->start + range_len - 1) >> PAGE_SHIFT) -  in defrag_one_cluster()
1316 				(entry->start >> PAGE_SHIFT) + 1);  in defrag_one_cluster()
1319 		 * we locked the pages.  in defrag_one_cluster()
1323 		ret = defrag_one_range(inode, entry->start, range_len,  in defrag_one_cluster()
1329 				      inode->root->fs_info->sectorsize_bits;  in defrag_one_cluster()
1333 		list_del_init(&entry->list);  in defrag_one_cluster()
1352  * Return >=0 for the number of sectors defragged, and range->start will be updated
1361 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_defrag_file()
1363 	u64 isize = i_size_read(&inode->vfs_inode);  in btrfs_defrag_file()
1366 	bool do_compress = (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS);  in btrfs_defrag_file()
1367 	bool no_compress = (range->flags & BTRFS_DEFRAG_RANGE_NOCOMPRESS);  in btrfs_defrag_file()
1371 	u32 extent_thresh = range->extent_thresh;  in btrfs_defrag_file()
1379 	if (range->start >= isize)  in btrfs_defrag_file()
1380 		return -EINVAL;  in btrfs_defrag_file()
1383 		if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS_LEVEL) {  in btrfs_defrag_file()
1384 			if (range->compress.type >= BTRFS_NR_COMPRESS_TYPES)  in btrfs_defrag_file()
1385 				return -EINVAL;  in btrfs_defrag_file()
1386 			if (range->compress.type) {  in btrfs_defrag_file()
1387 				compress_type  = range->compress.type;  in btrfs_defrag_file()
1388 				compress_level = range->compress.level;  in btrfs_defrag_file()
1390 					return -EINVAL;  in btrfs_defrag_file()
1393 			if (range->compress_type >= BTRFS_NR_COMPRESS_TYPES)  in btrfs_defrag_file()
1394 				return -EINVAL;  in btrfs_defrag_file()
1395 			if (range->compress_type)  in btrfs_defrag_file()
1396 				compress_type = range->compress_type;  in btrfs_defrag_file()
1398 	} else if (range->flags & BTRFS_DEFRAG_RANGE_NOCOMPRESS) {  in btrfs_defrag_file()
1406 	if (range->start + range->len > range->start) {  in btrfs_defrag_file()
1408 		last_byte = min(isize, range->start + range->len);  in btrfs_defrag_file()
1415 	cur = round_down(range->start, fs_info->sectorsize);  in btrfs_defrag_file()
1416 	last_byte = round_up(last_byte, fs_info->sectorsize) - 1;  in btrfs_defrag_file()
1423 	if (start_index < inode->vfs_inode.i_mapping->writeback_index)  in btrfs_defrag_file()
1424 		inode->vfs_inode.i_mapping->writeback_index = start_index;  in btrfs_defrag_file()
1432 			ret = -EAGAIN;  in btrfs_defrag_file()
1438 			       (SZ_256K >> PAGE_SHIFT)) << PAGE_SHIFT) - 1;  in btrfs_defrag_file()
1442 		if (IS_SWAPFILE(&inode->vfs_inode)) {  in btrfs_defrag_file()
1443 			ret = -ETXTBSY;  in btrfs_defrag_file()
1447 		if (!(inode->vfs_inode.i_sb->s_flags & SB_ACTIVE)) {  in btrfs_defrag_file()
1452 			inode->defrag_compress = compress_type;  in btrfs_defrag_file()
1453 			inode->defrag_compress_level = compress_level;  in btrfs_defrag_file()
1456 				cluster_end + 1 - cur, extent_thresh,  in btrfs_defrag_file()
1462 			balance_dirty_pages_ratelimited(inode->vfs_inode.i_mapping);  in btrfs_defrag_file()
1479 	range->start = cur;  in btrfs_defrag_file()
1485 		if (range->flags & BTRFS_DEFRAG_RANGE_START_IO) {  in btrfs_defrag_file()
1486 			filemap_flush(inode->vfs_inode.i_mapping);  in btrfs_defrag_file()
1488 				     &inode->runtime_flags))  in btrfs_defrag_file()
1489 				filemap_flush(inode->vfs_inode.i_mapping);  in btrfs_defrag_file()
1491 		if (range->compress_type == BTRFS_COMPRESS_LZO)  in btrfs_defrag_file()
1493 		else if (range->compress_type == BTRFS_COMPRESS_ZSTD)  in btrfs_defrag_file()
1499 		inode->defrag_compress = BTRFS_COMPRESS_NONE;  in btrfs_defrag_file()
1515 		return -ENOMEM;  in btrfs_auto_defrag_init()