Lines Matching refs:ordered
42 #include "ordered-data.h"
386 * Cleanup all submitted ordered extents in specified range to handle errors
392 * to be released, which we want to happen only when finishing the ordered
413 * the ordered extent accounting for the range.
837 * This is done inside an ordered work queue, and the compression is spread
838 * across many cpus. The actual IO submission is step two, and the ordered work
1092 struct btrfs_ordered_extent *ordered;
1160 ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
1162 if (IS_ERR(ordered)) {
1164 ret = PTR_ERR(ordered);
1173 btrfs_submit_compressed_write(ordered,
1242 * allocate extents on disk for the range, and create ordered data structs
1262 * while-loop, the ordered extents created in previous iterations are cleaned up.
1343 struct btrfs_ordered_extent *ordered;
1407 ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
1409 if (IS_ERR(ordered)) {
1412 ret = PTR_ERR(ordered);
1417 ret = btrfs_reloc_clone_csums(ordered);
1423 * at out_unlock label to free meta of this ordered
1428 * skip current ordered extent.
1435 btrfs_put_ordered_extent(ordered);
1450 * free metadata of current ordered extent, we're OK to exit.
1478 * For the range (1). We have already instantiated the ordered extents
1479 * for this region, thus we need to cleanup those ordered extents.
1481 * are also handled by the ordered extents cleanup.
1504 * (or a subrange) and failed to create the respective ordered extent,
1542 * Phase two of compressed writeback. This is the ordered portion of the code,
1968 struct btrfs_ordered_extent *ordered;
1987 ordered = btrfs_alloc_ordered_extent(inode, file_pos, &nocow_args->file_extent,
1991 if (IS_ERR(ordered)) {
1995 return PTR_ERR(ordered);
2002 * metadata of the created ordered extent.
2004 ret = btrfs_reloc_clone_csums(ordered);
2005 btrfs_put_ordered_extent(ordered);
2012 * On error, we need to cleanup the ordered extents we created.
2243 * Need to clear the dirty flags and finish the ordered extents.
2267 * So for all above cases, if @cow_start is set, cleanup ordered extents
2637 * given a list of ordered sums record them in the inode. This happens
2737 struct btrfs_ordered_extent *ordered;
2771 * while waiting for the ordered extent.
2800 /* already ordered? We're done */
2804 ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE);
2805 if (ordered) {
2809 btrfs_start_ordered_extent(ordered);
2810 btrfs_put_ordered_extent(ordered);
2862 * properly happens and the data=ordered rules are followed.
2866 * to fix it up. The async helper will wait for ordered extents, set
2875 /* This folio has ordered extent covering it already */
2990 * EXTENT_DELALLOC_BIT bit through the ordered extent completion.
3056 * For delalloc, when completing an ordered extent we update the inode's
3059 * except if the ordered extent was truncated.
3071 * As ordered data IO finishes, this gets called so we can finish
3072 * an ordered extent if the range of bytes in the file it covers are
3237 * If we failed to finish this ordered extent for any reason we
3238 * need to make sure BTRFS_ORDERED_IOERR is set on the ordered
3242 * marking this ordered extent as failed.
3272 * If the ordered extent had an IOERR or something else went
3273 * wrong we need to return the space for this ordered extent
3299 * the ordered extent was created.
3309 * updating everything for this ordered extent.
3321 int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered)
3323 if (btrfs_is_zoned(ordered->inode->root->fs_info) &&
3324 !test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) &&
3325 list_empty(&ordered->bioc_list))
3326 btrfs_finish_ordered_zoned(ordered);
3327 return btrfs_finish_one_ordered(ordered);
4848 struct btrfs_ordered_extent *ordered;
4967 ordered = btrfs_lookup_ordered_extent(inode, block_start);
4968 if (ordered) {
4972 btrfs_start_ordered_extent(ordered);
4973 btrfs_put_ordered_extent(ordered);
5314 * the ordered io finishing, while we release here the extent_map and
7191 * any ordered extents.
7443 * We have folio locked so no new ordered extent can be created on this
7449 * invalidate_folio to do the same ordered extent accounting twice
7453 * do double ordered extent accounting on the same folio.
7468 * still safe to wait for ordered extent to finish.
7480 struct btrfs_ordered_extent *ordered;
7485 ordered = btrfs_lookup_first_ordered_range(inode, cur,
7487 if (!ordered) {
7490 * No ordered extent covering this range, we are safe
7496 if (ordered->file_offset > cur) {
7499 * covered by any ordered extent.
7501 * the ordered extent in the next iteration.
7503 range_end = ordered->file_offset - 1;
7508 range_end = min(ordered->file_offset + ordered->num_bytes - 1,
7525 * for any ordered extents now. Don't clear EXTENT_DELALLOC_NEW
7526 * here, must leave that up for the ordered extent completion.
7538 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
7539 ordered->truncated_len = min(ordered->truncated_len,
7540 cur - ordered->file_offset);
7544 * If the ordered extent has finished, we're safe to delete all
7549 if (btrfs_dec_test_ordered_pending(inode, &ordered,
7551 btrfs_finish_ordered_io(ordered);
7553 * The ordered extent has finished, now we're again
7559 if (ordered)
7560 btrfs_put_ordered_extent(ordered);
7585 * We have iterated through all ordered extents of the page, the page
7891 struct btrfs_ordered_extent *ordered;
7918 * If this is a free space inode do not take the ordered extents lockdep
7924 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
7925 if (!ordered)
7929 "found ordered extent %llu %llu on inode cleanup",
7930 ordered->file_offset, ordered->num_bytes);
7935 btrfs_remove_ordered_extent(inode, ordered);
7936 btrfs_put_ordered_extent(ordered);
7937 btrfs_put_ordered_extent(ordered);
9517 struct btrfs_ordered_extent *ordered;
9530 ordered = btrfs_lookup_ordered_range(inode, start,
9532 if (ordered) {
9533 btrfs_put_ordered_extent(ordered);
9540 struct btrfs_ordered_extent *ordered;
9548 ordered = btrfs_lookup_ordered_range(inode, start,
9550 if (!ordered)
9552 btrfs_put_ordered_extent(ordered);
9660 struct btrfs_ordered_extent *ordered;
9781 struct btrfs_ordered_extent *ordered;
9792 ordered = btrfs_lookup_ordered_range(inode, start, num_bytes);
9793 if (!ordered &&
9796 if (ordered)
9797 btrfs_put_ordered_extent(ordered);
9850 ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
9853 if (IS_ERR(ordered)) {
9855 ret = PTR_ERR(ordered);
9867 btrfs_submit_compressed_write(ordered, folios, nr_folios, 0, false);
10388 * Verify that there are no ordered extents for a given file range.
10397 * we have flushed all delalloc in the range, we have waited for all ordered
10404 struct btrfs_ordered_extent *ordered;
10409 ordered = btrfs_lookup_first_ordered_range(inode, start, end + 1 - start);
10410 if (ordered) {
10412 "found unexpected ordered extent in file range [%llu, %llu] for inode %llu root %llu (ordered range [%llu, %llu])",
10414 ordered->file_offset,
10415 ordered->file_offset + ordered->num_bytes - 1);
10416 btrfs_put_ordered_extent(ordered);
10419 ASSERT(ordered == NULL);