btrfs-progs: send-stream: track the read position in the stream

[platform/upstream/btrfs-progs.git] / kerncompat.h

diff --git a/kerncompat.h b/kerncompat.h
index 8afadc8..ed9a042 100644 (file)
--- a/kerncompat.h
+++ b/kerncompat.h
@@ -16,8 +16,8 @@
  * Boston, MA 021110-1307, USA.
  */
 
-#ifndef __KERNCOMPAT
-#define __KERNCOMPAT
+#ifndef __KERNCOMPAT_H__
+#define __KERNCOMPAT_H__
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -29,6 +29,16 @@
 #include <stddef.h>
 #include <linux/types.h>
 #include <stdint.h>
+
+#include <features.h>
+
+#ifndef __GLIBC__
+#ifndef BTRFS_DISABLE_BACKTRACE
+#define BTRFS_DISABLE_BACKTRACE
+#endif
+#define __always_inline __inline __attribute__ ((__always_inline__))
+#endif
+
 #ifndef BTRFS_DISABLE_BACKTRACE
 #include <execinfo.h>
 #endif
@@ -45,7 +55,8 @@
 #define gfp_t int
 #define get_cpu_var(p) (p)
 #define __get_cpu_var(p) (p)
-#define BITS_PER_LONG (__SIZEOF_LONG__ * 8)
+#define BITS_PER_BYTE 8
+#define BITS_PER_LONG (__SIZEOF_LONG__ * BITS_PER_BYTE)
 #define __GFP_BITS_SHIFT 20
 #define __GFP_BITS_MASK ((int)((1 << __GFP_BITS_SHIFT) - 1))
 #define GFP_KERNEL 0
@@ -57,12 +68,20 @@
 #define ULONG_MAX       (~0UL)
 #endif
 
+#define __token_glue(a,b,c)    ___token_glue(a,b,c)
+#define ___token_glue(a,b,c)   a ## b ## c
+#ifdef DEBUG_BUILD_CHECKS
+#define BUILD_ASSERT(x)                extern int __token_glue(compile_time_assert_,__LINE__,__COUNTER__)[1-2*!(x)] __attribute__((unused))
+#else
+#define BUILD_ASSERT(x)
+#endif
+
 #ifndef BTRFS_DISABLE_BACKTRACE
 #define MAX_BACKTRACE  16
 static inline void print_trace(void)
 {
        void *array[MAX_BACKTRACE];
-       size_t size;
+       int size;
 
        size = backtrace(array, MAX_BACKTRACE);
        backtrace_symbols_fd(array, size, 2);
@@ -74,12 +93,13 @@ static inline void assert_trace(const char *assertion, const char *filename,
        if (val)
                return;
        if (assertion)
-               fprintf(stderr, "%s:%d: %s: Assertion `%s` failed.\n",
-                       filename, line, func, assertion);
+               fprintf(stderr, "%s:%d: %s: Assertion `%s` failed, value %d\n",
+                       filename, line, func, assertion, val);
        else
-               fprintf(stderr, "%s:%d: %s: Assertion failed.\n", filename,
-                       line, func);
+               fprintf(stderr, "%s:%d: %s: Assertion failed, value %d.\n",
+                       filename, line, func, val);
        print_trace();
+       abort();
        exit(1);
 }
 
@@ -88,6 +108,27 @@ static inline void assert_trace(const char *assertion, const char *filename,
 #define BUG() assert(0)
 #endif
 
+static inline void warning_trace(const char *assertion, const char *filename,
+                             const char *func, unsigned line, int val,
+                             int trace)
+{
+       if (val)
+               return;
+       if (assertion)
+               fprintf(stderr,
+                       "%s:%d: %s: Warning: assertion `%s` failed, value %d\n",
+                       filename, line, func, assertion, val);
+       else
+               fprintf(stderr,
+                       "%s:%d: %s: Warning: assertion failed, value %d.\n",
+                       filename, line, func, val);
+#ifndef BTRFS_DISABLE_BACKTRACE
+       if (trace)
+               print_trace();
+#endif
+}
+
+
 #ifdef __CHECKER__
 #define __force    __attribute__((force))
 #define __bitwise__ __attribute__((bitwise))
@@ -123,7 +164,7 @@ typedef unsigned long long u64;
 typedef unsigned char u8;
 typedef unsigned short u16;
 typedef long long s64;
-typedef int s32
+typedef int s32;
 #endif
 
 
@@ -231,26 +272,6 @@ static inline long IS_ERR(const void *ptr)
 }
 
 /*
- * max/min macro
- */
-#define min(x,y) ({ \
-       typeof(x) _x = (x);     \
-       typeof(y) _y = (y);     \
-       (void) (&_x == &_y);            \
-       _x < _y ? _x : _y; })
-
-#define max(x,y) ({ \
-       typeof(x) _x = (x);     \
-       typeof(y) _y = (y);     \
-       (void) (&_x == &_y);            \
-       _x > _y ? _x : _y; })
-
-#define min_t(type,x,y) \
-       ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-#define max_t(type,x,y) \
-       ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
-
-/*
  * This looks more complex than it should be. But we need to
  * get the type for the ~ right in round_down (it needs to be
  * as wide as the result!), and we want to evaluate the macro
@@ -279,12 +300,12 @@ static inline long IS_ERR(const void *ptr)
 
 #ifndef BTRFS_DISABLE_BACKTRACE
 #define BUG_ON(c) assert_trace(#c, __FILE__, __func__, __LINE__, !(c))
+#define WARN_ON(c) warning_trace(#c, __FILE__, __func__, __LINE__, !(c), 1)
 #else
 #define BUG_ON(c) assert(!(c))
+#define WARN_ON(c) warning_trace(#c, __FILE__, __func__, __LINE__, !(c), 0)
 #endif
 
-#define WARN_ON(c) BUG_ON(c)
-
 #ifndef BTRFS_DISABLE_BACKTRACE
 #define        ASSERT(c) assert_trace(#c, __FILE__, __func__, __LINE__, (c))
 #else
@@ -300,6 +321,14 @@ static inline long IS_ERR(const void *ptr)
 #define __bitwise
 #endif
 
+/* Alignment check */
+#define IS_ALIGNED(x, a)                (((x) & ((typeof(x))(a) - 1)) == 0)
+
+static inline int is_power_of_2(unsigned long n)
+{
+       return (n != 0 && ((n & (n - 1)) == 0));
+}
+
 typedef u16 __bitwise __le16;
 typedef u16 __bitwise __be16;
 typedef u32 __bitwise __le32;
@@ -336,14 +365,21 @@ struct __una_u32 { __le32 x; } __attribute__((__packed__));
 struct __una_u64 { __le64 x; } __attribute__((__packed__));
 
 #define get_unaligned_le8(p) (*((u8 *)(p)))
+#define get_unaligned_8(p) (*((u8 *)(p)))
 #define put_unaligned_le8(val,p) ((*((u8 *)(p))) = (val))
+#define put_unaligned_8(val,p) ((*((u8 *)(p))) = (val))
 #define get_unaligned_le16(p) le16_to_cpu(((const struct __una_u16 *)(p))->x)
+#define get_unaligned_16(p) (((const struct __una_u16 *)(p))->x)
 #define put_unaligned_le16(val,p) (((struct __una_u16 *)(p))->x = cpu_to_le16(val))
+#define put_unaligned_16(val,p) (((struct __una_u16 *)(p))->x = (val))
 #define get_unaligned_le32(p) le32_to_cpu(((const struct __una_u32 *)(p))->x)
+#define get_unaligned_32(p) (((const struct __una_u32 *)(p))->x)
 #define put_unaligned_le32(val,p) (((struct __una_u32 *)(p))->x = cpu_to_le32(val))
+#define put_unaligned_32(val,p) (((struct __una_u32 *)(p))->x = (val))
 #define get_unaligned_le64(p) le64_to_cpu(((const struct __una_u64 *)(p))->x)
+#define get_unaligned_64(p) (((const struct __una_u64 *)(p))->x)
 #define put_unaligned_le64(val,p) (((struct __una_u64 *)(p))->x = cpu_to_le64(val))
-#endif
+#define put_unaligned_64(val,p) (((struct __una_u64 *)(p))->x = (val))
 
 #ifndef true
 #define true 1
@@ -353,3 +389,5 @@ struct __una_u64 { __le64 x; } __attribute__((__packed__));
 #ifndef noinline
 #define noinline
 #endif
+
+#endif