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()
466 		 * replay the extents we've logged we get the right nbytes.  in overwrite_item()
533 	 * was logged as zero.  This is done when the tree logging code  in overwrite_item()
2031  * created in the log while the subvolume was logged.
2035  * directory is in a logged range item, but not actually in the log
2133 	 * by an older kernel that logged both dir index and dir item keys, all  in check_item_in_log()
2915  * logged are safely on disk only if it returns 0.
3304  * Check if an inode was logged in the current transaction. This correctly deals
3305  * with the case where the inode was logged but has a logged_trans of 0, which
3309  * Returns 1 if the inode was logged before in the transaction, 0 if it was not,
3324 	 * If logged_trans is not 0, then we know the inode logged was not logged  in inode_logged()
3332 	 * the inode can not have been logged in this transaction. In that case  in inode_logged()
3344 	 * for sure if the inode was logged before in this transaction by looking  in inode_logged()
3353 	 * 1) The inode was never logged since the filesystem was mounted, and may  in inode_logged()
3356 	 * 2) The inode was logged in a previous transaction, then evicted and  in inode_logged()
3359 	 * 3) The inode was logged in the current transaction, then evicted and  in inode_logged()
3385 	 * did not find the item we know the inode was not logged for sure.  in inode_logged()
3399 	 * The inode was previously logged and then evicted, set logged_trans to  in inode_logged()
3409 	 * leaves have been logged before, otherwise it would result in attempts  in inode_logged()
3457  * If both a file and directory are logged, and unlinks or renames are
3470  * log when a file that was logged in the current transaction is
3671 	 * than the last index we logged, warn and force a transaction commit.  in flush_dir_items_batch()
3770 		/* If we logged this dir index item before, we can skip it. */  in process_dir_items_leaf()
3891 		 * be logged might be in a previous leaf, and there might be a  in log_dir_items()
3968 			 * one or more deletions between the last key we logged and  in log_dir_items()
4007  * If the inode was logged before and it was evicted, then its
4076  * key in the range logged that is not present in the log tree, then it means
4080  * the smallest logged by this transaction and one key larger than the largest
4081  * key logged by this transaction.
4260 	 * If we are doing a fast fsync and the inode was logged before in the  in log_inode_item()
4261 	 * current transaction, then we know the inode was previously logged and  in log_inode_item()
4280 		 * logged before in the current transaction, when we load again  in log_inode_item()
4317 	 * same checksum being logged by another task that is logging another  in log_csums()
4326 	 * Due to extent cloning, we might have logged a csum item that covers a  in log_csums()
4507 	 * We have a leaf full of old extent items that don't need to be logged,  in copy_items()
4626 		 * extent has already been logged.  in log_extent_csums()
4634 			 * |--------- logged extent ---------|  in log_extent_csums()
4652 		 * extent that falls inside of the logged extent.  in log_extent_csums()
4998 	 * We have logged all extents successfully, now make sure the commit of  in btrfs_log_changed_extents()
5401 	 * time it was logged and is flagged as logged in the current transaction,  in need_log_inode()
5404 	 * In case the inode was logged and then evicted and reloaded, its  in need_log_inode()
5424  * directory, that directory's new entries are logged too (same behaviour as
5442  *    from the inode, leaving the logged inode item with a link count that does
5443  *    not match the number of logged inode reference items. This is fine because
5450  *    BTRFS_DIR_INDEX_KEY) are added to fs/subvol tree and the logged inode item
5451  *    has a size that doesn't match the sum of the lengths of all the logged
5721 	 * If the inode was already logged skip it - otherwise we can hit an  in add_conflicting_inode()
5739 	 * happen if we don't skip already logged inodes:  in add_conflicting_inode()
5780 	 * Conflicting inodes are logged by the first call to btrfs_log_inode(),  in log_conflicting_inodes()
5827 			 * might have been logged in LOG_INODE_EXISTS mode or  in log_conflicting_inodes()
5829 			 * dir index key range logged for the directory. So we  in log_conflicting_inodes()
5847 		 * it again because if some other task logged the inode after  in log_conflicting_inodes()
5912 			 * Extents at and beyond eof are logged with  in copy_inode_items_to_log()
5954 			/* Skip xattrs, logged later with btrfs_log_all_xattrs() */  in copy_inode_items_to_log()
6093 	 * So find the first delayed item that was not yet logged (they are  in log_delayed_insertion_items()
6103 	/* Empty list or all delayed items were already logged. */  in log_delayed_insertion_items()
6398  * or be logged already.
6514 	 * the inode was previously logged in this transaction.  in btrfs_log_inode()
6636 		 * If we are doing a fast fsync and the inode was logged before  in btrfs_log_inode()
6638 		 * they were logged before. If xattrs were added, changed or  in btrfs_log_inode()
6639 		 * deleted since the last time we logged the inode, then we have  in btrfs_log_inode()
6640 		 * already logged them because the inode had the runtime flag  in btrfs_log_inode()
6680 	 * Don't update last_log_commit if we logged that an inode exists.  in btrfs_log_inode()
6694 	 *    is logged with an i_size of 0 or whatever value was logged  in btrfs_log_inode()
7086 	 * Skip already logged inodes or inodes corresponding to tmpfiles  in btrfs_log_inode_parent()
7123 	 * inodes are fully logged. This is to prevent leaving dangling  in btrfs_log_inode_parent()
7191  * chunks.  This returns 0 if the dentry was logged, and 1 otherwise.
7385  * commit instead of allowing a directory to be logged.
7405 	 * into the file.  When the file is logged we check it and  in btrfs_record_unlink_dir()
7416 	 * If this directory was already logged, any new names will be logged  in btrfs_record_unlink_dir()
7425 	 * If the inode we're about to unlink was logged before, the log will be  in btrfs_record_unlink_dir()
7468  * allow the directory pointing to the subvolume to be logged with an entry that
7518 	 * if this inode hasn't been logged and directory we're renaming it  in btrfs_log_new_name()
7519 	 * from hasn't been logged, we don't need to log it  in btrfs_log_new_name()
7528 		 * If the inode was not logged and we are doing a rename (old_dir is not  in btrfs_log_new_name()
7529 		 * NULL), check if old_dir was logged - if it was not we can return and  in btrfs_log_new_name()
7542 	 * was previously logged, make sure that on log replay we get the old  in btrfs_log_new_name()
7566 		 * At least one of the inodes was logged before, so this should  in btrfs_log_new_name()
7632 	 * inodes was logged before in this transaction. Do it before unpinning  in btrfs_log_new_name()