23  * after adding space to the filesystem, we need to clear the full flags
186 	 * If we have dup, raid1 or raid10 then only half of the free  in can_overcommit()
188 	 * doesn't include the parity drive, so we don't have to  in can_overcommit()
195 	 * If we aren't flushing all things, let us overcommit up to  in can_overcommit()
196 	 * 1/2th of the space. If we can flush, don't let us overcommit  in can_overcommit()
210  * This is for space we already have accounted in space_info->bytes_may_use, so
211  * basically when we're returning space from block_rsv's.
325 		 * We needn't worry the filesystem going from r/w to r/o though  in btrfs_writeback_inodes_sb_nr()
326 		 * we don't acquire ->s_umount mutex, because the filesystem  in btrfs_writeback_inodes_sb_nr()
368 	/* Calc the number of the pages we need flush for space reservation */  in shrink_delalloc()
387 	 * If we are doing more ordered than delalloc we need to just wait on  in shrink_delalloc()
388 	 * ordered extents, otherwise we'll waste time trying to flush delalloc  in shrink_delalloc()
389 	 * that likely won't give us the space back we need.  in shrink_delalloc()
406 		 * We need to wait for the compressed pages to start before  in shrink_delalloc()
407 		 * we continue.  in shrink_delalloc()
414 		 * Calculate how many compressed pages we want to be written  in shrink_delalloc()
415 		 * before we continue. I.e if there are more async pages than we  in shrink_delalloc()
451  * @root - the root we're allocating for
452  * @bytes - the number of bytes we want to reserve
504 	 * we have block groups that are going to be freed, allowing us to  in may_commit_transaction()
609 		 * If we have pending delayed iputs then we could free up a  in flush_space()
610 		 * bunch of pinned space, so make sure we run the iputs before  in flush_space()
611 		 * we do our pinned bytes check below.  in flush_space()
674 	/* If we're just plain full then async reclaim just slows us down. */  in need_do_async_reclaim()
687  * maybe_fail_all_tickets - we've exhausted our flushing, start failing tickets
689  * @space_info - the space info we were flushing
691  * We call this when we've exhausted our flushing ability and haven't made
693  * order, so if there is a large ticket first and then smaller ones we could
721 		 * would result in the ticket succeeding.  However if we have a  in maybe_fail_all_tickets()
742 		 * We're just throwing tickets away, so more flushing may not  in maybe_fail_all_tickets()
743 		 * trip over btrfs_try_granting_tickets, so we need to call it  in maybe_fail_all_tickets()
744 		 * here to see if we can make progress with the next ticket in  in maybe_fail_all_tickets()
753  * This is for normal flushers, we can wait all goddamned day if we want to.  We
754  * will loop and continuously try to flush as long as we are making progress.
755  * We count progress as clearing off tickets each time we have to loop.
802 		 * We don't want to force a chunk allocation until we've tried  in btrfs_async_reclaim_metadata_space()
803 		 * pretty hard to reclaim space.  Think of the case where we  in btrfs_async_reclaim_metadata_space()
805 		 * to reclaim.  We would rather use that than possibly create a  in btrfs_async_reclaim_metadata_space()
809 		 * around then we can force a chunk allocation.  in btrfs_async_reclaim_metadata_space()
897 			 * Delete us from the list. After we unlock the space  in wait_reserve_ticket()
898 			 * info, we don't want the async reclaim job to reserve  in wait_reserve_ticket()
923  * @flush - how much we can flush
960 		 * or we delete it ourselves at wait_reserve_ticket().  in handle_reserve_ticket()
969 	 * Check that we can't have an error set if the reservation succeeded,  in handle_reserve_ticket()
980  * @root - the root we're allocating for
981  * @space_info - the space info we want to allocate from
982  * @orig_bytes - the number of bytes we want
983  * @flush - whether or not we can flush to make our reservation
1013 	 * Carry on if we have enough space (short-circuit) OR call  in __reserve_metadata_bytes()
1014 	 * can_overcommit() to ensure we can overcommit to continue.  in __reserve_metadata_bytes()
1026 	 * If we couldn't make a reservation then setup our reservation ticket  in __reserve_metadata_bytes()
1029 	 * If we are a priority flusher then we just need to add our ticket to  in __reserve_metadata_bytes()
1030 	 * the list and we will do our own flushing further down.  in __reserve_metadata_bytes()
1054 		 * We will do the space reservation dance during log replay,  in __reserve_metadata_bytes()
1055 		 * which means we won't have fs_info->fs_root set, so don't do  in __reserve_metadata_bytes()
1056 		 * the async reclaim as we will panic.  in __reserve_metadata_bytes()
1077  * @root - the root we're allocating for
1078  * @block_rsv - the block_rsv we're allocating for
1079  * @orig_bytes - the number of bytes we want
1080  * @flush - whether or not we can flush to make our reservation