mirror of
https://github.com/DragonOS-Community/DragonOS.git
synced 2025-06-19 09:06:32 +00:00
将common文件夹下的c文件移动到lib文件夹下
This commit is contained in:
fslongjin
@ -1,7 +1,7 @@
|
||||
|
||||
CFLAGS += -I .
|
||||
|
||||
kernel_common_subdirs:=libELF math
|
||||
kernel_common_subdirs:= math
|
||||
|
||||
ECHO:
|
||||
@echo "$@"
|
||||
@ -10,38 +10,5 @@ $(kernel_common_subdirs): ECHO
|
||||
|
||||
$(MAKE) -C $@ all CFLAGS="$(CFLAGS)" ASFLAGS="$(ASFLAGS)" PIC="$(PIC)"
|
||||
|
||||
all: glib.o printk.o cpu.o bitree.o kfifo.o wait_queue.o mutex.o wait.o unistd.o string.o semaphore.o $(kernel_common_subdirs)
|
||||
all: $(kernel_common_subdirs)
|
||||
|
||||
|
||||
glib.o: glib.c
|
||||
gcc $(CFLAGS) -c glib.c -o glib.o
|
||||
|
||||
printk.o: printk.c
|
||||
gcc $(CFLAGS) -c printk.c -o printk.o
|
||||
|
||||
cpu.o: cpu.c
|
||||
gcc $(CFLAGS) -c cpu.c -o cpu.o
|
||||
|
||||
bitree.o: bitree.c
|
||||
gcc $(CFLAGS) -c bitree.c -o bitree.o
|
||||
|
||||
kfifo.o: kfifo.c
|
||||
gcc $(CFLAGS) -c kfifo.c -o kfifo.o
|
||||
|
||||
wait_queue.o: wait_queue.c
|
||||
gcc $(CFLAGS) -c wait_queue.c -o wait_queue.o
|
||||
|
||||
mutex.o: mutex.c
|
||||
gcc $(CFLAGS) -c mutex.c -o mutex.o
|
||||
|
||||
wait.o: sys/wait.c
|
||||
gcc $(CFLAGS) -c sys/wait.c -o sys/wait.o
|
||||
|
||||
unistd.o: unistd.c
|
||||
gcc $(CFLAGS) -c unistd.c -o unistd.o
|
||||
|
||||
string.o: string.c
|
||||
gcc $(CFLAGS) -c string.c -o string.o
|
||||
|
||||
semaphore.o: semaphore.c
|
||||
gcc $(CFLAGS) -c semaphore.c -o semaphore.o
|
||||
@ -1,234 +0,0 @@
|
||||
#include "bitree.h"
|
||||
#include <mm/slab.h>
|
||||
#include <common/errno.h>
|
||||
#include <common/kfifo.h>
|
||||
#include <common/string.h>
|
||||
#include <debug/bug.h>
|
||||
|
||||
#define smaller(root, a, b) (root->cmp((a)->value, (b)->value) == -1)
|
||||
#define equal(root, a, b) (root->cmp((a)->value, (b)->value) == 0)
|
||||
#define greater(root, a, b) (root->cmp((a)->value, (b)->value) == 1)
|
||||
|
||||
/**
|
||||
* @brief 创建二叉搜索树
|
||||
*
|
||||
* @param node 根节点
|
||||
* @param cmp 比较函数
|
||||
* @param release 用来释放结点的value的函数
|
||||
* @return struct bt_root_t* 树根结构体
|
||||
*/
|
||||
struct bt_root_t *bt_create_tree(struct bt_node_t *node, int (*cmp)(void *a, void *b), int (*release)(void *value))
|
||||
{
|
||||
if (node == NULL || cmp == NULL)
|
||||
return (void*)-EINVAL;
|
||||
|
||||
struct bt_root_t *root = (struct bt_root_t *)kmalloc(sizeof(struct bt_root_t), 0);
|
||||
memset((void *)root, 0, sizeof(struct bt_root_t));
|
||||
root->bt_node = node;
|
||||
root->cmp = cmp;
|
||||
root->release = release;
|
||||
root->size = (node == NULL) ? 0 : 1;
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 创建结点
|
||||
*
|
||||
* @param left 左子节点
|
||||
* @param right 右子节点
|
||||
* @param value 当前节点的值
|
||||
* @return struct bt_node_t*
|
||||
*/
|
||||
struct bt_node_t *bt_create_node(struct bt_node_t *left, struct bt_node_t *right, struct bt_node_t *parent, void *value)
|
||||
{
|
||||
struct bt_node_t *node = (struct bt_node_t *)kmalloc(sizeof(struct bt_node_t), 0);
|
||||
FAIL_ON_TO(node == NULL, nomem);
|
||||
memset((void *)node, 0, sizeof(struct bt_node_t));
|
||||
|
||||
node->left = left;
|
||||
node->right = right;
|
||||
node->value = value;
|
||||
node->parent = parent;
|
||||
|
||||
return node;
|
||||
nomem:;
|
||||
return (void*)-ENOMEM;
|
||||
}
|
||||
/**
|
||||
* @brief 插入结点
|
||||
*
|
||||
* @param root 树根结点
|
||||
* @param value 待插入结点的值
|
||||
* @return int 返回码
|
||||
*/
|
||||
int bt_insert(struct bt_root_t *root, void *value)
|
||||
{
|
||||
if (root == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
struct bt_node_t *this_node = root->bt_node;
|
||||
struct bt_node_t *last_node = NULL;
|
||||
struct bt_node_t *insert_node = bt_create_node(NULL, NULL, NULL, value);
|
||||
FAIL_ON_TO((uint64_t)insert_node == (uint64_t)(-ENOMEM), failed);
|
||||
|
||||
while (this_node != NULL)
|
||||
{
|
||||
last_node = this_node;
|
||||
if (smaller(root, insert_node, this_node))
|
||||
this_node = this_node->left;
|
||||
else
|
||||
this_node = this_node->right;
|
||||
}
|
||||
|
||||
insert_node->parent = last_node;
|
||||
if (unlikely(last_node == NULL))
|
||||
root->bt_node = insert_node;
|
||||
else
|
||||
{
|
||||
if (smaller(root, insert_node, last_node))
|
||||
last_node->left = insert_node;
|
||||
else
|
||||
last_node->right = insert_node;
|
||||
}
|
||||
++root->size;
|
||||
return 0;
|
||||
|
||||
failed:;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 搜索值为value的结点
|
||||
*
|
||||
* @param value 值
|
||||
* @param ret_addr 返回的结点基地址
|
||||
* @return int 错误码
|
||||
*/
|
||||
int bt_query(struct bt_root_t *root, void *value, uint64_t *ret_addr)
|
||||
{
|
||||
struct bt_node_t *this_node = root->bt_node;
|
||||
struct bt_node_t tmp_node = {0};
|
||||
tmp_node.value = value;
|
||||
|
||||
// 如果返回地址为0
|
||||
if (ret_addr == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
while (this_node != NULL && !equal(root, this_node, &tmp_node))
|
||||
{
|
||||
if (smaller(root, &tmp_node, this_node))
|
||||
this_node = this_node->left;
|
||||
else
|
||||
this_node = this_node->right;
|
||||
}
|
||||
|
||||
if (this_node != NULL && equal(root, this_node, &tmp_node))
|
||||
{
|
||||
*ret_addr = (uint64_t)this_node;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// 找不到则返回-1，且addr设为0
|
||||
*ret_addr = NULL;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static struct bt_node_t *bt_get_minimum(struct bt_node_t *this_node)
|
||||
{
|
||||
while (this_node->left != NULL)
|
||||
this_node = this_node->left;
|
||||
return this_node;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 删除结点
|
||||
*
|
||||
* @param root 树根
|
||||
* @param value 待删除结点的值
|
||||
* @return int 返回码
|
||||
*/
|
||||
int bt_delete(struct bt_root_t *root, void *value)
|
||||
{
|
||||
uint64_t tmp_addr;
|
||||
int retval;
|
||||
|
||||
// 寻找待删除结点
|
||||
retval = bt_query(root, value, &tmp_addr);
|
||||
if (retval != 0 || tmp_addr == NULL)
|
||||
return retval;
|
||||
|
||||
struct bt_node_t *this_node = (struct bt_node_t *)tmp_addr;
|
||||
struct bt_node_t *to_delete = NULL, *to_delete_son = NULL;
|
||||
if (this_node->left == NULL || this_node->right == NULL)
|
||||
to_delete = this_node;
|
||||
else
|
||||
{
|
||||
to_delete = bt_get_minimum(this_node->right);
|
||||
// 释放要被删除的值，并把下一个结点的值替换上来
|
||||
root->release(this_node->value);
|
||||
this_node->value = to_delete->value;
|
||||
}
|
||||
|
||||
if (to_delete->left != NULL)
|
||||
to_delete_son = to_delete->left;
|
||||
else
|
||||
to_delete_son = to_delete->right;
|
||||
|
||||
if (to_delete_son != NULL)
|
||||
to_delete_son->parent = to_delete->parent;
|
||||
|
||||
if (to_delete->parent == NULL)
|
||||
root->bt_node = to_delete_son;
|
||||
else
|
||||
{
|
||||
if (to_delete->parent->left == to_delete)
|
||||
to_delete->parent->left = to_delete_son;
|
||||
else
|
||||
to_delete->parent->right = to_delete_son;
|
||||
}
|
||||
|
||||
--root->size;
|
||||
// 释放最终要删除的结点的对象
|
||||
kfree(to_delete);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 释放整个二叉搜索树
|
||||
*
|
||||
* @param root 树的根节点
|
||||
* @return int 错误码
|
||||
*/
|
||||
int bt_destroy_tree(struct bt_root_t *root)
|
||||
{
|
||||
// 新建一个kfifo缓冲区，将指向结点的指针存入fifo队列
|
||||
// 注：为了将指针指向的地址存入队列，我们需要对指针取地址
|
||||
struct kfifo_t fifo;
|
||||
kfifo_alloc(&fifo, ((root->size + 1) / 2) * sizeof(struct bt_node_t *), 0);
|
||||
kfifo_in(&fifo, (void *)&(root->bt_node), sizeof(struct bt_node_t *));
|
||||
|
||||
// bfs
|
||||
while (!kfifo_empty(&fifo))
|
||||
{
|
||||
// 取出队列头部的结点指针
|
||||
struct bt_node_t *nd;
|
||||
int count = kfifo_out(&fifo, &nd, sizeof(uint64_t));
|
||||
|
||||
// 将子节点加入队列
|
||||
if (nd->left != NULL)
|
||||
kfifo_in(&fifo, (void *)&(nd->left), sizeof(struct bt_node_t *));
|
||||
|
||||
if (nd->right != NULL)
|
||||
kfifo_in(&fifo, (void *)&(nd->right), sizeof(struct bt_node_t *));
|
||||
|
||||
// 销毁当前节点
|
||||
root->release(nd->value);
|
||||
kfree(nd);
|
||||
}
|
||||
|
||||
kfifo_free_alloc(&fifo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,122 +0,0 @@
|
||||
#include "cpu.h"
|
||||
#include "kprint.h"
|
||||
#include "printk.h"
|
||||
// #pragma GCC optimize("O0")
|
||||
// cpu支持的最大cpuid指令的基础主功能号
|
||||
uint Cpu_cpuid_max_Basic_mop;
|
||||
// cpu支持的最大cpuid指令的扩展主功能号
|
||||
uint Cpu_cpuid_max_Extended_mop;
|
||||
// cpu制造商信息
|
||||
char Cpu_Manufacturer_Name[17] = {0};
|
||||
// 处理器名称信息
|
||||
char Cpu_BrandName[49] = {0};
|
||||
// 处理器家族ID
|
||||
uint Cpu_Family_ID;
|
||||
// 处理器扩展家族ID
|
||||
uint Cpu_Extended_Family_ID;
|
||||
// 处理器模式ID
|
||||
uint Cpu_Model_ID;
|
||||
// 处理器扩展模式ID
|
||||
uint Cpu_Extended_Model_ID;
|
||||
// 处理器步进ID
|
||||
uint Cpu_Stepping_ID;
|
||||
// 处理器类型
|
||||
uint Cpu_Processor_Type;
|
||||
// 处理器支持的最大物理地址可寻址地址线宽度
|
||||
uint Cpu_max_phys_addrline_size;
|
||||
// 处理器支持的最大线性地址可寻址地址线宽度
|
||||
uint Cpu_max_linear_addrline_size;
|
||||
// 处理器的tsc频率（单位：hz）(HPET定时器在测定apic频率时，顺便测定了这个值)
|
||||
uint64_t Cpu_tsc_freq = 0;
|
||||
|
||||
struct cpu_core_info_t cpu_core_info[MAX_CPU_NUM];
|
||||
void cpu_init(void)
|
||||
{
|
||||
// 获取处理器制造商信息
|
||||
uint tmp_info[4] = {0};
|
||||
cpu_cpuid(0, 0, &tmp_info[0], &tmp_info[1], &tmp_info[2], &tmp_info[3]);
|
||||
|
||||
// 保存CPU支持的最大cpuid指令主功能号
|
||||
Cpu_cpuid_max_Basic_mop = tmp_info[0];
|
||||
// 保存制造商名称
|
||||
*(uint *)&Cpu_Manufacturer_Name[0] = tmp_info[1];
|
||||
*(uint *)&Cpu_Manufacturer_Name[4] = tmp_info[3];
|
||||
*(uint *)&Cpu_Manufacturer_Name[8] = tmp_info[2];
|
||||
Cpu_Manufacturer_Name[12] = '\0';
|
||||
kinfo("CPU manufacturer: %s", Cpu_Manufacturer_Name);
|
||||
|
||||
// 获取处理器型号信息
|
||||
int count = 0;
|
||||
for (uint i = 0x80000002; i < 0x80000005; ++i)
|
||||
{
|
||||
cpu_cpuid(i, 0, &tmp_info[0], &tmp_info[1], &tmp_info[2], &tmp_info[3]);
|
||||
for (int j = 0; j <= 3; ++j)
|
||||
{
|
||||
*(uint *)&Cpu_BrandName[4 * count] = tmp_info[j];
|
||||
++count;
|
||||
}
|
||||
}
|
||||
Cpu_BrandName[48] = '\0';
|
||||
|
||||
kinfo("CPU Brand Name: %s", Cpu_BrandName);
|
||||
|
||||
// 使用cpuid主功能号0x01进行查询(未保存ebx ecx edx的信息，具体参见白皮书)
|
||||
cpu_cpuid(1, 0, &tmp_info[0], &tmp_info[1], &tmp_info[2], &tmp_info[3]);
|
||||
|
||||
// EAX中包含 Version Informatin Type,Family,Model,and Stepping ID
|
||||
Cpu_Stepping_ID = tmp_info[0] & 0xf;
|
||||
Cpu_Model_ID = (tmp_info[0] >> 4) & 0xf;
|
||||
Cpu_Family_ID = (tmp_info[0] >> 8) & 0xf;
|
||||
Cpu_Processor_Type = (tmp_info[0] >> 12) & 0x3;
|
||||
// 14-15位保留
|
||||
Cpu_Extended_Model_ID = (tmp_info[0] >> 16) & 0xf;
|
||||
Cpu_Extended_Family_ID = (tmp_info[0] >> 20) & 0xff;
|
||||
// 31-25位保留
|
||||
kinfo("Family ID=%#03lx\t Extended Family ID=%#03lx\t Processor Type=%#03lx\t", Cpu_Family_ID, Cpu_Extended_Family_ID, Cpu_Processor_Type);
|
||||
kinfo("Model ID=%#03lx\t Extended Model ID=%#03lx\tStepping ID=%#03lx\t", Cpu_Model_ID, Cpu_Extended_Model_ID, Cpu_Stepping_ID);
|
||||
|
||||
// 使用0x80000008主功能号，查询处理器支持的最大可寻址地址线宽度
|
||||
cpu_cpuid(0x80000008, 0, &tmp_info[0], &tmp_info[1], &tmp_info[2], &tmp_info[3]);
|
||||
Cpu_max_phys_addrline_size = tmp_info[0] & 0xff;
|
||||
Cpu_max_linear_addrline_size = (tmp_info[0] >> 8) & 0xff;
|
||||
|
||||
kinfo("Cpu_max_phys_addrline_size = %d", Cpu_max_phys_addrline_size);
|
||||
kinfo("Cpu_max_linear_addrline_size = %d", Cpu_max_linear_addrline_size);
|
||||
|
||||
cpu_cpuid(0x80000000, 0, &tmp_info[0], &tmp_info[1], &tmp_info[2], &tmp_info[3]);
|
||||
Cpu_cpuid_max_Extended_mop = tmp_info[0];
|
||||
|
||||
kinfo("Max basic mop=%#05lx", Cpu_cpuid_max_Basic_mop);
|
||||
kinfo("Max extended mop=%#05lx", Cpu_cpuid_max_Extended_mop);
|
||||
return;
|
||||
}
|
||||
|
||||
void cpu_cpuid(uint32_t mop, uint32_t sop, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
|
||||
{
|
||||
// 向eax和ecx分别输入主功能号和子功能号
|
||||
// 结果输出到eax, ebx, ecx, edx
|
||||
__asm__ __volatile__("cpuid \n\t"
|
||||
: "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx)
|
||||
: "0"(mop), "2"(sop)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 获取当前cpu核心晶振频率（是一个Write-on-box的值）
|
||||
*
|
||||
* hint: 某些cpu无法提供该数据，返回值为0
|
||||
* @return uint32_t 当前cpu核心晶振频率
|
||||
*/
|
||||
uint32_t cpu_get_core_crysral_freq()
|
||||
{
|
||||
uint32_t a = 0, b = 0, c = 0, d = 0;
|
||||
|
||||
// cpu_cpuid(0x15, 0, &a, &b, &c, &d);
|
||||
__asm__ __volatile__("cpuid \n\t"
|
||||
: "=a"(a), "=b"(b), "=c"(c), "=d"(d)
|
||||
: "0"(0x15), "2"(0)
|
||||
: "memory");
|
||||
// kdebug("Cpu_cpuid_max_Basic_mop = %#03x, a=%ld, b=%ld, c=%ld, d=%ld", Cpu_cpuid_max_Basic_mop, a, b, c, d);
|
||||
|
||||
return c;
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
#include "glib.h"
|
||||
#include "string.h"
|
||||
|
||||
/**
|
||||
* @brief 这个函数让蜂鸣器发声，目前仅用于真机调试。未来将移除，请勿依赖此函数。
|
||||
*
|
||||
* @param times 发声循环多少遍
|
||||
*/
|
||||
void __experimental_beep(uint64_t times)
|
||||
{
|
||||
io_out8(0x43, 182&0xff);
|
||||
io_out8(0x42, 2280&0xff);
|
||||
io_out8(0x42, (2280>>8)&0xff);
|
||||
uint32_t x = io_in8(0x61)&0xff;
|
||||
x |= 3;
|
||||
io_out8(0x61, x&0xff);
|
||||
|
||||
times *= 10000;
|
||||
for(uint64_t i=0;i<times;++i)
|
||||
pause();
|
||||
x = io_in8(0x61);
|
||||
x &= 0xfc;
|
||||
io_out8(0x61, x&0xff);
|
||||
|
||||
// 延迟一段时间
|
||||
for(uint64_t i=0;i<times;++i)
|
||||
pause();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 将数据从src搬运到dst，并能正确处理地址重叠的问题
|
||||
*
|
||||
* @param dst 目标地址指针
|
||||
* @param src 源地址指针
|
||||
* @param size 大小
|
||||
* @return void* 指向目标地址的指针
|
||||
*/
|
||||
void *memmove(void *dst, const void *src, uint64_t size)
|
||||
{
|
||||
const char *_src = src;
|
||||
char *_dst = dst;
|
||||
|
||||
if (!size)
|
||||
return dst;
|
||||
|
||||
// 当源地址大于目标地址时，使用memcpy来完成
|
||||
if (dst <= src)
|
||||
return memcpy(dst, src, size);
|
||||
|
||||
// 当源地址小于目标地址时，为防止重叠覆盖，因此从后往前拷贝
|
||||
_src += size;
|
||||
_dst += size;
|
||||
|
||||
// 逐字节拷贝
|
||||
while (size--)
|
||||
*--_dst = *--_src;
|
||||
|
||||
return dst;
|
||||
}
|
||||
@ -1,151 +0,0 @@
|
||||
#include <common/kfifo.h>
|
||||
#include <common/glib.h>
|
||||
#include <common/errno.h>
|
||||
#include <common/compiler.h>
|
||||
#include <mm/slab.h>
|
||||
|
||||
/**
|
||||
* @brief 通过动态方式初始化kfifo缓冲队列
|
||||
*
|
||||
* @param fifo 队列结构体
|
||||
* @param size 缓冲区大小
|
||||
* @param reserved 暂时保留，请置为0
|
||||
* @return int 错误码：成功->0
|
||||
*/
|
||||
int kfifo_alloc(struct kfifo_t *fifo, uint32_t size, uint64_t reserved)
|
||||
{
|
||||
memset(fifo, 0, sizeof(struct kfifo_t));
|
||||
fifo->buffer = kmalloc(size, 0);
|
||||
if (fifo->buffer == NULL)
|
||||
goto failed;
|
||||
|
||||
fifo->total_size = size;
|
||||
return 0;
|
||||
failed:;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 使用指定的缓冲区来初始化kfifo缓冲队列
|
||||
*
|
||||
* @param fifo 队列结构体
|
||||
* @param buffer 缓冲区
|
||||
* @param size 缓冲区大小
|
||||
*/
|
||||
void kfifo_init(struct kfifo_t *fifo, void *buffer, uint32_t size)
|
||||
{
|
||||
memset(fifo, 0, sizeof(struct kfifo_t));
|
||||
|
||||
fifo->buffer = buffer;
|
||||
fifo->total_size = size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 向kfifo缓冲区推入数据
|
||||
*
|
||||
* @param fifo 队列结构体
|
||||
* @param from 来源数据地址
|
||||
* @param size 数据大小（字节数）
|
||||
* @return uint32_t 推入的数据大小
|
||||
*/
|
||||
uint32_t kfifo_in(struct kfifo_t *fifo, const void *from, uint32_t size)
|
||||
{
|
||||
// 判断空间是否够
|
||||
if (unlikely(fifo->size + size > fifo->total_size))
|
||||
return 0;
|
||||
if (unlikely(from == NULL))
|
||||
return 0;
|
||||
|
||||
// 分两种情况，一种是要发生回环，另一种不发生回环
|
||||
if (fifo->in_offset + size > fifo->total_size) // 发生回环
|
||||
{
|
||||
uint32_t tmp = fifo->total_size - fifo->in_offset;
|
||||
memcpy(fifo->buffer + fifo->in_offset, from, tmp);
|
||||
memcpy(fifo->buffer, from + tmp, size - tmp);
|
||||
fifo->in_offset = size - tmp;
|
||||
}
|
||||
else // 不发生回环
|
||||
{
|
||||
memcpy(fifo->buffer + fifo->in_offset, from, size);
|
||||
fifo->in_offset += size;
|
||||
}
|
||||
|
||||
fifo->size += size;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 从kfifo缓冲区取出数据，并从队列中删除数据
|
||||
*
|
||||
* @param fifo 队列结构体
|
||||
* @param to 拷贝目标地址
|
||||
* @param size 数据大小（字节数）
|
||||
* @return uint32_t 取出的数据大小
|
||||
*/
|
||||
uint32_t kfifo_out(struct kfifo_t *fifo, void *to, uint32_t size)
|
||||
{
|
||||
if (unlikely(to == NULL)) // 判断目标地址是否为空
|
||||
return 0;
|
||||
if (unlikely(size > fifo->size)) // 判断队列中是否有这么多数据
|
||||
return 0;
|
||||
|
||||
// 判断是否会发生回环
|
||||
if (fifo->out_offset + size > fifo->total_size) // 发生回环
|
||||
{
|
||||
uint32_t tmp = fifo->total_size - fifo->out_offset;
|
||||
memcpy(to, fifo->buffer + fifo->out_offset, tmp);
|
||||
memcpy(to + tmp, fifo->buffer, size - tmp);
|
||||
fifo->out_offset = size - tmp;
|
||||
}
|
||||
else // 未发生回环
|
||||
{
|
||||
memcpy(to, fifo->buffer + fifo->out_offset, size);
|
||||
fifo->out_offset += size;
|
||||
}
|
||||
|
||||
fifo->size -= size;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 从kfifo缓冲区取出数据，但是不从队列中删除数据
|
||||
*
|
||||
* @param fifo 队列结构体
|
||||
* @param to 拷贝目标地址
|
||||
* @param size 数据大小（字节数）
|
||||
* @return uint32_t 取出的数据大小
|
||||
*/
|
||||
uint32_t kfifo_out_peek(struct kfifo_t *fifo, void *to, uint32_t size)
|
||||
{
|
||||
if (unlikely(to == NULL)) // 判断目标地址是否为空
|
||||
return 0;
|
||||
if (unlikely(size > fifo->size)) // 判断队列中是否有这么多数据
|
||||
return 0;
|
||||
|
||||
// 判断是否会发生回环
|
||||
if (fifo->out_offset + size > fifo->total_size) // 发生回环
|
||||
{
|
||||
uint32_t tmp = fifo->total_size - fifo->out_offset;
|
||||
memcpy(to, fifo->buffer + fifo->out_offset, tmp);
|
||||
memcpy(to + tmp, fifo->buffer, size - tmp);
|
||||
}
|
||||
else // 未发生回环
|
||||
{
|
||||
memcpy(to, fifo->buffer + fifo->out_offset, size);
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 释放通过kfifo_alloc创建的fifo缓冲区
|
||||
*
|
||||
* @param fifo fifo队列结构体
|
||||
*/
|
||||
void kfifo_free_alloc(struct kfifo_t *fifo)
|
||||
{
|
||||
kfree(fifo->buffer);
|
||||
memset(fifo, 0, sizeof(struct kfifo_t));
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
|
||||
all: elf.o
|
||||
|
||||
CFLAGS += -I .
|
||||
|
||||
|
||||
elf.o: elf.c
|
||||
gcc $(CFLAGS) -c elf.c -o elf.o
|
||||
@ -1,33 +0,0 @@
|
||||
#include "elf.h"
|
||||
#include <common/unistd.h>
|
||||
#include <common/glib.h>
|
||||
|
||||
/**
|
||||
* @brief 校验是否为ELF文件
|
||||
*
|
||||
* @param ehdr
|
||||
*/
|
||||
bool elf_check(void *ehdr)
|
||||
{
|
||||
Elf32_Ehdr *ptr = (Elf32_Ehdr *)ehdr;
|
||||
bool flag = ptr->e_ident[EI_MAG0] == ELFMAG0 && ptr->e_ident[EI_MAG1] == ELFMAG1 && ptr->e_ident[EI_MAG2] == ELFMAG2 && ptr->e_ident[EI_MAG3] == ELFMAG3;
|
||||
|
||||
// 标头已经不符合要求
|
||||
if (!flag)
|
||||
return false;
|
||||
|
||||
// 检验EI_CLASS是否合法
|
||||
if (ptr->e_ident[EI_CLASS] == 0 || ptr->e_ident[EI_CLASS] > 2)
|
||||
return false;
|
||||
|
||||
// 检验EI_DATA是否合法
|
||||
if (ptr->e_ident[EI_DATA] == 0 || ptr->e_ident[EI_DATA] > 2)
|
||||
return false;
|
||||
|
||||
// 检验EI_VERSION是否合法
|
||||
if(ptr->e_ident[EI_VERSION]==EV_NONE)
|
||||
return false;
|
||||
// 是elf文件
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1,120 +0,0 @@
|
||||
#include <common/mutex.h>
|
||||
#include <mm/slab.h>
|
||||
#include <sched/sched.h>
|
||||
|
||||
/**
|
||||
* @brief 初始化互斥量
|
||||
*
|
||||
* @param lock mutex结构体
|
||||
*/
|
||||
void mutex_init(mutex_t *lock)
|
||||
{
|
||||
atomic_set(&lock->count, 1);
|
||||
spin_init(&lock->wait_lock);
|
||||
list_init(&lock->wait_list);
|
||||
}
|
||||
|
||||
static void __mutex_sleep()
|
||||
{
|
||||
current_pcb->state = PROC_UNINTERRUPTIBLE;
|
||||
sched();
|
||||
}
|
||||
|
||||
static void __mutex_acquire(mutex_t *lock)
|
||||
{
|
||||
}
|
||||
/**
|
||||
* @brief 对互斥量加锁
|
||||
*
|
||||
* @param lock mutex结构体
|
||||
*/
|
||||
void mutex_lock(mutex_t *lock)
|
||||
{
|
||||
bool lock_ok = 0;
|
||||
|
||||
while (lock_ok == false)
|
||||
{
|
||||
spin_lock(&lock->wait_lock);
|
||||
if (likely(mutex_is_locked(lock)))
|
||||
{
|
||||
struct mutex_waiter_t *waiter = (struct mutex_waiter_t *)kzalloc(sizeof(struct mutex_waiter_t), 0);
|
||||
if (waiter == NULL)
|
||||
{
|
||||
kerror("In mutex_lock: no memory to alloc waiter. Program's behaviour might be indetermined!");
|
||||
spin_unlock(&lock->wait_lock);
|
||||
return;
|
||||
}
|
||||
// memset(waiter, 0, sizeof(struct mutex_waiter_t));
|
||||
waiter->pcb = current_pcb;
|
||||
list_init(&waiter->list);
|
||||
list_append(&lock->wait_list, &waiter->list);
|
||||
|
||||
spin_unlock(&lock->wait_lock);
|
||||
|
||||
__mutex_sleep();
|
||||
}
|
||||
else
|
||||
{
|
||||
atomic_dec(&lock->count);
|
||||
spin_unlock(&lock->wait_lock);
|
||||
lock_ok = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 对互斥量解锁
|
||||
*
|
||||
* @param lock mutex结构体
|
||||
*/
|
||||
void mutex_unlock(mutex_t *lock)
|
||||
{
|
||||
if (unlikely(!mutex_is_locked(lock)))
|
||||
return;
|
||||
|
||||
spin_lock(&lock->wait_lock);
|
||||
struct mutex_waiter_t *wt = NULL;
|
||||
if (mutex_is_locked(lock))
|
||||
{
|
||||
if (!list_empty(&lock->wait_list))
|
||||
wt = container_of(list_next(&lock->wait_list), struct mutex_waiter_t, list);
|
||||
|
||||
atomic_inc(&lock->count);
|
||||
if (wt != NULL)
|
||||
list_del(&wt->list);
|
||||
}
|
||||
|
||||
spin_unlock(&lock->wait_lock);
|
||||
|
||||
if (wt != NULL)
|
||||
{
|
||||
process_wakeup(wt->pcb);
|
||||
kfree(wt);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 尝试对互斥量加锁
|
||||
*
|
||||
* @param lock mutex结构体
|
||||
*
|
||||
* @return 成功加锁->1, 加锁失败->0
|
||||
*/
|
||||
int mutex_trylock(mutex_t *lock)
|
||||
{
|
||||
if (mutex_is_locked(lock))
|
||||
return 0;
|
||||
|
||||
spin_lock(&lock->wait_lock);
|
||||
if (mutex_is_locked(lock))
|
||||
{
|
||||
spin_unlock(&lock->wait_lock);
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
atomic_dec(&lock->count);
|
||||
spin_unlock(&lock->wait_lock);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@ -1,575 +0,0 @@
|
||||
//
|
||||
// Created by longjin on 2022/1/22.
|
||||
//
|
||||
#include "printk.h"
|
||||
#include "kprint.h"
|
||||
|
||||
#include <mm/mm.h>
|
||||
#include <common/spinlock.h>
|
||||
#include <lib/libUI/textui.h>
|
||||
|
||||
#include "math.h"
|
||||
#include <common/string.h>
|
||||
|
||||
static spinlock_t __printk_lock = {1};
|
||||
/**
|
||||
* @brief 将数字按照指定的要求转换成对应的字符串（2~36进制）
|
||||
*
|
||||
* @param str 要返回的字符串
|
||||
* @param num 要打印的数值
|
||||
* @param base 基数
|
||||
* @param field_width 区域宽度
|
||||
* @param precision 精度
|
||||
* @param flags 标志位
|
||||
*/
|
||||
static char *write_num(char *str, ul num, int base, int field_width, int precision, int flags);
|
||||
|
||||
static char *write_float_point_num(char *str, double num, int field_width, int precision, int flags);
|
||||
|
||||
static int skip_and_atoi(const char **s)
|
||||
{
|
||||
/**
|
||||
* @brief 获取连续的一段字符对应整数的值
|
||||
* @param:**s 指向 指向字符串的指针 的指针
|
||||
*/
|
||||
int ans = 0;
|
||||
while (is_digit(**s))
|
||||
{
|
||||
ans = ans * 10 + (**s) - '0';
|
||||
++(*s);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
int vsprintf(char *buf, const char *fmt, va_list args)
|
||||
{
|
||||
/**
|
||||
* 将字符串按照fmt和args中的内容进行格式化，然后保存到buf中
|
||||
* @param buf 结果缓冲区
|
||||
* @param fmt 格式化字符串
|
||||
* @param args 内容
|
||||
* @return 最终字符串的长度
|
||||
*/
|
||||
|
||||
char *str, *s;
|
||||
|
||||
str = buf;
|
||||
|
||||
int flags; // 用来存储格式信息的bitmap
|
||||
int field_width; //区域宽度
|
||||
int precision; //精度
|
||||
int qualifier; //数据显示的类型
|
||||
int len;
|
||||
|
||||
//开始解析字符串
|
||||
for (; *fmt; ++fmt)
|
||||
{
|
||||
//内容不涉及到格式化，直接输出
|
||||
if (*fmt != '%')
|
||||
{
|
||||
*str = *fmt;
|
||||
++str;
|
||||
continue;
|
||||
}
|
||||
|
||||
//开始格式化字符串
|
||||
|
||||
//清空标志位和field宽度
|
||||
field_width = flags = 0;
|
||||
|
||||
bool flag_tmp = true;
|
||||
bool flag_break = false;
|
||||
|
||||
++fmt;
|
||||
while (flag_tmp)
|
||||
{
|
||||
switch (*fmt)
|
||||
{
|
||||
case '\0':
|
||||
//结束解析
|
||||
flag_break = true;
|
||||
flag_tmp = false;
|
||||
break;
|
||||
|
||||
case '-':
|
||||
// 左对齐
|
||||
flags |= LEFT;
|
||||
++fmt;
|
||||
break;
|
||||
case '+':
|
||||
//在正数前面显示加号
|
||||
flags |= PLUS;
|
||||
++fmt;
|
||||
break;
|
||||
case ' ':
|
||||
flags |= SPACE;
|
||||
++fmt;
|
||||
break;
|
||||
case '#':
|
||||
//在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
|
||||
flags |= SPECIAL;
|
||||
++fmt;
|
||||
break;
|
||||
case '0':
|
||||
//显示的数字之前填充‘0’来取代空格
|
||||
flags |= PAD_ZERO;
|
||||
++fmt;
|
||||
break;
|
||||
default:
|
||||
flag_tmp = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (flag_break)
|
||||
break;
|
||||
|
||||
//获取区域宽度
|
||||
field_width = -1;
|
||||
if (*fmt == '*')
|
||||
{
|
||||
field_width = va_arg(args, int);
|
||||
++fmt;
|
||||
}
|
||||
else if (is_digit(*fmt))
|
||||
{
|
||||
field_width = skip_and_atoi(&fmt);
|
||||
if (field_width < 0)
|
||||
{
|
||||
field_width = -field_width;
|
||||
flags |= LEFT;
|
||||
}
|
||||
}
|
||||
|
||||
//获取小数精度
|
||||
precision = -1;
|
||||
if (*fmt == '.')
|
||||
{
|
||||
++fmt;
|
||||
if (*fmt == '*')
|
||||
{
|
||||
precision = va_arg(args, int);
|
||||
++fmt;
|
||||
}
|
||||
else if is_digit (*fmt)
|
||||
{
|
||||
precision = skip_and_atoi(&fmt);
|
||||
}
|
||||
}
|
||||
|
||||
//获取要显示的数据的类型
|
||||
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'Z')
|
||||
{
|
||||
qualifier = *fmt;
|
||||
++fmt;
|
||||
}
|
||||
//为了支持lld
|
||||
if (qualifier == 'l' && *fmt == 'l', *(fmt + 1) == 'd')
|
||||
++fmt;
|
||||
|
||||
//转化成字符串
|
||||
long long *ip;
|
||||
switch (*fmt)
|
||||
{
|
||||
//输出 %
|
||||
case '%':
|
||||
*str++ = '%';
|
||||
|
||||
break;
|
||||
// 显示一个字符
|
||||
case 'c':
|
||||
//靠右对齐
|
||||
if (!(flags & LEFT))
|
||||
{
|
||||
while (--field_width > 0)
|
||||
{
|
||||
*str = ' ';
|
||||
++str;
|
||||
}
|
||||
}
|
||||
|
||||
*str++ = (unsigned char)va_arg(args, int);
|
||||
|
||||
while (--field_width > 0)
|
||||
{
|
||||
*str = ' ';
|
||||
++str;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
//显示一个字符串
|
||||
case 's':
|
||||
s = va_arg(args, char *);
|
||||
if (!s)
|
||||
s = '\0';
|
||||
len = strlen(s);
|
||||
if (precision < 0)
|
||||
{
|
||||
//未指定精度
|
||||
precision = len;
|
||||
}
|
||||
|
||||
else if (len > precision)
|
||||
{
|
||||
len = precision;
|
||||
}
|
||||
|
||||
//靠右对齐
|
||||
if (!(flags & LEFT))
|
||||
while (len < field_width--)
|
||||
{
|
||||
*str = ' ';
|
||||
++str;
|
||||
}
|
||||
|
||||
for (int i = 0; i < len; i++)
|
||||
{
|
||||
*str = *s;
|
||||
++s;
|
||||
++str;
|
||||
}
|
||||
|
||||
while (len < field_width--)
|
||||
{
|
||||
*str = ' ';
|
||||
++str;
|
||||
}
|
||||
|
||||
break;
|
||||
//以八进制显示字符串
|
||||
case 'o':
|
||||
flags |= SMALL;
|
||||
case 'O':
|
||||
flags |= SPECIAL;
|
||||
if (qualifier == 'l')
|
||||
str = write_num(str, va_arg(args, long long), 8, field_width, precision, flags);
|
||||
else
|
||||
str = write_num(str, va_arg(args, int), 8, field_width, precision, flags);
|
||||
break;
|
||||
|
||||
//打印指针指向的地址
|
||||
case 'p':
|
||||
if (field_width == 0)
|
||||
{
|
||||
field_width = 2 * sizeof(void *);
|
||||
flags |= PAD_ZERO;
|
||||
}
|
||||
|
||||
str = write_num(str, (unsigned long)va_arg(args, void *), 16, field_width, precision, flags);
|
||||
|
||||
break;
|
||||
|
||||
//打印十六进制
|
||||
case 'x':
|
||||
flags |= SMALL;
|
||||
case 'X':
|
||||
// flags |= SPECIAL;
|
||||
if (qualifier == 'l')
|
||||
str = write_num(str, va_arg(args, ll), 16, field_width, precision, flags);
|
||||
else
|
||||
str = write_num(str, va_arg(args, int), 16, field_width, precision, flags);
|
||||
break;
|
||||
|
||||
//打印十进制有符号整数
|
||||
case 'i':
|
||||
case 'd':
|
||||
|
||||
flags |= SIGN;
|
||||
if (qualifier == 'l')
|
||||
str = write_num(str, va_arg(args, long long), 10, field_width, precision, flags);
|
||||
else
|
||||
str = write_num(str, va_arg(args, int), 10, field_width, precision, flags);
|
||||
break;
|
||||
|
||||
//打印十进制无符号整数
|
||||
case 'u':
|
||||
if (qualifier == 'l')
|
||||
str = write_num(str, va_arg(args, unsigned long long), 10, field_width, precision, flags);
|
||||
else
|
||||
str = write_num(str, va_arg(args, unsigned int), 10, field_width, precision, flags);
|
||||
break;
|
||||
|
||||
//输出有效字符数量到*ip对应的变量
|
||||
case 'n':
|
||||
|
||||
if (qualifier == 'l')
|
||||
ip = va_arg(args, long long *);
|
||||
else
|
||||
ip = (ll *)va_arg(args, int *);
|
||||
|
||||
*ip = str - buf;
|
||||
break;
|
||||
case 'f':
|
||||
// 默认精度为3
|
||||
// printk("1111\n");
|
||||
// va_arg(args, double);
|
||||
// printk("222\n");
|
||||
|
||||
if (precision < 0)
|
||||
precision = 3;
|
||||
|
||||
str = write_float_point_num(str, va_arg(args, double), field_width, precision, flags);
|
||||
|
||||
break;
|
||||
|
||||
//对于不识别的控制符，直接输出
|
||||
default:
|
||||
*str++ = '%';
|
||||
if (*fmt)
|
||||
*str++ = *fmt;
|
||||
else
|
||||
--fmt;
|
||||
break;
|
||||
}
|
||||
}
|
||||
*str = '\0';
|
||||
|
||||
//返回缓冲区已有字符串的长度。
|
||||
return str - buf;
|
||||
}
|
||||
|
||||
static char *write_num(char *str, ul num, int base, int field_width, int precision, int flags)
|
||||
{
|
||||
/**
|
||||
* @brief 将数字按照指定的要求转换成对应的字符串
|
||||
*
|
||||
* @param str 要返回的字符串
|
||||
* @param num 要打印的数值
|
||||
* @param base 基数
|
||||
* @param field_width 区域宽度
|
||||
* @param precision 精度
|
||||
* @param flags 标志位
|
||||
*/
|
||||
|
||||
// 首先判断是否支持该进制
|
||||
if (base < 2 || base > 36)
|
||||
return 0;
|
||||
char pad, sign, tmp_num[100];
|
||||
|
||||
const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
// 显示小写字母
|
||||
if (flags & SMALL)
|
||||
digits = "0123456789abcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
if (flags & LEFT)
|
||||
flags &= ~PAD_ZERO;
|
||||
// 设置填充元素
|
||||
pad = (flags & PAD_ZERO) ? '0' : ' ';
|
||||
|
||||
sign = 0;
|
||||
|
||||
if (flags & SIGN)
|
||||
{
|
||||
int64_t signed_num = (int64_t)num;
|
||||
if (signed_num < 0)
|
||||
{
|
||||
sign = '-';
|
||||
num = -signed_num;
|
||||
}
|
||||
else
|
||||
num = signed_num;
|
||||
}
|
||||
else
|
||||
{
|
||||
// 设置符号
|
||||
sign = (flags & PLUS) ? '+' : ((flags & SPACE) ? ' ' : 0);
|
||||
}
|
||||
|
||||
// sign占用了一个宽度
|
||||
if (sign)
|
||||
--field_width;
|
||||
|
||||
if (flags & SPECIAL)
|
||||
if (base == 16) // 0x占用2个位置
|
||||
field_width -= 2;
|
||||
else if (base == 8) // O占用一个位置
|
||||
--field_width;
|
||||
|
||||
int js_num = 0; // 临时数字字符串tmp_num的长度
|
||||
|
||||
if (num == 0)
|
||||
tmp_num[js_num++] = '0';
|
||||
else
|
||||
{
|
||||
num = ABS(num);
|
||||
//进制转换
|
||||
while (num > 0)
|
||||
{
|
||||
tmp_num[js_num++] = digits[num % base]; // 注意这里，输出的数字，是小端对齐的。低位存低位
|
||||
num /= base;
|
||||
}
|
||||
}
|
||||
|
||||
if (js_num > precision)
|
||||
precision = js_num;
|
||||
|
||||
field_width -= precision;
|
||||
|
||||
// 靠右对齐
|
||||
if (!(flags & (LEFT + PAD_ZERO)))
|
||||
while (field_width-- > 0)
|
||||
*str++ = ' ';
|
||||
|
||||
if (sign)
|
||||
*str++ = sign;
|
||||
if (flags & SPECIAL)
|
||||
if (base == 16)
|
||||
{
|
||||
*str++ = '0';
|
||||
*str++ = digits[33];
|
||||
}
|
||||
else if (base == 8)
|
||||
*str++ = digits[24]; //注意这里是英文字母O或者o
|
||||
if (!(flags & LEFT))
|
||||
while (field_width-- > 0)
|
||||
*str++ = pad;
|
||||
while (js_num < precision)
|
||||
{
|
||||
--precision;
|
||||
*str++ = '0';
|
||||
}
|
||||
|
||||
while (js_num-- > 0)
|
||||
*str++ = tmp_num[js_num];
|
||||
|
||||
while (field_width-- > 0)
|
||||
*str++ = ' ';
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
static char *write_float_point_num(char *str, double num, int field_width, int precision, int flags)
|
||||
{
|
||||
/**
|
||||
* @brief 将浮点数按照指定的要求转换成对应的字符串
|
||||
*
|
||||
* @param str 要返回的字符串
|
||||
* @param num 要打印的数值
|
||||
* @param field_width 区域宽度
|
||||
* @param precision 精度
|
||||
* @param flags 标志位
|
||||
*/
|
||||
|
||||
char pad, sign, tmp_num_z[100], tmp_num_d[350];
|
||||
|
||||
const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
// 显示小写字母
|
||||
if (flags & SMALL)
|
||||
digits = "0123456789abcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
// 设置填充元素
|
||||
pad = (flags & PAD_ZERO) ? '0' : ' ';
|
||||
sign = 0;
|
||||
if (flags & SIGN && num < 0)
|
||||
{
|
||||
sign = '-';
|
||||
num = -num;
|
||||
}
|
||||
else
|
||||
{
|
||||
// 设置符号
|
||||
sign = (flags & PLUS) ? '+' : ((flags & SPACE) ? ' ' : 0);
|
||||
}
|
||||
|
||||
// sign占用了一个宽度
|
||||
if (sign)
|
||||
--field_width;
|
||||
|
||||
int js_num_z = 0, js_num_d = 0; // 临时数字字符串tmp_num_z tmp_num_d的长度
|
||||
uint64_t num_z = (uint64_t)(num); // 获取整数部分
|
||||
uint64_t num_decimal = (uint64_t)(round(1.0 * (num - num_z) * pow(10, precision))); // 获取小数部分
|
||||
|
||||
if (num == 0 || num_z == 0)
|
||||
tmp_num_z[js_num_z++] = '0';
|
||||
else
|
||||
{
|
||||
//存储整数部分
|
||||
while (num_z > 0)
|
||||
{
|
||||
tmp_num_z[js_num_z++] = digits[num_z % 10]; // 注意这里，输出的数字，是小端对齐的。低位存低位
|
||||
num_z /= 10;
|
||||
}
|
||||
}
|
||||
|
||||
while (num_decimal > 0)
|
||||
{
|
||||
tmp_num_d[js_num_d++] = digits[num_decimal % 10];
|
||||
num_decimal /= 10;
|
||||
}
|
||||
|
||||
field_width -= (precision + 1 + js_num_z);
|
||||
|
||||
// 靠右对齐
|
||||
if (!(flags & LEFT))
|
||||
while (field_width-- > 0)
|
||||
*str++ = pad;
|
||||
|
||||
if (sign)
|
||||
*str++ = sign;
|
||||
|
||||
// 输出整数部分
|
||||
while (js_num_z > 0)
|
||||
{
|
||||
*str++ = tmp_num_z[js_num_z - 1];
|
||||
--js_num_z;
|
||||
}
|
||||
*str++ = '.';
|
||||
|
||||
// 输出小数部分
|
||||
int total_dec_count = js_num_d;
|
||||
for (int i = 0; i < precision && js_num_d-- > 0; ++i)
|
||||
*str++ = tmp_num_d[js_num_d];
|
||||
|
||||
while (total_dec_count < precision)
|
||||
{
|
||||
++total_dec_count;
|
||||
*str++ = '0';
|
||||
}
|
||||
|
||||
while (field_width-- > 0)
|
||||
*str++ = ' ';
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 格式化打印字符串
|
||||
*
|
||||
* @param FRcolor 前景色
|
||||
* @param BKcolor 背景色
|
||||
* @param ... 格式化字符串
|
||||
*/
|
||||
int printk_color(unsigned int FRcolor, unsigned int BKcolor, const char *fmt, ...)
|
||||
{
|
||||
uint64_t rflags;
|
||||
spin_lock_irqsave(&__printk_lock, rflags);
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
char buf[4096]; // vsprintf()的缓冲区
|
||||
int len = vsprintf(buf, fmt, args);
|
||||
|
||||
va_end(args);
|
||||
unsigned char current;
|
||||
|
||||
int i; // 总共输出的字符数
|
||||
for (i = 0; i < len; ++i)
|
||||
{
|
||||
current = *(buf + i);
|
||||
// 输出
|
||||
textui_putchar(current, FRcolor, BKcolor);
|
||||
}
|
||||
spin_unlock_irqrestore(&__printk_lock, rflags);
|
||||
return i;
|
||||
}
|
||||
|
||||
int sprintk(char *buf, const char *fmt, ...)
|
||||
{
|
||||
int count = 0;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
count = vsprintf(buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return count;
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
#include "semaphore.h"
|
||||
#include <sched/sched.h>
|
||||
#include <process/process.h>
|
||||
|
||||
|
||||
void semaphore_down(semaphore_t *sema)
|
||||
{
|
||||
if (atomic_read(&sema->counter) > 0) // 信号量大于0，资源充足
|
||||
atomic_dec(&sema->counter);
|
||||
else // 资源不足，进程休眠
|
||||
{
|
||||
// 将当前进程加入信号量的等待队列
|
||||
wait_queue_node_t wait;
|
||||
wait_queue_init(&wait, current_pcb);
|
||||
|
||||
current_pcb->state = PROC_UNINTERRUPTIBLE;
|
||||
|
||||
list_append(&sema->wait_queue.wait_list, &wait.wait_list);
|
||||
|
||||
// 执行调度
|
||||
sched();
|
||||
}
|
||||
}
|
||||
|
||||
void semaphore_up(semaphore_t *sema)
|
||||
{
|
||||
if (list_empty(&sema->wait_queue.wait_list)) // 没有进程在等待资源
|
||||
{
|
||||
atomic_inc(&sema->counter);
|
||||
}
|
||||
else // 有进程在等待资源，唤醒进程
|
||||
{
|
||||
|
||||
wait_queue_node_t *wq = container_of(list_next(&sema->wait_queue.wait_list), wait_queue_node_t, wait_list);
|
||||
list_del(&wq->wait_list);
|
||||
|
||||
wq->pcb->state = PROC_RUNNING;
|
||||
sched_enqueue(wq->pcb);
|
||||
|
||||
// 当前进程缺少需要的资源，立即标为需要被调度
|
||||
current_pcb->flags |= PF_NEED_SCHED;
|
||||
}
|
||||
};
|
||||
@ -1,109 +0,0 @@
|
||||
#include "string.h"
|
||||
#include "glib.h"
|
||||
|
||||
/**
|
||||
* @brief 拷贝整个字符串
|
||||
*
|
||||
* @param dst 目标地址
|
||||
* @param src 源地址
|
||||
* @return char* 目标字符串
|
||||
*/
|
||||
char *strcpy(char *dst, const char *src)
|
||||
{
|
||||
while (*src)
|
||||
{
|
||||
*(dst++) = *(src++);
|
||||
}
|
||||
*dst = 0;
|
||||
|
||||
return dst;
|
||||
}
|
||||
|
||||
long strnlen(const char *src, unsigned long maxlen)
|
||||
{
|
||||
|
||||
if (src == NULL)
|
||||
return 0;
|
||||
register int __res = 0;
|
||||
while (src[__res] != '\0' && __res < maxlen)
|
||||
{
|
||||
++__res;
|
||||
}
|
||||
return __res;
|
||||
}
|
||||
|
||||
/*
|
||||
比较字符串 FirstPart and SecondPart
|
||||
FirstPart = SecondPart => 0
|
||||
FirstPart > SecondPart => 1
|
||||
FirstPart < SecondPart => -1
|
||||
*/
|
||||
|
||||
int strcmp(const char *FirstPart, const char *SecondPart)
|
||||
{
|
||||
register int __res;
|
||||
__asm__ __volatile__("cld \n\t"
|
||||
"1: \n\t"
|
||||
"lodsb \n\t"
|
||||
"scasb \n\t"
|
||||
"jne 2f \n\t"
|
||||
"testb %%al, %%al \n\t"
|
||||
"jne 1b \n\t"
|
||||
"xorl %%eax, %%eax \n\t"
|
||||
"jmp 3f \n\t"
|
||||
"2: \n\t"
|
||||
"movl $1, %%eax \n\t"
|
||||
"jl 3f \n\t"
|
||||
"negl %%eax \n\t"
|
||||
"3: \n\t"
|
||||
: "=a"(__res)
|
||||
: "D"(FirstPart), "S"(SecondPart)
|
||||
:);
|
||||
return __res;
|
||||
}
|
||||
|
||||
char *strncpy(char *dst, const char *src, long count)
|
||||
{
|
||||
__asm__ __volatile__("cld \n\t"
|
||||
"1: \n\t"
|
||||
"decq %2 \n\t"
|
||||
"js 2f \n\t"
|
||||
"lodsb \n\t"
|
||||
"stosb \n\t"
|
||||
"testb %%al, %%al \n\t"
|
||||
"jne 1b \n\t"
|
||||
"rep \n\t"
|
||||
"stosb \n\t"
|
||||
"2: \n\t"
|
||||
:
|
||||
: "S"(src), "D"(dst), "c"(count)
|
||||
: "ax", "memory");
|
||||
return dst;
|
||||
}
|
||||
|
||||
long strncpy_from_user(char *dst, const char *src, unsigned long size)
|
||||
{
|
||||
if (!verify_area((uint64_t)src, size))
|
||||
return 0;
|
||||
|
||||
strncpy(dst, src, size);
|
||||
return size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 测量来自用户空间的字符串的长度，会检验地址空间是否属于用户空间
|
||||
* @param src
|
||||
* @param maxlen
|
||||
* @return long
|
||||
*/
|
||||
long strnlen_user(const char *src, unsigned long maxlen)
|
||||
{
|
||||
|
||||
unsigned long size = strlen(src);
|
||||
// 地址不合法
|
||||
if (!verify_area((uint64_t)src, size))
|
||||
return 0;
|
||||
|
||||
return size <= maxlen ? size : maxlen;
|
||||
}
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
#include <syscall/syscall_num.h>
|
||||
#include <syscall/syscall.h>
|
||||
|
||||
/**
|
||||
* @brief 等待指定pid的子进程退出
|
||||
*
|
||||
* @param pid 子进程的pid
|
||||
* @param stat_loc 返回的子进程结束状态
|
||||
* @param options 额外的控制选项
|
||||
* @return pid_t
|
||||
*/
|
||||
pid_t waitpid(pid_t pid, int *stat_loc, int options)
|
||||
{
|
||||
return (pid_t)enter_syscall_int(SYS_WAIT4, (uint64_t)pid, (uint64_t)stat_loc, options, 0, 0, 0, 0, 0);
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
#include <common/unistd.h>
|
||||
|
||||
/**
|
||||
* @brief fork当前进程
|
||||
*
|
||||
* @return pid_t
|
||||
*/
|
||||
pid_t fork(void)
|
||||
{
|
||||
return (pid_t)enter_syscall_int(SYS_FORK, 0, 0, 0, 0, 0, 0, 0, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief vfork当前进程
|
||||
*
|
||||
* @return pid_t
|
||||
*/
|
||||
pid_t vfork(void)
|
||||
{
|
||||
return (pid_t)enter_syscall_int(SYS_VFORK, 0, 0, 0, 0, 0, 0, 0, 0);
|
||||
}
|
||||
@ -1,84 +0,0 @@
|
||||
#include "wait_queue.h"
|
||||
#include <sched/sched.h>
|
||||
#include <process/process.h>
|
||||
#include <mm/slab.h>
|
||||
#include <common/spinlock.h>
|
||||
|
||||
/**
|
||||
* @brief 初始化等待队列
|
||||
*
|
||||
* @param wait_queue 等待队列
|
||||
* @param pcb pcb
|
||||
*/
|
||||
void wait_queue_init(wait_queue_node_t *wait_queue, struct process_control_block *pcb)
|
||||
{
|
||||
list_init(&wait_queue->wait_list);
|
||||
wait_queue->pcb = pcb;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 在等待队列上进行等待
|
||||
*
|
||||
* @param wait_queue_head 队列头指针
|
||||
*/
|
||||
void wait_queue_sleep_on(wait_queue_node_t *wait_queue_head)
|
||||
{
|
||||
wait_queue_node_t *wait = (wait_queue_node_t *)kmalloc(sizeof(wait_queue_node_t), 0);
|
||||
wait_queue_init(wait, current_pcb);
|
||||
current_pcb->state = PROC_UNINTERRUPTIBLE;
|
||||
list_append(&wait_queue_head->wait_list, &wait->wait_list);
|
||||
|
||||
sched();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 在等待队列上进行等待，同时释放自旋锁
|
||||
*
|
||||
* @param wait_queue_head 队列头指针
|
||||
*/
|
||||
void wait_queue_sleep_on_unlock(wait_queue_node_t *wait_queue_head,
|
||||
void *lock)
|
||||
{
|
||||
wait_queue_node_t *wait = (wait_queue_node_t *)kmalloc(sizeof(wait_queue_node_t), 0);
|
||||
wait_queue_init(wait, current_pcb);
|
||||
current_pcb->state = PROC_UNINTERRUPTIBLE;
|
||||
list_append(&wait_queue_head->wait_list, &wait->wait_list);
|
||||
spin_unlock((spinlock_t *)lock);
|
||||
sched();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 在等待队列上进行等待(允许中断)
|
||||
*
|
||||
* @param wait_queue_head 队列头指针
|
||||
*/
|
||||
void wait_queue_sleep_on_interriptible(wait_queue_node_t *wait_queue_head)
|
||||
{
|
||||
wait_queue_node_t *wait = (wait_queue_node_t *)kmalloc(sizeof(wait_queue_node_t), 0);
|
||||
wait_queue_init(wait, current_pcb);
|
||||
current_pcb->state = PROC_INTERRUPTIBLE;
|
||||
list_append(&wait_queue_head->wait_list, &wait->wait_list);
|
||||
|
||||
sched();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 唤醒在等待队列的头部的进程
|
||||
*
|
||||
* @param wait_queue_head
|
||||
* @param state
|
||||
*/
|
||||
void wait_queue_wakeup(wait_queue_node_t *wait_queue_head, int64_t state)
|
||||
{
|
||||
if (list_empty(&wait_queue_head->wait_list))
|
||||
return;
|
||||
wait_queue_node_t *wait = container_of(list_next(&wait_queue_head->wait_list), wait_queue_node_t, wait_list);
|
||||
|
||||
// 符合唤醒条件
|
||||
if (wait->pcb->state & state)
|
||||
{
|
||||
list_del(&wait->wait_list);
|
||||
process_wakeup(wait->pcb);
|
||||
kfree(wait);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user