67  * when the directory they are being removed from was logged.
137  * using in ram and once, once to create all the inodes logged in the tree
353 	 * pin down any logged extents, so we have to read the block.  in process_one_buffer()
463 		 * replay the extents we've logged we get the right nbytes.  in overwrite_item()
531 	 * was logged as zero.  This is done when the tree logging code  in overwrite_item()
2015  * created in the log while the subvolume was logged.
2019  * directory is in a logged range item, but not actually in the log
2117 	 * by an older kernel that logged both dir index and dir item keys, all  in check_item_in_log()
2897  * logged are safely on disk only if it returns 0.
3286  * Check if an inode was logged in the current transaction. This correctly deals
3287  * with the case where the inode was logged but has a logged_trans of 0, which
3291  * Returns 1 if the inode was logged before in the transaction, 0 if it was not,
3306 	 * If logged_trans is not 0, then we know the inode logged was not logged  in inode_logged()
3314 	 * the inode can not have been logged in this transaction. In that case  in inode_logged()
3326 	 * for sure if the inode was logged before in this transaction by looking  in inode_logged()
3335 	 * 1) The inode was never logged since the filesystem was mounted, and may  in inode_logged()
3338 	 * 2) The inode was logged in a previous transaction, then evicted and  in inode_logged()
3341 	 * 3) The inode was logged in the current transaction, then evicted and  in inode_logged()
3367 	 * did not find the item we know the inode was not logged for sure.  in inode_logged()
3381 	 * The inode was previously logged and then evicted, set logged_trans to  in inode_logged()
3391 	 * leaves have been logged before, otherwise it would result in attempts  in inode_logged()
3439  * If both a file and directory are logged, and unlinks or renames are
3452  * log when a file that was logged in the current transaction is
3653 	 * than the last index we logged, warn and force a transaction commit.  in flush_dir_items_batch()
3752 		/* If we logged this dir index item before, we can skip it. */  in process_dir_items_leaf()
3873 		 * be logged might be in a previous leaf, and there might be a  in log_dir_items()
3950 			 * one or more deletions between the last key we logged and  in log_dir_items()
3989  * If the inode was logged before and it was evicted, then its
4058  * key in the range logged that is not present in the log tree, then it means
4062  * the smallest logged by this transaction and one key larger than the largest
4063  * key logged by this transaction.
4242 	 * If we are doing a fast fsync and the inode was logged before in the  in log_inode_item()
4243 	 * current transaction, then we know the inode was previously logged and  in log_inode_item()
4262 		 * logged before in the current transaction, when we load again  in log_inode_item()
4299 	 * same checksum being logged by another task that is logging another  in log_csums()
4308 	 * Due to extent cloning, we might have logged a csum item that covers a  in log_csums()
4489 	 * We have a leaf full of old extent items that don't need to be logged,  in copy_items()
4608 		 * extent has already been logged.  in log_extent_csums()
4616 			 * |--------- logged extent ---------|  in log_extent_csums()
4634 		 * extent that falls inside of the logged extent.  in log_extent_csums()
4980 	 * We have logged all extents successfully, now make sure the commit of  in btrfs_log_changed_extents()
5383 	 * time it was logged and is flagged as logged in the current transaction,  in need_log_inode()
5386 	 * In case the inode was logged and then evicted and reloaded, its  in need_log_inode()
5406  * directory, that directory's new entries are logged too (same behaviour as
5424  *    from the inode, leaving the logged inode item with a link count that does
5425  *    not match the number of logged inode reference items. This is fine because
5432  *    BTRFS_DIR_INDEX_KEY) are added to fs/subvol tree and the logged inode item
5433  *    has a size that doesn't match the sum of the lengths of all the logged
5700 	 * If the inode was already logged skip it - otherwise we can hit an  in add_conflicting_inode()
5718 	 * happen if we don't skip already logged inodes:  in add_conflicting_inode()
5759 	 * Conflicting inodes are logged by the first call to btrfs_log_inode(),  in log_conflicting_inodes()
5806 			 * might have been logged in LOG_INODE_EXISTS mode or  in log_conflicting_inodes()
5808 			 * dir index key range logged for the directory. So we  in log_conflicting_inodes()
5825 		 * it again because if some other task logged the inode after  in log_conflicting_inodes()
5890 			 * Extents at and beyond eof are logged with  in copy_inode_items_to_log()
5932 			/* Skip xattrs, logged later with btrfs_log_all_xattrs() */  in copy_inode_items_to_log()
6071 	 * So find the first delayed item that was not yet logged (they are  in log_delayed_insertion_items()
6081 	/* Empty list or all delayed items were already logged. */  in log_delayed_insertion_items()
6376  * or be logged already.
6492 	 * the inode was previously logged in this transaction.  in btrfs_log_inode()
6614 		 * If we are doing a fast fsync and the inode was logged before  in btrfs_log_inode()
6616 		 * they were logged before. If xattrs were added, changed or  in btrfs_log_inode()
6617 		 * deleted since the last time we logged the inode, then we have  in btrfs_log_inode()
6618 		 * already logged them because the inode had the runtime flag  in btrfs_log_inode()
6658 	 * Don't update last_log_commit if we logged that an inode exists.  in btrfs_log_inode()
6672 	 *    is logged with an i_size of 0 or whatever value was logged  in btrfs_log_inode()
7055 	 * Skip already logged inodes or inodes corresponding to tmpfiles  in btrfs_log_inode_parent()
7093 	 * inodes are fully logged. This is to prevent leaving dangling  in btrfs_log_inode_parent()
7159  * chunks.  This returns 0 if the dentry was logged, and 1 otherwise.
7353  * commit instead of allowing a directory to be logged.
7373 	 * into the file.  When the file is logged we check it and  in btrfs_record_unlink_dir()
7384 	 * If this directory was already logged, any new names will be logged  in btrfs_record_unlink_dir()
7393 	 * If the inode we're about to unlink was logged before, the log will be  in btrfs_record_unlink_dir()
7436  * allow the directory pointing to the subvolume to be logged with an entry that
7486 	 * if this inode hasn't been logged and directory we're renaming it  in btrfs_log_new_name()
7487 	 * from hasn't been logged, we don't need to log it  in btrfs_log_new_name()
7496 		 * If the inode was not logged and we are doing a rename (old_dir is not  in btrfs_log_new_name()
7497 		 * NULL), check if old_dir was logged - if it was not we can return and  in btrfs_log_new_name()
7510 	 * was previously logged, make sure that on log replay we get the old  in btrfs_log_new_name()
7534 		 * At least one of the inodes was logged before, so this should  in btrfs_log_new_name()
7600 	 * inodes was logged before in this transaction. Do it before unpinning  in btrfs_log_new_name()