fs/bcachefs/move.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _BCACHEFS_MOVE_H
   3 #define _BCACHEFS_MOVE_H
   4
   5 #include "bbpos.h"
   6 #include "bcachefs_ioctl.h"
   7 #include "btree_iter.h"
   8 #include "buckets.h"
   9 #include "data_update.h"
  10 #include "move_types.h"
  11
  12 struct bch_read_bio;
  13
  14 struct moving_context {
  15         struct btree_trans      *trans;
  16         struct list_head        list;
  17         void                    *fn;
  18
  19         struct bch_ratelimit    *rate;
  20         struct bch_move_stats   *stats;
  21         struct write_point_specifier wp;
  22         bool                    wait_on_copygc;
  23         bool                    write_error;
  24
  25         /* For waiting on outstanding reads and writes: */
  26         struct closure          cl;
  27
  28         struct mutex            lock;
  29         struct list_head        reads;
  30         struct list_head        ios;
  31
  32         /* in flight sectors: */
  33         atomic_t                read_sectors;
  34         atomic_t                write_sectors;
  35         atomic_t                read_ios;
  36         atomic_t                write_ios;
  37
  38         wait_queue_head_t       wait;
  39 };
  40
  41 #define move_ctxt_wait_event_timeout(_ctxt, _cond, _timeout)                    \
  42 ({                                                                              \
  43         int _ret = 0;                                                           \
  44         while (true) {                                                          \
  45                 bool cond_finished = false;                                     \
  46                 bch2_moving_ctxt_do_pending_writes(_ctxt);                      \
  47                                                                                 \
  48                 if (_cond)                                                      \
  49                         break;                                                  \
  50                 bch2_trans_unlock_long((_ctxt)->trans);                         \
  51                 _ret = __wait_event_timeout((_ctxt)->wait,                      \
  52                              bch2_moving_ctxt_next_pending_write(_ctxt) ||      \
  53                              (cond_finished = (_cond)), _timeout);              \
  54                 if (_ret || ( cond_finished))                                   \
  55                         break;                                                  \
  56         }                                                                       \
  57         _ret;                                                                   \
  58 })
  59
  60 #define move_ctxt_wait_event(_ctxt, _cond)                              \
  61 do {                                                                    \
  62         bool cond_finished = false;                                     \
  63         bch2_moving_ctxt_do_pending_writes(_ctxt);                      \
  64                                                                         \
  65         if (_cond)                                                      \
  66                 break;                                                  \
  67         bch2_trans_unlock_long((_ctxt)->trans);                         \
  68         __wait_event((_ctxt)->wait,                                     \
  69                      bch2_moving_ctxt_next_pending_write(_ctxt) ||      \
  70                      (cond_finished = (_cond)));                        \
  71         if (cond_finished)                                              \
  72                 break;                                                  \
  73 } while (1)
  74
  75 typedef bool (*move_pred_fn)(struct bch_fs *, void *, struct bkey_s_c,
  76                              struct bch_io_opts *, struct data_update_opts *);
  77
  78 extern const char * const bch2_data_ops_strs[];
  79
  80 void bch2_moving_ctxt_exit(struct moving_context *);
  81 void bch2_moving_ctxt_init(struct moving_context *, struct bch_fs *,
  82                            struct bch_ratelimit *, struct bch_move_stats *,
  83                            struct write_point_specifier, bool);
  84 struct moving_io *bch2_moving_ctxt_next_pending_write(struct moving_context *);
  85 void bch2_moving_ctxt_do_pending_writes(struct moving_context *);
  86 void bch2_moving_ctxt_flush_all(struct moving_context *);
  87 void bch2_move_ctxt_wait_for_io(struct moving_context *);
  88 int bch2_move_ratelimit(struct moving_context *);
  89
  90 /* Inodes in different snapshots may have different IO options: */
  91 struct snapshot_io_opts_entry {
  92         u32                     snapshot;
  93         struct bch_io_opts      io_opts;
  94 };
  95
  96 struct per_snapshot_io_opts {
  97         u64                     cur_inum;
  98         struct bch_io_opts      fs_io_opts;
  99         DARRAY(struct snapshot_io_opts_entry) d;
 100 };
 101
 102 static inline void per_snapshot_io_opts_init(struct per_snapshot_io_opts *io_opts, struct bch_fs *c)
 103 {
 104         memset(io_opts, 0, sizeof(*io_opts));
 105         io_opts->fs_io_opts = bch2_opts_to_inode_opts(c->opts);
 106 }
 107
 108 static inline void per_snapshot_io_opts_exit(struct per_snapshot_io_opts *io_opts)
 109 {
 110         darray_exit(&io_opts->d);
 111 }
 112
 113 int bch2_move_get_io_opts_one(struct btree_trans *, struct bch_io_opts *,
 114                               struct btree_iter *, struct bkey_s_c);
 115
 116 int bch2_scan_old_btree_nodes(struct bch_fs *, struct bch_move_stats *);
 117
 118 int bch2_move_extent(struct moving_context *,
 119                      struct move_bucket_in_flight *,
 120                      struct btree_iter *,
 121                      struct bkey_s_c,
 122                      struct bch_io_opts,
 123                      struct data_update_opts);
 124
 125 int __bch2_move_data(struct moving_context *,
 126                      struct bbpos,
 127                      struct bbpos,
 128                      move_pred_fn, void *);
 129 int bch2_move_data(struct bch_fs *,
 130                    struct bbpos start,
 131                    struct bbpos end,
 132                    struct bch_ratelimit *,
 133                    struct bch_move_stats *,
 134                    struct write_point_specifier,
 135                    bool,
 136                    move_pred_fn, void *);
 137
 138 int bch2_evacuate_bucket(struct moving_context *,
 139                            struct move_bucket_in_flight *,
 140                            struct bpos, int,
 141                            struct data_update_opts);
 142 int bch2_data_job(struct bch_fs *,
 143                   struct bch_move_stats *,
 144                   struct bch_ioctl_data);
 145
 146 void bch2_move_stats_to_text(struct printbuf *, struct bch_move_stats *);
 147 void bch2_move_stats_exit(struct bch_move_stats *, struct bch_fs *);
 148 void bch2_move_stats_init(struct bch_move_stats *, const char *);
 149
 150 void bch2_fs_moving_ctxts_to_text(struct printbuf *, struct bch_fs *);
 151
 152 void bch2_fs_move_init(struct bch_fs *);
 153
 154 #endif /* _BCACHEFS_MOVE_H */