Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * Copyright (C) 2008 Oracle.  All rights reserved.
       4             :  */
       5             : 
       6             : #ifndef BTRFS_TREE_LOG_H
       7             : #define BTRFS_TREE_LOG_H
       8             : 
       9             : #include "messages.h"
      10             : #include "ctree.h"
      11             : #include "transaction.h"
      12             : 
      13             : /* return value for btrfs_log_dentry_safe that means we don't need to log it at all */
      14             : #define BTRFS_NO_LOG_SYNC 256
      15             : 
      16             : /*
      17             :  * We can't use the tree log for whatever reason, force a transaction commit.
      18             :  * We use a negative value because there are functions through the logging code
      19             :  * that need to return an error (< 0 value), false (0) or true (1). Any negative
      20             :  * value will do, as it will cause the log to be marked for a full sync.
      21             :  */
      22             : #define BTRFS_LOG_FORCE_COMMIT                          (-(MAX_ERRNO + 1))
      23             : 
      24             : struct btrfs_log_ctx {
      25             :         int log_ret;
      26             :         int log_transid;
      27             :         bool log_new_dentries;
      28             :         bool logging_new_name;
      29             :         bool logging_new_delayed_dentries;
      30             :         /* Indicate if the inode being logged was logged before. */
      31             :         bool logged_before;
      32             :         struct inode *inode;
      33             :         struct list_head list;
      34             :         /* Only used for fast fsyncs. */
      35             :         struct list_head ordered_extents;
      36             :         struct list_head conflict_inodes;
      37             :         int num_conflict_inodes;
      38             :         bool logging_conflict_inodes;
      39             : };
      40             : 
      41             : static inline void btrfs_init_log_ctx(struct btrfs_log_ctx *ctx,
      42             :                                       struct inode *inode)
      43             : {
      44           0 :         ctx->log_ret = 0;
      45           0 :         ctx->log_transid = 0;
      46           0 :         ctx->log_new_dentries = false;
      47           0 :         ctx->logging_new_name = false;
      48           0 :         ctx->logging_new_delayed_dentries = false;
      49           0 :         ctx->logged_before = false;
      50           0 :         ctx->inode = inode;
      51           0 :         INIT_LIST_HEAD(&ctx->list);
      52           0 :         INIT_LIST_HEAD(&ctx->ordered_extents);
      53           0 :         INIT_LIST_HEAD(&ctx->conflict_inodes);
      54           0 :         ctx->num_conflict_inodes = 0;
      55           0 :         ctx->logging_conflict_inodes = false;
      56             : }
      57             : 
      58           0 : static inline void btrfs_release_log_ctx_extents(struct btrfs_log_ctx *ctx)
      59             : {
      60           0 :         struct btrfs_ordered_extent *ordered;
      61           0 :         struct btrfs_ordered_extent *tmp;
      62             : 
      63           0 :         ASSERT(inode_is_locked(ctx->inode));
      64             : 
      65           0 :         list_for_each_entry_safe(ordered, tmp, &ctx->ordered_extents, log_list) {
      66           0 :                 list_del_init(&ordered->log_list);
      67           0 :                 btrfs_put_ordered_extent(ordered);
      68             :         }
      69           0 : }
      70             : 
      71             : static inline void btrfs_set_log_full_commit(struct btrfs_trans_handle *trans)
      72             : {
      73           0 :         WRITE_ONCE(trans->fs_info->last_trans_log_full_commit, trans->transid);
      74           0 : }
      75             : 
      76             : static inline int btrfs_need_log_full_commit(struct btrfs_trans_handle *trans)
      77             : {
      78           0 :         return READ_ONCE(trans->fs_info->last_trans_log_full_commit) ==
      79           0 :                 trans->transid;
      80             : }
      81             : 
      82             : int btrfs_sync_log(struct btrfs_trans_handle *trans,
      83             :                    struct btrfs_root *root, struct btrfs_log_ctx *ctx);
      84             : int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root);
      85             : int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
      86             :                              struct btrfs_fs_info *fs_info);
      87             : int btrfs_recover_log_trees(struct btrfs_root *tree_root);
      88             : int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
      89             :                           struct dentry *dentry,
      90             :                           struct btrfs_log_ctx *ctx);
      91             : void btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
      92             :                                   struct btrfs_root *root,
      93             :                                   const struct fscrypt_str *name,
      94             :                                   struct btrfs_inode *dir, u64 index);
      95             : void btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
      96             :                                 struct btrfs_root *root,
      97             :                                 const struct fscrypt_str *name,
      98             :                                 struct btrfs_inode *inode, u64 dirid);
      99             : void btrfs_end_log_trans(struct btrfs_root *root);
     100             : void btrfs_pin_log_trans(struct btrfs_root *root);
     101             : void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
     102             :                              struct btrfs_inode *dir, struct btrfs_inode *inode,
     103             :                              bool for_rename);
     104             : void btrfs_record_snapshot_destroy(struct btrfs_trans_handle *trans,
     105             :                                    struct btrfs_inode *dir);
     106             : void btrfs_log_new_name(struct btrfs_trans_handle *trans,
     107             :                         struct dentry *old_dentry, struct btrfs_inode *old_dir,
     108             :                         u64 old_dir_index, struct dentry *parent);
     109             : 
     110             : #endif