tools: add more linux include files to fix x86 build on macos
Signed-off-by: Felix Fietkau <nbd@nbd.name>
This commit is contained in:
Felix Fietkau
parent
931b2bafa7
commit
c3d4598c01
|
|
@ -0,0 +1,27 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef __ASM_GENERIC_BITS_PER_LONG
|
||||
#define __ASM_GENERIC_BITS_PER_LONG
|
||||
|
||||
#ifndef __BITS_PER_LONG
|
||||
/*
|
||||
* In order to keep safe and avoid regression, only unify uapi
|
||||
* bitsperlong.h for some archs which are using newer toolchains
|
||||
* that have the definitions of __CHAR_BIT__ and __SIZEOF_LONG__.
|
||||
* See the following link for more info:
|
||||
* https://lore.kernel.org/linux-arch/b9624545-2c80-49a1-ac3c-39264a591f7b@app.fastmail.com/
|
||||
*/
|
||||
#if defined(__CHAR_BIT__) && defined(__SIZEOF_LONG__)
|
||||
#define __BITS_PER_LONG (__CHAR_BIT__ * __SIZEOF_LONG__)
|
||||
#else
|
||||
/*
|
||||
* There seems to be no way of detecting this automatically from user
|
||||
* space, so 64 bit architectures should override this in their
|
||||
* bitsperlong.h. In particular, an architecture that supports
|
||||
* both 32 and 64 bit user space must not rely on CONFIG_64BIT
|
||||
* to decide it, but rather check a compiler provided macro.
|
||||
*/
|
||||
#define __BITS_PER_LONG 32
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* __ASM_GENERIC_BITS_PER_LONG */
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#ifndef __ASM_BYTEORDER_H
|
||||
#define __ASM_BYTEORDER_H
|
||||
|
||||
#include <endian.h>
|
||||
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
#include <linux/byteorder/little_endian.h>
|
||||
#else
|
||||
#include <linux/byteorder/big_endian.h>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _ASM_GENERIC_ERRNO_BASE_H
|
||||
#define _ASM_GENERIC_ERRNO_BASE_H
|
||||
|
||||
#define EPERM 1 /* Operation not permitted */
|
||||
#define ENOENT 2 /* No such file or directory */
|
||||
#define ESRCH 3 /* No such process */
|
||||
#define EINTR 4 /* Interrupted system call */
|
||||
#define EIO 5 /* I/O error */
|
||||
#define ENXIO 6 /* No such device or address */
|
||||
#define E2BIG 7 /* Argument list too long */
|
||||
#define ENOEXEC 8 /* Exec format error */
|
||||
#define EBADF 9 /* Bad file number */
|
||||
#define ECHILD 10 /* No child processes */
|
||||
#define EAGAIN 11 /* Try again */
|
||||
#define ENOMEM 12 /* Out of memory */
|
||||
#define EACCES 13 /* Permission denied */
|
||||
#define EFAULT 14 /* Bad address */
|
||||
#define ENOTBLK 15 /* Block device required */
|
||||
#define EBUSY 16 /* Device or resource busy */
|
||||
#define EEXIST 17 /* File exists */
|
||||
#define EXDEV 18 /* Cross-device link */
|
||||
#define ENODEV 19 /* No such device */
|
||||
#define ENOTDIR 20 /* Not a directory */
|
||||
#define EISDIR 21 /* Is a directory */
|
||||
#define EINVAL 22 /* Invalid argument */
|
||||
#define ENFILE 23 /* File table overflow */
|
||||
#define EMFILE 24 /* Too many open files */
|
||||
#define ENOTTY 25 /* Not a typewriter */
|
||||
#define ETXTBSY 26 /* Text file busy */
|
||||
#define EFBIG 27 /* File too large */
|
||||
#define ENOSPC 28 /* No space left on device */
|
||||
#define ESPIPE 29 /* Illegal seek */
|
||||
#define EROFS 30 /* Read-only file system */
|
||||
#define EMLINK 31 /* Too many links */
|
||||
#define EPIPE 32 /* Broken pipe */
|
||||
#define EDOM 33 /* Math argument out of domain of func */
|
||||
#define ERANGE 34 /* Math result not representable */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _ASM_GENERIC_ERRNO_H
|
||||
#define _ASM_GENERIC_ERRNO_H
|
||||
|
||||
#include <asm/errno-base.h>
|
||||
|
||||
#define EDEADLK 35 /* Resource deadlock would occur */
|
||||
#define ENAMETOOLONG 36 /* File name too long */
|
||||
#define ENOLCK 37 /* No record locks available */
|
||||
|
||||
/*
|
||||
* This error code is special: arch syscall entry code will return
|
||||
* -ENOSYS if users try to call a syscall that doesn't exist. To keep
|
||||
* failures of syscalls that really do exist distinguishable from
|
||||
* failures due to attempts to use a nonexistent syscall, syscall
|
||||
* implementations should refrain from returning -ENOSYS.
|
||||
*/
|
||||
#define ENOSYS 38 /* Invalid system call number */
|
||||
|
||||
#define ENOTEMPTY 39 /* Directory not empty */
|
||||
#define ELOOP 40 /* Too many symbolic links encountered */
|
||||
#define EWOULDBLOCK EAGAIN /* Operation would block */
|
||||
#define ENOMSG 42 /* No message of desired type */
|
||||
#define EIDRM 43 /* Identifier removed */
|
||||
#define ECHRNG 44 /* Channel number out of range */
|
||||
#define EL2NSYNC 45 /* Level 2 not synchronized */
|
||||
#define EL3HLT 46 /* Level 3 halted */
|
||||
#define EL3RST 47 /* Level 3 reset */
|
||||
#define ELNRNG 48 /* Link number out of range */
|
||||
#define EUNATCH 49 /* Protocol driver not attached */
|
||||
#define ENOCSI 50 /* No CSI structure available */
|
||||
#define EL2HLT 51 /* Level 2 halted */
|
||||
#define EBADE 52 /* Invalid exchange */
|
||||
#define EBADR 53 /* Invalid request descriptor */
|
||||
#define EXFULL 54 /* Exchange full */
|
||||
#define ENOANO 55 /* No anode */
|
||||
#define EBADRQC 56 /* Invalid request code */
|
||||
#define EBADSLT 57 /* Invalid slot */
|
||||
|
||||
#define EDEADLOCK EDEADLK
|
||||
|
||||
#define EBFONT 59 /* Bad font file format */
|
||||
#define ENOSTR 60 /* Device not a stream */
|
||||
#define ENODATA 61 /* No data available */
|
||||
#define ETIME 62 /* Timer expired */
|
||||
#define ENOSR 63 /* Out of streams resources */
|
||||
#define ENONET 64 /* Machine is not on the network */
|
||||
#define ENOPKG 65 /* Package not installed */
|
||||
#define EREMOTE 66 /* Object is remote */
|
||||
#define ENOLINK 67 /* Link has been severed */
|
||||
#define EADV 68 /* Advertise error */
|
||||
#define ESRMNT 69 /* Srmount error */
|
||||
#define ECOMM 70 /* Communication error on send */
|
||||
#define EPROTO 71 /* Protocol error */
|
||||
#define EMULTIHOP 72 /* Multihop attempted */
|
||||
#define EDOTDOT 73 /* RFS specific error */
|
||||
#define EBADMSG 74 /* Not a data message */
|
||||
#define EOVERFLOW 75 /* Value too large for defined data type */
|
||||
#define ENOTUNIQ 76 /* Name not unique on network */
|
||||
#define EBADFD 77 /* File descriptor in bad state */
|
||||
#define EREMCHG 78 /* Remote address changed */
|
||||
#define ELIBACC 79 /* Can not access a needed shared library */
|
||||
#define ELIBBAD 80 /* Accessing a corrupted shared library */
|
||||
#define ELIBSCN 81 /* .lib section in a.out corrupted */
|
||||
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
|
||||
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
|
||||
#define EILSEQ 84 /* Illegal byte sequence */
|
||||
#define ERESTART 85 /* Interrupted system call should be restarted */
|
||||
#define ESTRPIPE 86 /* Streams pipe error */
|
||||
#define EUSERS 87 /* Too many users */
|
||||
#define ENOTSOCK 88 /* Socket operation on non-socket */
|
||||
#define EDESTADDRREQ 89 /* Destination address required */
|
||||
#define EMSGSIZE 90 /* Message too long */
|
||||
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
|
||||
#define ENOPROTOOPT 92 /* Protocol not available */
|
||||
#define EPROTONOSUPPORT 93 /* Protocol not supported */
|
||||
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
|
||||
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
|
||||
#define EPFNOSUPPORT 96 /* Protocol family not supported */
|
||||
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
|
||||
#define EADDRINUSE 98 /* Address already in use */
|
||||
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
|
||||
#define ENETDOWN 100 /* Network is down */
|
||||
#define ENETUNREACH 101 /* Network is unreachable */
|
||||
#define ENETRESET 102 /* Network dropped connection because of reset */
|
||||
#define ECONNABORTED 103 /* Software caused connection abort */
|
||||
#define ECONNRESET 104 /* Connection reset by peer */
|
||||
#define ENOBUFS 105 /* No buffer space available */
|
||||
#define EISCONN 106 /* Transport endpoint is already connected */
|
||||
#define ENOTCONN 107 /* Transport endpoint is not connected */
|
||||
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
|
||||
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
|
||||
#define ETIMEDOUT 110 /* Connection timed out */
|
||||
#define ECONNREFUSED 111 /* Connection refused */
|
||||
#define EHOSTDOWN 112 /* Host is down */
|
||||
#define EHOSTUNREACH 113 /* No route to host */
|
||||
#define EALREADY 114 /* Operation already in progress */
|
||||
#define EINPROGRESS 115 /* Operation now in progress */
|
||||
#define ESTALE 116 /* Stale file handle */
|
||||
#define EUCLEAN 117 /* Structure needs cleaning */
|
||||
#define ENOTNAM 118 /* Not a XENIX named type file */
|
||||
#define ENAVAIL 119 /* No XENIX semaphores available */
|
||||
#define EISNAM 120 /* Is a named type file */
|
||||
#define EREMOTEIO 121 /* Remote I/O error */
|
||||
#define EDQUOT 122 /* Quota exceeded */
|
||||
|
||||
#define ENOMEDIUM 123 /* No medium found */
|
||||
#define EMEDIUMTYPE 124 /* Wrong medium type */
|
||||
#define ECANCELED 125 /* Operation Canceled */
|
||||
#define ENOKEY 126 /* Required key not available */
|
||||
#define EKEYEXPIRED 127 /* Key has expired */
|
||||
#define EKEYREVOKED 128 /* Key has been revoked */
|
||||
#define EKEYREJECTED 129 /* Key was rejected by service */
|
||||
|
||||
/* for robust mutexes */
|
||||
#define EOWNERDEAD 130 /* Owner died */
|
||||
#define ENOTRECOVERABLE 131 /* State not recoverable */
|
||||
|
||||
#define ERFKILL 132 /* Operation not possible due to RF-kill */
|
||||
|
||||
#define EHWPOISON 133 /* Memory page has hardware error */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef __ASM_GENERIC_POSIX_TYPES_H
|
||||
#define __ASM_GENERIC_POSIX_TYPES_H
|
||||
|
||||
#include <asm/bitsperlong.h>
|
||||
|
||||
/*
|
||||
* This file is generally used by user-level software, so you need to
|
||||
* be a little careful about namespace pollution etc.
|
||||
*
|
||||
* First the types that are often defined in different ways across
|
||||
* architectures, so that you can override them.
|
||||
*/
|
||||
|
||||
#ifndef __kernel_long_t
|
||||
typedef long __kernel_long_t;
|
||||
typedef unsigned long __kernel_ulong_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_ino_t
|
||||
typedef __kernel_ulong_t __kernel_ino_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_mode_t
|
||||
typedef unsigned int __kernel_mode_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_pid_t
|
||||
typedef int __kernel_pid_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_ipc_pid_t
|
||||
typedef int __kernel_ipc_pid_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_uid_t
|
||||
typedef unsigned int __kernel_uid_t;
|
||||
typedef unsigned int __kernel_gid_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_suseconds_t
|
||||
typedef __kernel_long_t __kernel_suseconds_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_daddr_t
|
||||
typedef int __kernel_daddr_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_uid32_t
|
||||
typedef unsigned int __kernel_uid32_t;
|
||||
typedef unsigned int __kernel_gid32_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_old_uid_t
|
||||
typedef __kernel_uid_t __kernel_old_uid_t;
|
||||
typedef __kernel_gid_t __kernel_old_gid_t;
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_old_dev_t
|
||||
typedef unsigned int __kernel_old_dev_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Most 32 bit architectures use "unsigned int" size_t,
|
||||
* and all 64 bit architectures use "unsigned long" size_t.
|
||||
*/
|
||||
#ifndef __kernel_size_t
|
||||
#if __BITS_PER_LONG != 64
|
||||
typedef unsigned int __kernel_size_t;
|
||||
typedef int __kernel_ssize_t;
|
||||
typedef int __kernel_ptrdiff_t;
|
||||
#else
|
||||
typedef __kernel_ulong_t __kernel_size_t;
|
||||
typedef __kernel_long_t __kernel_ssize_t;
|
||||
typedef __kernel_long_t __kernel_ptrdiff_t;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __kernel_fsid_t
|
||||
typedef struct {
|
||||
int val[2];
|
||||
} __kernel_fsid_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* anything below here should be completely generic
|
||||
*/
|
||||
typedef __kernel_long_t __kernel_off_t;
|
||||
typedef long long __kernel_loff_t;
|
||||
typedef __kernel_long_t __kernel_old_time_t;
|
||||
typedef __kernel_long_t __kernel_time_t;
|
||||
typedef long long __kernel_time64_t;
|
||||
typedef __kernel_long_t __kernel_clock_t;
|
||||
typedef int __kernel_timer_t;
|
||||
typedef int __kernel_clockid_t;
|
||||
typedef char * __kernel_caddr_t;
|
||||
typedef unsigned short __kernel_uid16_t;
|
||||
typedef unsigned short __kernel_gid16_t;
|
||||
|
||||
#endif /* __ASM_GENERIC_POSIX_TYPES_H */
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _ASM_GENERIC_SWAB_H
|
||||
#define _ASM_GENERIC_SWAB_H
|
||||
|
||||
#include <asm/bitsperlong.h>
|
||||
|
||||
/*
|
||||
* 32 bit architectures typically (but not always) want to
|
||||
* set __SWAB_64_THRU_32__. In user space, this is only
|
||||
* valid if the compiler supports 64 bit data types.
|
||||
*/
|
||||
|
||||
#if __BITS_PER_LONG == 32
|
||||
#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__)
|
||||
#define __SWAB_64_THRU_32__
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* _ASM_GENERIC_SWAB_H */
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _LINUX_BYTEORDER_BIG_ENDIAN_H
|
||||
#define _LINUX_BYTEORDER_BIG_ENDIAN_H
|
||||
|
||||
#ifndef __BIG_ENDIAN
|
||||
#define __BIG_ENDIAN 4321
|
||||
#endif
|
||||
#ifndef __BIG_ENDIAN_BITFIELD
|
||||
#define __BIG_ENDIAN_BITFIELD
|
||||
#endif
|
||||
|
||||
#include <linux/stddef.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/swab.h>
|
||||
|
||||
#define __constant_htonl(x) ((__be32)(__u32)(x))
|
||||
#define __constant_ntohl(x) ((__u32)(__be32)(x))
|
||||
#define __constant_htons(x) ((__be16)(__u16)(x))
|
||||
#define __constant_ntohs(x) ((__u16)(__be16)(x))
|
||||
#define __constant_cpu_to_le64(x) ((__le64)___constant_swab64((x)))
|
||||
#define __constant_le64_to_cpu(x) ___constant_swab64((__u64)(__le64)(x))
|
||||
#define __constant_cpu_to_le32(x) ((__le32)___constant_swab32((x)))
|
||||
#define __constant_le32_to_cpu(x) ___constant_swab32((__u32)(__le32)(x))
|
||||
#define __constant_cpu_to_le16(x) ((__le16)___constant_swab16((x)))
|
||||
#define __constant_le16_to_cpu(x) ___constant_swab16((__u16)(__le16)(x))
|
||||
#define __constant_cpu_to_be64(x) ((__be64)(__u64)(x))
|
||||
#define __constant_be64_to_cpu(x) ((__u64)(__be64)(x))
|
||||
#define __constant_cpu_to_be32(x) ((__be32)(__u32)(x))
|
||||
#define __constant_be32_to_cpu(x) ((__u32)(__be32)(x))
|
||||
#define __constant_cpu_to_be16(x) ((__be16)(__u16)(x))
|
||||
#define __constant_be16_to_cpu(x) ((__u16)(__be16)(x))
|
||||
#define __cpu_to_le64(x) ((__le64)__swab64((x)))
|
||||
#define __le64_to_cpu(x) __swab64((__u64)(__le64)(x))
|
||||
#define __cpu_to_le32(x) ((__le32)__swab32((x)))
|
||||
#define __le32_to_cpu(x) __swab32((__u32)(__le32)(x))
|
||||
#define __cpu_to_le16(x) ((__le16)__swab16((x)))
|
||||
#define __le16_to_cpu(x) __swab16((__u16)(__le16)(x))
|
||||
#define __cpu_to_be64(x) ((__be64)(__u64)(x))
|
||||
#define __be64_to_cpu(x) ((__u64)(__be64)(x))
|
||||
#define __cpu_to_be32(x) ((__be32)(__u32)(x))
|
||||
#define __be32_to_cpu(x) ((__u32)(__be32)(x))
|
||||
#define __cpu_to_be16(x) ((__be16)(__u16)(x))
|
||||
#define __be16_to_cpu(x) ((__u16)(__be16)(x))
|
||||
|
||||
static __always_inline __le64 __cpu_to_le64p(const __u64 *p)
|
||||
{
|
||||
return (__le64)__swab64p(p);
|
||||
}
|
||||
static __always_inline __u64 __le64_to_cpup(const __le64 *p)
|
||||
{
|
||||
return __swab64p((__u64 *)p);
|
||||
}
|
||||
static __always_inline __le32 __cpu_to_le32p(const __u32 *p)
|
||||
{
|
||||
return (__le32)__swab32p(p);
|
||||
}
|
||||
static __always_inline __u32 __le32_to_cpup(const __le32 *p)
|
||||
{
|
||||
return __swab32p((__u32 *)p);
|
||||
}
|
||||
static __always_inline __le16 __cpu_to_le16p(const __u16 *p)
|
||||
{
|
||||
return (__le16)__swab16p(p);
|
||||
}
|
||||
static __always_inline __u16 __le16_to_cpup(const __le16 *p)
|
||||
{
|
||||
return __swab16p((__u16 *)p);
|
||||
}
|
||||
static __always_inline __be64 __cpu_to_be64p(const __u64 *p)
|
||||
{
|
||||
return (__be64)*p;
|
||||
}
|
||||
static __always_inline __u64 __be64_to_cpup(const __be64 *p)
|
||||
{
|
||||
return (__u64)*p;
|
||||
}
|
||||
static __always_inline __be32 __cpu_to_be32p(const __u32 *p)
|
||||
{
|
||||
return (__be32)*p;
|
||||
}
|
||||
static __always_inline __u32 __be32_to_cpup(const __be32 *p)
|
||||
{
|
||||
return (__u32)*p;
|
||||
}
|
||||
static __always_inline __be16 __cpu_to_be16p(const __u16 *p)
|
||||
{
|
||||
return (__be16)*p;
|
||||
}
|
||||
static __always_inline __u16 __be16_to_cpup(const __be16 *p)
|
||||
{
|
||||
return (__u16)*p;
|
||||
}
|
||||
#define __cpu_to_le64s(x) __swab64s((x))
|
||||
#define __le64_to_cpus(x) __swab64s((x))
|
||||
#define __cpu_to_le32s(x) __swab32s((x))
|
||||
#define __le32_to_cpus(x) __swab32s((x))
|
||||
#define __cpu_to_le16s(x) __swab16s((x))
|
||||
#define __le16_to_cpus(x) __swab16s((x))
|
||||
#define __cpu_to_be64s(x) do { (void)(x); } while (0)
|
||||
#define __be64_to_cpus(x) do { (void)(x); } while (0)
|
||||
#define __cpu_to_be32s(x) do { (void)(x); } while (0)
|
||||
#define __be32_to_cpus(x) do { (void)(x); } while (0)
|
||||
#define __cpu_to_be16s(x) do { (void)(x); } while (0)
|
||||
#define __be16_to_cpus(x) do { (void)(x); } while (0)
|
||||
|
||||
|
||||
#endif /* _LINUX_BYTEORDER_BIG_ENDIAN_H */
|
||||
|
|
@ -0,0 +1 @@
|
|||
#include <asm/errno.h>
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _LINUX_BYTEORDER_LITTLE_ENDIAN_H
|
||||
#define _LINUX_BYTEORDER_LITTLE_ENDIAN_H
|
||||
|
||||
#ifndef __LITTLE_ENDIAN
|
||||
#define __LITTLE_ENDIAN 1234
|
||||
#endif
|
||||
#ifndef __LITTLE_ENDIAN_BITFIELD
|
||||
#define __LITTLE_ENDIAN_BITFIELD
|
||||
#endif
|
||||
|
||||
#include <linux/stddef.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/swab.h>
|
||||
|
||||
#define __constant_htonl(x) ((__be32)___constant_swab32((x)))
|
||||
#define __constant_ntohl(x) ___constant_swab32((__be32)(x))
|
||||
#define __constant_htons(x) ((__be16)___constant_swab16((x)))
|
||||
#define __constant_ntohs(x) ___constant_swab16((__be16)(x))
|
||||
#define __constant_cpu_to_le64(x) ((__le64)(__u64)(x))
|
||||
#define __constant_le64_to_cpu(x) ((__u64)(__le64)(x))
|
||||
#define __constant_cpu_to_le32(x) ((__le32)(__u32)(x))
|
||||
#define __constant_le32_to_cpu(x) ((__u32)(__le32)(x))
|
||||
#define __constant_cpu_to_le16(x) ((__le16)(__u16)(x))
|
||||
#define __constant_le16_to_cpu(x) ((__u16)(__le16)(x))
|
||||
#define __constant_cpu_to_be64(x) ((__be64)___constant_swab64((x)))
|
||||
#define __constant_be64_to_cpu(x) ___constant_swab64((__u64)(__be64)(x))
|
||||
#define __constant_cpu_to_be32(x) ((__be32)___constant_swab32((x)))
|
||||
#define __constant_be32_to_cpu(x) ___constant_swab32((__u32)(__be32)(x))
|
||||
#define __constant_cpu_to_be16(x) ((__be16)___constant_swab16((x)))
|
||||
#define __constant_be16_to_cpu(x) ___constant_swab16((__u16)(__be16)(x))
|
||||
#define __cpu_to_le64(x) ((__le64)(__u64)(x))
|
||||
#define __le64_to_cpu(x) ((__u64)(__le64)(x))
|
||||
#define __cpu_to_le32(x) ((__le32)(__u32)(x))
|
||||
#define __le32_to_cpu(x) ((__u32)(__le32)(x))
|
||||
#define __cpu_to_le16(x) ((__le16)(__u16)(x))
|
||||
#define __le16_to_cpu(x) ((__u16)(__le16)(x))
|
||||
#define __cpu_to_be64(x) ((__be64)__swab64((x)))
|
||||
#define __be64_to_cpu(x) __swab64((__u64)(__be64)(x))
|
||||
#define __cpu_to_be32(x) ((__be32)__swab32((x)))
|
||||
#define __be32_to_cpu(x) __swab32((__u32)(__be32)(x))
|
||||
#define __cpu_to_be16(x) ((__be16)__swab16((x)))
|
||||
#define __be16_to_cpu(x) __swab16((__u16)(__be16)(x))
|
||||
|
||||
static __always_inline __le64 __cpu_to_le64p(const __u64 *p)
|
||||
{
|
||||
return (__le64)*p;
|
||||
}
|
||||
static __always_inline __u64 __le64_to_cpup(const __le64 *p)
|
||||
{
|
||||
return (__u64)*p;
|
||||
}
|
||||
static __always_inline __le32 __cpu_to_le32p(const __u32 *p)
|
||||
{
|
||||
return (__le32)*p;
|
||||
}
|
||||
static __always_inline __u32 __le32_to_cpup(const __le32 *p)
|
||||
{
|
||||
return (__u32)*p;
|
||||
}
|
||||
static __always_inline __le16 __cpu_to_le16p(const __u16 *p)
|
||||
{
|
||||
return (__le16)*p;
|
||||
}
|
||||
static __always_inline __u16 __le16_to_cpup(const __le16 *p)
|
||||
{
|
||||
return (__u16)*p;
|
||||
}
|
||||
static __always_inline __be64 __cpu_to_be64p(const __u64 *p)
|
||||
{
|
||||
return (__be64)__swab64p(p);
|
||||
}
|
||||
static __always_inline __u64 __be64_to_cpup(const __be64 *p)
|
||||
{
|
||||
return __swab64p((__u64 *)p);
|
||||
}
|
||||
static __always_inline __be32 __cpu_to_be32p(const __u32 *p)
|
||||
{
|
||||
return (__be32)__swab32p(p);
|
||||
}
|
||||
static __always_inline __u32 __be32_to_cpup(const __be32 *p)
|
||||
{
|
||||
return __swab32p((__u32 *)p);
|
||||
}
|
||||
static __always_inline __be16 __cpu_to_be16p(const __u16 *p)
|
||||
{
|
||||
return (__be16)__swab16p(p);
|
||||
}
|
||||
static __always_inline __u16 __be16_to_cpup(const __be16 *p)
|
||||
{
|
||||
return __swab16p((__u16 *)p);
|
||||
}
|
||||
#define __cpu_to_le64s(x) do { (void)(x); } while (0)
|
||||
#define __le64_to_cpus(x) do { (void)(x); } while (0)
|
||||
#define __cpu_to_le32s(x) do { (void)(x); } while (0)
|
||||
#define __le32_to_cpus(x) do { (void)(x); } while (0)
|
||||
#define __cpu_to_le16s(x) do { (void)(x); } while (0)
|
||||
#define __le16_to_cpus(x) do { (void)(x); } while (0)
|
||||
#define __cpu_to_be64s(x) __swab64s((x))
|
||||
#define __be64_to_cpus(x) __swab64s((x))
|
||||
#define __cpu_to_be32s(x) __swab32s((x))
|
||||
#define __be32_to_cpus(x) __swab32s((x))
|
||||
#define __cpu_to_be16s(x) __swab16s((x))
|
||||
#define __be16_to_cpus(x) __swab16s((x))
|
||||
|
||||
|
||||
#endif /* _LINUX_BYTEORDER_LITTLE_ENDIAN_H */
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _UAPI_LINUX_STDDEF_H
|
||||
#define _UAPI_LINUX_STDDEF_H
|
||||
|
||||
#ifndef __always_inline
|
||||
#define __always_inline inline
|
||||
#endif
|
||||
|
||||
/**
|
||||
* __struct_group() - Create a mirrored named and anonyomous struct
|
||||
*
|
||||
* @TAG: The tag name for the named sub-struct (usually empty)
|
||||
* @NAME: The identifier name of the mirrored sub-struct
|
||||
* @ATTRS: Any struct attributes (usually empty)
|
||||
* @MEMBERS: The member declarations for the mirrored structs
|
||||
*
|
||||
* Used to create an anonymous union of two structs with identical layout
|
||||
* and size: one anonymous and one named. The former's members can be used
|
||||
* normally without sub-struct naming, and the latter can be used to
|
||||
* reason about the start, end, and size of the group of struct members.
|
||||
* The named struct can also be explicitly tagged for layer reuse, as well
|
||||
* as both having struct attributes appended.
|
||||
*/
|
||||
#define __struct_group(TAG, NAME, ATTRS, MEMBERS...) \
|
||||
union { \
|
||||
struct { MEMBERS } ATTRS; \
|
||||
struct TAG { MEMBERS } ATTRS NAME; \
|
||||
} ATTRS
|
||||
|
||||
#ifdef __cplusplus
|
||||
/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */
|
||||
#define __DECLARE_FLEX_ARRAY(T, member) \
|
||||
T member[0]
|
||||
#else
|
||||
/**
|
||||
* __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union
|
||||
*
|
||||
* @TYPE: The type of each flexible array element
|
||||
* @NAME: The name of the flexible array member
|
||||
*
|
||||
* In order to have a flexible array member in a union or alone in a
|
||||
* struct, it needs to be wrapped in an anonymous struct with at least 1
|
||||
* named member, but that member can be empty.
|
||||
*/
|
||||
#define __DECLARE_FLEX_ARRAY(TYPE, NAME) \
|
||||
struct { \
|
||||
struct { } __empty_ ## NAME; \
|
||||
TYPE NAME[]; \
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef __counted_by
|
||||
#define __counted_by(m)
|
||||
#endif
|
||||
|
||||
#endif /* _UAPI_LINUX_STDDEF_H */
|
||||
|
|
@ -0,0 +1,305 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _LINUX_SWAB_H
|
||||
#define _LINUX_SWAB_H
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/stddef.h>
|
||||
#include <asm/bitsperlong.h>
|
||||
#include <asm/swab.h>
|
||||
|
||||
/*
|
||||
* casts are necessary for constants, because we never know how for sure
|
||||
* how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
|
||||
*/
|
||||
#define ___constant_swab16(x) ((__u16)( \
|
||||
(((__u16)(x) & (__u16)0x00ffU) << 8) | \
|
||||
(((__u16)(x) & (__u16)0xff00U) >> 8)))
|
||||
|
||||
#define ___constant_swab32(x) ((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
|
||||
(((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \
|
||||
(((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \
|
||||
(((__u32)(x) & (__u32)0xff000000UL) >> 24)))
|
||||
|
||||
#define ___constant_swab64(x) ((__u64)( \
|
||||
(((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) | \
|
||||
(((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) | \
|
||||
(((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) | \
|
||||
(((__u64)(x) & (__u64)0x00000000ff000000ULL) << 8) | \
|
||||
(((__u64)(x) & (__u64)0x000000ff00000000ULL) >> 8) | \
|
||||
(((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) | \
|
||||
(((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) | \
|
||||
(((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56)))
|
||||
|
||||
#define ___constant_swahw32(x) ((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x0000ffffUL) << 16) | \
|
||||
(((__u32)(x) & (__u32)0xffff0000UL) >> 16)))
|
||||
|
||||
#define ___constant_swahb32(x) ((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x00ff00ffUL) << 8) | \
|
||||
(((__u32)(x) & (__u32)0xff00ff00UL) >> 8)))
|
||||
|
||||
/*
|
||||
* Implement the following as inlines, but define the interface using
|
||||
* macros to allow constant folding when possible:
|
||||
* ___swab16, ___swab32, ___swab64, ___swahw32, ___swahb32
|
||||
*/
|
||||
|
||||
static __inline__ __u16 __fswab16(__u16 val)
|
||||
{
|
||||
#if defined (__arch_swab16)
|
||||
return __arch_swab16(val);
|
||||
#else
|
||||
return ___constant_swab16(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ __u32 __fswab32(__u32 val)
|
||||
{
|
||||
#if defined(__arch_swab32)
|
||||
return __arch_swab32(val);
|
||||
#else
|
||||
return ___constant_swab32(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ __u64 __fswab64(__u64 val)
|
||||
{
|
||||
#if defined (__arch_swab64)
|
||||
return __arch_swab64(val);
|
||||
#elif defined(__SWAB_64_THRU_32__)
|
||||
__u32 h = val >> 32;
|
||||
__u32 l = val & ((1ULL << 32) - 1);
|
||||
return (((__u64)__fswab32(l)) << 32) | ((__u64)(__fswab32(h)));
|
||||
#else
|
||||
return ___constant_swab64(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ __u32 __fswahw32(__u32 val)
|
||||
{
|
||||
#ifdef __arch_swahw32
|
||||
return __arch_swahw32(val);
|
||||
#else
|
||||
return ___constant_swahw32(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ __u32 __fswahb32(__u32 val)
|
||||
{
|
||||
#ifdef __arch_swahb32
|
||||
return __arch_swahb32(val);
|
||||
#else
|
||||
return ___constant_swahb32(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swab16 - return a byteswapped 16-bit value
|
||||
* @x: value to byteswap
|
||||
*/
|
||||
#ifdef __HAVE_BUILTIN_BSWAP16__
|
||||
#define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
|
||||
#else
|
||||
#define __swab16(x) \
|
||||
(__u16)(__builtin_constant_p(x) ? \
|
||||
___constant_swab16(x) : \
|
||||
__fswab16(x))
|
||||
#endif
|
||||
|
||||
/**
|
||||
* __swab32 - return a byteswapped 32-bit value
|
||||
* @x: value to byteswap
|
||||
*/
|
||||
#ifdef __HAVE_BUILTIN_BSWAP32__
|
||||
#define __swab32(x) (__u32)__builtin_bswap32((__u32)(x))
|
||||
#else
|
||||
#define __swab32(x) \
|
||||
(__u32)(__builtin_constant_p(x) ? \
|
||||
___constant_swab32(x) : \
|
||||
__fswab32(x))
|
||||
#endif
|
||||
|
||||
/**
|
||||
* __swab64 - return a byteswapped 64-bit value
|
||||
* @x: value to byteswap
|
||||
*/
|
||||
#ifdef __HAVE_BUILTIN_BSWAP64__
|
||||
#define __swab64(x) (__u64)__builtin_bswap64((__u64)(x))
|
||||
#else
|
||||
#define __swab64(x) \
|
||||
(__u64)(__builtin_constant_p(x) ? \
|
||||
___constant_swab64(x) : \
|
||||
__fswab64(x))
|
||||
#endif
|
||||
|
||||
static __always_inline unsigned long __swab(const unsigned long y)
|
||||
{
|
||||
#if __BITS_PER_LONG == 64
|
||||
return __swab64(y);
|
||||
#else /* __BITS_PER_LONG == 32 */
|
||||
return __swab32(y);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swahw32 - return a word-swapped 32-bit value
|
||||
* @x: value to wordswap
|
||||
*
|
||||
* __swahw32(0x12340000) is 0x00001234
|
||||
*/
|
||||
#define __swahw32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
___constant_swahw32(x) : \
|
||||
__fswahw32(x))
|
||||
|
||||
/**
|
||||
* __swahb32 - return a high and low byte-swapped 32-bit value
|
||||
* @x: value to byteswap
|
||||
*
|
||||
* __swahb32(0x12345678) is 0x34127856
|
||||
*/
|
||||
#define __swahb32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
___constant_swahb32(x) : \
|
||||
__fswahb32(x))
|
||||
|
||||
/**
|
||||
* __swab16p - return a byteswapped 16-bit value from a pointer
|
||||
* @p: pointer to a naturally-aligned 16-bit value
|
||||
*/
|
||||
static __always_inline __u16 __swab16p(const __u16 *p)
|
||||
{
|
||||
#ifdef __arch_swab16p
|
||||
return __arch_swab16p(p);
|
||||
#else
|
||||
return __swab16(*p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swab32p - return a byteswapped 32-bit value from a pointer
|
||||
* @p: pointer to a naturally-aligned 32-bit value
|
||||
*/
|
||||
static __always_inline __u32 __swab32p(const __u32 *p)
|
||||
{
|
||||
#ifdef __arch_swab32p
|
||||
return __arch_swab32p(p);
|
||||
#else
|
||||
return __swab32(*p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swab64p - return a byteswapped 64-bit value from a pointer
|
||||
* @p: pointer to a naturally-aligned 64-bit value
|
||||
*/
|
||||
static __always_inline __u64 __swab64p(const __u64 *p)
|
||||
{
|
||||
#ifdef __arch_swab64p
|
||||
return __arch_swab64p(p);
|
||||
#else
|
||||
return __swab64(*p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swahw32p - return a wordswapped 32-bit value from a pointer
|
||||
* @p: pointer to a naturally-aligned 32-bit value
|
||||
*
|
||||
* See __swahw32() for details of wordswapping.
|
||||
*/
|
||||
static __inline__ __u32 __swahw32p(const __u32 *p)
|
||||
{
|
||||
#ifdef __arch_swahw32p
|
||||
return __arch_swahw32p(p);
|
||||
#else
|
||||
return __swahw32(*p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swahb32p - return a high and low byteswapped 32-bit value from a pointer
|
||||
* @p: pointer to a naturally-aligned 32-bit value
|
||||
*
|
||||
* See __swahb32() for details of high/low byteswapping.
|
||||
*/
|
||||
static __inline__ __u32 __swahb32p(const __u32 *p)
|
||||
{
|
||||
#ifdef __arch_swahb32p
|
||||
return __arch_swahb32p(p);
|
||||
#else
|
||||
return __swahb32(*p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swab16s - byteswap a 16-bit value in-place
|
||||
* @p: pointer to a naturally-aligned 16-bit value
|
||||
*/
|
||||
static __inline__ void __swab16s(__u16 *p)
|
||||
{
|
||||
#ifdef __arch_swab16s
|
||||
__arch_swab16s(p);
|
||||
#else
|
||||
*p = __swab16p(p);
|
||||
#endif
|
||||
}
|
||||
/**
|
||||
* __swab32s - byteswap a 32-bit value in-place
|
||||
* @p: pointer to a naturally-aligned 32-bit value
|
||||
*/
|
||||
static __always_inline void __swab32s(__u32 *p)
|
||||
{
|
||||
#ifdef __arch_swab32s
|
||||
__arch_swab32s(p);
|
||||
#else
|
||||
*p = __swab32p(p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swab64s - byteswap a 64-bit value in-place
|
||||
* @p: pointer to a naturally-aligned 64-bit value
|
||||
*/
|
||||
static __always_inline void __swab64s(__u64 *p)
|
||||
{
|
||||
#ifdef __arch_swab64s
|
||||
__arch_swab64s(p);
|
||||
#else
|
||||
*p = __swab64p(p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swahw32s - wordswap a 32-bit value in-place
|
||||
* @p: pointer to a naturally-aligned 32-bit value
|
||||
*
|
||||
* See __swahw32() for details of wordswapping
|
||||
*/
|
||||
static __inline__ void __swahw32s(__u32 *p)
|
||||
{
|
||||
#ifdef __arch_swahw32s
|
||||
__arch_swahw32s(p);
|
||||
#else
|
||||
*p = __swahw32p(p);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* __swahb32s - high and low byteswap a 32-bit value in-place
|
||||
* @p: pointer to a naturally-aligned 32-bit value
|
||||
*
|
||||
* See __swahb32() for details of high and low byte swapping
|
||||
*/
|
||||
static __inline__ void __swahb32s(__u32 *p)
|
||||
{
|
||||
#ifdef __arch_swahb32s
|
||||
__arch_swahb32s(p);
|
||||
#else
|
||||
*p = __swahb32p(p);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#endif /* _LINUX_SWAB_H */
|
||||
Loading…
Reference in New Issue