CoCalc -- headers-debian-byteshift.patch

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.

GitHub Repository: orangepi-xunlong/orangepi-build
Path: blob/next/external/patch/misc/headers-debian-byteshift.patch
Views: ³⁹⁵⁹

1
Signed-off-by: Matt Fleming <[email protected]>
2
Link: http://lkml.kernel.org/r/[email protected]
3
Signed-off-by: H. Peter Anvin <[email protected]>
4
Signed-off-by: Greg Kroah-Hartman <[email protected]>
5

6
---
7
tools/include/tools/be_byteshift.h | 70 +++++++++++++++++++++++++++++++++++++
8
tools/include/tools/le_byteshift.h | 70 +++++++++++++++++++++++++++++++++++++
9
2 files changed, 140 insertions(+)
10

11
--- /dev/null
12
+++ b/tools/include/tools/be_byteshift.h
13
@@ -0,0 +1,70 @@
14
+#ifndef _TOOLS_BE_BYTESHIFT_H
15
+#define _TOOLS_BE_BYTESHIFT_H
16
+
17
+#include <linux/types.h>
18
+
19
+static inline __u16 __get_unaligned_be16(const __u8 *p)
20
+{
21
+ return p[0] << 8 | p[1];
22
+}
23
+
24
+static inline __u32 __get_unaligned_be32(const __u8 *p)
25
+{
26
+ return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
27
+}
28
+
29
+static inline __u64 __get_unaligned_be64(const __u8 *p)
30
+{
31
+ return (__u64)__get_unaligned_be32(p) << 32 |
32
+ __get_unaligned_be32(p + 4);
33
+}
34
+
35
+static inline void __put_unaligned_be16(__u16 val, __u8 *p)
36
+{
37
+ *p++ = val >> 8;
38
+ *p++ = val;
39
+}
40
+
41
+static inline void __put_unaligned_be32(__u32 val, __u8 *p)
42
+{
43
+ __put_unaligned_be16(val >> 16, p);
44
+ __put_unaligned_be16(val, p + 2);
45
+}
46
+
47
+static inline void __put_unaligned_be64(__u64 val, __u8 *p)
48
+{
49
+ __put_unaligned_be32(val >> 32, p);
50
+ __put_unaligned_be32(val, p + 4);
51
+}
52
+
53
+static inline __u16 get_unaligned_be16(const void *p)
54
+{
55
+ return __get_unaligned_be16((const __u8 *)p);
56
+}
57
+
58
+static inline __u32 get_unaligned_be32(const void *p)
59
+{
60
+ return __get_unaligned_be32((const __u8 *)p);
61
+}
62
+
63
+static inline __u64 get_unaligned_be64(const void *p)
64
+{
65
+ return __get_unaligned_be64((const __u8 *)p);
66
+}
67
+
68
+static inline void put_unaligned_be16(__u16 val, void *p)
69
+{
70
+ __put_unaligned_be16(val, p);
71
+}
72
+
73
+static inline void put_unaligned_be32(__u32 val, void *p)
74
+{
75
+ __put_unaligned_be32(val, p);
76
+}
77
+
78
+static inline void put_unaligned_be64(__u64 val, void *p)
79
+{
80
+ __put_unaligned_be64(val, p);
81
+}
82
+
83
+#endif /* _TOOLS_BE_BYTESHIFT_H */
84
--- /dev/null
85
+++ b/tools/include/tools/le_byteshift.h
86
@@ -0,0 +1,70 @@
87
+#ifndef _TOOLS_LE_BYTESHIFT_H
88
+#define _TOOLS_LE_BYTESHIFT_H
89
+
90
+#include <linux/types.h>
91
+
92
+static inline __u16 __get_unaligned_le16(const __u8 *p)
93
+{
94
+ return p[0] | p[1] << 8;
95
+}
96
+
97
+static inline __u32 __get_unaligned_le32(const __u8 *p)
98
+{
99
+ return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
100
+}
101
+
102
+static inline __u64 __get_unaligned_le64(const __u8 *p)
103
+{
104
+ return (__u64)__get_unaligned_le32(p + 4) << 32 |
105
+ __get_unaligned_le32(p);
106
+}
107
+
108
+static inline void __put_unaligned_le16(__u16 val, __u8 *p)
109
+{
110
+ *p++ = val;
111
+ *p++ = val >> 8;
112
+}
113
+
114
+static inline void __put_unaligned_le32(__u32 val, __u8 *p)
115
+{
116
+ __put_unaligned_le16(val >> 16, p + 2);
117
+ __put_unaligned_le16(val, p);
118
+}
119
+
120
+static inline void __put_unaligned_le64(__u64 val, __u8 *p)
121
+{
122
+ __put_unaligned_le32(val >> 32, p + 4);
123
+ __put_unaligned_le32(val, p);
124
+}
125
+
126
+static inline __u16 get_unaligned_le16(const void *p)
127
+{
128
+ return __get_unaligned_le16((const __u8 *)p);
129
+}
130
+
131
+static inline __u32 get_unaligned_le32(const void *p)
132
+{
133
+ return __get_unaligned_le32((const __u8 *)p);
134
+}
135
+
136
+static inline __u64 get_unaligned_le64(const void *p)
137
+{
138
+ return __get_unaligned_le64((const __u8 *)p);
139
+}
140
+
141
+static inline void put_unaligned_le16(__u16 val, void *p)
142
+{
143
+ __put_unaligned_le16(val, p);
144
+}
145
+
146
+static inline void put_unaligned_le32(__u32 val, void *p)
147
+{
148
+ __put_unaligned_le32(val, p);
149
+}
150
+
151
+static inline void put_unaligned_le64(__u64 val, void *p)
152
+{
153
+ __put_unaligned_le64(val, p);
154
+}
155
+
156
+#endif /* _TOOLS_LE_BYTESHIFT_H */
157

158

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.

Product

Resources

Company

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more, all in one place. Commercial Alternative to JupyterHub.

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.