Lines Matching defs:ordered
124 * look find the first ordered struct that has this offset, otherwise
166 * The ordered extent has reserved qgroup space, release now
229 "inconsistency in ordered tree at offset %llu",
247 * Add an ordered extent to the per-inode tree.
260 * tree is given a single reference on the ordered extent that was inserted, and
263 * Return: the new ordered extent or error pointer.
285 * when an ordered extent is finished. If the list covers more than one
286 * ordered extent, it is split across multiples.
307 static bool can_finish_ordered_extent(struct btrfs_ordered_extent *ordered,
311 struct btrfs_inode *inode = BTRFS_I(ordered->inode);
323 * pending io unfinished for the ordered extent.
333 if (WARN_ON_ONCE(len > ordered->bytes_left)) {
335 "bad ordered extent accounting, root=%llu ino=%llu OE offset=%llu OE len=%llu to_dec=%llu left=%llu",
337 ordered->file_offset, ordered->num_bytes,
338 len, ordered->bytes_left);
339 ordered->bytes_left = 0;
341 ordered->bytes_left -= len;
345 set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
347 if (ordered->bytes_left)
351 * All the IO of the ordered extent is finished, we need to queue
354 set_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags);
355 cond_wake_up(&ordered->wait);
356 refcount_inc(&ordered->refs);
357 trace_btrfs_ordered_extent_mark_finished(inode, ordered);
361 static void btrfs_queue_ordered_fn(struct btrfs_ordered_extent *ordered)
363 struct btrfs_inode *inode = BTRFS_I(ordered->inode);
368 btrfs_init_work(&ordered->work, finish_ordered_fn, NULL, NULL);
369 btrfs_queue_work(wq, &ordered->work);
372 bool btrfs_finish_ordered_extent(struct btrfs_ordered_extent *ordered,
376 struct btrfs_inode *inode = BTRFS_I(ordered->inode);
383 ret = can_finish_ordered_extent(ordered, page, file_offset, len, uptodate);
387 btrfs_queue_ordered_fn(ordered);
392 * Mark all ordered extents io inside the specified range finished.
396 * updated to indicate whether the pending ordered io is finished.
401 * This function is called for endio, thus the range must have ordered
425 /* No ordered extents at all */
438 /* No more ordered extents, exit */
444 /* Go to next ordered extent and continue */
459 * Now we are definitely inside one ordered extent.
481 * Finish IO for one ordered extent across a given range. The range can only
482 * contain one ordered extent.
484 * @cached: The cached ordered extent. If not NULL, we can skip the tree
485 * search and use the ordered extent directly.
486 * Will be also used to store the finished ordered extent.
490 * Return true if the ordered extent is finished in the range, and update
494 * NOTE: The range can NOT cross multiple ordered extents.
495 * Thus caller should ensure the range doesn't cross ordered extents.
524 "bad ordered accounting left %llu size %llu",
549 * used to drop a reference on an ordered extent. This will free
576 * remove an ordered extent from the tree. No references are dropped
590 * If this is a free space inode the thread has not acquired the ordered
675 struct btrfs_ordered_extent *ordered;
677 ordered = container_of(work, struct btrfs_ordered_extent, flush_work);
678 btrfs_start_ordered_extent(ordered);
679 complete(&ordered->completion);
683 * wait for all the ordered extents in a root. This is done when balancing
693 struct btrfs_ordered_extent *ordered, *next;
701 ordered = list_first_entry(&splice, struct btrfs_ordered_extent,
704 if (range_end <= ordered->disk_bytenr ||
705 ordered->disk_bytenr + ordered->disk_num_bytes <= range_start) {
706 list_move_tail(&ordered->root_extent_list, &skipped);
711 list_move_tail(&ordered->root_extent_list,
713 refcount_inc(&ordered->refs);
716 btrfs_init_work(&ordered->flush_work,
718 list_add_tail(&ordered->work_list, &works);
719 btrfs_queue_work(fs_info->flush_workers, &ordered->flush_work);
731 list_for_each_entry_safe(ordered, next, &works, work_list) {
732 list_del_init(&ordered->work_list);
733 wait_for_completion(&ordered->completion);
734 btrfs_put_ordered_extent(ordered);
776 * Start IO and wait for a given ordered extent to finish.
791 * If this is a free space inode do not take the ordered extents lockdep
810 * Used to wait on ordered extents across a large range of bytes.
818 struct btrfs_ordered_extent *ordered;
837 * for any ordered extents that haven't completed yet. This is to make
839 * before the ordered extents complete - to avoid failures (-EEXIST)
840 * when adding the new ordered extents to the ordered tree.
846 ordered = btrfs_lookup_first_ordered_extent(BTRFS_I(inode), end);
847 if (!ordered)
849 if (ordered->file_offset > orig_end) {
850 btrfs_put_ordered_extent(ordered);
853 if (ordered->file_offset + ordered->num_bytes <= start) {
854 btrfs_put_ordered_extent(ordered);
857 btrfs_start_ordered_extent(ordered);
858 end = ordered->file_offset;
860 * If the ordered extent had an error save the error but don't
861 * exit without waiting first for all other ordered extents in
864 if (test_bit(BTRFS_ORDERED_IOERR, &ordered->flags))
866 btrfs_put_ordered_extent(ordered);
875 * find an ordered extent corresponding to file_offset. return NULL if
904 /* Since the DIO code tries to lock a wide area we need to look for any ordered
947 * Adds all ordered extents to the given list. The list ends up sorted by the
948 * file_offset of the ordered extents.
960 struct btrfs_ordered_extent *ordered;
962 ordered = rb_entry(n, struct btrfs_ordered_extent, rb_node);
964 if (test_bit(BTRFS_ORDERED_LOGGED, &ordered->flags))
967 ASSERT(list_empty(&ordered->log_list));
968 list_add_tail(&ordered->log_list, list);
969 refcount_inc(&ordered->refs);
970 trace_btrfs_ordered_extent_lookup_for_logging(inode, ordered);
1001 * Lookup the first ordered extent that overlaps the range
1005 * that this one won't return any ordered extent that does not overlap the range.
1007 * ensures the first ordered extent gets returned.
1024 * And __tree_search() can't return the adjacent ordered extents
1036 * Direct hit, got an ordered extent that starts at
1066 /* No ordered extent in the range */
1079 * Lock the passed range and ensures all pending ordered extents in it are run
1082 * @inode: Inode whose ordered tree is to be searched
1096 struct btrfs_ordered_extent *ordered;
1105 ordered = btrfs_lookup_ordered_range(inode, start,
1107 if (!ordered) {
1118 btrfs_start_ordered_extent(ordered);
1119 btrfs_put_ordered_extent(ordered);
1124 * Lock the passed range and ensure all pending ordered extents in it are run
1133 struct btrfs_ordered_extent *ordered;
1138 ordered = btrfs_lookup_ordered_range(inode, start, end - start + 1);
1139 if (!ordered)
1142 btrfs_put_ordered_extent(ordered);
1148 /* Split out a new ordered extent for this first @len bytes of @ordered. */
1150 struct btrfs_ordered_extent *ordered, u64 len)
1152 struct btrfs_inode *inode = BTRFS_I(ordered->inode);
1156 u64 file_offset = ordered->file_offset;
1157 u64 disk_bytenr = ordered->disk_bytenr;
1158 unsigned long flags = ordered->flags;
1164 trace_btrfs_ordered_extent_split(inode, ordered);
1169 * The entire bio must be covered by the ordered extent, but we can't
1172 if (WARN_ON_ONCE(len >= ordered->num_bytes))
1174 /* We cannot split partially completed ordered extents. */
1175 if (ordered->bytes_left) {
1177 if (WARN_ON_ONCE(ordered->bytes_left != ordered->disk_num_bytes))
1180 /* We cannot split a compressed ordered extent. */
1181 if (WARN_ON_ONCE(ordered->disk_num_bytes != ordered->num_bytes))
1185 len, 0, flags, ordered->compress_type);
1195 node = &ordered->rb_node;
1201 ordered->file_offset += len;
1202 ordered->disk_bytenr += len;
1203 ordered->num_bytes -= len;
1204 ordered->disk_num_bytes -= len;
1206 if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags)) {
1207 ASSERT(ordered->bytes_left == 0);
1210 ordered->bytes_left -= len;
1213 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags)) {
1214 if (ordered->truncated_len > len) {
1215 ordered->truncated_len -= len;
1217 new->truncated_len = ordered->truncated_len;
1218 ordered->truncated_len = 0;
1222 list_for_each_entry_safe(sum, tmpsum, &ordered->list, list) {
1230 node = tree_insert(&tree->tree, ordered->file_offset, &ordered->rb_node);
1233 "zoned: inconsistency in ordered tree at offset %llu",
1234 ordered->file_offset);
1239 "zoned: inconsistency in ordered tree at offset %llu",