From e8d8949d3826b4ff3681b4b249f0c38627e6304f Mon Sep 17 00:00:00 2001 From: David Sterba Date: Wed, 4 Jan 2023 16:52:57 +0100 Subject: [PATCH] btrfs-progs: libbtrfs: use own copy of kerncompat.h Add a copy from v6.0.2 of kerncompat.h for libbtrfs to avoid accidental build breakage as it's a public header and until now also shared with the rest of btrfs-progs code. Signed-off-by: David Sterba --- Makefile | 2 +- libbtrfs/ctree.h | 2 +- libbtrfs/kerncompat.h | 553 +++++++++++++++++++++++++++++++++++++++++ libbtrfs/send-stream.h | 2 +- libbtrfs/send-utils.h | 2 +- 5 files changed, 557 insertions(+), 4 deletions(-) create mode 100644 libbtrfs/kerncompat.h diff --git a/Makefile b/Makefile index 23b1fae1..d80bd457 100644 --- a/Makefile +++ b/Makefile @@ -220,7 +220,7 @@ libbtrfs_objects = \ crypto/crc32c.o libbtrfs_headers = libbtrfs/send-stream.h libbtrfs/send-utils.h libbtrfs/send.h kernel-lib/rbtree.h \ - kernel-lib/list.h kernel-lib/rbtree_types.h kerncompat.h \ + kernel-lib/list.h kernel-lib/rbtree_types.h libbtrfs/kerncompat.h \ libbtrfs/ioctl.h libbtrfs/ctree.h version.h libbtrfsutil_major := $(shell sed -rn 's/^\#define BTRFS_UTIL_VERSION_MAJOR ([0-9])+$$/\1/p' libbtrfsutil/btrfsutil.h) libbtrfsutil_minor := $(shell sed -rn 's/^\#define BTRFS_UTIL_VERSION_MINOR ([0-9])+$$/\1/p' libbtrfsutil/btrfsutil.h) diff --git a/libbtrfs/ctree.h b/libbtrfs/ctree.h index eeaebe3e..e7a51c4b 100644 --- a/libbtrfs/ctree.h +++ b/libbtrfs/ctree.h @@ -24,7 +24,7 @@ #if BTRFS_FLAT_INCLUDES #include "kernel-lib/list.h" #include "kernel-lib/rbtree.h" -#include "kerncompat.h" +#include "libbtrfs/kerncompat.h" #include "libbtrfs/ioctl.h" #else #include diff --git a/libbtrfs/kerncompat.h b/libbtrfs/kerncompat.h new file mode 100644 index 00000000..f7598627 --- /dev/null +++ b/libbtrfs/kerncompat.h @@ -0,0 +1,553 @@ +/* + * Copyright (C) 2007 Oracle. All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License v2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + */ + +#ifndef __KERNCOMPAT_H__ +#define __KERNCOMPAT_H__ + +#ifndef __SANE_USERSPACE_TYPES__ +/* For PPC64 to get LL64 types */ +#define __SANE_USERSPACE_TYPES__ +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * Glibc supports backtrace, some other libc implementations don't but need to + * be more careful detecting proper glibc. + */ +#if !defined(__GLIBC__) || defined(__UCLIBC__) +#ifndef BTRFS_DISABLE_BACKTRACE +#define BTRFS_DISABLE_BACKTRACE +#endif + +#ifndef __always_inline +#define __always_inline __inline __attribute__ ((__always_inline__)) +#endif + +#endif + +#ifndef BTRFS_DISABLE_BACKTRACE +#include +#endif + +#define ptr_to_u64(x) ((u64)(uintptr_t)x) +#define u64_to_ptr(x) ((void *)(uintptr_t)x) + +#ifndef READ +#define READ 0 +#define WRITE 1 +#define READA 2 +#endif + +#define gfp_t int +#define get_cpu_var(p) (p) +#define __get_cpu_var(p) (p) +#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 +#define GFP_NOFS 0 +#define __read_mostly +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) + +#ifndef ULONG_MAX +#define ULONG_MAX (~0UL) +#endif + +#ifndef SECTOR_SHIFT +#define SECTOR_SHIFT (9) +#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]; + int size; + + size = backtrace(array, MAX_BACKTRACE); + backtrace_symbols_fd(array, size, 2); +} +#endif + +static inline void warning_trace(const char *assertion, const char *filename, + const char *func, unsigned line, long val) +{ + if (!val) + return; + fprintf(stderr, + "%s:%u: %s: Warning: assertion `%s` failed, value %ld\n", + filename, line, func, assertion, val); +#ifndef BTRFS_DISABLE_BACKTRACE + print_trace(); +#endif +} + +static inline void bugon_trace(const char *assertion, const char *filename, + const char *func, unsigned line, long val) +{ + if (!val) + return; + fprintf(stderr, + "%s:%u: %s: BUG_ON `%s` triggered, value %ld\n", + filename, line, func, assertion, val); +#ifndef BTRFS_DISABLE_BACKTRACE + print_trace(); +#endif + abort(); + exit(1); +} + +#ifdef __CHECKER__ +#define __force __attribute__((force)) +#define __bitwise__ __attribute__((bitwise)) +#else +#define __force +#ifndef __bitwise__ +#define __bitwise__ +#endif +#endif + +#ifndef __CHECKER__ +/* + * Since we're using primitive definitions from kernel-space, we need to + * define __KERNEL__ so that system header files know which definitions + * to use. + */ +#define __KERNEL__ +#include +typedef __u32 u32; +typedef __u64 u64; +typedef __u16 u16; +typedef __u8 u8; +typedef __s64 s64; +typedef __s32 s32; + +/* + * Continuing to define __KERNEL__ breaks others parts of the code, so + * we can just undefine it now that we have the correct headers... + */ +#undef __KERNEL__ +#else +typedef unsigned int u32; +typedef unsigned int __u32; +typedef unsigned long long u64; +typedef unsigned char u8; +typedef unsigned short u16; +typedef long long s64; +typedef int s32; +#endif + +typedef u64 sector_t; + +struct vma_shared { int prio_tree_node; }; +struct vm_area_struct { + unsigned long vm_pgoff; + unsigned long vm_start; + unsigned long vm_end; + struct vma_shared shared; +}; + +struct page { + unsigned long index; +}; + +struct mutex { + unsigned long lock; +}; + +#define mutex_init(m) \ +do { \ + (m)->lock = 1; \ +} while (0) + +static inline void mutex_lock(struct mutex *m) +{ + m->lock--; +} + +static inline void mutex_unlock(struct mutex *m) +{ + m->lock++; +} + +static inline int mutex_is_locked(struct mutex *m) +{ + return (m->lock != 1); +} + +#define cond_resched() do { } while (0) +#define preempt_enable() do { } while (0) +#define preempt_disable() do { } while (0) + +#define BITOP_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) +#define BITOP_WORD(nr) ((nr) / BITS_PER_LONG) + +#ifndef __attribute_const__ +#define __attribute_const__ __attribute__((__const__)) +#endif + +/** + * __set_bit - Set a bit in memory + * @nr: the bit to set + * @addr: the address to start counting from + * + * Unlike set_bit(), this function is non-atomic and may be reordered. + * If it's called on the same region of memory simultaneously, the effect + * may be that only one operation succeeds. + */ +static inline void __set_bit(int nr, volatile unsigned long *addr) +{ + unsigned long mask = BITOP_MASK(nr); + unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr); + + *p |= mask; +} + +static inline void __clear_bit(int nr, volatile unsigned long *addr) +{ + unsigned long mask = BITOP_MASK(nr); + unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr); + + *p &= ~mask; +} + +/** + * test_bit - Determine whether a bit is set + * @nr: bit number to test + * @addr: Address to start counting from + */ +static inline int test_bit(int nr, const volatile unsigned long *addr) +{ + return 1UL & (addr[BITOP_WORD(nr)] >> (nr & (BITS_PER_LONG-1))); +} + +/* + * error pointer + */ +#define MAX_ERRNO 4095 +#define IS_ERR_VALUE(x) ((x) >= (unsigned long)-MAX_ERRNO) + +static inline void *ERR_PTR(long error) +{ + return (void *) error; +} + +static inline long PTR_ERR(const void *ptr) +{ + return (long) ptr; +} + +static inline int IS_ERR(const void *ptr) +{ + return IS_ERR_VALUE((unsigned long)ptr); +} + +static inline int IS_ERR_OR_NULL(const void *ptr) +{ + return !ptr || IS_ERR(ptr); +} + +#define div_u64(x, y) ((x) / (y)) + +/** + * __swap - swap values of @a and @b + * @a: first value + * @b: second value + */ +#define __swap(a, b) \ + do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) + +/* + * 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 + * arguments just once each. + */ +#define __round_mask(x, y) ((__typeof__(x))((y)-1)) +#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1) +#define round_down(x, y) ((x) & ~__round_mask(x, y)) + +/* + * printk + */ +#define printk(fmt, args...) fprintf(stderr, fmt, ##args) +#define KERN_CRIT "" +#define KERN_ERR "" + +/* + * kmalloc/kfree + */ +#define kmalloc(x, y) malloc(x) +#define kzalloc(x, y) calloc(1, x) +#define kstrdup(x, y) strdup(x) +#define kfree(x) free(x) +#define vmalloc(x) malloc(x) +#define vfree(x) free(x) +#define kvzalloc(x, y) kzalloc(x,y) +#define kvfree(x) free(x) +#define memalloc_nofs_save() (0) +#define memalloc_nofs_restore(x) ((void)(x)) + +#ifndef BTRFS_DISABLE_BACKTRACE +static inline void assert_trace(const char *assertion, const char *filename, + const char *func, unsigned line, long val) +{ + if (val) + return; + fprintf(stderr, + "%s:%d: %s: Assertion `%s` failed, value %ld\n", + filename, line, func, assertion, val); +#ifndef BTRFS_DISABLE_BACKTRACE + print_trace(); +#endif + abort(); + exit(1); +} +#define ASSERT(c) assert_trace(#c, __FILE__, __func__, __LINE__, (long)(c)) +#else +#define ASSERT(c) assert(c) +#endif + +#define BUG_ON(c) bugon_trace(#c, __FILE__, __func__, __LINE__, (long)(c)) +#define BUG() \ +do { \ + BUG_ON(1); \ + __builtin_unreachable(); \ +} while (0) +#define WARN_ON(c) warning_trace(#c, __FILE__, __func__, __LINE__, (long)(c)) + +#define container_of(ptr, type, member) ({ \ + const typeof( ((type *)0)->member ) *__mptr = (ptr); \ + (type *)( (char *)__mptr - offsetof(type,member) );}) +#ifndef __bitwise +#ifdef __CHECKER__ +#define __bitwise __bitwise__ +#else +#define __bitwise +#endif /* __CHECKER__ */ +#endif /* __bitwise */ + +/* Alignment check */ +#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0) + +/* + * Alignment, copied and renamed from /usr/include/linux/const.h to work around + * issues caused by moving the definition in 5.12 + */ +#define __ALIGN_KERNEL__(x, a) __ALIGN_KERNEL_MASK__(x, (typeof(x))(a) - 1) +#define __ALIGN_KERNEL_MASK__(x, mask) (((x) + (mask)) & ~(mask)) +#define ALIGN(x, a) __ALIGN_KERNEL__((x), (a)) + +static inline int is_power_of_2(unsigned long n) +{ + return (n != 0 && ((n & (n - 1)) == 0)); +} + +/** + * const_ilog2 - log base 2 of 32-bit or a 64-bit constant unsigned value + * @n: parameter + * + * Use this where sparse expects a true constant expression, e.g. for array + * indices. + */ +#define const_ilog2(n) \ +( \ + __builtin_constant_p(n) ? ( \ + (n) < 2 ? 0 : \ + (n) & (1ULL << 63) ? 63 : \ + (n) & (1ULL << 62) ? 62 : \ + (n) & (1ULL << 61) ? 61 : \ + (n) & (1ULL << 60) ? 60 : \ + (n) & (1ULL << 59) ? 59 : \ + (n) & (1ULL << 58) ? 58 : \ + (n) & (1ULL << 57) ? 57 : \ + (n) & (1ULL << 56) ? 56 : \ + (n) & (1ULL << 55) ? 55 : \ + (n) & (1ULL << 54) ? 54 : \ + (n) & (1ULL << 53) ? 53 : \ + (n) & (1ULL << 52) ? 52 : \ + (n) & (1ULL << 51) ? 51 : \ + (n) & (1ULL << 50) ? 50 : \ + (n) & (1ULL << 49) ? 49 : \ + (n) & (1ULL << 48) ? 48 : \ + (n) & (1ULL << 47) ? 47 : \ + (n) & (1ULL << 46) ? 46 : \ + (n) & (1ULL << 45) ? 45 : \ + (n) & (1ULL << 44) ? 44 : \ + (n) & (1ULL << 43) ? 43 : \ + (n) & (1ULL << 42) ? 42 : \ + (n) & (1ULL << 41) ? 41 : \ + (n) & (1ULL << 40) ? 40 : \ + (n) & (1ULL << 39) ? 39 : \ + (n) & (1ULL << 38) ? 38 : \ + (n) & (1ULL << 37) ? 37 : \ + (n) & (1ULL << 36) ? 36 : \ + (n) & (1ULL << 35) ? 35 : \ + (n) & (1ULL << 34) ? 34 : \ + (n) & (1ULL << 33) ? 33 : \ + (n) & (1ULL << 32) ? 32 : \ + (n) & (1ULL << 31) ? 31 : \ + (n) & (1ULL << 30) ? 30 : \ + (n) & (1ULL << 29) ? 29 : \ + (n) & (1ULL << 28) ? 28 : \ + (n) & (1ULL << 27) ? 27 : \ + (n) & (1ULL << 26) ? 26 : \ + (n) & (1ULL << 25) ? 25 : \ + (n) & (1ULL << 24) ? 24 : \ + (n) & (1ULL << 23) ? 23 : \ + (n) & (1ULL << 22) ? 22 : \ + (n) & (1ULL << 21) ? 21 : \ + (n) & (1ULL << 20) ? 20 : \ + (n) & (1ULL << 19) ? 19 : \ + (n) & (1ULL << 18) ? 18 : \ + (n) & (1ULL << 17) ? 17 : \ + (n) & (1ULL << 16) ? 16 : \ + (n) & (1ULL << 15) ? 15 : \ + (n) & (1ULL << 14) ? 14 : \ + (n) & (1ULL << 13) ? 13 : \ + (n) & (1ULL << 12) ? 12 : \ + (n) & (1ULL << 11) ? 11 : \ + (n) & (1ULL << 10) ? 10 : \ + (n) & (1ULL << 9) ? 9 : \ + (n) & (1ULL << 8) ? 8 : \ + (n) & (1ULL << 7) ? 7 : \ + (n) & (1ULL << 6) ? 6 : \ + (n) & (1ULL << 5) ? 5 : \ + (n) & (1ULL << 4) ? 4 : \ + (n) & (1ULL << 3) ? 3 : \ + (n) & (1ULL << 2) ? 2 : \ + 1) : \ + -1) + +static inline int ilog2(u64 num) +{ + int l = 0; + + num >>= 1; + while (num) { + l++; + num >>= 1; + } + + return l; +} + +typedef u16 __bitwise __le16; +typedef u16 __bitwise __be16; +typedef u32 __bitwise __le32; +typedef u32 __bitwise __be32; +typedef u64 __bitwise __le64; +typedef u64 __bitwise __be64; + +#define U64_MAX UINT64_MAX +#define U32_MAX UINT32_MAX + +/* Macros to generate set/get funcs for the struct fields + * assume there is a lefoo_to_cpu for every type, so lets make a simple + * one for u8: + */ +#define le8_to_cpu(v) (v) +#define cpu_to_le8(v) (v) +#define __le8 u8 + +#if __BYTE_ORDER == __BIG_ENDIAN +#define cpu_to_le64(x) ((__force __le64)(u64)(bswap_64(x))) +#define le64_to_cpu(x) ((__force u64)(__le64)(bswap_64(x))) +#define cpu_to_le32(x) ((__force __le32)(u32)(bswap_32(x))) +#define le32_to_cpu(x) ((__force u32)(__le32)(bswap_32(x))) +#define cpu_to_le16(x) ((__force __le16)(u16)(bswap_16(x))) +#define le16_to_cpu(x) ((__force u16)(__le16)(bswap_16(x))) +#else +#define cpu_to_le64(x) ((__force __le64)(u64)(x)) +#define le64_to_cpu(x) ((__force u64)(__le64)(x)) +#define cpu_to_le32(x) ((__force __le32)(u32)(x)) +#define le32_to_cpu(x) ((__force u32)(__le32)(x)) +#define cpu_to_le16(x) ((__force __le16)(u16)(x)) +#define le16_to_cpu(x) ((__force u16)(__le16)(x)) +#endif + +struct __una_u16 { __le16 x; } __attribute__((__packed__)); +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)) +#define put_unaligned_64(val,p) (((struct __una_u64 *)(p))->x = (val)) + +#ifndef true +#define true 1 +#define false 0 +#endif + +#ifndef noinline +#define noinline +#endif + +/* + * Note: simplified versions of READ_ONCE and WRITE_ONCE for source + * compatibility only, not usable for lock-less implementation like in kernel. + * + * Changed: + * - __unqual_scalar_typeof: volatile cast to typeof() + * - compiletime_assert_rwonce_type: no word size compatibility checks + * - no const volatile cast + */ + +#define READ_ONCE(x) (x) + +#define WRITE_ONCE(x, val) \ +do { \ + (x) = (val); \ +} while (0) + +#endif diff --git a/libbtrfs/send-stream.h b/libbtrfs/send-stream.h index d21964ef..01acd6db 100644 --- a/libbtrfs/send-stream.h +++ b/libbtrfs/send-stream.h @@ -29,7 +29,7 @@ extern "C" { #endif #if BTRFS_FLAT_INCLUDES -#include "kerncompat.h" +#include "libbtrfs/kerncompat.h" #else #include #endif /* BTRFS_FLAT_INCLUDES */ diff --git a/libbtrfs/send-utils.h b/libbtrfs/send-utils.h index 5a43af7b..b39ee925 100644 --- a/libbtrfs/send-utils.h +++ b/libbtrfs/send-utils.h @@ -20,7 +20,7 @@ #define __BTRFS_SEND_UTILS_H__ #if BTRFS_FLAT_INCLUDES -#include "kerncompat.h" +#include "libbtrfs/kerncompat.h" #include #include "libbtrfs/ctree.h" #include "kernel-lib/rbtree_types.h"