xref: /DragonOS/kernel/src/common/glib.h (revision ba0d93d8b26034abc54bcaf3f0ff04863bbd076e)
1 //
2 // 内核全局通用库
3 // Created by longjin on 2022/1/22.
4 //
5 
6 #pragma once
7 
8 //引入对bool类型的支持
9 #include <stdbool.h>
10 #include <DragonOS/stdint.h>
11 #include <common/stddef.h>
12 #include <arch/arch.h>
13 #include <common/compiler.h>
14 #include <common/list.h>
15 
16 
17 #include <asm/asm.h>
18 
19 /**
20  * @brief 根据结构体变量内某个成员变量member的基地址,计算出该结构体变量的基地址
21  * @param ptr 指向结构体变量内的成员变量member的指针
22  * @param type 成员变量所在的结构体
23  * @param member 成员变量名
24  *
25  * 方法:使用ptr减去结构体内的偏移,得到结构体变量的基地址
26  */
27 #define container_of(ptr, type, member)                                     \
28     ({                                                                      \
29         typeof(((type *)0)->member) *p = (ptr);                             \
30         (type *)((unsigned long)p - (unsigned long)&(((type *)0)->member)); \
31     })
32 
33 // 定义类型的缩写
34 typedef unsigned char uchar;
35 typedef unsigned short ushort;
36 typedef unsigned int uint;
37 typedef unsigned long ul;
38 typedef unsigned long long int ull;
39 typedef long long int ll;
40 
41 #define ABS(x) ((x) > 0 ? (x) : -(x)) // 绝对值
42 // 最大最小值
43 #define max(x, y) ((x > y) ? (x) : (y))
44 #define min(x, y) ((x < y) ? (x) : (y))
45 
46 // 遮罩高32bit
47 #define MASK_HIGH_32bit(x) (x & (0x00000000ffffffffUL))
48 
49 // 四舍五入成整数
50 ul round(double x)
51 {
52     return (ul)(x + 0.5);
53 }
54 
55 /**
56  * @brief 地址按照align进行对齐
57  *
58  * @param addr
59  * @param _align
60  * @return ul 对齐后的地址
61  */
62 static __always_inline ul ALIGN(const ul addr, const ul _align)
63 {
64     return (ul)((addr + _align - 1) & (~(_align - 1)));
65 }
66 
67 
68 void *memset(void *dst, unsigned char C, ul size)
69 {
70 
71     int d0, d1;
72     unsigned long tmp = C * 0x0101010101010101UL;
73     __asm__ __volatile__("cld	\n\t"
74                          "rep	\n\t"
75                          "stosq	\n\t"
76                          "testb	$4, %b3	\n\t"
77                          "je	1f	\n\t"
78                          "stosl	\n\t"
79                          "1:\ttestb	$2, %b3	\n\t"
80                          "je	2f\n\t"
81                          "stosw	\n\t"
82                          "2:\ttestb	$1, %b3	\n\t"
83                          "je	3f	\n\t"
84                          "stosb	\n\t"
85                          "3:	\n\t"
86                          : "=&c"(d0), "=&D"(d1)
87                          : "a"(tmp), "q"(size), "0"(size / 8), "1"(dst)
88                          : "memory");
89     return dst;
90 }
91 
92 void *memset_c(void *dst, uint8_t c, size_t count)
93 {
94     uint8_t *xs = (uint8_t *)dst;
95 
96     while (count--)
97         *xs++ = c;
98 
99     return dst;
100 }
101 
102 /**
103  * @brief 内存拷贝函数
104  *
105  * @param dst 目标数组
106  * @param src 源数组
107  * @param Num 字节数
108  * @return void*
109  */
110 static void *memcpy(void *dst, const void *src, long Num)
111 {
112     int d0 = 0, d1 = 0, d2 = 0;
113     __asm__ __volatile__("cld	\n\t"
114                          "rep	\n\t"
115                          "movsq	\n\t"
116                          "testb	$4,%b4	\n\t"
117                          "je	1f	\n\t"
118                          "movsl	\n\t"
119                          "1:\ttestb	$2,%b4	\n\t"
120                          "je	2f	\n\t"
121                          "movsw	\n\t"
122                          "2:\ttestb	$1,%b4	\n\t"
123                          "je	3f	\n\t"
124                          "movsb	\n\t"
125                          "3:	\n\t"
126                          : "=&c"(d0), "=&D"(d1), "=&S"(d2)
127                          : "0"(Num / 8), "q"(Num), "1"(dst), "2"(src)
128                          : "memory");
129     return dst;
130 }
131 
132 // 从io口读入8个bit
133 unsigned char io_in8(unsigned short port)
134 {
135     unsigned char ret = 0;
136     __asm__ __volatile__("inb	%%dx,	%0	\n\t"
137                          "mfence			\n\t"
138                          : "=a"(ret)
139                          : "d"(port)
140                          : "memory");
141     return ret;
142 }
143 
144 // 从io口读入32个bit
145 unsigned int io_in32(unsigned short port)
146 {
147     unsigned int ret = 0;
148     __asm__ __volatile__("inl	%%dx,	%0	\n\t"
149                          "mfence			\n\t"
150                          : "=a"(ret)
151                          : "d"(port)
152                          : "memory");
153     return ret;
154 }
155 
156 // 输出8个bit到输出端口
157 void io_out8(unsigned short port, unsigned char value)
158 {
159     __asm__ __volatile__("outb	%0,	%%dx	\n\t"
160                          "mfence			\n\t"
161                          :
162                          : "a"(value), "d"(port)
163                          : "memory");
164 }
165 
166 // 输出32个bit到输出端口
167 void io_out32(unsigned short port, unsigned int value)
168 {
169     __asm__ __volatile__("outl	%0,	%%dx	\n\t"
170                          "mfence			\n\t"
171                          :
172                          : "a"(value), "d"(port)
173                          : "memory");
174 }
175 
176 /**
177  * @brief 从端口读入n个word到buffer
178  *
179  */
180 #define io_insw(port, buffer, nr)                                                 \
181     __asm__ __volatile__("cld;rep;insw;mfence;" ::"d"(port), "D"(buffer), "c"(nr) \
182                          : "memory")
183 
184 /**
185  * @brief 从输出buffer中的n个word到端口
186  *
187  */
188 #define io_outsw(port, buffer, nr)                                                 \
189     __asm__ __volatile__("cld;rep;outsw;mfence;" ::"d"(port), "S"(buffer), "c"(nr) \
190                          : "memory")
191 
192 
193 /**
194  * @brief 验证地址空间是否为用户地址空间
195  *
196  * @param addr_start 地址起始值
197  * @param length 地址长度
198  * @return true
199  * @return false
200  */
201 bool verify_area(uint64_t addr_start, uint64_t length)
202 {
203     if ((addr_start + length) <= 0x00007fffffffffffUL) // 用户程序可用的的地址空间应<= 0x00007fffffffffffUL
204         return true;
205     else
206         return false;
207 }
208 
209 /**
210  * @brief 从用户空间搬运数据到内核空间
211  *
212  * @param dst 目的地址
213  * @param src 源地址
214  * @param size 搬运的大小
215  * @return uint64_t
216  */
217 static inline uint64_t copy_from_user(void *dst, void *src, uint64_t size)
218 {
219     uint64_t tmp0, tmp1;
220     if (!verify_area((uint64_t)src, size))
221         return 0;
222 
223     /**
224      * @brief 先每次搬运8 bytes,剩余就直接一个个byte搬运
225      *
226      */
227     asm volatile("rep   \n\t"
228                  "movsq  \n\t"
229                  "movq %3, %0   \n\t"
230                  "rep   \n\t"
231                  "movsb \n\t"
232                  : "=&c"(size), "=&D"(tmp0), "=&S"(tmp1)
233                  : "r"(size & 7), "0"(size >> 3), "1"(dst), "2"(src)
234                  : "memory");
235     return size;
236 }
237 
238 /**
239  * @brief 从内核空间搬运数据到用户空间
240  *
241  * @param dst 目的地址
242  * @param src 源地址
243  * @param size 搬运的大小
244  * @return uint64_t
245  */
246 static inline uint64_t copy_to_user(void *dst, void *src, uint64_t size)
247 {
248     uint64_t tmp0, tmp1;
249     if (verify_area((uint64_t)src, size))
250         return 0;
251 
252     /**
253      * @brief 先每次搬运8 bytes,剩余就直接一个个byte搬运
254      *
255      */
256     // todo:编译有bug
257     // asm volatile("rep   \n\t"
258     //              "movsq  \n\t"
259     //              "movq %3, %0   \n\t"
260     //              "rep   \n\t"
261     //              "movsb \n\t"
262     //              : "=&c"(size), "=&D"(tmp0), "=&S"(tmp1)
263     //              : "r"(size & 7), "0"(size >> 3), "1"(dst), "2"(src)
264     //              : "memory");
265     memcpy(dst,src,size);
266 
267     return size;
268 }
269 
270 /**
271  * @brief 这个函数让蜂鸣器发声,目前仅用于真机调试。未来将移除,请勿依赖此函数。
272  *
273  * @param times 发声循环多少遍
274  */
275 void __experimental_beep(uint64_t times);
276 
277 /**
278  * @brief 往指定地址写入8字节
279  * 防止由于编译器优化导致不支持的内存访问类型(尤其是在mmio的时候)
280  *
281  * @param vaddr 虚拟地址
282  * @param value 要写入的值
283  */
284 static __always_inline void __write8b(uint64_t vaddr, uint64_t value)
285 {
286     asm volatile("movq %%rdx, 0(%%rax)" ::"a"(vaddr), "d"(value)
287                  : "memory");
288 
289 }
290 
291 /**
292  * @brief 往指定地址写入4字节
293  * 防止由于编译器优化导致不支持的内存访问类型(尤其是在mmio的时候)
294  *
295  * @param vaddr 虚拟地址
296  * @param value 要写入的值
297  */
298 static __always_inline void __write4b(uint64_t vaddr, uint32_t value)
299 {
300     asm volatile("movl %%edx, 0(%%rax)" ::"a"(vaddr), "d"(value)
301                  : "memory");
302 
303 }
304 
305 /**
306  * @brief 从指定地址读取8字节
307  * 防止由于编译器优化导致不支持的内存访问类型(尤其是在mmio的时候)
308  *
309  * @param vaddr 虚拟地址
310  * @return uint64_t 读取到的值
311  */
312 static __always_inline uint64_t __read8b(uint64_t vaddr)
313 {
314     uint64_t retval;
315     asm volatile("movq 0(%%rax), %0"
316                  : "=r"(retval)
317                  : "a"(vaddr)
318                  : "memory");
319     return retval;
320 }
321 
322 /**
323  * @brief 从指定地址读取4字节
324  * 防止由于编译器优化导致不支持的内存访问类型(尤其是在mmio的时候)
325  *
326  * @param vaddr 虚拟地址
327  * @return uint64_t 读取到的值
328  */
329 static __always_inline uint32_t __read4b(uint64_t vaddr)
330 {
331     uint32_t retval;
332     asm volatile("movl 0(%%rax), %0"
333                  : "=d"(retval)
334                  : "a"(vaddr)
335                  : "memory");
336     return retval;
337 }
338 
339 /**
340  * @brief 将数据从src搬运到dst,并能正确处理地址重叠的问题
341  *
342  * @param dst 目标地址指针
343  * @param src 源地址指针
344  * @param size 大小
345  * @return void* 指向目标地址的指针
346  */
347 void *memmove(void *dst, const void *src, uint64_t size);