1 // 2 // 内核全局通用库 3 // Created by longjin on 2022/1/22. 4 // 5 6 #pragma once 7 8 //引入对bool类型的支持 9 #include <stdbool.h> 10 #include <stdint.h> 11 #include <common/stddef.h> 12 #include <arch/arch.h> 13 #include <common/compiler.h> 14 #include <common/list.h> 15 16 #if ARCH(I386) || ARCH(X86_64) 17 #include <arch/x86_64/asm/asm.h> 18 #else 19 #error Arch not supported. 20 #endif 21 22 /** 23 * @brief 根据结构体变量内某个成员变量member的基地址，计算出该结构体变量的基地址 24 * @param ptr 指向结构体变量内的成员变量member的指针 25 * @param type 成员变量所在的结构体 26 * @param member 成员变量名 27 * 28 * 方法：使用ptr减去结构体内的偏移，得到结构体变量的基地址 29 */ 30 #define container_of(ptr, type, member) \ 31 ({ \ 32 typeof(((type *)0)->member) *p = (ptr); \ 33 (type *)((unsigned long)p - (unsigned long)&(((type *)0)->member)); \ 34 }) 35 36 // 定义类型的缩写 37 typedef unsigned char uchar; 38 typedef unsigned short ushort; 39 typedef unsigned int uint; 40 typedef unsigned long ul; 41 typedef unsigned long long int ull; 42 typedef long long int ll; 43 44 #define ABS(x) ((x) > 0 ? (x) : -(x)) // 绝对值 45 // 最大最小值 46 #define max(x, y) ((x > y) ? (x) : (y)) 47 #define min(x, y) ((x < y) ? (x) : (y)) 48 49 // 遮罩高32bit 50 #define MASK_HIGH_32bit(x) (x & (0x00000000ffffffffUL)) 51 52 // 四舍五入成整数 53 ul round(double x) 54 { 55 return (ul)(x + 0.5); 56 } 57 58 /** 59 * @brief 地址按照align进行对齐 60 * 61 * @param addr 62 * @param _align 63 * @return ul 对齐后的地址 64 */ 65 static __always_inline ul ALIGN(const ul addr, const ul _align) 66 { 67 return (ul)((addr + _align - 1) & (~(_align - 1))); 68 } 69 70 71 void *memset(void *dst, unsigned char C, ul size) 72 { 73 74 int d0, d1; 75 unsigned long tmp = C * 0x0101010101010101UL; 76 __asm__ __volatile__("cld \n\t" 77 "rep \n\t" 78 "stosq \n\t" 79 "testb $4, %b3 \n\t" 80 "je 1f \n\t" 81 "stosl \n\t" 82 "1:\ttestb $2, %b3 \n\t" 83 "je 2f\n\t" 84 "stosw \n\t" 85 "2:\ttestb $1, %b3 \n\t" 86 "je 3f \n\t" 87 "stosb \n\t" 88 "3: \n\t" 89 : "=&c"(d0), "=&D"(d1) 90 : "a"(tmp), "q"(size), "0"(size / 8), "1"(dst) 91 : "memory"); 92 return dst; 93 } 94 95 void *memset_c(void *dst, uint8_t c, size_t count) 96 { 97 uint8_t *xs = (uint8_t *)dst; 98 99 while (count--) 100 *xs++ = c; 101 102 return dst; 103 } 104 105 /** 106 * @brief 内存拷贝函数 107 * 108 * @param dst 目标数组 109 * @param src 源数组 110 * @param Num 字节数 111 * @return void* 112 */ 113 static void *memcpy(void *dst, const void *src, long Num) 114 { 115 int d0 = 0, d1 = 0, d2 = 0; 116 __asm__ __volatile__("cld \n\t" 117 "rep \n\t" 118 "movsq \n\t" 119 "testb $4,%b4 \n\t" 120 "je 1f \n\t" 121 "movsl \n\t" 122 "1:\ttestb $2,%b4 \n\t" 123 "je 2f \n\t" 124 "movsw \n\t" 125 "2:\ttestb $1,%b4 \n\t" 126 "je 3f \n\t" 127 "movsb \n\t" 128 "3: \n\t" 129 : "=&c"(d0), "=&D"(d1), "=&S"(d2) 130 : "0"(Num / 8), "q"(Num), "1"(dst), "2"(src) 131 : "memory"); 132 return dst; 133 } 134 135 // 从io口读入8个bit 136 unsigned char io_in8(unsigned short port) 137 { 138 unsigned char ret = 0; 139 __asm__ __volatile__("inb %%dx, %0 \n\t" 140 "mfence \n\t" 141 : "=a"(ret) 142 : "d"(port) 143 : "memory"); 144 return ret; 145 } 146 147 // 从io口读入32个bit 148 unsigned int io_in32(unsigned short port) 149 { 150 unsigned int ret = 0; 151 __asm__ __volatile__("inl %%dx, %0 \n\t" 152 "mfence \n\t" 153 : "=a"(ret) 154 : "d"(port) 155 : "memory"); 156 return ret; 157 } 158 159 // 输出8个bit到输出端口 160 void io_out8(unsigned short port, unsigned char value) 161 { 162 __asm__ __volatile__("outb %0, %%dx \n\t" 163 "mfence \n\t" 164 : 165 : "a"(value), "d"(port) 166 : "memory"); 167 } 168 169 // 输出32个bit到输出端口 170 void io_out32(unsigned short port, unsigned int value) 171 { 172 __asm__ __volatile__("outl %0, %%dx \n\t" 173 "mfence \n\t" 174 : 175 : "a"(value), "d"(port) 176 : "memory"); 177 } 178 179 /** 180 * @brief 从端口读入n个word到buffer 181 * 182 */ 183 #define io_insw(port, buffer, nr) \ 184 __asm__ __volatile__("cld;rep;insw;mfence;" ::"d"(port), "D"(buffer), "c"(nr) \ 185 : "memory") 186 187 /** 188 * @brief 从输出buffer中的n个word到端口 189 * 190 */ 191 #define io_outsw(port, buffer, nr) \ 192 __asm__ __volatile__("cld;rep;outsw;mfence;" ::"d"(port), "S"(buffer), "c"(nr) \ 193 : "memory") 194 195 196 /** 197 * @brief 验证地址空间是否为用户地址空间 198 * 199 * @param addr_start 地址起始值 200 * @param length 地址长度 201 * @return true 202 * @return false 203 */ 204 bool verify_area(uint64_t addr_start, uint64_t length) 205 { 206 if ((addr_start + length) <= 0x00007fffffffffffUL) // 用户程序可用的的地址空间应<= 0x00007fffffffffffUL 207 return true; 208 else 209 return false; 210 } 211 212 /** 213 * @brief 从用户空间搬运数据到内核空间 214 * 215 * @param dst 目的地址 216 * @param src 源地址 217 * @param size 搬运的大小 218 * @return uint64_t 219 */ 220 static inline uint64_t copy_from_user(void *dst, void *src, uint64_t size) 221 { 222 uint64_t tmp0, tmp1; 223 if (!verify_area((uint64_t)src, size)) 224 return 0; 225 226 /** 227 * @brief 先每次搬运8 bytes，剩余就直接一个个byte搬运 228 * 229 */ 230 asm volatile("rep \n\t" 231 "movsq \n\t" 232 "movq %3, %0 \n\t" 233 "rep \n\t" 234 "movsb \n\t" 235 : "=&c"(size), "=&D"(tmp0), "=&S"(tmp1) 236 : "r"(size & 7), "0"(size >> 3), "1"(dst), "2"(src) 237 : "memory"); 238 return size; 239 } 240 241 /** 242 * @brief 从内核空间搬运数据到用户空间 243 * 244 * @param dst 目的地址 245 * @param src 源地址 246 * @param size 搬运的大小 247 * @return uint64_t 248 */ 249 static inline uint64_t copy_to_user(void *dst, void *src, uint64_t size) 250 { 251 uint64_t tmp0, tmp1; 252 if (verify_area((uint64_t)src, size)) 253 return 0; 254 255 /** 256 * @brief 先每次搬运8 bytes，剩余就直接一个个byte搬运 257 * 258 */ 259 asm volatile("rep \n\t" 260 "movsq \n\t" 261 "movq %3, %0 \n\t" 262 "rep \n\t" 263 "movsb \n\t" 264 : "=&c"(size), "=&D"(tmp0), "=&S"(tmp1) 265 : "r"(size & 7), "0"(size >> 3), "1"(dst), "2"(src) 266 : "memory"); 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);