fs/btrfs/ordered-data.c

123  * look find the first ordered struct that has this offset, otherwise
164 		 * The ordered extent has reserved qgroup space, release now
228 				"inconsistency in ordered tree at offset %llu",
246  * Add an ordered extent to the per-inode tree.
259  * tree is given a single reference on the ordered extent that was inserted, and
262  * Return: the new ordered extent or error pointer.
284  * when an ordered extent is finished.  If the list covers more than one
285  * ordered extent, it is split across multiples.
305 static bool can_finish_ordered_extent(struct btrfs_ordered_extent *ordered,
309 	struct btrfs_inode *inode = BTRFS_I(ordered->inode);
321 		 * pending io unfinished for the ordered extent.
332 	if (WARN_ON_ONCE(len > ordered->bytes_left)) {
334 "bad ordered extent accounting, root=%llu ino=%llu OE offset=%llu OE len=%llu to_dec=%llu left=%llu",
336 			   ordered->file_offset, ordered->num_bytes,
337 			   len, ordered->bytes_left);
338 		ordered->bytes_left = 0;
340 		ordered->bytes_left -= len;
344 		set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
346 	if (ordered->bytes_left)
350 	 * All the IO of the ordered extent is finished, we need to queue
353 	set_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags);
354 	cond_wake_up(&ordered->wait);
355 	refcount_inc(&ordered->refs);
356 	trace_btrfs_ordered_extent_mark_finished(inode, ordered);
360 static void btrfs_queue_ordered_fn(struct btrfs_ordered_extent *ordered)
362 	struct btrfs_inode *inode = BTRFS_I(ordered->inode);
367 	btrfs_init_work(&ordered->work, finish_ordered_fn, NULL);
368 	btrfs_queue_work(wq, &ordered->work);
371 bool btrfs_finish_ordered_extent(struct btrfs_ordered_extent *ordered,
375 	struct btrfs_inode *inode = BTRFS_I(ordered->inode);
382 	ret = can_finish_ordered_extent(ordered, page, file_offset, len, uptodate);
386 		btrfs_queue_ordered_fn(ordered);
391  * Mark all ordered extents io inside the specified range finished.
395  *		 updated to indicate whether the pending ordered io is finished.
400  * This function is called for endio, thus the range must have ordered
423 		/* No ordered extents at all */
436 			/* No more ordered extents, exit */
442 			/* Go to next ordered extent and continue */
457 		 * Now we are definitely inside one ordered extent.
479  * Finish IO for one ordered extent across a given range.  The range can only
480  * contain one ordered extent.
482  * @cached:	 The cached ordered extent. If not NULL, we can skip the tree
483  *               search and use the ordered extent directly.
484  * 		 Will be also used to store the finished ordered extent.
488  * Return true if the ordered extent is finished in the range, and update
492  * NOTE: The range can NOT cross multiple ordered extents.
493  * Thus caller should ensure the range doesn't cross ordered extents.
521 			   "bad ordered accounting left %llu size %llu",
546  * used to drop a reference on an ordered extent.  This will free
573  * remove an ordered extent from the tree.  No references are dropped
586 	 * If this is a free space inode the thread has not acquired the ordered
670 	struct btrfs_ordered_extent *ordered;
672 	ordered = container_of(work, struct btrfs_ordered_extent, flush_work);
673 	btrfs_start_ordered_extent(ordered);
674 	complete(&ordered->completion);
678  * wait for all the ordered extents in a root.  This is done when balancing
688 	struct btrfs_ordered_extent *ordered, *next;
696 		ordered = list_first_entry(&splice, struct btrfs_ordered_extent,
699 		if (range_end <= ordered->disk_bytenr ||
700 		    ordered->disk_bytenr + ordered->disk_num_bytes <= range_start) {
701 			list_move_tail(&ordered->root_extent_list, &skipped);
706 		list_move_tail(&ordered->root_extent_list,
708 		refcount_inc(&ordered->refs);
711 		btrfs_init_work(&ordered->flush_work,
713 		list_add_tail(&ordered->work_list, &works);
714 		btrfs_queue_work(fs_info->flush_workers, &ordered->flush_work);
726 	list_for_each_entry_safe(ordered, next, &works, work_list) {
727 		list_del_init(&ordered->work_list);
728 		wait_for_completion(&ordered->completion);
729 		btrfs_put_ordered_extent(ordered);
771  * Start IO and wait for a given ordered extent to finish.
786 	 * If this is a free space inode do not take the ordered extents lockdep
805  * Used to wait on ordered extents across a large range of bytes.
813 	struct btrfs_ordered_extent *ordered;
832 	 * for any ordered extents that haven't completed yet. This is to make
834 	 * before the ordered extents complete - to avoid failures (-EEXIST)
835 	 * when adding the new ordered extents to the ordered tree.
841 		ordered = btrfs_lookup_first_ordered_extent(BTRFS_I(inode), end);
842 		if (!ordered)
844 		if (ordered->file_offset > orig_end) {
845 			btrfs_put_ordered_extent(ordered);
848 		if (ordered->file_offset + ordered->num_bytes <= start) {
849 			btrfs_put_ordered_extent(ordered);
852 		btrfs_start_ordered_extent(ordered);
853 		end = ordered->file_offset;
855 		 * If the ordered extent had an error save the error but don't
856 		 * exit without waiting first for all other ordered extents in
859 		if (test_bit(BTRFS_ORDERED_IOERR, &ordered->flags))
861 		btrfs_put_ordered_extent(ordered);
870  * find an ordered extent corresponding to file_offset.  return NULL if
897 /* Since the DIO code tries to lock a wide area we need to look for any ordered
938  * Adds all ordered extents to the given list. The list ends up sorted by the
939  * file_offset of the ordered extents.
950 		struct btrfs_ordered_extent *ordered;
952 		ordered = rb_entry(n, struct btrfs_ordered_extent, rb_node);
954 		if (test_bit(BTRFS_ORDERED_LOGGED, &ordered->flags))
957 		ASSERT(list_empty(&ordered->log_list));
958 		list_add_tail(&ordered->log_list, list);
959 		refcount_inc(&ordered->refs);
960 		trace_btrfs_ordered_extent_lookup_for_logging(inode, ordered);
989  * Lookup the first ordered extent that overlaps the range
993  * that this one won't return any ordered extent that does not overlap the range.
995  * ensures the first ordered extent gets returned.
1011 	 * And __tree_search() can't return the adjacent ordered extents
1023 			 * Direct hit, got an ordered extent that starts at
1053 	/* No ordered extent in the range */
1066  * Lock the passed range and ensures all pending ordered extents in it are run
1069  * @inode:        Inode whose ordered tree is to be searched
1083 	struct btrfs_ordered_extent *ordered;
1092 		ordered = btrfs_lookup_ordered_range(inode, start,
1094 		if (!ordered) {
1105 		btrfs_start_ordered_extent(ordered);
1106 		btrfs_put_ordered_extent(ordered);
1111  * Lock the passed range and ensure all pending ordered extents in it are run
1120 	struct btrfs_ordered_extent *ordered;
1125 	ordered = btrfs_lookup_ordered_range(inode, start, end - start + 1);
1126 	if (!ordered)
1129 	btrfs_put_ordered_extent(ordered);
1135 /* Split out a new ordered extent for this first @len bytes of @ordered. */
1137 			struct btrfs_ordered_extent *ordered, u64 len)
1139 	struct btrfs_inode *inode = BTRFS_I(ordered->inode);
1142 	u64 file_offset = ordered->file_offset;
1143 	u64 disk_bytenr = ordered->disk_bytenr;
1144 	unsigned long flags = ordered->flags;
1150 	trace_btrfs_ordered_extent_split(inode, ordered);
1155 	 * The entire bio must be covered by the ordered extent, but we can't
1158 	if (WARN_ON_ONCE(len >= ordered->num_bytes))
1160 	/* We cannot split partially completed ordered extents. */
1161 	if (ordered->bytes_left) {
1163 		if (WARN_ON_ONCE(ordered->bytes_left != ordered->disk_num_bytes))
1166 	/* We cannot split a compressed ordered extent. */
1167 	if (WARN_ON_ONCE(ordered->disk_num_bytes != ordered->num_bytes))
1171 				   len, 0, flags, ordered->compress_type);
1181 	node = &ordered->rb_node;
1187 	ordered->file_offset += len;
1188 	ordered->disk_bytenr += len;
1189 	ordered->num_bytes -= len;
1190 	ordered->disk_num_bytes -= len;
1192 	if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags)) {
1193 		ASSERT(ordered->bytes_left == 0);
1196 		ordered->bytes_left -= len;
1199 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags)) {
1200 		if (ordered->truncated_len > len) {
1201 			ordered->truncated_len -= len;
1203 			new->truncated_len = ordered->truncated_len;
1204 			ordered->truncated_len = 0;
1208 	list_for_each_entry_safe(sum, tmpsum, &ordered->list, list) {
1216 	node = tree_insert(&inode->ordered_tree, ordered->file_offset,
1217 			   &ordered->rb_node);
1220 			"zoned: inconsistency in ordered tree at offset %llu",
1221 			ordered->file_offset);
1226 			"zoned: inconsistency in ordered tree at offset %llu",