60  * when the directory they are being removed from was logged.
130  * using in ram and once, once to create all the inodes logged in the tree
333 	 * pin down any logged extents, so we have to read the block.  in process_one_buffer()
435 		 * replay the extents we've logged we get the right nbytes.  in do_overwrite_item()
502 	 * was logged as zero.  This is done when the tree logging code  in do_overwrite_item()
2050  * created in the log while the subvolume was logged.
2054  * directory is in a logged range item, but not actually in the log
2153 	 * by an older kernel that logged both dir index and dir item keys, all  in check_item_in_log()
2924  * you know that any inodes previously logged are safely on disk only
3323  * Check if an inode was logged in the current transaction. This correctly deals
3324  * with the case where the inode was logged but has a logged_trans of 0, which
3328  * Returns 1 if the inode was logged before in the transaction, 0 if it was not,
3343 	 * If logged_trans is not 0, then we know the inode logged was not logged  in inode_logged()
3351 	 * the inode can not have been logged in this transaction. In that case  in inode_logged()
3363 	 * for sure if the inode was logged before in this transaction by looking  in inode_logged()
3372 	 * 1) The inode was never logged since the filesystem was mounted, and may  in inode_logged()
3375 	 * 2) The inode was logged in a previous transaction, then evicted and  in inode_logged()
3378 	 * 3) The inode was logged in the current transaction, then evicted and  in inode_logged()
3404 	 * did not find the item we know the inode was not logged for sure.  in inode_logged()
3418 	 * The inode was previously logged and then evicted, set logged_trans to  in inode_logged()
3428 	 * leaves have been logged before, otherwise it would result in attempts  in inode_logged()
3476  * If both a file and directory are logged, and unlinks or renames are
3489  * log when a file that was logged in the current transaction is
3753 		/* If we logged this dir index item before, we can skip it. */  in process_dir_items_leaf()
3872 		 * be logged might be in a previous leaf, and there might be a  in log_dir_items()
3932 			 * one or more deletions between the last key we logged and  in log_dir_items()
3973  * If the inode was logged before and it was evicted, then its
4042  * key in the range logged that is not present in the log tree, then it means
4046  * the smallest logged by this transaction and one key larger than the largest
4047  * key logged by this transaction.
4227 	 * If we are doing a fast fsync and the inode was logged before in the  in log_inode_item()
4228 	 * current transaction, then we know the inode was previously logged and  in log_inode_item()
4247 		 * logged before in the current transaction, when we load again  in log_inode_item()
4284 	 * same checksum being logged by another task that is logging another  in log_csums()
4293 	 * Due to extent cloning, we might have logged a csum item that covers a  in log_csums()
4477 	 * We have a leaf full of old extent items that don't need to be logged,  in copy_items()
4596 		 * extent has already been logged.  in log_extent_csums()
4604 			 * |--------- logged extent ---------|  in log_extent_csums()
4622 		 * extent that falls inside of the logged extent.  in log_extent_csums()
4852 			 * Avoid logging extent items logged in past fsync calls  in btrfs_log_prealloc_extents()
4962 	 * We have logged all extents successfully, now make sure the commit of  in btrfs_log_changed_extents()
5360 	 * time it was logged and is flagged as logged in the current transaction,  in need_log_inode()
5363 	 * In case the inode was logged and then evicted and reloaded, its  in need_log_inode()
5383  * directory, that directory's new entries are logged too (same behaviour as
5401  *    from the inode, leaving the logged inode item with a link count that does
5402  *    not match the number of logged inode reference items. This is fine because
5409  *    BTRFS_DIR_INDEX_KEY) are added to fs/subvol tree and the logged inode item
5410  *    has a size that doesn't match the sum of the lengths of all the logged
5659 	 * If the inode was already logged skip it - otherwise we can hit an  in add_conflicting_inode()
5677 	 * happen if we don't skip already logged inodes:  in add_conflicting_inode()
5719 	 * Conflicting inodes are logged by the first call to btrfs_log_inode(),  in log_conflicting_inodes()
5766 			 * might have been logged in LOG_INODE_EXISTS mode or  in log_conflicting_inodes()
5768 			 * dir index key range logged for the directory. So we  in log_conflicting_inodes()
5786 		 * it again because if some other task logged the inode after  in log_conflicting_inodes()
5851 			 * Extents at and beyond eof are logged with  in copy_inode_items_to_log()
5893 			/* Skip xattrs, logged later with btrfs_log_all_xattrs() */  in copy_inode_items_to_log()
6032 	 * So find the first delayed item that was not yet logged (they are  in log_delayed_insertion_items()
6042 	/* Empty list or all delayed items were already logged. */  in log_delayed_insertion_items()
6339  * or be logged already.
6455 	 * the inode was previously logged in this transaction.  in btrfs_log_inode()
6578 		 * If we are doing a fast fsync and the inode was logged before  in btrfs_log_inode()
6580 		 * they were logged before. If xattrs were added, changed or  in btrfs_log_inode()
6581 		 * deleted since the last time we logged the inode, then we have  in btrfs_log_inode()
6582 		 * already logged them because the inode had the runtime flag  in btrfs_log_inode()
6622 	 * Don't update last_log_commit if we logged that an inode exists.  in btrfs_log_inode()
6636 	 *    is logged with an i_size of 0 or whatever value was logged  in btrfs_log_inode()
7022 	 * Skip already logged inodes or inodes corresponding to tmpfiles  in btrfs_log_inode_parent()
7059 	 * inodes are fully logged. This is to prevent leaving dangling  in btrfs_log_inode_parent()
7127  * chunks.  This returns 0 if the dentry was logged, and 1 otherwise.
7323  * commit instead of allowing a directory to be logged.
7343 	 * into the file.  When the file is logged we check it and  in btrfs_record_unlink_dir()
7351 	 * if this directory was already logged any new  in btrfs_record_unlink_dir()
7358 	 * if the inode we're about to unlink was logged,  in btrfs_record_unlink_dir()
7438 	 * if this inode hasn't been logged and directory we're renaming it  in btrfs_log_new_name()
7439 	 * from hasn't been logged, we don't need to log it  in btrfs_log_new_name()
7448 		 * If the inode was not logged and we are doing a rename (old_dir is not  in btrfs_log_new_name()
7449 		 * NULL), check if old_dir was logged - if it was not we can return and  in btrfs_log_new_name()
7462 	 * was previously logged, make sure that on log replay we get the old  in btrfs_log_new_name()
7481 		 * At least one of the inodes was logged before, so this should  in btrfs_log_new_name()
7541 	 * inodes was logged before in this transaction. Do it before unpinning  in btrfs_log_new_name()