Lines Matching refs: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,
1258 * allocate extents on disk for the range, and create ordered data structs
1278 * while-loop, the ordered extents created in previous iterations are kept
1384 struct btrfs_ordered_extent *ordered;
1435 ordered = btrfs_alloc_ordered_extent(inode, start, ram_size,
1439 if (IS_ERR(ordered)) {
1440 ret = PTR_ERR(ordered);
1445 ret = btrfs_reloc_clone_csums(ordered);
1451 * at out_unlock label to free meta of this ordered
1456 * skip current ordered extent.
1463 btrfs_put_ordered_extent(ordered);
1493 * free metadata of current ordered extent, we're OK to exit.
1523 * For the range (1). We have already instantiated the ordered extents
1543 * (or a subrange) and failed to create the respective ordered extent,
1575 * Phase two of compressed writeback. This is the ordered portion of the code,
2007 struct btrfs_ordered_extent *ordered;
2168 ordered = btrfs_alloc_ordered_extent(inode, cur_offset,
2176 if (IS_ERR(ordered)) {
2181 ret = PTR_ERR(ordered);
2189 * from freeing metadata of created ordered extent.
2191 ret = btrfs_reloc_clone_csums(ordered);
2192 btrfs_put_ordered_extent(ordered);
2204 * handler, as metadata for created ordered extent will only
2579 struct btrfs_ordered_extent *ordered)
2586 /* Must always be called for the beginning of an ordered extent. */
2587 if (WARN_ON_ONCE(start != ordered->disk_bytenr))
2590 /* No need to split if the ordered extent covers the entire bio. */
2591 if (ordered->disk_num_bytes == len) {
2592 refcount_inc(&ordered->refs);
2593 bbio->ordered = ordered;
2601 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) {
2603 ordered->num_bytes, len,
2604 ordered->disk_bytenr);
2609 new = btrfs_split_ordered_extent(ordered, len);
2612 bbio->ordered = new;
2617 * given a list of ordered sums record them in the inode. This happens
2717 struct btrfs_ordered_extent *ordered;
2750 * while waiting for the ordered extent.
2779 /* already ordered? We're done */
2783 ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE);
2784 if (ordered) {
2788 btrfs_start_ordered_extent(ordered);
2789 btrfs_put_ordered_extent(ordered);
2841 * properly happens and the data=ordered rules are followed.
2845 * to fix it up. The async helper will wait for ordered extents, set
2854 /* This page has ordered extent covering it already */
2954 * EXTENT_DELALLOC_BIT bit through the ordered extent completion.
3024 * For delalloc, when completing an ordered extent we update the inode's
3027 * except if the ordered extent was truncated.
3039 * As ordered data IO finishes, this gets called so we can finish
3040 * an ordered extent if the range of bytes in the file it covers are
3196 * If we failed to finish this ordered extent for any reason we
3197 * need to make sure BTRFS_ORDERED_IOERR is set on the ordered
3201 * marking this ordered extent as failed.
3230 * If the ordered extent had an IOERR or something else went
3231 * wrong we need to return the space for this ordered extent
3257 * the ordered extent was created.
3267 * updating everything for this ordered extent.
3279 int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered)
3281 if (btrfs_is_zoned(inode_to_fs_info(ordered->inode)) &&
3282 !test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) &&
3283 list_empty(&ordered->bioc_list))
3284 btrfs_finish_ordered_zoned(ordered);
3285 return btrfs_finish_one_ordered(ordered);
4733 struct btrfs_ordered_extent *ordered;
4810 ordered = btrfs_lookup_ordered_extent(inode, block_start);
4811 if (ordered) {
4815 btrfs_start_ordered_extent(ordered);
4816 btrfs_put_ordered_extent(ordered);
5150 * the ordered io finishing, while we release here the extent_map and
7018 struct btrfs_ordered_extent *ordered;
7028 ordered = btrfs_alloc_ordered_extent(inode, start, len, len,
7033 if (IS_ERR(ordered)) {
7039 em = ERR_CAST(ordered);
7041 ASSERT(!dio_data->ordered);
7042 dio_data->ordered = ordered;
7115 * any ordered extents.
7223 struct btrfs_ordered_extent *ordered;
7236 * doing DIO to, so we need to make sure there's no ordered
7239 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), lockstart,
7249 if (!ordered &&
7256 if (ordered) {
7258 btrfs_put_ordered_extent(ordered);
7263 * If we are doing a DIO read and the ordered extent we
7269 * created an ordered extent for a previous extent map
7278 test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags))
7279 btrfs_start_ordered_extent(ordered);
7282 btrfs_put_ordered_extent(ordered);
7291 * ordered dio extent we created before but did not have
7294 * ordered extent to complete while holding a lock on
7475 * We have created our ordered extent, so we can now release our reservation
7762 btrfs_finish_ordered_extent(dio_data->ordered, NULL,
7770 btrfs_put_ordered_extent(dio_data->ordered);
7771 dio_data->ordered = NULL;
7794 btrfs_finish_ordered_extent(bbio->ordered, NULL,
7826 * the ordered extent to match the submitted bio. Hang on to the
7829 * remaining pages is blocked on the outstanding ordered extent.
7834 ret = btrfs_extract_ordered_extent(bbio, dio_data->ordered);
7836 btrfs_finish_ordered_extent(dio_data->ordered, NULL,
7892 * complete and writeback to start. We also need to wait for ordered
7908 * triggering writeback and waiting for the completion of IO and ordered
8023 * We have folio locked so no new ordered extent can be created on this
8029 * invalidate_folio to do the same ordered extent accounting twice
8033 * do double ordered extent accounting on the same folio.
8048 * still safe to wait for ordered extent to finish.
8060 struct btrfs_ordered_extent *ordered;
8065 ordered = btrfs_lookup_first_ordered_range(inode, cur,
8067 if (!ordered) {
8070 * No ordered extent covering this range, we are safe
8076 if (ordered->file_offset > cur) {
8079 * covered by any ordered extent.
8081 * the ordered extent in the next iteration.
8083 range_end = ordered->file_offset - 1;
8088 range_end = min(ordered->file_offset + ordered->num_bytes - 1,
8105 * for any ordered extents now. Don't clear EXTENT_DELALLOC_NEW
8106 * here, must leave that up for the ordered extent completion.
8118 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
8119 ordered->truncated_len = min(ordered->truncated_len,
8120 cur - ordered->file_offset);
8124 * If the ordered extent has finished, we're safe to delete all
8129 if (btrfs_dec_test_ordered_pending(inode, &ordered,
8131 btrfs_finish_ordered_io(ordered);
8133 * The ordered extent has finished, now we're again
8139 if (ordered)
8140 btrfs_put_ordered_extent(ordered);
8166 * We have iterated through all ordered extents of the page, the page
8199 struct btrfs_ordered_extent *ordered;
8264 * we can't set the delalloc bits if there are pending ordered
8267 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
8269 if (ordered) {
8273 btrfs_start_ordered_extent(ordered);
8274 btrfs_put_ordered_extent(ordered);
8652 struct btrfs_ordered_extent *ordered;
8678 * If this is a free space inode do not take the ordered extents lockdep
8684 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
8685 if (!ordered)
8689 "found ordered extent %llu %llu on inode cleanup",
8690 ordered->file_offset, ordered->num_bytes);
8695 btrfs_remove_ordered_extent(inode, ordered);
8696 btrfs_put_ordered_extent(ordered);
8697 btrfs_put_ordered_extent(ordered);
10191 struct btrfs_ordered_extent *ordered;
10198 ordered = btrfs_lookup_ordered_range(inode, start,
10200 if (!ordered)
10202 btrfs_put_ordered_extent(ordered);
10314 struct btrfs_ordered_extent *ordered;
10434 struct btrfs_ordered_extent *ordered;
10445 ordered = btrfs_lookup_ordered_range(inode, start, num_bytes);
10446 if (!ordered &&
10449 if (ordered)
10450 btrfs_put_ordered_extent(ordered);
10498 ordered = btrfs_alloc_ordered_extent(inode, start, num_bytes, ram_bytes,
10504 if (IS_ERR(ordered)) {
10506 ret = PTR_ERR(ordered);
10518 btrfs_submit_compressed_write(ordered, pages, nr_pages, 0, false);
10973 * Verify that there are no ordered extents for a given file range.
10982 * we have flushed all delalloc in the range, we have waited for all ordered
10989 struct btrfs_ordered_extent *ordered;
10994 ordered = btrfs_lookup_first_ordered_range(inode, start, end + 1 - start);
10995 if (ordered) {
10997 "found unexpected ordered extent in file range [%llu, %llu] for inode %llu root %llu (ordered range [%llu, %llu])",
10999 ordered->file_offset,
11000 ordered->file_offset + ordered->num_bytes - 1);
11001 btrfs_put_ordered_extent(ordered);
11004 ASSERT(ordered == NULL);