Lines Matching defs:ordered
42 #include "ordered-data.h"
82 struct btrfs_ordered_extent *ordered;
409 * Cleanup all submitted ordered extents in specified range to handle errors
415 * to be released, which we want to happen only when finishing the ordered
437 * clear page Ordered and run the ordered extent accounting.
441 * for the page range, and the ordered extent will never finish.
455 * the ordered extent accounting for the range.
828 * This is done inside an ordered work queue, and the compression is spread
829 * across many cpus. The actual IO submission is step two, and the ordered work
1113 struct btrfs_ordered_extent *ordered;
1173 ordered = btrfs_alloc_ordered_extent(inode, start, /* file_offset */
1181 if (IS_ERR(ordered)) {
1183 ret = PTR_ERR(ordered);
1192 btrfs_submit_compressed_write(ordered,
1259 * allocate extents on disk for the range, and create ordered data structs
1279 * while-loop, the ordered extents created in previous iterations are kept
1385 struct btrfs_ordered_extent *ordered;
1436 ordered = btrfs_alloc_ordered_extent(inode, start, ram_size,
1440 if (IS_ERR(ordered)) {
1441 ret = PTR_ERR(ordered);
1446 ret = btrfs_reloc_clone_csums(ordered);
1452 * at out_unlock label to free meta of this ordered
1457 * skip current ordered extent.
1464 btrfs_put_ordered_extent(ordered);
1494 * free metadata of current ordered extent, we're OK to exit.
1524 * For the range (1). We have already instantiated the ordered extents
1544 * (or a subrange) and failed to create the respective ordered extent,
1576 * Phase two of compressed writeback. This is the ordered portion of the code,
2008 struct btrfs_ordered_extent *ordered;
2169 ordered = btrfs_alloc_ordered_extent(inode, cur_offset,
2177 if (IS_ERR(ordered)) {
2182 ret = PTR_ERR(ordered);
2190 * from freeing metadata of created ordered extent.
2192 ret = btrfs_reloc_clone_csums(ordered);
2193 btrfs_put_ordered_extent(ordered);
2205 * handler, as metadata for created ordered extent will only
2580 struct btrfs_ordered_extent *ordered)
2587 /* Must always be called for the beginning of an ordered extent. */
2588 if (WARN_ON_ONCE(start != ordered->disk_bytenr))
2591 /* No need to split if the ordered extent covers the entire bio. */
2592 if (ordered->disk_num_bytes == len) {
2593 refcount_inc(&ordered->refs);
2594 bbio->ordered = ordered;
2602 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) {
2604 ordered->num_bytes, len,
2605 ordered->disk_bytenr);
2610 new = btrfs_split_ordered_extent(ordered, len);
2613 bbio->ordered = new;
2618 * given a list of ordered sums record them in the inode. This happens
2718 struct btrfs_ordered_extent *ordered;
2751 * while waiting for the ordered extent.
2780 /* already ordered? We're done */
2784 ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE);
2785 if (ordered) {
2789 btrfs_start_ordered_extent(ordered);
2790 btrfs_put_ordered_extent(ordered);
2842 * properly happens and the data=ordered rules are followed.
2846 * to fix it up. The async helper will wait for ordered extents, set
2855 /* This page has ordered extent covering it already */
2955 * EXTENT_DELALLOC_BIT bit through the ordered extent completion.
3025 * For delalloc, when completing an ordered extent we update the inode's
3028 * except if the ordered extent was truncated.
3040 * As ordered data IO finishes, this gets called so we can finish
3041 * an ordered extent if the range of bytes in the file it covers are
3197 * If we failed to finish this ordered extent for any reason we
3198 * need to make sure BTRFS_ORDERED_IOERR is set on the ordered
3202 * marking this ordered extent as failed.
3231 * If the ordered extent had an IOERR or something else went
3232 * wrong we need to return the space for this ordered extent
3258 * the ordered extent was created.
3268 * updating everything for this ordered extent.
3280 int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered)
3282 if (btrfs_is_zoned(inode_to_fs_info(ordered->inode)) &&
3283 !test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) &&
3284 list_empty(&ordered->bioc_list))
3285 btrfs_finish_ordered_zoned(ordered);
3286 return btrfs_finish_one_ordered(ordered);
4734 struct btrfs_ordered_extent *ordered;
4811 ordered = btrfs_lookup_ordered_extent(inode, block_start);
4812 if (ordered) {
4816 btrfs_start_ordered_extent(ordered);
4817 btrfs_put_ordered_extent(ordered);
5151 * the ordered io finishing, while we release here the extent_map and
7019 struct btrfs_ordered_extent *ordered;
7029 ordered = btrfs_alloc_ordered_extent(inode, start, len, len,
7034 if (IS_ERR(ordered)) {
7040 em = ERR_CAST(ordered);
7042 ASSERT(!dio_data->ordered);
7043 dio_data->ordered = ordered;
7116 * any ordered extents.
7224 struct btrfs_ordered_extent *ordered;
7237 * doing DIO to, so we need to make sure there's no ordered
7240 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), lockstart,
7250 if (!ordered &&
7257 if (ordered) {
7259 btrfs_put_ordered_extent(ordered);
7264 * If we are doing a DIO read and the ordered extent we
7270 * created an ordered extent for a previous extent map
7279 test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags))
7280 btrfs_start_ordered_extent(ordered);
7283 btrfs_put_ordered_extent(ordered);
7292 * ordered dio extent we created before but did not have
7295 * ordered extent to complete while holding a lock on
7476 * We have created our ordered extent, so we can now release our reservation
7763 btrfs_finish_ordered_extent(dio_data->ordered, NULL,
7771 btrfs_put_ordered_extent(dio_data->ordered);
7772 dio_data->ordered = NULL;
7795 btrfs_finish_ordered_extent(bbio->ordered, NULL,
7827 * the ordered extent to match the submitted bio. Hang on to the
7830 * remaining pages is blocked on the outstanding ordered extent.
7835 ret = btrfs_extract_ordered_extent(bbio, dio_data->ordered);
7837 btrfs_finish_ordered_extent(dio_data->ordered, NULL,
7893 * complete and writeback to start. We also need to wait for ordered
7909 * triggering writeback and waiting for the completion of IO and ordered
8024 * We have folio locked so no new ordered extent can be created on this
8030 * invalidate_folio to do the same ordered extent accounting twice
8034 * do double ordered extent accounting on the same folio.
8049 * still safe to wait for ordered extent to finish.
8061 struct btrfs_ordered_extent *ordered;
8066 ordered = btrfs_lookup_first_ordered_range(inode, cur,
8068 if (!ordered) {
8071 * No ordered extent covering this range, we are safe
8077 if (ordered->file_offset > cur) {
8080 * covered by any ordered extent.
8082 * the ordered extent in the next iteration.
8084 range_end = ordered->file_offset - 1;
8089 range_end = min(ordered->file_offset + ordered->num_bytes - 1,
8106 * for any ordered extents now. Don't clear EXTENT_DELALLOC_NEW
8107 * here, must leave that up for the ordered extent completion.
8119 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
8120 ordered->truncated_len = min(ordered->truncated_len,
8121 cur - ordered->file_offset);
8125 * If the ordered extent has finished, we're safe to delete all
8130 if (btrfs_dec_test_ordered_pending(inode, &ordered,
8132 btrfs_finish_ordered_io(ordered);
8134 * The ordered extent has finished, now we're again
8140 if (ordered)
8141 btrfs_put_ordered_extent(ordered);
8167 * We have iterated through all ordered extents of the page, the page
8200 struct btrfs_ordered_extent *ordered;
8265 * we can't set the delalloc bits if there are pending ordered
8268 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
8270 if (ordered) {
8274 btrfs_start_ordered_extent(ordered);
8275 btrfs_put_ordered_extent(ordered);
8653 struct btrfs_ordered_extent *ordered;
8679 * If this is a free space inode do not take the ordered extents lockdep
8685 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
8686 if (!ordered)
8690 "found ordered extent %llu %llu on inode cleanup",
8691 ordered->file_offset, ordered->num_bytes);
8696 btrfs_remove_ordered_extent(inode, ordered);
8697 btrfs_put_ordered_extent(ordered);
8698 btrfs_put_ordered_extent(ordered);
10192 struct btrfs_ordered_extent *ordered;
10199 ordered = btrfs_lookup_ordered_range(inode, start,
10201 if (!ordered)
10203 btrfs_put_ordered_extent(ordered);
10315 struct btrfs_ordered_extent *ordered;
10435 struct btrfs_ordered_extent *ordered;
10446 ordered = btrfs_lookup_ordered_range(inode, start, num_bytes);
10447 if (!ordered &&
10450 if (ordered)
10451 btrfs_put_ordered_extent(ordered);
10499 ordered = btrfs_alloc_ordered_extent(inode, start, num_bytes, ram_bytes,
10505 if (IS_ERR(ordered)) {
10507 ret = PTR_ERR(ordered);
10519 btrfs_submit_compressed_write(ordered, pages, nr_pages, 0, false);
10974 * Verify that there are no ordered extents for a given file range.
10983 * we have flushed all delalloc in the range, we have waited for all ordered
10990 struct btrfs_ordered_extent *ordered;
10995 ordered = btrfs_lookup_first_ordered_range(inode, start, end + 1 - start);
10996 if (ordered) {
10998 "found unexpected ordered extent in file range [%llu, %llu] for inode %llu root %llu (ordered range [%llu, %llu])",
11000 ordered->file_offset,
11001 ordered->file_offset + ordered->num_bytes - 1);
11002 btrfs_put_ordered_extent(ordered);
11005 ASSERT(ordered == NULL);