Update bcachefs sources to 717b356d1d bcachefs: Convert journal validation to bkey_in...

[bcachefs-tools-debian] / libbcachefs / alloc_types.h

diff --git a/libbcachefs/alloc_types.h b/libbcachefs/alloc_types.h
index 4f14650779947f8c854a5bf16782aaa1d277ee5b..804a843f23c16ea4100baba6690d589ab98368e1 100644 (file)
--- a/libbcachefs/alloc_types.h
+++ b/libbcachefs/alloc_types.h
@@ -8,66 +8,61 @@
 #include "clock_types.h"
 #include "fifo.h"
 
-struct ec_bucket_buf;
-
-/* There's two of these clocks, one for reads and one for writes: */
-struct bucket_clock {
-       /*
-        * "now" in (read/write) IO time - incremented whenever we do X amount
-        * of reads or writes.
-        *
-        * Goes with the bucket read/write prios: when we read or write to a
-        * bucket we reset the bucket's prio to the current hand; thus hand -
-        * prio = time since bucket was last read/written.
-        *
-        * The units are some amount (bytes/sectors) of data read/written, and
-        * the units can change on the fly if we need to rescale to fit
-        * everything in a u16 - your only guarantee is that the units are
-        * consistent.
-        */
-       u16                     hand;
-       u16                     max_last_io;
-
-       int                     rw;
-
-       struct io_timer         rescale;
-       struct mutex            lock;
+struct bucket_alloc_state {
+       u64     buckets_seen;
+       u64     skipped_open;
+       u64     skipped_need_journal_commit;
+       u64     skipped_nocow;
+       u64     skipped_nouse;
 };
 
-/* There is one reserve for each type of btree, one for prios and gens
- * and one for moving GC */
-enum alloc_reserve {
-       RESERVE_ALLOC           = -1,
-       RESERVE_BTREE           = 0,
-       RESERVE_MOVINGGC        = 1,
-       RESERVE_NONE            = 2,
-       RESERVE_NR              = 3,
+#define BCH_WATERMARKS()               \
+       x(stripe)                       \
+       x(normal)                       \
+       x(copygc)                       \
+       x(btree)                        \
+       x(btree_copygc)                 \
+       x(reclaim)
+
+enum bch_watermark {
+#define x(name)        BCH_WATERMARK_##name,
+       BCH_WATERMARKS()
+#undef x
+       BCH_WATERMARK_NR,
 };
 
-typedef FIFO(long)     alloc_fifo;
+#define BCH_WATERMARK_BITS     3
+#define BCH_WATERMARK_MASK     ~(~0U << BCH_WATERMARK_BITS)
 
 #define OPEN_BUCKETS_COUNT     1024
 
 #define WRITE_POINT_HASH_NR    32
 #define WRITE_POINT_MAX                32
 
+/*
+ * 0 is never a valid open_bucket_idx_t:
+ */
 typedef u16                    open_bucket_idx_t;
 
 struct open_bucket {
        spinlock_t              lock;
        atomic_t                pin;
        open_bucket_idx_t       freelist;
+       open_bucket_idx_t       hash;
 
        /*
         * When an open bucket has an ec_stripe attached, this is the index of
         * the block in the stripe this open_bucket corresponds to:
         */
        u8                      ec_idx;
-       u8                      type;
+       enum bch_data_type      data_type:6;
        unsigned                valid:1;
        unsigned                on_partial_list:1;
-       unsigned                sectors_free;
-       struct bch_extent_ptr   ptr;
+
+       u8                      dev;
+       u8                      gen;
+       u32                     sectors_free;
+       u64                     bucket;
        struct ec_stripe_new    *ec;
 };
 
@@ -82,31 +77,50 @@ struct dev_stripe_state {
        u64                     next_alloc[BCH_SB_MEMBERS_MAX];
 };
 
+#define WRITE_POINT_STATES()           \
+       x(stopped)                      \
+       x(waiting_io)                   \
+       x(waiting_work)                 \
+       x(running)
+
+enum write_point_state {
+#define x(n)   WRITE_POINT_##n,
+       WRITE_POINT_STATES()
+#undef x
+       WRITE_POINT_STATE_NR
+};
+
 struct write_point {
-       struct hlist_node       node;
-       struct mutex            lock;
-       u64                     last_used;
-       unsigned long           write_point;
-       enum bch_data_type      type;
-       bool                    is_ec;
-
-       /* calculated based on how many pointers we're actually going to use: */
-       unsigned                sectors_free;
-
-       struct open_buckets     ptrs;
-       struct dev_stripe_state stripe;
+       struct {
+               struct hlist_node       node;
+               struct mutex            lock;
+               u64                     last_used;
+               unsigned long           write_point;
+               enum bch_data_type      data_type;
+
+               /* calculated based on how many pointers we're actually going to use: */
+               unsigned                sectors_free;
+
+               struct open_buckets     ptrs;
+               struct dev_stripe_state stripe;
+
+               u64                     sectors_allocated;
+       } __attribute__((__aligned__(SMP_CACHE_BYTES)));
+
+       struct {
+               struct work_struct      index_update_work;
+
+               struct list_head        writes;
+               spinlock_t              writes_lock;
+
+               enum write_point_state  state;
+               u64                     last_state_change;
+               u64                     time[WRITE_POINT_STATE_NR];
+       } __attribute__((__aligned__(SMP_CACHE_BYTES)));
 };
 
 struct write_point_specifier {
        unsigned long           v;
 };
 
-struct alloc_heap_entry {
-       size_t                  bucket;
-       size_t                  nr;
-       unsigned long           key;
-};
-
-typedef HEAP(struct alloc_heap_entry) alloc_heap;
-
 #endif /* _BCACHEFS_ALLOC_TYPES_H */