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 // 四舍五入成整数
round(double x)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 */
ALIGN(const ul addr,const ul _align)62 static __always_inline ul ALIGN(const ul addr, const ul _align)
63 {
64 return (ul)((addr + _align - 1) & (~(_align - 1)));
65 }
66
67
memset(void * dst,unsigned char C,ul size)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
memset_c(void * dst,uint8_t c,size_t count)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 */
memcpy(void * dst,const void * src,long Num)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
io_in8(unsigned short port)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
io_in32(unsigned short port)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到输出端口
io_out8(unsigned short port,unsigned char value)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到输出端口
io_out32(unsigned short port,unsigned int value)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 */
verify_area(uint64_t addr_start,uint64_t length)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 */
copy_from_user(void * dst,void * src,uint64_t size)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 */
copy_to_user(void * dst,void * src,uint64_t size)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 */
__write8b(uint64_t vaddr,uint64_t value)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 */
__write4b(uint64_t vaddr,uint32_t value)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 */
__read8b(uint64_t vaddr)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 */
__read4b(uint64_t vaddr)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);