Update bcachefs sources to 50d6a25d9c bcachefs: Erasure coding fixes

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

diff --git a/libbcachefs/util.h b/libbcachefs/util.h
index 25d6750915e30661d7c588b29491e1fda99a54e3..80402b3984421f543631b8f0d10dcc72104c729a 100644 (file)
--- a/libbcachefs/util.h
+++ b/libbcachefs/util.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 #ifndef _BCACHEFS_UTIL_H
 #define _BCACHEFS_UTIL_H
 
@@ -11,14 +12,12 @@
 #include <linux/llist.h>
 #include <linux/log2.h>
 #include <linux/percpu.h>
+#include <linux/preempt.h>
 #include <linux/ratelimit.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
 
-#define PAGE_SECTOR_SHIFT      (PAGE_SHIFT - 9)
-#define PAGE_SECTORS           (1UL << PAGE_SECTOR_SHIFT)
-
 struct closure;
 
 #ifdef CONFIG_BCACHEFS_DEBUG
@@ -35,17 +34,6 @@ struct closure;
 #define atomic64_sub_bug(i, v) BUG_ON(atomic64_sub_return(i, v) < 0)
 #define atomic64_add_bug(i, v) BUG_ON(atomic64_add_return(i, v) < 0)
 
-#define memcpy(dst, src, len)                                          \
-({                                                                     \
-       void *_dst = (dst);                                             \
-       const void *_src = (src);                                       \
-       size_t _len = (len);                                            \
-                                                                       \
-       BUG_ON(!((void *) (_dst) >= (void *) (_src) + (_len) ||         \
-                (void *) (_dst) + (_len) <= (void *) (_src)));         \
-       memcpy(_dst, _src, _len);                                       \
-})
-
 #else /* DEBUG */
 
 #define EBUG_ON(cond)
@@ -97,7 +85,7 @@ static inline void *vpmalloc(size_t size, gfp_t gfp_mask)
 {
        return (void *) __get_free_pages(gfp_mask|__GFP_NOWARN,
                                         get_order(size)) ?:
-               __vmalloc(size, gfp_mask, PAGE_KERNEL);
+               __vmalloc(size, gfp_mask);
 }
 
 static inline void kvpfree(void *p, size_t size)
@@ -396,7 +384,7 @@ static inline void bch2_time_stats_update(struct time_stats *stats, u64 start)
        __bch2_time_stats_update(stats, start, local_clock());
 }
 
-size_t bch2_time_stats_print(struct time_stats *, char *, size_t);
+void bch2_time_stats_to_text(struct printbuf *, struct time_stats *);
 
 void bch2_time_stats_exit(struct time_stats *);
 void bch2_time_stats_init(struct time_stats *);
@@ -509,8 +497,8 @@ static inline unsigned fract_exp_two(unsigned x, unsigned fract_bits)
        return x;
 }
 
-void bch2_bio_map(struct bio *bio, void *base);
-int bch2_bio_alloc_pages(struct bio *bio, gfp_t gfp_mask);
+void bch2_bio_map(struct bio *bio, void *base, size_t);
+int bch2_bio_alloc_pages(struct bio *, size_t, gfp_t);
 
 static inline sector_t bdev_sectors(struct block_device *bdev)
 {
@@ -545,9 +533,19 @@ do {                                                                       \
 
 size_t bch2_rand_range(size_t);
 
-void memcpy_to_bio(struct bio *, struct bvec_iter, void *);
+void memcpy_to_bio(struct bio *, struct bvec_iter, const void *);
 void memcpy_from_bio(void *, struct bio *, struct bvec_iter);
 
+static inline void memcpy_u64s_small(void *dst, const void *src,
+                                    unsigned u64s)
+{
+       u64 *d = dst;
+       const u64 *s = src;
+
+       while (u64s--)
+               *d++ = *s++;
+}
+
 static inline void __memcpy_u64s(void *dst, const void *src,
                                 unsigned u64s)
 {
@@ -589,6 +587,24 @@ static inline void memmove_u64s_down(void *dst, const void *src,
        __memmove_u64s_down(dst, src, u64s);
 }
 
+static inline void __memmove_u64s_up_small(void *_dst, const void *_src,
+                                          unsigned u64s)
+{
+       u64 *dst = (u64 *) _dst + u64s;
+       u64 *src = (u64 *) _src + u64s;
+
+       while (u64s--)
+               *--dst = *--src;
+}
+
+static inline void memmove_u64s_up_small(void *dst, const void *src,
+                                        unsigned u64s)
+{
+       EBUG_ON(dst < src);
+
+       __memmove_u64s_up_small(dst, src, u64s);
+}
+
 static inline void __memmove_u64s_up(void *_dst, const void *_src,
                                     unsigned u64s)
 {
@@ -626,35 +642,14 @@ static inline void memmove_u64s(void *dst, const void *src,
                __memmove_u64s_up(dst, src, u64s);
 }
 
-static inline struct bio_vec next_contig_bvec(struct bio *bio,
-                                             struct bvec_iter *iter)
+/* Set the last few bytes up to a u64 boundary given an offset into a buffer. */
+static inline void memset_u64s_tail(void *s, int c, unsigned bytes)
 {
-       struct bio_vec bv = bio_iter_iovec(bio, *iter);
-
-       bio_advance_iter(bio, iter, bv.bv_len);
-#ifndef CONFIG_HIGHMEM
-       while (iter->bi_size) {
-               struct bio_vec next = bio_iter_iovec(bio, *iter);
-
-               if (page_address(bv.bv_page) + bv.bv_offset + bv.bv_len !=
-                   page_address(next.bv_page) + next.bv_offset)
-                       break;
+       unsigned rem = round_up(bytes, sizeof(u64)) - bytes;
 
-               bv.bv_len += next.bv_len;
-               bio_advance_iter(bio, iter, next.bv_len);
-       }
-#endif
-       return bv;
+       memset(s + bytes, c, rem);
 }
 
-#define __bio_for_each_contig_segment(bv, bio, iter, start)            \
-       for (iter = (start);                                            \
-            (iter).bi_size &&                                          \
-               ((bv = next_contig_bvec((bio), &(iter))), 1);)
-
-#define bio_for_each_contig_segment(bv, bio, iter)                     \
-       __bio_for_each_contig_segment(bv, bio, iter, (bio)->bi_iter)
-
 void sort_cmp_size(void *base, size_t num, size_t size,
          int (*cmp_func)(const void *, const void *, size_t),
          void (*swap_func)(void *, void *, size_t));
@@ -698,6 +693,25 @@ do {                                                                       \
        }                                                               \
 } while (0)
 
+static inline u64 percpu_u64_get(u64 __percpu *src)
+{
+       u64 ret = 0;
+       int cpu;
+
+       for_each_possible_cpu(cpu)
+               ret += *per_cpu_ptr(src, cpu);
+       return ret;
+}
+
+static inline void percpu_u64_set(u64 __percpu *dst, u64 src)
+{
+       int cpu;
+
+       for_each_possible_cpu(cpu)
+               *per_cpu_ptr(dst, cpu) = 0;
+       this_cpu_write(*dst, src);
+}
+
 static inline void acc_u64s(u64 *acc, const u64 *src, unsigned nr)
 {
        unsigned i;
@@ -715,4 +729,21 @@ static inline void acc_u64s_percpu(u64 *acc, const u64 __percpu *src,
                acc_u64s(acc, per_cpu_ptr(src, cpu), nr);
 }
 
+static inline void percpu_memset(void __percpu *p, int c, size_t bytes)
+{
+       int cpu;
+
+       for_each_possible_cpu(cpu)
+               memset(per_cpu_ptr(p, cpu), c, bytes);
+}
+
+u64 *bch2_acc_percpu_u64s(u64 __percpu *, unsigned);
+
+#define cmp_int(l, r)          ((l > r) - (l < r))
+
+static inline int u8_cmp(u8 l, u8 r)
+{
+       return cmp_int(l, r);
+}
+
 #endif /* _BCACHEFS_UTIL_H */