repo_name
stringlengths 6
97
| path
stringlengths 3
341
| text
stringlengths 8
1.02M
|
|---|---|---|
NightfallDM/xbook2
|
src/include/xbook/spinlock.h
|
#ifndef _XBOOK_SPINLOCK_H
#define _XBOOK_SPINLOCK_H
/*
自旋锁：
在多核处理器系统中,系统不允许在不同的CPU上运行的内核控制路径同时访问某些内核数据结构,
在这种情况下如果修改数据结构所需的时间比较短，那么信号量（参考信号量）是低效的。
这是系统会使用自旋锁，当一个进程发现锁被另一个进程锁着时，他就不停”旋转”，执行一个紧凑的循环指令直到锁被打开。
但是这种自旋锁在单核处理器下是无效的。当内核控制路径试图访问一个上锁的数据结构，他就开始无休止的循环。因此，
内核控制路径可能因为正在修改受保护的数据结构而没有机会继续执行，也没有机会释放这个自旋锁。最后的结果可能是系统挂起。
（1） 一个被争用的自旋锁使得请求它的线程在等待锁重新可用时自旋，会特别浪费处理器时间。
所以自旋锁不应该被长时间持有。因此，自旋锁应该使用在：短时间内进行轻量级加锁。
（2）还可以采取另外的方式来处理对锁的争用：让请求线程睡眠，直到锁重新可用时再唤醒它这样处理器不必循环等待，可以执行其他任务。
但是让请求线程睡眠的处理也会带来一定开销：会有两次上下文切换，被阻塞的线程要换出和换入所以，
自旋持有锁的时间最好小于完成两次上下文e月刊的耗时，也就是让持有自旋锁的时间尽可能短。
（在抢占式内核中，的锁持有等价于系统-的调度等待时间），信号量可以在发生争用时，等待的线程能投入睡眠，而不是旋转。
（3）在单处理机器上，自旋锁是无意义的。因为在编译时不会加入自旋锁，仅仅被当作一个设置内核抢占机制是否被启用的开关。
如果禁止内核抢占，那么在编译时自旋锁会被完全剔除出内核。
（4）自旋锁是不可递归的。如果试图得到一个你正在持有的锁，你必须去自旋，等待你自己释放这个锁。
但这时你处于自旋忙等待中，所以永远不会释放锁，就会造成死锁现象。
（5）在中断处理程序中，获取锁之前一定要先禁止本地中断（当前处理器的中断），否则，中断程序就会打断正持有锁的内核代码，
有可能会试图去争用这个已经被持有的自旋锁。这样就会造成双重请求死锁（中断处理程序会自旋，等待该锁重新可用，
但锁的持有者在这个处理程序执行完之前是不可能运行的）
（6）锁真正保护的是数据（共享数据），而不是代码。对于BLK（大内核锁）保护的是代码。
*/
#include <arch/atomic.h>
#include <arch/interrupt.h>
typedef struct spinlock {
atomic_t count; /* 锁变量是原子，为0表示空闲，1表示上锁 */
} spinlock_t;
/* 自旋锁的初始化 */
#define SPIN_LOCK_INIT_UNLOCKED() \
{ .count = ATOMIC_INIT(0) }
#define SPIN_LOCK_INIT_LOCKED() \
{ .count = ATOMIC_INIT(1) }
#define SPIN_LOCK_INIT() SPIN_LOCK_INIT_UNLOCKED()
/* 定义未上锁的自旋锁 */
#define DEFINE_SPIN_LOCK_UNLOCKED(lockname) \
spinlock_t lockname = { .count = ATOMIC_INIT(0) }
/* 定义上锁的自旋锁 */
#define DEFINE_SPIN_LOCK_LOCKED(lockname) \
Spinlock_t lockname = { .count = ATOMIC_INIT(1) }
/* 定义自旋锁，默认是未上锁的自旋锁 */
#define DEFINE_SPIN_LOCK(lockname) \
DEFINE_SPIN_LOCK_UNLOCKED(lockname)
#define spinlock_init(lock) \
atomic_set(&(lock)->count, 0)
/* while old value is 1， it means the lock had used，wait here. */
#define spin_lock(lock) \
do { \
if (atomic_xchg(&(lock)->count, 1) != 1) \
break; \
} while(1)
#define spin_unlock(lock) \
atomic_set(&(lock)->count, 0)
/**
* spin_lock_irqsave - 自旋锁加锁并保存中断状态
* @lock: 锁对象
*
* 会关闭中断
* 返回进入前的中断状态
*/
#define spin_lock_irqsave(lock, flags) \
save_intr(flags); \
spin_lock(lock);
/**
* spin_unlock_irqrestore - 自旋锁解锁并恢复中断状态
* @lock: 锁对象
* @eflags: 之前的状态
* 恢复进入自旋锁之前的中断状态
*/
#define spin_unlock_irqrestore(lock, flags) \
spin_unlock(lock); \
restore_intr(flags)
/**
* spin_lock_irq - 自旋锁加锁并关闭中断
* @lock: 锁对象
*
* 关闭中断并获取自选锁
*/
#define spin_lock_irq(lock) \
disable_intr(); \
spin_lock(lock)
/**
* spin_unlock_irq - 自旋锁解锁并打开中断
* @lock: 锁对象
*
* 恢复进入自旋锁之前的中断状态
*/
#define spin_unlock_irq(lock) \
spin_unlock(lock); \
enable_intr()
/**
* spin_try_lock - 尝试自旋锁加锁
* @lock: 锁对象
*
* 非阻塞式获取锁
* 如果锁已经被使用，就返回一个非0值，不会自旋等待锁释放。
* 如果成功获得了锁，就返回0
*/
static inline int spin_try_lock(spinlock_t *lock)
{
return atomic_xchg(&(lock)->count, 1);
}
/**
* spin_is_locked - 检测锁是否被占用
* @lock: 锁对象
*
* 如果锁已经被使用，就返回1
* 不然就返回0
*/
static inline int spin_is_locked(spinlock_t *lock)
{
return atomic_get(&(lock)->count) > 0;
}
#endif /*_BOOK_SPINLOCK_H*/
|
NightfallDM/xbook2
|
src/include/xbook/kernel.h
|
#ifndef _XBOOK_KERNEL_H
#define _XBOOK_KERNEL_H
#include <arch/page.h>
#define KERN_EMERG "<0>" /* system is unuseable */
#define KERN_ALTER "<1>" /* action must be taken immediatgely */
#define KERN_CRIT "<2>" /* critical condition */
#define KERN_ERR "<3>" /* error condition */
#define KERN_WARING "<4>" /* waring condition */
#define KERN_NOTICE "<5>" /* normal significant */
#define KERN_INFO "<6>" /* infomational */
#define KERN_DEBUG "<7>" /* debug message */
#define KERN_VADDR PAGE_OFFSET
#endif /* _XBOOK_KERNEL_H */
|
NightfallDM/xbook2
|
library/xlibc/include/arch/const.h
|
<reponame>NightfallDM/xbook2
#ifndef _LIB_ARCH_CONST_H
#define _LIB_ARCH_CONST_H
#include <arch/config.h>
#define KB 1024
#define MB (KB * 1024)
#define GB (MB * 1024)
#define TB (GB * 1024)
#define WORDSZ _WORDSZ
#endif /* _LIB_ARCH_CONST_H */
|
NightfallDM/xbook2
|
library/xlibc/syslib/spinlock.c
|
<gh_stars>0
#include <arch/xchg.h>
#include <sys/proc.h>
#include <sys/spinlock.h>
#include <stdio.h>
#include <errno.h>
/* 自选一定次数后，才进行yeild */
#define __SPIN_COUNT 10
int spin_lock_init(spinlock_t *lock)
{
if (!lock)
return EINVAL;
lock->lock = 0;
return 0;
}
int spin_lock(spinlock_t *lock)
{
if (!lock)
return EINVAL;
int i;
while (1) {
for (i = 0; i < __SPIN_COUNT; i++) { /* 尝试多次后才让出cpu，以减少进程间切换。 */
if (spin_trylock(lock) == 0)
return 0;
}
sched_yeild();
}
return 0;
}
int spin_trylock(spinlock_t *lock)
{
if (!lock)
return EINVAL;
uint32_t oldvale;
/* 如果返回的旧值是0，那么成功获取，如果是1表示已经被占用，需要等待 */
oldvale = test_and_set(&lock->lock, 1);
if (oldvale != 1) /* 没有上锁就成功 */
return 0;
else
return EBUSY; /* EBUSY繁忙 */
}
int spin_unlock(spinlock_t *lock)
{
if (!lock)
return EINVAL;
lock->lock--;
return 0;
}
int spin_is_locked(spinlock_t *lock)
{
if (!lock)
return EINVAL;
return lock->lock;
}
|
NightfallDM/xbook2
|
src/kernel/syscall.c
|
#include <xbook/syscall.h>
#include <xbook/process.h>
#include <xbook/vmspace.h>
#include <xbook/resource.h>
#include <xbook/trigger.h>
#include <xbook/alarm.h>
#include <xbook/ktime.h>
#include <xbook/clock.h>
#include <xbook/waitque.h>
#include <xbook/srvcall.h>
#include <xbook/fs.h>
#include <xbook/driver.h>
#include <xbook/net.h>
#include <xbook/sharemem.h>
#include <xbook/sem.h>
#include <xbook/msgqueue.h>
#include <sys/stat.h>
#include <dirent.h>
#include <gui/console/console.h>
/* 系统调用表 */
syscall_t syscall_table[SYSCALL_NR];
void init_syscall()
{
/* 进程管理 */
syscall_table[SYS_EXIT] = sys_exit;
syscall_table[SYS_FORK] = sys_fork;
syscall_table[SYS_WAITPID] = sys_waitpid;
syscall_table[SYS_GETPID] = sys_get_pid;
syscall_table[SYS_GETPPID] = sys_get_ppid;
syscall_table[SYS_TRIGGER] = sys_trigger_handler;
syscall_table[SYS_TRIGGERON] = sys_trigger_active;
syscall_table[SYS_TRIGGERACT] = sys_trigger_action;
syscall_table[SYS_TRIGRET] = sys_trigger_return;
syscall_table[SYS_SLEEP] = sys_sleep;
syscall_table[SYS_THREAD_CREATE] = sys_thread_create;
syscall_table[SYS_THREAD_EXIT] = sys_thread_exit;
syscall_table[SYS_THREAD_JOIN] = sys_thread_join;
syscall_table[SYS_THREAD_DETACH] = sys_thread_detach;
syscall_table[SYS_GETTID] = sys_get_tid;
syscall_table[SYS_THREAD_CANCEL] = sys_thread_cancel;
syscall_table[SYS_THREAD_TESTCANCEL] = sys_thread_testcancel;
syscall_table[SYS_THREAD_CANCELSTATE] = sys_thread_setcancelstate;
syscall_table[SYS_THREAD_CANCELTYPE] = sys_thread_setcanceltype;
syscall_table[SYS_SCHED_YEILD] = sys_sched_yeild;
syscall_table[SYS_WAITQUE_CREATE] = sys_waitque_create;
syscall_table[SYS_WAITQUE_DESTROY] = sys_waitque_destroy;
syscall_table[SYS_WAITQUE_WAIT] = sys_waitque_wait;
syscall_table[SYS_WAITQUE_WAKE] = sys_waitque_wake;
/* 内存管理 */
syscall_table[SYS_HEAP] = sys_vmspace_heap;
syscall_table[SYS_MUNMAP] = sys_munmap;
/* 设备资源管理 */
syscall_table[SYS_GETRES] = sys_getres;
syscall_table[SYS_PUTRES] = sys_putres;
syscall_table[SYS_READRES] = sys_readres;
syscall_table[SYS_WRITERES] = sys_writeres;
syscall_table[SYS_CTLRES] = sys_ctlres;
syscall_table[SYS_DEVSCAN] = sys_devscan;
syscall_table[SYS_MMAP] = sys_mmap;
syscall_table[SYS_ALARM] = sys_alarm;
syscall_table[SYS_KTIME] = sys_get_ktime;
syscall_table[SYS_GETTICKS] = sys_get_ticks;
syscall_table[SYS_GETTIMEOFDAY] = sys_gettimeofday;
syscall_table[SYS_CLOCK_GETTIME] = sys_clock_gettime;
syscall_table[SYS_SRVCALL] = sys_srvcall;
syscall_table[SYS_SRVCALL_LISTEN] = sys_srvcall_listen;
syscall_table[SYS_SRVCALL_ACK] = sys_srvcall_ack;
syscall_table[SYS_SRVCALL_BIND] = sys_srvcall_bind;
syscall_table[SYS_SRVCALL_UNBIND] = sys_srvcall_unbind;
syscall_table[SYS_SRVCALL_FETCH] = sys_srvcall_fetch;
syscall_table[SYS_UNID] = sys_unid;
syscall_table[SYS_TSTATE] = sys_tstate;
syscall_table[SYS_GETVER] = sys_getver;
syscall_table[SYS_MSTATE] = sys_mstate;
syscall_table[SYS_USLEEP] = sys_usleep;
/* 文件系统 */
syscall_table[SYS_OPEN] = sys_open;
syscall_table[SYS_CLOSE] = sys_close;
syscall_table[SYS_READ] = sys_read;
syscall_table[SYS_WRITE] = sys_write;
syscall_table[SYS_LSEEK] = sys_lseek;
syscall_table[SYS_ACCESS] = sys_access;
syscall_table[SYS_UNLINK] = sys_unlink;
syscall_table[SYS_FTRUNCATE] = sys_ftruncate;
syscall_table[SYS_FSYNC] = sys_fsync;
syscall_table[SYS_IOCTL] = sys_ioctl;
syscall_table[SYS_FCNTL] = sys_fcntl;
syscall_table[SYS_TELL] = sys_tell;
syscall_table[SYS_MKDIR] = sys_mkdir;
syscall_table[SYS_RMDIR] = sys_rmdir;
syscall_table[SYS_RENAME] = sys_rename;
syscall_table[SYS_CHDIR] = sys_chdir;
syscall_table[SYS_GETCWD] = sys_getcwd;
syscall_table[SYS_EXECVE] = sys_execve;
syscall_table[SYS_STAT] = sys_stat;
syscall_table[SYS_FSTAT] = sys_fstat;
syscall_table[SYS_CHMOD] = sys_chmod;
syscall_table[SYS_FCHMOD] = sys_fchmod;
syscall_table[SYS_OPENDIR] = sys_opendir;
syscall_table[SYS_CLOSEDIR] = sys_closedir;
syscall_table[SYS_READDIR] = sys_readdir;
syscall_table[SYS_REWINDDIR] = sys_rewinddir;
/* socket 套接字 */
syscall_table[SYS_SOCKET] = sys_socket;
syscall_table[SYS_BIND] = sys_bind;
syscall_table[SYS_CONNECT] = sys_connect;
syscall_table[SYS_LISTEN] = sys_listen;
syscall_table[SYS_ACCEPT] = sys_accept;
syscall_table[SYS_SEND] = sys_send;
syscall_table[SYS_RECV] = sys_recv;
syscall_table[SYS_SENDTO] = sys_sendto;
syscall_table[SYS_RECVFROM] = sys_recvfrom;
syscall_table[SYS_SHUTDOWN] = sys_shutdown;
syscall_table[SYS_GETPEERNAME] = sys_getpeername;
syscall_table[SYS_GETSOCKNAME] = sys_getsockname;
syscall_table[SYS_GETSOCKOPT] = sys_getsockopt;
syscall_table[SYS_SETSOCKOPT] = sys_setsockopt;
syscall_table[SYS_IOCTLSOCKET] = sys_ioctlsocket;
syscall_table[SYS_SELECT] = sys_select;
syscall_table[SYS_DUP] = sys_dup;
syscall_table[SYS_DUP2] = sys_dup2;
syscall_table[SYS_PIPE] = sys_pipe;
syscall_table[SYS_SHMGET] = sys_shmem_get;
syscall_table[SYS_SHMPUT] = sys_shmem_put;
syscall_table[SYS_SHMMAP] = sys_shmem_map;
syscall_table[SYS_SHMUNMAP] = sys_shmem_unmap;
syscall_table[SYS_SEMGET] = sys_sem_get;
syscall_table[SYS_SEMPUT] = sys_sem_put;
syscall_table[SYS_SEMDOWN] = sys_sem_down;
syscall_table[SYS_SEMUP] = sys_sem_up;
syscall_table[SYS_MSGGET] = sys_msgque_get;
syscall_table[SYS_MSGPUT] = sys_msgque_put;
syscall_table[SYS_MSGSEND] = sys_msgque_send;
syscall_table[SYS_MSGRECV] = sys_msgque_recv;
syscall_table[SYS_TRIGPENDING] = sys_trigger_pending;
syscall_table[SYS_TRIGPROCMASK] = sys_trigger_proc_mask;
syscall_table[SYS_XCONGET] = sys_xcon_get;
syscall_table[SYS_XCONCLEAR] = sys_xcon_clear;
syscall_table[SYS_XCONPUT] = sys_xcon_put;
}
|
NightfallDM/xbook2
|
src/kernel/interrupt.c
|
<filename>src/kernel/interrupt.c
#include <arch/interrupt.h>
#include <xbook/kmalloc.h>
#include <stddef.h>
#include <types.h>
/* var: hardware_intr_contorller must be support in arch */
extern struct hardware_intr_controller hardware_intr_contorller;
/* irq描述表，更深层次地表现中断 */
irq_description_t irq_description_table[NR_IRQS];
/**
* init_irq_description - 初始化中断描述
*/
void init_irq_description()
{
int i;
irq_description_t *irq;
for (i = 0; i < NR_IRQS; i++) {
irq = &irq_description_table[i];
irq->action = NULL;
irq->flags = 0;
irq->controller = NULL;
irq->irqname = NULL;
irq->irqname = NULL;
atomic_set(&irq->device_count, 0);
}
}
/**
* get_irq_description - 通过irq获取中断描述
* @irq: 中断号
*
* 获取中断描述表中的一项
*/
static irq_description_t *get_irq_description(unsigned long irq)
{
/* 要是在范围内才返回表中的项 */
if (0 <= irq && irq < NR_IRQS) {
return &irq_description_table[irq];
}
return NULL;
}
/**
* register_irq - 注册一个中断
* @irq: 中断号
* @handler: 中断处理函数
* @flags: 注册时的标志
* @irqname: 中断所在irq的名字
* @devname: 设备名字（如果是共享中断，用于不同的行为的名字）
* @data: 中断处理传入的数据
*
* 注册一个中断，并且打开该线
*/
int register_irq(unsigned long irq,
int (*handler)(unsigned long, unsigned long),
unsigned long flags,
char *irqname,
char *devname,
unsigned long data)
{
irq_description_t *irq_desc = get_irq_description(irq);
if (!irq_desc)
return -1;
/* 指定硬件控制器 */
irq_desc->controller = &hardware_intr_contorller;
/* 设置irq名字 */
irq_desc->irqname = irqname;
irq_desc->flags = flags;
/* 创建一个中断行为 */
irq_action_t *action = kmalloc(sizeof(irq_action_t));
if (!action)
return -1;
/* 为行为结构体赋值 */
action->data = data;
action->flags = flags;
action->handler = handler;
action->name = devname;
action->next = NULL;
/* 如果是共享中断，就添加行为 */
if (flags & IRQF_SHARED) {
/* 把新的行为插入到最后面 */
/* 指向行为头 */
irq_action_t *p = irq_desc->action;
/* 如果指针是空，说明还没有行为 */
if (p == NULL) {
/* 注册到第一个行为 */
irq_desc->action = action;
} else {
/* 如果有下一个，就指向下一个 */
while (p->next) {
p = p->next;
}
/* 现在action指向最后一个，把当前的行为追加到最后面 */
p->next = action;
}
} else {
/* 不是共享中断，就没有下一个行为 */
irq_desc->action = action;
}
/* 增加一个设备记录 */
atomic_inc(&irq_desc->device_count);
/* 执行控制器的安装和打开中断操作 */
irq_desc->controller->install(irq, handler);
irq_desc->controller->enable(irq);
return 0;
}
/**
* unregister_irq - 注销中断
* @irq: 中断号
* @data: 注销时需要的数据
*
* 注销中断，如果不是共享中断就直接关闭中断线，不然就减少中断数
* 直到中断数为0就关闭中断线
*/
int unregister_irq(unsigned long irq, void *data)
{
irq_description_t *irq_desc = get_irq_description(irq);
if (!irq_desc)
return -1;
/* 注销的时候不能产生中断 */
unsigned long flags;
save_intr(flags);
/* 删除action */
if (irq_desc->flags & IRQF_SHARED) {
/* 指向行为头 */
irq_action_t *p = irq_desc->action, *prev;
do {
prev = p;
/* 找到该设备 */
if (p->data == (unsigned long) data) {
/* 如果是第一个就找到了 */
if (p == irq_desc->action) {
irq_desc->action = irq_desc->action->next;
} else {
/* 不是的话，就把自己从链表脱去，不影响链表头 */
prev->next = p->next;
}
/* 释放action */
kfree(p);
/* 释放完毕，退出 */
break;
}
p = p->next;
} while (p);
} else {
/* 释放action */
kfree(irq_desc->action);
/* 设置为空 */
irq_desc->action = NULL;
}
atomic_dec(&irq_desc->device_count);
/* 如果没有设备在这条中断线上，就关闭该中断 */
if (!atomic_get(&irq_desc->device_count)) {
/* 执行控制器的卸载和关闭中断操作 */
irq_desc->controller->disable(irq);
irq_desc->controller->uninstall(irq);
irq_desc->controller = NULL;
irq_desc->irqname = NULL;
irq_desc->flags = 0;
}
/* 恢复之前的中断状态 */
restore_intr(flags);
return 0;
}
/**
* handle_action - 处理中断行为
* @irq: irq号
* @action: 具体要做的某一个行为
*/
static int handle_action(unsigned long irq, irq_action_t *action)
{
unsigned long retval = 0;
/* 如果有关闭中断标志。就关闭中断 */
if (action->flags & IRQF_DISABLED) {
disable_intr();
}
/* 具体的行为处理 */
retval = action->handler(irq, action->data);
/* 如果有关闭中断标志。就打开中断 */
if (action->flags & IRQF_DISABLED) {
enable_intr();
}
return retval;
}
/**
* handle_irq - 处理irq
* @irq: irq号
* @frame: 中断栈
*/
int handle_irq(unsigned long irq, trap_frame_t *frame)
{
irq_description_t *irq_desc = get_irq_description(irq);
if (!irq_desc)
return -1;
/* 获取行为并执行行为 */
irq_action_t *action = irq_desc->action;
/* 处理中断行为 */
while (action)
{
handle_action(irq, action);
/* 指向下一个行为 */
action = action->next;
}
/* 进行应答 */
if (irq_desc->controller->ack) {
irq_desc->controller->ack(irq);
}
return -1;
}
|
NightfallDM/xbook2
|
library/xlibc/stdio/remove.c
|
/*
* libc/stdio/remove.c
*/
#include <stdio.h>
#include <unistd.h>
int remove(const char * path)
{
return unlink(path);
}
|
NightfallDM/xbook2
|
library/xlibc/include/wchar.h
|
#ifndef _XLIBC_WCHAR_H
#define _XLIBC_WCHAR_H
#ifndef _WCHAR_T_DEFINED
typedef unsigned short wchar_t;
#define _WCHAR_T_DEFINED
#endif
#endif /* _XLIBC_WCHAR_H */
|
NightfallDM/xbook2
|
src/include/const.h
|
<filename>src/include/const.h
#ifndef _XBOOK_CONST_H
#define _XBOOK_CONST_H
/* 系统信息 */
#define OS_NAME "xbook2 kernel "
#define OS_VERSION "0.1.0"
#define KB 1024
#define MB (1024*KB)
#define GB (1024*MB)
#define SECTOR_SIZE 512
#define BLOCK_SIZE 1024
#endif /* _XBOOK_CONST_H */
|
NightfallDM/xbook2
|
library/xlibc/include/sys/vmm.h
|
#ifndef _SYS_VMM_H
#define _SYS_VMM_H
#include <stddef.h>
/* 物理内存信息 */
typedef struct {
unsigned long ms_total; /* 物理内存总大小 */
unsigned long ms_free; /* 物理内存空闲大小 */
unsigned long ms_used; /* 物理内存已使用大小 */
} mstate_t;
int mstate(mstate_t *ms);
/* vmm */
void *heap(void *heap);
int munmap(void *addr, size_t length);
#endif /* _SYS_VMM_H */
|
NightfallDM/xbook2
|
src/include/list.h
|
#ifndef _xBOOK_LIST_H
#define _xBOOK_LIST_H
#include <stddef.h>
/*
* 链表数据结构，在看了Linux的链表结构之后，觉得他那个比较通用，
* 而且也比较清晰，所以我打算移植一个过来。本文件里面的都是内联函数，
* 使用的时候会编译在调用的地方。并且还有很多宏定义。
*/
/*
* 链表结构体
*/
typedef struct list {
struct list *prev;
struct list *next;
} list_t;
/* 为链表结构赋值 */
#define LIST_HEAD_INIT(name) { &(name), &(name) }
/* 创建并赋值 */
#define LIST_HEAD(name) \
struct list name = LIST_HEAD_INIT(name)
/* 让链表内容指针指向自己本身 */
static inline void INIT_LIST_HEAD(struct list *list)
{
list->next = list;
list->prev = list;
}
/* 把一个新的节点new插入到prev后，next前 */
static inline void __list_add(struct list *new,
struct list *prev,
struct list *next)
{
//new和next绑定关系
next->prev = new;
new->next = next;
//new和next绑定关系
new->prev = prev;
prev->next = new;
}
/*
* list_add - 添加一个新的节点到链表头
* @new： 要新添加的节点
* @head：要添加到哪个链表头
*
* 把一个节点添加到链表头后面，相当于添加到整个链表的最前面。
*/
static inline void list_add(struct list *new, struct list *head)
{
// :) 插入到链表头和链表头的下一个节点之间
__list_add(new, head, head->next);
}
/*
* list_add_before - 把节点添加到一个节点前面
* @new： 要新添加的节点
* @head：比较的节点
*
* 把一个新节点添加到一个节点前面。旧节点的前驱需要指向新节点，
* 旧节点的前驱指向新节点，新节点的前驱指向旧节点的前驱，后驱指向旧节点。
*
*/
static inline void list_add_before(struct list *new, struct list *node)
{
node->prev->next = new;
new->prev = node->prev;
new->next = node;
node->prev = new;
}
/*
* list_add_after - 把节点添加到一个节点后面
* @new： 要新添加的节点
* @head：比较的节点
*
* 把一个新节点添加到一个节点后面。旧节点的后驱需要指向新节点，
* 旧节点的后驱指向新节点，新节点的前驱指向旧节点，后驱指向旧节点的后驱。
*
*/
static inline void list_add_after(struct list *new, struct list *node)
{
node->next->prev = new;
new->prev = node;
new->next = node->next;
node->next = new;
}
/*
* list_add_tail - 添加一个新的节点到链表尾
* @new： 要新添加的节点
* @head：要添加到哪个链表头
*
* 把一个节点添加到链表头前面，相当于添加到整个链表的最后面。
*/
static inline void list_add_tail(struct list *new, struct list *head)
{
// :) 插入到链表头前一个和链表头之间
__list_add(new, head->prev, head);
}
/* 把一个节点从链表中删除 */
static inline void __list_del(struct list *prev, struct list *next)
{
// ^_^ 把前一个和下一个进行关联，那中间一个就被删去了
next->prev = prev;
prev->next = next;
}
/* 把一个节点从链表中删除 */
static inline void __list_del_node(struct list *node)
{
// 传入节点的前一个和后一个，执行后只是脱离链表，而自身还保留了节点信息
__list_del(node->prev, node->next);
}
/*
* list_del - 把节点从链表中删除
* @node：要删除的节点
*
* 把一个已经存在于链表中的节点删除
*/
static inline void list_del(struct list *node)
{
__list_del_node(node);
// @.@ 把前驱指针和后驱指针都指向空，完全脱离
node->prev = NULL;
node->next = NULL;
}
/*
* list_del_init - 把节点从链表中删除
* @node：要删除的节点
*
* 把一个已经存在于链表中的节点删除
*/
static inline void list_del_init(struct list *node)
{
__list_del_node(node);
//初始化节点，使得可以成为链表头，我猜的。:-)
INIT_LIST_HEAD(node);
}
/*
* list_replace - 用新的节点替代旧的节点
* @old：旧的节点
* @new：要插入的新节点
*
* 用一个节点替代已经存在于链表中的节点
*/
static inline void list_replace(struct list *old, struct list *new)
{
/*
@.@ 把old的前后指针都指向new，那么new就替代了old，真可恶！
不过，旧的节点中还保留了链表的信息
*/
new->next = old->next;
new->next->prev = new;
new->prev = old->prev;
new->prev->next = new;
}
static inline void list_replace_init(struct list *old, struct list *new)
{
/*
先把old取代，然后把old节点初始化，使它完全脱离链表。
*/
list_replace(old, new);
INIT_LIST_HEAD(old);
}
/*
* list_move - 从一个链表删除，然后移动到另外一个链表头后面
* @node：要操作的节点
* @head：新的链表头
*/
static inline void list_move(struct list *node, struct list *head)
{
// ^.^ 先把自己脱离关系，然后添加到新的链表
__list_del_node(node);
list_add(node, head);
}
/*
* list_move_tail - 从一个链表删除，然后移动到另外一个链表头前面
* @node：要操作的节点
* @head：新的链表头
*/
static inline void list_move_tail(struct list *node, struct list *head)
{
// ^.^ 先把自己脱离关系，然后添加到新的链表
__list_del_node(node);
list_add_tail(node, head);
}
/*
* list_is_first - 检测节点是否是链表中的第一个节点
* @node：要检测的节点
* @head：链表头
*/
static inline int list_is_first(const struct list *node,
const struct list *head)
{
return (node->prev == head); //节点的前一个是否为链表头
}
/*
* list_is_last - 检测节点是否是链表中的最后一个节点
* @node：要检测的节点
* @head：链表头
*/
static inline int list_is_last(const struct list *node,
const struct list *head)
{
return (node->next == head); //节点的后一个是否为链表头
}
/*
* list_empty - 测试链表是否为空链表
* @head：链表头
*
* 把链表头传进去，通过链表头来判断
*/
static inline int list_empty(const struct list *head)
{
return (head->next == head); //链表头的下一个是否为自己
}
/* ！！！！前方！！！！高能！！！！ */
/*
* list_owner - 获取节点的宿主
* @ptr： 节点的指针
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*/
#define list_owner(ptr, type, member) container_of(ptr, type, member)
/* 嘻嘻，就这样就把container_of用上了 */
/*
* list_first_owner - 获取链表中的第一个宿主
* @head： 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：链表不能为空
*/
#define list_first_owner(head, type, member) \
list_owner((head)->next, type, member)
/*
* list_last_owner - 获取链表中的最后一个宿主
* @head: 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：链表不能为空
*/
#define list_last_owner(head, type, member) \
list_owner((head)->prev, type, member)
/*
* list_first_owner_or_null - 获取链表中的第一个宿主
* @head： 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：如果链表是空就返回NULL
*/
#define list_first_owner_or_null(head, type, member) ({ \
struct list *__head = (head); \
struct list *__pos = (__head->next); \
__pos != __head ? list_owner(__pos, type, member) : NULL; \
})
/*
* list_last_owner_or_null - 获取链表中的最后一个宿主
* @head： 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：如果链表是空就返回NULL
*/
#define list_last_owner_or_null(head, type, member) ({ \
struct list *__head = (head); \
struct list *__pos = (__head->prev); \
__pos != __head ? list_owner(__pos, type, member) : NULL; \
})
/*
* list_next_owner - 获取链表中的下一个宿主
* @pos： 临时宿主的指针
* @member: 节点在宿主结构体中的名字
*/
#define list_next_owner(pos, member) \
list_owner((pos)->member.next, typeof(*(pos)), member)
/*
* list_prev_onwer - 获取链表中的前一个宿主
* @pos： 临时宿主的指针
* @member: 节点在宿主结构体中的名字
*/
#define list_prev_onwer(pos, member) \
list_owner((pos)->member.prev, typeof(*(pos)), member)
/* 把代码自己打一遍，好累啊！但是感觉这些东西也更加明白了 */
/* 记住啦，这是遍历链表节点，不是宿主 -->>*/
/*
* list_for_each - 从前往后遍历每一个链表节点
* @pos： 节点指针
* @head: 链表头
*/
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/*
* list_find - 从前往后遍历查找链表节点
* @list: 要查找的节点指针
* @head: 链表头
*
* 找到返回1，否则返回0
*/
static inline int list_find(struct list *list, struct list *head)
{
struct list *node;
list_for_each(node, head) {
// 找到一样的
if (node == list) {
return 1;
}
}
return 0;
}
/*
* list_length - 获取链表长度
* @head: 链表头
*/
static inline int list_length(struct list *head)
{
struct list *list;
int n = 0;
list_for_each(list, head) {
// 找到一样的
if (list == head)
break;
n++;
}
return n;
}
/*
* list_for_each_prev - 从后往前遍历每一个链表节点
* @pos： 节点指针
* @head: 链表头
*/
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
/*
* list_for_each_safe - 从前往后遍历每一个链表节点
* @pos: 节点指针
* @_next: 临时节点指针（为了避免和pos->next混淆，在前面加_）
* @head: 链表头
*
* 用next来保存下一个节点指针，如果在遍历过程中pos出的节点被删除了，
* 还是可以继续往后面遍历其它节点。
*/
#define list_for_each_safe(pos, _next, head) \
for (pos = (head)->next, _next = pos->next; pos != (head); \
pos = _next, _next = pos->next)
/*
* list_for_each_prev_safe - 从后往前遍历每一个链表节点
* @pos: 节点指针
* @_prev: 临时节点指针（为了避免和pos->prev混淆，在前面加_）
* @head: 链表头
*
* 用prev来保存前一个节点指针，如果在遍历过程中pos出的节点被删除了，
* 还是可以继续往前面遍历其它节点。
*/
#define list_for_each_prev_safe(pos, _prev, head) \
for (pos = (head)->prev, _prev = pos->prev; pos != (head); \
pos = _prev, _prev = pos->prev)
/* <<-- 遍历链表节点结束了，接下来开始的是遍历宿主 -->> */
/*
* list_for_each_owner - 从前往后遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @head: 链表头
* @member: 节点在宿主中的名字
*/
#define list_for_each_owner(pos, head, member) \
for (pos = list_first_owner(head, typeof(*pos), member); \
&pos->member != (head); \
pos = list_next_owner(pos, member))
/*
* list_for_each_owner_reverse - 从后往前遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @head: 链表头
* @member: 节点在宿主中的名字
*/
#define list_for_each_owner_reverse(pos, head, member) \
for (pos = list_last_owner(head, typeof(*pos), member); \
&pos->member != (head); \
pos = list_prev_onwer(pos, member))
/*
* list_for_each_owner_safe - 从前往后遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @next: 临时指向下一个节点的指针
* @head: 链表头
* @member: 节点在宿主中的名字
*
* 可以保证在遍历过程中如果
*/
#define list_for_each_owner_safe(pos, next, head, member) \
for (pos = list_first_owner(head, typeof(*pos), member), \
next = list_next_owner(pos, member); \
&pos->member != (head); \
pos = next, next = list_next_owner(next, member))
/*
* list_for_each_owner_reverse_safe - 从后往前遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @_prev: 临时指向前一个节点的指针
* @head: 链表头
* @member: 节点在宿主中的名字
*
* 可以保证在遍历过程中如果
*/
#define list_for_each_owner_reverse_safe(pos, prev, head, member) \
for (pos = list_last_owner(head, typeof(*pos), member), \
prev = list_prev_onwer(pos, member); \
&pos->member != (head); \
pos = prev, prev = list_prev_onwer(prev, member))
/* <<-- 遍历链表宿主也结束了，very nice 啊！ */
#endif /* _xBOOK_LIST_H */
|
NightfallDM/xbook2
|
src/lib/fifoio.c
|
#include <xbook/fifoio.h>
#include <assert.h>
#include <math.h>
#include <string.h>
/**
* fifo_io_init - io队列的初始化
* @fifo: io队列
*/
int fifo_io_init(fifo_io_t *fifo,
unsigned char *buffer, unsigned int size)
{
/* 大小必须是2的n次幂 */
if (!is_power_of_2(size))
return -1;
fifo->buffer = buffer;
/* 数据区以字节为单位的长度 */
fifo->size = size;
memset(fifo->buffer, 0, size);
/* 把头指针和尾指针都指向buf */
fifo->head = fifo->tail = fifo->buffer;
/* 空信号量数和缓冲区一样长 */
semaphore_init(&fifo->empty, size);
semaphore_init(&fifo->full, 0);
mutexlock_init(&fifo->mutex);
return 0;
}
/**
* fifo_io_alloc - 动态创建一个io队列
*/
fifo_io_t *fifo_io_alloc(unsigned int size)
{
unsigned char *buffer;
fifo_io_t *fifo;
/* 如果size不是2的n次幂，就调整为2的n次幂 */
if (!is_power_of_2(size)) {
ASSERT(size < 0x80000000);
size = roundup_pow_of_two(size);
}
buffer = kmalloc(size);
if (buffer == NULL)
return NULL;
fifo = kmalloc(sizeof(fifo_io_t));
if (fifo == NULL) {
kfree(buffer);
return NULL;
}
fifo_io_init(fifo, buffer, size);
if (fifo == NULL) {
kfree(buffer);
kfree(fifo);
}
return fifo;
}
void fifo_io_free(fifo_io_t *fifo)
{
kfree(fifo->buffer);
kfree(fifo);
}
/**
* fifo_io_put - 往io队列中放入一个数据
* @fifo: io队列
* @data: 数据
*/
void fifo_io_put(fifo_io_t *fifo, unsigned char data)
{
semaphore_down(&fifo->empty); /* 获取空信号，表示要存放数据 */
mutex_lock(&fifo->mutex); /* 互斥锁上锁，保护数据存放 */
/* 放入一个数据 */
*fifo->head++ = data;
if(fifo->head >= fifo->buffer + fifo->size) /* 修复越界 */
fifo->head = fifo->buffer;
mutex_unlock(&fifo->mutex); /* 互斥锁解锁 */
semaphore_up(&fifo->full); /* 释放满信号，表示有1个数据可以获取 */
}
/**
* fifo_io_get - 从io队列中获取一个数据
* @fifo: io队列
*/
unsigned char fifo_io_get(fifo_io_t *fifo)
{
semaphore_down(&fifo->full); /* 获取满信号，表示要获取一个数据 */
mutex_lock(&fifo->mutex); /* 互斥锁上锁，保护数据获取 */
/* 获取一个数据 */
unsigned char data = *fifo->tail++;
if(fifo->tail >= fifo->buffer + fifo->size) /* 如果到达了最后面，就跳到最前面，形成一个环 */
fifo->tail = fifo->buffer;
mutex_unlock(&fifo->mutex); /* 互斥锁解锁 */
semaphore_up(&fifo->empty); /* 释放空信号，表示腾出一个数据 */
return data;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/memory.h
|
#ifndef _X86_MEMORY_H
#define _X86_MEMORY_H
#define flush_tlb_one(addr) \
__asm__ __volatile__ ("invlpg (%0) \n\t"::"r"(addr):"memory")
/*
*/
#define flush_tlb() \
do \
{ \
unsigned long tmpreg; \
__asm__ __volatile__ ( \
"movl %%cr3, %0 \n\t" \
"movl %0, %%cr3 \n\t" \
:"=r"(tmpreg) \
: \
:"memory" \
); \
}while(0)
#endif /* _X86_MEMORY_H */
|
NightfallDM/xbook2
|
src/lib/fifobuf.c
|
#include <xbook/fifobuf.h>
#include <xbook/kmalloc.h>
#include <math.h>
#include <assert.h>
#include <string.h>
void fifo_buf_init(fifo_buf_t *fifo, unsigned char *buffer,
unsigned int size)
{
/* 大小必须是2的n次幂 */
if (!is_power_of_2(size))
return;
fifo->buffer = buffer;
fifo->size = size;
fifo->in = fifo->out = 0;
spinlock_init(&fifo->lock);
}
fifo_buf_t *fifo_buf_alloc(unsigned int size)
{
unsigned char *buffer;
fifo_buf_t *fifo;
/* 如果size不是2的n次幂，就调整为2的n次幂 */
if (!is_power_of_2(size)) {
ASSERT(size < 0x80000000);
size = roundup_pow_of_two(size);
}
buffer = kmalloc(size);
if (buffer == NULL)
return NULL;
fifo = kmalloc(sizeof(fifo_buf_t));
if (fifo == NULL) {
kfree(buffer);
return NULL;
}
fifo_buf_init(fifo, buffer, size);
if (fifo == NULL) {
kfree(buffer);
kfree(fifo);
}
return fifo;
}
void fifo_buf_free(fifo_buf_t *fifo)
{
kfree(fifo->buffer);
kfree(fifo);
}
unsigned int __fifo_buf_put(fifo_buf_t *fifo,
const unsigned char *buffer, unsigned int len)
{
unsigned int l;
/* buffer中空的长度 */
len = MIN(len, fifo->size - fifo->in + fifo->out);
/*
* Ensure that we sample the fifo->out index -before- we
* start putting bytes into the kfifo.
*/
mb();
/* first put the data starting from fifo->in to buffer end */
l = MIN(len, fifo->size - (fifo->in & (fifo->size - 1)));
memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);
/* then put the rest (if any) at the beginning of the buffer */
memcpy(fifo->buffer, buffer + l, len - l);
/*
* Ensure that we add the bytes to the kfifo -before-
* we update the fifo->in index.
*/
wmb();
fifo->in += len; //每次累加，到达最大值后溢出，自动转为0
return len;
}
unsigned int __fifo_buf_get(fifo_buf_t *fifo,
const unsigned char *buffer, unsigned int len)
{
unsigned int l;
/* 有数据的缓冲区的长度 */
len = MIN(len, fifo->in - fifo->out);
/*
* Ensure that we sample the fifo->in index -before- we
* start removing bytes from the kfifo.
*/
rmb();
/* first get the data from fifo->out until the end of the buffer */
l = MIN(len, fifo->size - (fifo->out & (fifo->size - 1)));
memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
/* then get the rest (if any) from the beginning of the buffer */
memcpy(buffer + l, fifo->buffer, len - l);
/*
* Ensure that we remove the bytes from the kfifo -before-
* we update the fifo->out index.
*/
mb();
fifo->out += len; //每次累加，到达最大值后溢出，自动转为0
return len;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/config.h
|
<reponame>NightfallDM/xbook2
#ifndef _X86_CONFIG_H
#define _X86_CONFIG_H
/*
debug methods：
1 -> in text mode, in os.
2 -> serial send to host machine console
*/
#define CONFIG_DEBUG_METHOD 2
/* 把控制台的信息同时输出到串口，用于调试 */
#define CONFIG_CONS_TO_SERIAL 1
#endif /* _X86_CONFIG_H */
|
NightfallDM/xbook2
|
library/xlibc/stdlib/stream.c
|
#include <stdlib.h>
int fflush(void *file)
{
return 0;
}
|
NightfallDM/xbook2
|
src/include/gui/keyboard.h
|
#ifndef __GUISRV_DRIVER_KEYBOARD_H__
#define __GUISRV_DRIVER_KEYBOARD_H__
#define GUI_KMOD_SHIFT_L 0x01
#define GUI_KMOD_SHIFT_R 0x02
#define GUI_KMOD_SHIFT (GUI_KMOD_SHIFT_L | GUI_KMOD_SHIFT_R)
#define GUI_KMOD_CTRL_L 0x04
#define GUI_KMOD_CTRL_R 0x08
#define GUI_KMOD_CTRL (GUI_KMOD_CTRL_L | GUI_KMOD_CTRL_R)
#define GUI_KMOD_ALT_L 0x10
#define GUI_KMOD_ALT_R 0x20
#define GUI_KMOD_ALT (GUI_KMOD_ALT_L | GUI_KMOD_ALT_R)
#define GUI_KMOD_PAD 0x40
#define GUI_KMOD_NUM 0x80
#define GUI_KMOD_CAPS 0x100
/* 图形键盘输入 */
typedef struct _keyevent {
unsigned char state; /* 按钮状态 */
int code; /* 键值 */
int modify; /* 修饰按键 */
} keyevent_t;
typedef struct _gui_keyboard {
int (*open)(void);
int (*close)(void);
int (*read)(void);
int ledstate; /* 修饰按键 */
int key_modify; /* 修饰按键 */
keyevent_t keyevent; /* 按键事件 */
} gui_keyboard_t;
extern gui_keyboard_t gui_keyboard;
int gui_init_keyboard();
#endif /* __GUISRV_DRIVER_KEYBOARD_H__ */
|
NightfallDM/xbook2
|
src/kernel/rawblock.c
|
#include <xbook/rawblock.h>
#include <string.h>
#include <math.h>
#include <xbook/debug.h>
#include <xbook/driver.h>
#include <xbook/kmalloc.h>
#define DEBUG_LOCAL 0
LIST_HEAD(raw_block_list);
raw_block_t *raw_block_alloc(handle_t handle, char *name)
{
raw_block_t *block = kmalloc(sizeof(raw_block_t));
if (block == NULL)
return NULL;
block->handle = handle;
memset(block->name, 0, RAW_BLOCK_NAME_LEN);
strcpy(block->name, name);
block->offset = 0;
block->count = 0;
block->vaddr = NULL;
block->memsz = 0;
block->pos = 0;
return block;
}
void raw_block_free(raw_block_t *block)
{
list_del_init(&block->list);
kfree(block);
}
int raw_block_init(raw_block_t *block, unsigned long off, unsigned long count,
unsigned long memsz)
{
block->offset = off;
block->count = count;
block->memsz = memsz;
block->pos = 0;
block->vaddr = kmalloc(block->memsz);
if (block->vaddr == NULL)
return -1;
list_add_tail(&block->list, &raw_block_list);
return 0;
}
/**
* raw_block_tmp_add - 添加一个临时原始块
*
* @buf: 数据缓冲区
* @size: 数据大小
*
* 一般用于proc_exec_file中
*
*/
int raw_block_tmp_add(raw_block_t *block, unsigned char *buf, unsigned long size)
{
block->offset = 0;
block->count = 0;
block->memsz = size;
block->pos = 0;
block->vaddr = NULL;
/* 根据缓冲区大小创建一个新的缓冲区，并把数据复制进去 */
if (block->memsz <= MAX_MEM_CACHE_SIZE) { /* 分配一个小块内存 */
block->vaddr = kmalloc(block->memsz);
} else { /* 添加一个新的高速缓存 */
printk(KERN_NOTICE "raw_block_tmp_add: need a large buffer!\n");
return -1;
}
if (block->vaddr == NULL)
return -1;
/* 复制数据 */
memcpy(block->vaddr, buf, size);
return 0;
}
void raw_block_tmp_del(raw_block_t *block)
{
if (block->memsz <= MAX_MEM_CACHE_SIZE) {
kfree(block->vaddr);
} else {
printk(KERN_NOTICE "raw_block_tmp_del: free a large buffer!\n");
}
}
raw_block_t *raw_block_get_by_name(char *name)
{
raw_block_t *rb;
list_for_each_owner (rb, &raw_block_list, list) {
if (!strcmp(rb->name, name))
return rb;
}
return NULL;
}
/* 从磁盘上传到内存 */
int raw_block_upload(raw_block_t *block)
{
int count = block->count;
long off = block->offset;
/* 小于1个块 */
if (count < RB_BLOCK_NR) {
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "raw_block_upload: buf=%x off=%d count=%d\n", block->vaddr, off, count);
#endif
if (device_read(block->handle, block->vaddr, count * SECTOR_SIZE, off) < 0)
return -1;
} else {
/* 处理小于DATA_BLOCK个块 */
int chunk = count & 0xff; /* 取256以下的数据数量 */
unsigned char *p = block->vaddr;
while (count > 0) {
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "raw_block_upload: buf=%x off=%d count=%d\n", p, off, chunk);
#endif
if (device_read(block->handle, p, chunk * SECTOR_SIZE, off) < 0)
return -1;
off += chunk;
count -= chunk;
p += chunk * SECTOR_SIZE;
/* 每次处理BLOCK个 */
chunk = RB_BLOCK_NR;
}
}
return 0;
}
/* 从内存下载到磁盘 */
int raw_block_download(raw_block_t *block)
{
int count = block->count;
long off = block->offset;
/* 小于1个块 */
if (count < RB_BLOCK_NR) {
if (device_write(block->handle, block->vaddr, count * SECTOR_SIZE, off) < 0)
return -1;
} else {
/* 处理小于DATA_BLOCK个块 */
int chunk = count & 0xff; /* 取256以下的数据数量 */
unsigned char *p = block->vaddr;
while (count > 0) {
if (device_write(block->handle, p, chunk * SECTOR_SIZE, off) < 0)
return -1;
off += chunk;
count -= chunk;
p += chunk * SECTOR_SIZE;
/* 每次处理BLOCK个 */
chunk = RB_BLOCK_NR;
}
}
return 0;
}
void raw_block_seek(raw_block_t *block, unsigned long pos, unsigned char seek)
{
switch (seek)
{
case RB_SEEK_SET:
block->pos = pos;
break;
case RB_SEEK_CUR:
block->pos += pos;
break;
case RB_SEEK_END:
block->pos = block->count + pos;
break;
default:
break;
}
if (block->pos < 0)
block->pos = 0;
if (block->pos >= block->memsz)
block->pos = block->memsz - 1;
}
/* 成功返回读取的字节数，失败返回0 */
long raw_block_read(raw_block_t *block, void *buffer, unsigned long size)
{
if (block->pos >= block->memsz)
return 0;
unsigned char *buf = (unsigned char *)buffer;
unsigned char *p = block->vaddr + block->pos;
unsigned long len = MIN(size, block->memsz - block->pos);
memcpy(buf, p, len);
block->pos += size;
return len; /* return read byte */
}
/* 成功返回写入的字节数，失败返回0 */
long raw_block_write(raw_block_t *block, void *buffer, unsigned long size)
{
if (block->pos >= block->memsz)
return 0;
unsigned char *buf = (unsigned char *)buffer;
unsigned char *p = block->vaddr + block->pos;
unsigned long len = MIN(size, block->memsz - block->pos);
memcpy(p, buf, len);
block->pos += size;
return len; /* return read byte */
}
/**
* raw_block_read_off - 从某个偏移位置读取数据
* @rb: 原始块
* @buffer: 读取到的buffer
* @offset: 偏移
* @size: 要读取的数据数量
*/
int raw_block_read_off(raw_block_t *rb, void *buffer, unsigned long offset, unsigned long size)
{
raw_block_seek(rb, offset, RB_SEEK_SET);
if (!raw_block_read(rb, buffer, size)) {
printk(KERN_ERR "raw_block_read_off: read %d failed!\n", size);
return -1;
}
return 0;
}
/**
* raw_block_write_off - 往某个偏移位置写入数据
* @rb: 原始块
* @buffer: 读取到的buffer
* @offset: 偏移
* @size: 要读取的数据数量
*/
int raw_block_write_off(raw_block_t *rb, void *buffer, unsigned long offset, unsigned long size)
{
raw_block_seek(rb, offset, RB_SEEK_SET);
if (!raw_block_write(rb, buffer, size)) {
printk(KERN_ERR "raw_block_write_off: write %d failed!\n", size);
return -1;
}
return 0;
}
#define FILESRV_FILE_VADDR 0x80050000
/* 构建文件服务块 */
raw_block_t filesrv_rawblock;
void init_raw_block()
{
filesrv_rawblock.handle = -1; /* no handle */
filesrv_rawblock.offset = 0; /* no disk off */
filesrv_rawblock.count = 512; /* 512 sector, 256 kb */
filesrv_rawblock.vaddr = (unsigned char *) FILESRV_FILE_VADDR; /* 512 sector, 256 kb */
filesrv_rawblock.memsz = filesrv_rawblock.count * SECTOR_SIZE; /* 512 sector, 256 kb */
filesrv_rawblock.pos = 0; /* 512 sector, 256 kb */
memset(filesrv_rawblock.name, 0, RAW_BLOCK_NAME_LEN);
strcpy(filesrv_rawblock.name, RB_USERSRV);
list_add_tail(&filesrv_rawblock.list, &raw_block_list);
}
|
NightfallDM/xbook2
|
library/xlibc/include/srv/guisrv.h
|
<filename>library/xlibc/include/srv/guisrv.h
#ifndef _SRV_GUI_SRV_H
#define _SRV_GUI_SRV_H
/* gui server call */
#if 0
enum guisrv_call_num {
GUISRV_OPEN_DISPLAY = 0,
GUISRV_CLOSE_DISPLAY,
GUISRV_CREATE_WIN,
GUISRV_DESTROY_WIN,
GUISRV_MAP_WIN,
GUISRV_UNMAP_WIN,
GUISRV_SET_WMNAME,
GUISRV_SET_WMICONNAME,
GUISRV_SET_WMICON,
GUISRV_SELECT_INPUT,
GUISRV_CALL_NR, /* 最大数量 */
};
#endif
enum guisrv_call_num {
GUISRV_CONNECT = 0,
GUISRV_CLOSE,
GUISRV_CLEAR,
GUISRV_CALL_NR, /* 最大数量 */
};
#endif /* _SRV_GUI_SRV_H */
|
NightfallDM/xbook2
|
library/xlibc/unistd/dir.c
|
<reponame>NightfallDM/xbook2<filename>library/xlibc/unistd/dir.c
#include <unistd.h>
#include <types.h>
#include <stddef.h>
#include <string.h>
#include <math.h>
#include <dirent.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <sys/srvcall.h>
#include <srv/filesrv.h>
#include <sys/dir.h>
#include <sys/syscall.h>
/* 任务可以打开的目录数量 */
#define _MAX_DIRDES_NR 32
struct _dirdes __dirdes_table[_MAX_DIRDES_NR] = {{0, -1}, };
/* 将最上层路径名称解析出来 */
/**
* __parse_path_afterward - 朝后解析路径
* @path: 路径名
* @name: 储存名字的地址
*
* 成功返回解析到的位置，失败返回NULL
*/
char *__parse_path_afterward(char *path, char *name)
{
if (path[0] == '/') { // 根目录不需要单独解析
/* 路径中出现1个或多个连续的字符'/',将这些'/'跳过,如"///a/b" */
while(*(++path) == '/');
}
/* 开始一般的路径解析 */
while (*path != '/' && *path != 0) {
*name++ = *path++;
}
if (path[0] == 0) { // 若路径字符串为空则返回NULL
return NULL;
}
return path;
}
/**
* __wash_path - 对路径进行清洗
* @old_path: 旧的路径
* @new_path: 新的路径
*
* 转换路径中的.和..，使路径没有这些，并且是一个正确的路径
* 转换后的路径存放到new_path中
*/
void __wash_path(char *old_path, char *new_path)
{
assert(old_path[0] == '/');
char name[MAX_PATH_LEN] = {0};
char* sub_path = old_path;
sub_path = __parse_path_afterward(sub_path, name);
if (name[0] == 0) { // 若只有"/",直接将"/"存入new_path后返回
new_path[0] = '/';
new_path[1] = 0;
return;
}
new_path[0] = 0; // 避免传给new_path的缓冲区不干净
strcat(new_path, "/");
while (name[0]) {
/* 如果是上一级目录“..” */
if (!strcmp("..", name)) {
char* slash_ptr = strrchr(new_path, '/');
/*如果未到new_path中的顶层目录,就将最右边的'/'替换为0,
这样便去除了new_path中最后一层路径,相当于到了上一级目录 */
if (slash_ptr != new_path) { // 如new_path为“/a/b”,".."之后则变为“/a”
*slash_ptr = 0;
} else { // 如new_path为"/a",".."之后则变为"/"
/* 若new_path中只有1个'/',即表示已经到了顶层目录,
就将下一个字符置为结束符0. */
*(slash_ptr + 1) = 0;
}
} else if (strcmp(".", name)) { // 如果路径不是‘.’,就将name拼接到new_path
if (strcmp(new_path, "/")) { // 如果new_path不是"/",就拼接一个"/",此处的判断是为了避免路径开头变成这样"//"
strcat(new_path, "/");
}
strcat(new_path, name);
} // 若name为当前目录".",无须处理new_path
/* 继续遍历下一层路径 */
memset(name, 0, MAX_PATH_LEN);
if (sub_path) {
sub_path = __parse_path_afterward(sub_path, name);
}
}
}
/**
* __make_abs_path - 根据路径名生成绝对路径
* @path: 路径名
* @abspath: 绝对路径存放的地址
*
* 有可能路径名是相对路径，所以需要进行路径合并处理
*/
void __make_abs_path(const char *path, char *abspath)
{
/*
判断是否有磁盘符，如果有，就说明是绝对路径，不然就是相对路径。
如果是相对路径，那么就需要读取当前的工作目录
*/
if (*path != '/') { /* 不是'/'，表明不是绝对路径 */
/* 获取当前工作目录 */
if (!getcwd(abspath, MAX_PATH)) {
//printf("cwd:%s\n", abspath);
/* 检测当前工作目录是否是合格的目录
必须要有一个'/'，表明是根目录 */
char *p = strchr(abspath, '/');
if (p != NULL) { /* 找到一个'/' */
if (!((p[0] == '/') && (p[1] == 0))) { /* 在'/'后面还有内容 */
strcat(abspath, "/");
}
}
//printf("getcwd done!\n");
}
}
/* 想要直接进入根目录'/' */
if (path[0] == '/' && path[1] == '\0') {
//printf("will into root dir!\n");
abspath[0] = '/';
abspath[1] = '\0';
} else {
/* 不是进入根目录。如果是相对路径，就会和工作路径拼合，
不是的话就是绝对路径。
*/
strcat(abspath, path);
/* 没有'/'，那么就需要在这个后面添加一个'/' */
if (strchr(abspath, '/') == NULL) {
printf("path %s only drive, add a '/'.\n", path);
strcat(abspath, "/");
}
}
}
/**
* build_path - 构建完整的目录
* @path: 输入路径
* @out_path: 输出路径
*
* 把传入的一个路径经过转换后，获取一个完整的路径
*
*/
void build_path(const char *path, char *out_path)
{
/* 生成绝对路径测试 */
char abs_path[MAX_PATH] = {0};
__make_abs_path(path, abs_path);
/* 移动到第一个'/'处，也就是根目录处 */
char *p = strchr(abs_path, '/');
__wash_path(p, out_path);
}
int chdir(const char *path)
{
const char *p;
/* is root dir, do nothing */
if (!(*path == '/' && *(path+1) == '\0')) {
char full_path[MAX_PATH] = {0};
build_path(path, full_path);
p = (const char *) full_path;
} else {
p = path;
}
return syscall1(int, SYS_CHDIR, p);
}
int getcwd(char *buf, int bufsz)
{
return syscall2(int, SYS_GETCWD, buf, bufsz);
}
static struct _dirdes *__alloc_dirdes()
{
int i;
for (i = 0; i < _MAX_DIRDES_NR; i++) {
if (__dirdes_table[i].flags == 0) {
__dirdes_table[i].flags = 1;
__dirdes_table[i].diridx = -1;
return &__dirdes_table[i];
}
}
return NULL;
}
static void __free_dirdes(struct _dirdes *_dir)
{
_dir->flags = 0;
_dir->diridx = -1;
}
DIR *opendir(const char *path)
{
if (path == NULL)
return NULL;
char full_path[MAX_PATH] = {0};
build_path(path, full_path);
char *p = (char *) full_path;
/* 文件描述符地址 */
struct _dirdes *_dir = __alloc_dirdes();
if (_dir == NULL) {
printf("alloc dirdes failed!\n");
return NULL;
}
dir_t diridx = syscall1(int, SYS_OPENDIR, p);
if (diridx < 0) {
__free_dirdes(_dir);
return NULL;
}
_dir->diridx = diridx;
return _dir;
}
int closedir(DIR *dir)
{
if (dir < __dirdes_table || dir >= __dirdes_table + _MAX_DIRDES_NR)
return -1;
if (dir->flags == 0)
return -1;
if (syscall1(int, SYS_CLOSEDIR, dir->diridx) < 0)
return -1;
__free_dirdes(dir);
return -1;
}
static struct dirent __dirent_buf;
struct dirent *readdir(DIR *dir)
{
if (dir < __dirdes_table || dir >= __dirdes_table + _MAX_DIRDES_NR)
return NULL;
if (dir->flags == 0)
return NULL;
memset(&__dirent_buf, 0, sizeof(struct dirent));
if (syscall2(int, SYS_READDIR, dir->diridx, &__dirent_buf) < 0)
return NULL;
return &__dirent_buf;
}
int rewinddir(DIR *dir)
{
if (dir < __dirdes_table || dir >= __dirdes_table + _MAX_DIRDES_NR)
return -1;
if (dir->flags == 0)
return -1;
return syscall1(int, SYS_REWINDDIR, dir->diridx);
}
int mkdir(const char *path, mode_t mode)
{
if (path == NULL)
return -1;
char full_path[MAX_PATH] = {0};
build_path(path, full_path);
const char *p = (const char *) full_path;
return syscall2(int, SYS_MKDIR, p, mode);
}
int rmdir(const char *path)
{
if (path == NULL)
return -1;
char full_path[MAX_PATH] = {0};
build_path(path, full_path);
const char *p = (const char *) full_path;
return syscall1(int, SYS_RMDIR, p);
}
int _rename(const char *source, const char *target)
{
if (source == NULL || target == NULL)
return -1;
char full_path0[MAX_PATH] = {0};
build_path(source, full_path0);
char full_path1[MAX_PATH] = {0};
build_path(target, full_path1);
const char *src = (const char *) full_path0;
const char *dest = (const char *) full_path1;
return syscall2(int, SYS_RENAME, src, dest);
}
|
NightfallDM/xbook2
|
src/include/xbook/vmarea.h
|
#ifndef _XBOOK_VMAREA_H
#define _XBOOK_VMAREA_H
#include <stddef.h>
#include <list.h>
#include <types.h>
#include <arch/page.h>
#include <arch/pmem.h>
#define VMAREA_BASE __VMAREA_BASE
#define VMAREA_END __VMAREA_END
/* 虚拟区域结构体 */
typedef struct vmarea {
unsigned long addr;
unsigned long size;
list_t list;
} vmarea_t;
void *vmalloc(size_t size);
int vfree(void *ptr);
unsigned long alloc_vaddr(size_t size);
unsigned long free_vaddr(unsigned long vaddr, size_t size);
void *ioremap(unsigned long paddr, size_t size);
int iounmap(void *vaddr);
void init_vmarea();
#endif /* _XBOOK_VMAREA_H */
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/ioremap.c
|
#include <xbook/debug.h>
#include <arch/page.h>
#include <arch/ioremap.h>
int __ioremap(unsigned long paddr, unsigned long vaddr, size_t size)
{
unsigned long end = vaddr + size;
while (vaddr < end) {
/* 添加页面 */
__page_link(vaddr, paddr, PG_RW_W | PG_US_S);
vaddr += PAGE_SIZE;
paddr += PAGE_SIZE;
}
return 0;
}
int __iounmap(unsigned long addr, size_t size)
{
unsigned long end = addr + size;
/* 取消虚拟地址的内存映射 */
while (addr < end) {
__page_unlink(addr);
addr += PAGE_SIZE;
}
return 0;
}
|
NightfallDM/xbook2
|
src/task/pthread.c
|
#include <xbook/task.h>
#include <xbook/schedule.h>
#include <xbook/process.h>
#include <xbook/pthread.h>
#include <arch/interrupt.h>
#include <arch/task.h>
#define DEBUG_LOCAL 0
/* 用户线程 */
void pthread_desc_init(pthread_desc_t *pthread)
{
if (pthread != NULL) {
/* 最开始只有一个主线程（当前进程） */
atomic_set(&pthread->thread_count, 1);
}
}
void pthread_desc_exit(pthread_desc_t *pthread)
{
if (pthread != NULL)
kfree(pthread);
}
/**
* pthread_entry - 用户线程内核的入口
* @arg: 参数
*
* 通过这个入口，可以跳转到用户态运行。
*
*/
void pthread_entry(void *arg)
{
trap_frame_t *frame = GET_TASK_TRAP_FRAME(current_task);
switch_to_user(frame);
}
/**
* thread_release_resource - 释放线程资源
* @task: 任务
*
* 线程资源比较少，主要是任务结构体（需要交给父进程处理），
* 自己要处理的很少很少。。。
*
* @return: 释放成功返回0，释放失败返回-1
*/
int thread_release_resource(task_t *task)
{
/* 取消定时器 */
timer_cancel(task->sleep_timer);
task->sleep_timer = NULL;
return 0;
}
/**
* wait_one_hangging_thread - 处理一个挂起线程
*
*/
int wait_one_hangging_thread(task_t *parent, pid_t pid, int *status)
{
task_t *child, *next;
/* 可能删除列表元素，需要用safe */
list_for_each_owner_safe (child, next, &task_global_list, global_list) {
if (child->pid == pid) { /* find a child process we ordered */
if (child->state == TASK_HANGING) { /* child is hanging, destroy it */
#if DEBUG_LOCAL == 1
printk(KERN_NOTICE "wait_one_hangging_thread: pid=%d find a hanging thread %d \n",
parent->pid, pid);
#endif
/* 状态是可以为空的，不为空才写入子进程退出状态 */
if (status != NULL)
*status = child->exit_status;
/* 销毁子进程的PCB */
proc_destroy(child, 1);
return pid;
}
}
}
return -1;
}
/**
* pthread_start - 开始一个用户线程
* @func: 线程入口
* @arg: 线程参数
*
* 1.进程需要分配线程的堆栈
* 2.需要传入线程入口
* 3.需要传入线程例程和参数
*/
task_t *pthread_start(task_func_t *func, void *arg,
pthread_attr_t *attr, void *thread_entry)
{
/* 创建线程的父进程 */
task_t *parent = current_task;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_start: pid=%d routine=%x arg=%x stackaddr=%x stacksize=%x detach=%d\n",
parent->pid, func, arg, attr->stackaddr, attr->stacksize, attr->detachstate);
#endif
if (parent->pthread == NULL) { /* 第一次创建线程 */
if (proc_pthread_init(parent))
return NULL; /* 初始化失败 */
}
// 创建一个新的线程结构体
task_t *task = (task_t *) kmalloc(TASK_KSTACK_SIZE);
if (!task)
return NULL;
// 初始化线程
task_init(task, "pthread", TASK_PRIO_USER);
if (parent->tgid == parent->pid) { /* 父进程是主线程 */
task->tgid = parent->pid; /* 线程组id指向父进程的pid */
} else { /* 父进程不是主线程，是子线程 */
task->tgid = parent->tgid; /* 线程组指向父进程的线程组 */
}
task->parent_pid = parent->pid; /* 父进程是创建者 */
task->pthread = parent->pthread; /* 指向父进程的线程管理 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_start: new thread pid=%d tgid=%x parent pid=%d\n",
task->pid, task->tgid, task->parent_pid);
#endif
task->vmm = parent->vmm; /*共享内存 */
task->res = parent->res; /* 共享资源 */
task->triggers = parent->triggers; /* 共享触发器 */
task->fileman = parent->fileman; /* 共享文件管理 */
/* 中断栈框 */
proc_make_trap_frame(task);
// 创建一个线程
make_task_stack(task, pthread_entry, arg);
#if 0
/* 写入关键信息 */
trap_frame_t *frame = GET_TASK_TRAP_FRAME(task);
frame->eip = func;
frame->esp = stack_top;
#endif
/* 构建用户线程栈框 */
trap_frame_t *frame = GET_TASK_TRAP_FRAME(task);
build_user_thread_frame(frame, arg, (void *)func, thread_entry,
(unsigned char *)attr->stackaddr + attr->stacksize);
if (attr->detachstate == PTHREAD_CREATE_DETACHED) { /* 设置detach分离 */
task->flags |= THREAD_FLAG_DETACH;
}
/* 操作链表时关闭中断，结束后恢复之前状态 */
unsigned long flags;
save_intr(flags);
atomic_inc(&task->pthread->thread_count); /* 增加一个线程 */
if (atomic_get(&task->pthread->thread_count) > PTHREAD_MAX_NR) { /* 超过最大线程数量，就不能创建 */
#if DEBUG_LOCAL == 1
printk(KERN_NOTICE "pthread_start: pid=%d tgid=%d the number of thread out of range!\n",
parent->pid, parent->tgid);
#endif
atomic_dec(&task->pthread->thread_count);
kfree(task);
restore_intr(flags);
return NULL;
}
#if DEBUG_LOCAL == 1
printk(KERN_NOTICE "pthread_start: thread count %d\n", atomic_get(&task->pthread->thread_count));
#endif
task_global_list_add(task);
task_priority_queue_add_tail(task);
restore_intr(flags);
return task;
}
pid_t sys_thread_create(
pthread_attr_t *attr,
task_func_t *func,
void *arg,
void *thread_entry
){
/* 传进来的属性为空就返回 */
if (attr == NULL)
return -1;
task_t *task = pthread_start(func, arg, attr, thread_entry);
if (task == NULL)
return -1; /* failed */
return task->pid; /* 返回线程的id */
}
void pthread_exit(void *status)
{
unsigned long flags;
save_intr(flags);
task_t *cur = current_task;
/* 减少线程数量 */
atomic_dec(&cur->pthread->thread_count);
if (atomic_get(&cur->pthread->thread_count) == 0) { /* 没有线程，就直接退出整个进程 */
/* 退出整个进程 */
printk(KERN_DEBUG "pthread_exit: pid=%d no other threads, exit process!\n", cur->pid);
sys_exit((int) status);
}
cur->exit_status = (int)status;
/* 释放内核资源 */
thread_release_resource(cur);
/* 子线程退出 */
if (cur->flags & THREAD_FLAG_DETACH) { /* 不需要同步等待，"自己释放资源" */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_exit: pid=%d detached.\n", cur->pid);
#endif
/* 有可能启动时是joinable的，但是执行过程中变成detach状态，
因此，可能存在父进程join等待，所以，这里就需要检测任务状态 */
if (cur->flags & THREAD_FLAG_JOINED) { /* 处于join状态 */
/* 父进程指向join中的进程 */
task_t *parent = find_task_by_pid(cur->parent_pid);
if (parent != NULL && parent->state == TASK_WAITING) { /* 如果父进程在等待中 */
if (parent->tgid == cur->tgid) { /* 父进程和自己属于同一个线程组 */
printk(KERN_DEBUG "pthread_exit: pid=%d parent %s pid=%d joining, wakeup it.\n",
cur->pid, parent->name, parent->pid);
parent->flags &= ~THREAD_FLAG_JOINING; /* 去掉等待中标志 */
/* 唤醒父进程 */
task_unblock(parent);
}
}
}
/* 过继给主线程 */
//cur->parent_pid = cur->tgid;
cur->parent_pid = INIT_PROC_PID;
} else { /* 需要同步释放 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_exit: pid=%d joinable.\n", cur->pid);
#endif
}
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_exit: pid=%d tgid=%d ppid=%d.\n", cur->pid, cur->tgid, cur->parent_pid);
#endif
task_t *parent = find_task_by_pid(cur->parent_pid);
if (parent) {
/* 查看父进程状态 */
if (parent->state == TASK_WAITING) {
restore_intr(flags);
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_exit: pid=%d parent %d waiting...\n", cur->pid, parent->pid);
#endif
//printk("parent waiting...\n");
task_unblock(parent); /* 唤醒父进程 */
task_block(TASK_HANGING); /* 把自己挂起 */
} else { /* 父进程没有 */
restore_intr(flags);
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_exit: pid=%d parent %d not waiting, zombie!\n", cur->pid, parent->pid);
#endif
//printk("parent not waiting, zombie!\n");
task_block(TASK_ZOMBIE); /* 变成僵尸进程 */
}
} else {
/* 没有父进程，变成不可被收养的孤儿+僵尸进程 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_exit: pid=%d no parent! zombie!\n", cur->pid);
#endif
//printk("no parent!\n");
restore_intr(flags);
task_block(TASK_ZOMBIE);
}
}
void sys_thread_exit(void *retval)
{
pthread_exit(retval);
}
/**
* sys_thread_detach - 设置线程为分离状态
* @thread: 线程
*
*/
int sys_thread_detach(pthread_t thread)
{
task_t *task = find_task_by_pid(thread);
if (task == NULL) /* not found */
return -1;
printk(KERN_DEBUG "sys_thread_detach: thread=%s pid=%d tgid=%d ppid=%d set detach.\n",
task->name, task->pid, task->tgid, task->parent_pid);
task->flags |= THREAD_FLAG_DETACH; /* 分离标志 */
/* 有可能启动时是joinable的，但是执行过程中变成detach状态，
因此，可能存在父进程join等待，所以，这里就需要检测任务状态 */
if (task->flags & THREAD_FLAG_JOINED) { /* 处于join状态 */
/* 父进程指向join中的进程 */
task_t *parent = find_task_by_pid(task->parent_pid);
if (parent != NULL && parent->state == TASK_WAITING) { /* 如果父进程在等待中 */
if (parent->tgid == task->tgid) { /* 父进程和自己属于同一个线程组 */
printk(KERN_DEBUG "pthread_exit: pid=%d parent %s pid=%d joining, wakeup it.\n",
task->pid, parent->name, parent->pid);
parent->flags &= ~THREAD_FLAG_JOINING; /* 去掉等待中标志 */
/* 唤醒父进程 */
task_unblock(parent);
}
}
}
return 0;
}
int pthread_join(pthread_t thread, void **thread_return)
{
task_t *waiter = current_task; /* 当前进程是父进程 */
unsigned long flags;
save_intr(flags);
/* 先查看线程，是否存在，并且要是线程才行 */
task_t *task, *find = NULL;
list_for_each_owner (task, &task_global_list, global_list) {
/* find the thread and not zombie */
if (task->pid == thread && task->state != TASK_ZOMBIE) {
find = task; /* find thread */
break;
}
}
if (find == NULL) { /* 线程不存在 */
restore_intr(flags);
return -1; /* 没找到线程 */
}
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_join: pid=%d join thread %d\n", waiter->pid, thread);
#endif
/* 线程存在，查看其是否为分离状态 */
if (find->flags & THREAD_FLAG_DETACH) {
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_join: pid=%d join the %d was detached, just return.\n", waiter->pid, thread);
#endif
restore_intr(flags);
return -1;
}
/* 么有线程等待中才能等待 */
if (find->flags & THREAD_FLAG_JOINED) {
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_join: pid=%d the thread %d had joined by thread %d, return.\n",
waiter->pid, find->pid, find->parent_pid);
#endif
restore_intr(flags);
return -1; /* 已经有一个线程在等待，不能等待 */
}
find->flags |= THREAD_FLAG_JOINED; /* 被线程等待 */
find->parent_pid = waiter->pid; /* 等待者变成父进程，等待子线程，可以通过thread_exit来唤醒父进程 */
waiter->flags |= THREAD_FLAG_JOINING; /* 处于等待中 */
int status;
pid_t pid;
/* 当线程没有退出的时候就一直等待 */
do {
status = 0;
pid = wait_one_hangging_thread(waiter, find->pid, &status);
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_join: pid=%d wait pid=%d status=%x\n",
waiter->pid, pid, status);
#endif
if (pid == thread) {
break; /* 处理了指定的任务，就返回 */
}
/* 如果等待者joining状态取消了，就说明等待的线程在执行过程中变成DETACH状态，
并且退出时来取消该标志 */
if (!(waiter->flags & THREAD_FLAG_JOINING)) {
break;
}
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_join: pid=%d waiting...\n", waiter->pid);
#endif
restore_intr(flags);
/* WATING for thread to exit */
task_block(TASK_WAITING);
save_intr(flags);
} while (pid == -1);
/* 回写状态 */
if (thread_return != NULL) {
*thread_return = (void *)status;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "pthread_join: pid=%d thread %d exit, will return status=%x\n",
waiter->pid, thread, *thread_return);
#endif
}
restore_intr(flags);
return 0;
}
/**
* sys_thread_join - 等待线程退出
* @thread: 线程
* @thread_return: 返回值
*/
int sys_thread_join(pthread_t thread, void **thread_return)
{
CHECK_THREAD_CANCELATION_POTINT(current_task);
return pthread_join(thread, thread_return);
}
/**
* sys_thread_cancel - 设置线程取消点
* @thread: 线程
*
* 引起阻塞的系统调用都是Cancelation-point
*
* 成功返回0，失败返回-1
*/
int sys_thread_cancel(pthread_t thread)
{
task_t *task;
unsigned long flags;
save_intr(flags);
task = find_task_by_pid(thread);
if (task == NULL) { /* 没找到 */
#if DEBUG_LOCAL == 1
printk(KERN_ERR "sys_thread_cancel: pid=%d not find thread %d!\n",
current_task->pid, thread);
#endif
restore_intr(flags);
return -1;
}
#if DEBUG_LOCAL == 1
printk(KERN_ERR "sys_thread_cancel: pid=%d set thread %d cancelation point.\n",
current_task->pid, thread);
#endif
/* 设置取消点 */
task->flags |= THREAD_FLAG_CANCELED;
if (task->flags & THREAD_FLAG_CANCEL_ASYCHRONOUS) { /* 立即取消线程处理 */
/* 查看是否为自己取消自己 */
if (task == task_current) { /* 是自己 */
restore_intr(flags);
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_cancel: pid=%d cancel self.\n", current_task->pid);
#endif
pthread_exit((void *) THREAD_FLAG_CANCEL_ASYCHRONOUS); /* 退出线程运行 */
} else { /* 取消其它线程 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_cancel: pid=%d will cancel thread %d.\n",
current_task->pid, thread);
#endif
close_one_thread(task);
}
}
restore_intr(flags);
return 0;
}
/**
* sys_thread_testcancel - 线程测试取消点
*
* 如果有取消点，就退出线程
*/
void sys_thread_testcancel(void)
{
CHECK_THREAD_CANCELATION_POTINT(current_task);
}
/**
* sys_thread_setcancelstate - 设置取消状态
* @state: 状态：PTHREAD_CANCEL_ENABLE（缺省）, 收到信号后设为CANCLED状态
* PTHREAD_CANCEL_DISABLE, 忽略CANCEL信号继续运行
* @oldstate: 原来的状态,old_state如果不为NULL则存入原来的Cancel状态以便恢复。
*
* 成功返回0，失败返回-1
*/
int sys_thread_setcancelstate(int state, int *oldstate)
{
task_t *cur = current_task;
if (oldstate != NULL) { /* 保存原来的类型 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_setcancelstate: pid=%d fetch oldstate.\n",
current_task->pid);
#endif
if (cur->flags & THREAD_FLAG_CANCEL_DISABLE) {
*oldstate = PTHREAD_CANCEL_DISABLE;
} else {
*oldstate = PTHREAD_CANCEL_ENABLE;
}
}
if (state == PTHREAD_CANCEL_DISABLE) {
cur->flags |= THREAD_FLAG_CANCEL_DISABLE;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_setcancelstate: pid=%d set cancel disable.\n",
current_task->pid);
#endif
} else if (state == PTHREAD_CANCEL_ENABLE) {
cur->flags &= ~THREAD_FLAG_CANCEL_DISABLE;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_setcancelstate: pid=%d set cancel enable.\n",
current_task->pid);
#endif
} else {
return -1;
}
return 0;
}
/**
* sys_thread_setcanceltype - 设置取消动作的执行时机
* @type: 取消类型，2种结果：PTHREAD_CANCEL_DEFFERED，收到信号后继续运行至下一个取消点再退出
* PTHREAD_CANCEL_ASYCHRONOUS，立即执行取消动作（退出）
* @oldtype: oldtype如果不为NULL则存入原来的取消动作类型值。
*
* 成功返回0，失败返回-1
*/
int sys_thread_setcanceltype(int type, int *oldtype)
{
task_t *cur = current_task;
if (oldtype != NULL) { /* 保存原来的类型 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_setcanceltype: pid=%d fetch oldtype.\n",
current_task->pid);
#endif
if (cur->flags & THREAD_FLAG_CANCEL_ASYCHRONOUS) {
*oldtype = PTHREAD_CANCEL_ASYCHRONOUS;
} else {
*oldtype = PTHREAD_CANCEL_DEFFERED;
}
}
if (type == PTHREAD_CANCEL_ASYCHRONOUS) {
cur->flags |= THREAD_FLAG_CANCEL_ASYCHRONOUS;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_setcanceltype: pid=%d set cancel asychronous.\n",
current_task->pid);
#endif
} else if (type == PTHREAD_CANCEL_DEFFERED) {
cur->flags &= ~THREAD_FLAG_CANCEL_ASYCHRONOUS;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_thread_setcanceltype: pid=%d set cancel deffered.\n",
current_task->pid);
#endif
} else {
return -1;
}
return 0;
}
|
NightfallDM/xbook2
|
src/include/xbook/mutexlock.h
|
/*
互斥锁：
互斥锁（Mutex）是在原子操作API的基础上实现的信号量行为。互斥锁不能进行递归锁定或解锁，
能用于交互上下文但是不能用于中断上下文，同一时间只能有一个任务持有互斥锁，而且只有这个任务可以对互斥锁进行解锁。
当无法获取锁时，线程进入睡眠等待状态。
互斥锁是信号量的特例。信号量的初始值表示有多少个任务可以同时访问共享资源，如果初始值为1，表示只有1个任务可以访问，
信号量变成互斥锁（Mutex）。但是互斥锁和信号量又有所区别，互斥锁的加锁和解锁必须在同一线程里对应使用，所以互斥锁只能用于线程的互斥；
信号量可以由一个线程释放，另一个线程得到，所以信号量可以用于线程的同步。
1、互斥锁和信号量比较
a、互斥锁功能上基本与二元信号量一样，但是互斥锁占用空间比信号量小，运行效率比信号量高。所以，如果要用于线程间的互斥，优先选择互斥锁。
2、互斥锁和自旋锁比较
a、互斥锁在无法得到资源时，内核线程会进入睡眠阻塞状态，而自旋锁处于忙等待状态。因此，如果资源被占用的时间较长，使用互斥锁较好，
因为可让CPU调度去做其它进程的工作。
b、如果被保护资源需要睡眠的话，那么只能使用互斥锁或者信号量，不能使用自旋锁。而互斥锁的效率又比信号量高，所以这时候最佳选择是互斥锁。
c、中断里面不能使用互斥锁，因为互斥锁在获取不到锁的情况下会进入睡眠，而中断是不能睡眠的。
*/
#ifndef _XBOOK_MUTEX_LOCK_H
#define _XBOOK_MUTEX_LOCK_H
#include "spinlock.h"
#include <list.h>
/* 互斥锁结构 */
typedef struct mutex_lock {
atomic_t count; /* 为0表示未上锁，1表示上锁 */
list_t wait_list; /* 等待队列 */
int waiters; /* 等待者数量 */
} mutexlock_t;
/* 初始化互斥锁 */
#define MUTEX_LOCK_INIT(lockname) \
{ .count = ATOMIC_INIT(0) \
, .wait_list = LIST_HEAD_INIT((lockname).wait_list) \
, .waiters = 0 \
}
/* 定义一个互斥锁 */
#define DEFINE_MUTEX_LOCK(lockname) \
mutexlock_t lockname = MUTEX_LOCK_INIT(lockname)
/**
* mutexlock_init - 初始化互斥锁
* @mutex: 锁对象
*/
static inline void mutexlock_init(mutexlock_t *mutex)
{
atomic_set(&mutex->count, 0); /* 0 means unused */
INIT_LIST_HEAD(&mutex->wait_list);
mutex->waiters = 0;
}
void mutex_unlock(mutexlock_t *mutex);
void mutex_lock(mutexlock_t *mutex);
/**
* mutex_try_lock - 尝试自旋锁加锁
* @lock: 锁对象
*
* 非阻塞式获取锁
* 如果锁已经被使用，就返回一个非0值，不会自旋等待锁释放。
* 如果成功获得了锁，就返回0
*/
static inline int mutex_try_lock(mutexlock_t *lock)
{
return atomic_xchg(&(lock)->count, 1);
}
/**
* mutex_is_locked - 检测锁是否被占用
* @lock: 锁对象
*
* 如果锁已经被使用，就返回1
* 不然就返回0
*/
static inline int mutex_is_locked(mutexlock_t *lock)
{
return atomic_get(&(lock)->count) > 0;
}
void dump_mutex(mutexlock_t *lock);
#endif /* _XBOOK_MUTEX_LOCK_H */
|
NightfallDM/xbook2
|
library/xlibc/include/srv/filesrv.h
|
<filename>library/xlibc/include/srv/filesrv.h
#ifndef _SRV_FILE_SRV_H
#define _SRV_FILE_SRV_H
/* file server call */
enum filesrv_call_num {
FILESRV_OPEN = 0,
FILESRV_CLOSE,
FILESRV_READ,
FILESRV_WRITE,
FILESRV_LSEEK,
FILESRV_ASSERT,
FILESRV_OPENDIR,
FILESRV_CLOSEDIR,
FILESRV_READDIR,
FILESRV_REWINDDIR,
FILESRV_MKDIR,
FILESRV_UNLINK,
FILESRV_RMDIR,
FILESRV_RENAME,
FILESRV_FTRUNCATE,
FILESRV_FSYNC,
FILESRV_STAT,
FILESRV_CHMOD,
FILESRV_FCHMOD,
FILESRV_UTIME,
FILESRV_FEOF,
FILESRV_FERROR,
FILESRV_FTELL,
FILESRV_FSIZE,
FILESRV_REWIND,
FILESRV_MOUNT,
FILESRV_UNMOUNT,
FILESRV_MKFS,
FILESRV_CHDIR,
FILESRV_IOCTL,
FILESRV_FCNTL,
FILESRV_FSTAT,
FILESRV_CALL_NR, /* 最大数量 */
};
/* 缓冲区最大长度 */
#define FILESRV_BUF_MAX_SIZE (128*1024)
#define MAX_PATH_LEN 260
#endif /* _SRV_FILE_SRV_H */
|
NightfallDM/xbook2
|
library/xlibc/math/floor.c
|
<reponame>NightfallDM/xbook2
/*
File: floor.c
Contains: For round down
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT floor(M_FLOAT x) {
int intX = x;
if (x < 0 && x < intX)
return intX - 1.0;
return intX;
}
|
NightfallDM/xbook2
|
src/ipc/pipe.c
|
<gh_stars>0
#include <xbook/pipe.h>
#include <xbook/trigger.h>
#include <xbook/debug.h>
#include <fsal/fsal.h>
#include <types.h>
#include <fcntl.h>
#include <unistd.h>
LIST_HEAD(pipe_list_head);
static kobjid_t pipe_next_id = 0;
pipe_t *create_pipe()
{
pipe_t *pipe = kmalloc(sizeof(pipe_t));
if (pipe == NULL) {
return NULL;
}
pipe->fifo = fifo_buf_alloc(PIPE_SIZE);
if (pipe->fifo == NULL) {
kfree(pipe);
return NULL;
}
atomic_set(&pipe->read_count, 1);
atomic_set(&pipe->write_count, 1);
pipe->rdflags = 0;
pipe->wrflags = 0;
pipe->flags = 0;
pipe->id = pipe_next_id;
pipe_next_id++;
mutexlock_init(&pipe->mutex);
wait_queue_init(&pipe->wait_queue);
/* add to pipe list */
list_add_tail(&pipe->list, &pipe_list_head);
return pipe;
}
int destroy_pipe(pipe_t *pipe)
{
if (!pipe)
return -1;
list_del_init(&pipe->list);
fifo_buf_free(pipe->fifo);
kfree(pipe);
return 0;
}
pipe_t *pipe_find(kobjid_t id)
{
pipe_t *pipe;
list_for_each_owner (pipe, &pipe_list_head, list) {
if (pipe->id == id)
return pipe;
}
return NULL;
}
/**
* 从管道读取数据。
* 1.如果管道读端没有打开，读取返回-1
* 2.如果管道是阻塞状态，管道有数据则返回读取的数据量，不管写端是否关闭。
* 如果是无阻塞状态，没有数据就不阻塞，而是返回
* 3.管道中没有数据，如果写端全部关闭，则返回0.
* 4.如果写端没有全部关闭，则阻塞。
*/
int pipe_read(kobjid_t pipeid, void *buffer, size_t bytes)
{
if (!buffer || !bytes)
return -1;
/* find the pipe id */
pipe_t *pipe = pipe_find(pipeid);
if (pipe == NULL)
return -1;
if (atomic_get(&pipe->read_count) <= 0)
return -1;
mutex_lock(&pipe->mutex);
/* 没有数据就要检查写端状态，如果关闭则返回0，不然就读取阻塞，等待有数据后，读取数据返回 */
if (fifo_buf_len(pipe->fifo) <= 0) {
/* 写端全部被关闭，返回0 */
if (atomic_get(&pipe->write_count) <= 0) {
mutex_unlock(&pipe->mutex);
return 0;
}
if (pipe->rdflags & PIPE_NOWAIT) { /* 无阻塞 */
mutex_unlock(&pipe->mutex);
return -1;
}
/* 添加到等待队列 */
wait_queue_add(&pipe->wait_queue, current_task);
mutex_unlock(&pipe->mutex);
task_block(TASK_BLOCKED); /* 阻塞自己，等待唤醒 */
mutex_lock(&pipe->mutex);
}
/* 获取缓冲区大小，如果有数据，则直接读取数据，然后返回 */
int rdsize = 0;
int chunk = min(bytes, PIPE_SIZE); /* 获取一次能读取的数据量 */
chunk = min(chunk, fifo_buf_len(pipe->fifo)); /* 获取能读取的数据量 */
chunk = fifo_buf_get(pipe->fifo, buffer, chunk);
rdsize += chunk;
/* 读取完数据后，此时写者可能因为管道满了而阻塞，所以尝试唤醒 */
if (atomic_get(&pipe->write_count) > 0) {
if (wait_queue_length(&pipe->wait_queue) > 0)
wait_queue_wakeup(&pipe->wait_queue);
}
mutex_unlock(&pipe->mutex);
return rdsize;
}
/**
* 从管道写入数据。
* 1.如果管道写端没有打开，读取返回-1
* 2.如果读端全关闭，则触发进程异常
* 3.如果管道是阻塞状态，管道满则阻塞。
* 如果是无阻塞状态，管道满则不阻塞，直接返回-1
* 4.如果管道未满，则写入数据，并返回实际的数据量
*/
int pipe_write(kobjid_t pipeid, void *buffer, size_t bytes)
{
if (!buffer || !bytes)
return -1;
/* find the pipe id */
pipe_t *pipe = pipe_find(pipeid);
if (pipe == NULL) {
return -1;
}
if (atomic_get(&pipe->write_count) <= 0)
return -1;
if (atomic_get(&pipe->read_count) <= 0) {
/* 没有读端时写入，触发管道异常 */
sys_trigger_active(TRIGHSOFT, current_task->pid);
return -1;
}
mutex_lock(&pipe->mutex);
int left_size = (int )bytes;
int off = 0;
unsigned char *buf = buffer;
int chunk = 0;
int wrsize = 0;
/* 只要还有数据，就不停地写入，直到写完为止 */
while (left_size > 0) {
chunk = min(left_size, PIPE_SIZE); /* 获取一次要写入的数据量 */
chunk = min(chunk, fifo_buf_avali(pipe->fifo)); /* 获取能写入的数据量 */
/* 把数据存入缓冲区 */
chunk = fifo_buf_put(pipe->fifo, buf + off, chunk);
off += chunk;
left_size -= chunk;
wrsize += chunk;
/* try wakeup reader */
if (atomic_get(&pipe->read_count) > 0) {
if (wait_queue_length(&pipe->wait_queue) > 0)
wait_queue_wakeup(&pipe->wait_queue);
}
/* 如果fifo缓冲区为已经满了，并且还需要写入数据，就进入抉择阶段 */
if (fifo_buf_avali(pipe->fifo) <= 0 && left_size > 0) {
if (pipe->wrflags & PIPE_NOWAIT) { /* 无阻塞 */
mutex_unlock(&pipe->mutex);
return -1;
}
/* 添加到等待队列 */
wait_queue_add(&pipe->wait_queue, current_task);
mutex_unlock(&pipe->mutex);
task_block(TASK_BLOCKED); /* 阻塞自己，等待唤醒 */
mutex_lock(&pipe->mutex);
}
}
mutex_unlock(&pipe->mutex);
return wrsize;
}
/**
* pipe_close - 关闭管道
* @pipeid: 管道id
* @rw: 读写端口（0：读端，1：写端）
*
* 成功关闭返回0，失败返回-1
*/
int pipe_close(kobjid_t pipeid, int rw)
{
/* find the pipe id */
pipe_t *pipe = pipe_find(pipeid);
if (pipe == NULL) {
return -1;
}
if (rw) {
atomic_dec(&pipe->write_count);
//pr_dbg("[pipe]: %s: close write pipe %d.\n", __func__, atomic_get(&pipe->write_count));
} else {
atomic_dec(&pipe->read_count);
//pr_dbg("[pipe]: %s: close read pipe %d.\n", __func__, atomic_get(&pipe->read_count));
}
/* both closed */
if (atomic_get(&pipe->write_count) <= 0 && atomic_get(&pipe->read_count) <= 0) {
destroy_pipe(pipe);
//pr_dbg("[pipe]: %s: destroy pipe.\n", __func__);
}
return 0;
}
/**
* pipe_close - 关闭管道
* @pipeid: 管道id
* @rw: 读写端口（0：读端，1：写端）
*
* 读写端都关闭返回1，只关闭一个返回0，失败返回-1
*/
int pipe_ioctl(kobjid_t pipeid, unsigned int cmd, unsigned long arg, int rw)
{
/* find the pipe id */
pipe_t *pipe = pipe_find(pipeid);
if (pipe == NULL) {
return -1;
}
mutex_lock(&pipe->mutex);
int err = -1;
switch (cmd) {
case F_SETFL:
if (arg & O_NONBLOCK) {
if (rw)
pipe->wrflags |= PIPE_NOWAIT;
else
pipe->rdflags |= PIPE_NOWAIT;
}
err = 0;
break;
default:
break;
}
mutex_unlock(&pipe->mutex);
return err;
}
int pipe_grow(kobjid_t pipeid, int rw)
{
pipe_t *pipe = pipe_find(pipeid);
if (pipe == NULL) {
return -1;
}
mutex_lock(&pipe->mutex);
if (rw)
atomic_inc(&pipe->write_count);
else
atomic_inc(&pipe->read_count);
mutex_unlock(&pipe->mutex);
return 0;
}
|
NightfallDM/xbook2
|
src/kernel/debug.c
|
<reponame>NightfallDM/xbook2<filename>src/kernel/debug.c
#include <xbook/debug.h>
#include <stdarg.h>
#include <string.h>
#include <xbook/spinlock.h>
#include <arch/interrupt.h>
#include <arch/cpu.h>
#include <arch/debug.h>
#include <stdio.h>
char *printk_msg[] = {
"emege: ",
"alter: ",
"crit: ",
"error: ",
"waring: ",
"notice: ",
"info: ",
"debug: ",
0,
};
int printk_level = DEFAULT_LOG_LEVEL;
//停机并输出大量信息
void panic(const char *fmt, ...)
{
char buf[256];
/* 4 is the size of fmt in the stack */
va_list arg = (va_list)((char*)&fmt + 4);
vsprintf(buf, fmt, arg);
printk("\npanic: %s", buf);
disable_intr();
while(1){
cpu_idle();
}
}
//断言
void assertion_failure(char *exp, char *file, char *baseFile, int line)
{
printk("\nassert(%s) failed:\nfile: %s\nbase_file: %s\nln: %d",
exp, file, baseFile, line);
spin("assertion failure()");
}
//停机显示函数名
void spin(char * functionName)
{
printk("\nspinning in %s", functionName);
disable_intr();
while(1){
cpu_idle();
}
}
DEFINE_SPIN_LOCK_UNLOCKED(print_lock);
/**
* printk - 格式化输出
* @fmt: 格式
* @...: 参数
*
* 返回缓冲区长度
*/
int printk(const char *fmt, ...)
{
/* 自旋锁上锁 */
spin_lock(&print_lock);
int i;
char buf[256];
memset(buf, 0, 256);
va_list arg = (va_list)((char*)(&fmt) + 4); /*4是参数fmt所占堆栈中的大小*/
i = vsprintf(buf, fmt, arg);
int count = i;
char *p = buf;
int level = -1;
char show = 1;
/* 如果显示指明调试等级 */
if (*p == '<') {
/* 有完整的调试等级 */
if (*(p + 1) >= '0' && *(p + 1) <= '7' && *(p + 2) == '>') {
level = *(p + 1) - '0'; /* 获取等级 */
if (level > printk_level) /* 如果等级过低，就不显示 */
show = 0;
/* move print start ptr */
p += 3;
count -= 3;
}
}
if (show) {
#if PRINT_LEVEL_MSG == 1
/* print level first */
if (level >= 0) {
char *q = printk_msg[level];
while (*q)
debug_putchar(*q++);
}
#endif
while (count-- > 0)
debug_putchar(*p++);
}
/* 自旋锁解锁锁 */
spin_unlock(&print_lock);
return i;
}
void dump_value(unsigned long val)
{
printk(KERN_DEBUG "dump_value: %d\n", val);
}
void dump_buffer(void *buffer, unsigned long len, char factor)
{
printk(KERN_DEBUG "dump_buffer: addr=%x len=%d factor=%d\n", buffer, len, factor);
int i;
if (factor == 1) {
unsigned char *buf = (unsigned char *)buffer;
for (i = 0; i < len; i++) {
printk("%x ", buf[i]);
}
printk("\n");
} else if (factor == 2) {
unsigned short *buf = (unsigned short *)buffer;
for (i = 0; i < len / factor; i++) {
printk("%x ", buf[i]);
}
printk("\n");
} else if (factor == 4) {
unsigned int *buf = (unsigned int *)buffer;
for (i = 0; i < len / factor; i++) {
printk("%x ", buf[i]);
}
printk("\n");
}
}
|
NightfallDM/xbook2
|
library/xlibc/stdlib/malloc.c
|
<reponame>NightfallDM/xbook2
/**
* 这种内存分配方式，只会扩展堆，而不会对堆进行缩小。
* 1.使用显示双向链表，按地址顺序维护内存块。
* 2.使用循环首次适应算法进行空闲块的选择。
*/
#include <stddef.h>
#include <types.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#define __HAS_NOT_USED 0
#define __HAS_USED 1
#define ALIGN8(size) ((size + 8) & (~7))
#define ALIGN4(size) ((size + 4) & (~3))
struct __memory_block
{
int used; // 是否被使用了
int size; // 所在块的大小
/* 指向前驱和后驱的指针 */
struct __memory_block *prev;
struct __memory_block *next;
};
#define MEM_BLOCK_SIZE sizeof(struct __memory_block)
/* 内存块头指针 */
struct __memory_block *head;
/* 内存块尾指针 */
struct __memory_block *tail;
/* 遍历内存块的标记 */
struct __memory_block *flag;
/* 最开始运行时，没有初始化，当第一次调用malloc时才初始化 */
static char __had_initialized = 0;
/**
* __init_memory_alloctor - 初始化内存管理器
*
* 成功返回0， 失败返回-1
*/
static int __init_memory_alloctor()
{
head = sbrk(sizeof(struct __memory_block));
tail = sbrk(sizeof(struct __memory_block));
if (head == (void *)-1 || tail == (void *)-1) {
return -1;
}
head->used = tail->used = __HAS_USED;
head->prev = tail;
tail->prev = head;
head->next = tail;
tail->next = head;
/* 遍历指针指向头 */
flag = head;
/* 已经初始化了，后面就不会在调用初始化函数 */
__had_initialized = 1;
return 0;
}
/**
* __copy_block_data - 复制内存块数据
* @src: 源内存块
* @dst: 目的内存块
*
* 复制的数据量都小于等于源和目的内存块的大小
*/
static void __copy_block_data(struct __memory_block *src, struct __memory_block *dst)
{
int *sdata, *ddata;
size_t i;
// 指向数据区域
sdata = (int *)(src + 1);
ddata = (int *)(dst + 1);
/* 当双方大小都满足时才进行舒服复制 */
for(i = 0; i*4 < src->size && i*4 < dst->size; ++i)
ddata[i] = sdata[i];
}
/**
* __get_block - 通过地址获取内存块结构
* @ptr: 内存指针
*/
static struct __memory_block *__get_block(void *ptr)
{
return (struct __memory_block *)(ptr - MEM_BLOCK_SIZE);
};
/**
* __split_block - 分裂一个块
* @current: 要分裂的块
* @size: 块的大小
*
* 分裂一个块，截取size作为当前块大小，把后面的空间做出一个新的块
*/
static void __split_block(struct __memory_block *current, size_t size)
{
struct __memory_block *next, *new;
next = current->next;
/* alloc block 在current后面 */
new = (void*)current + size + MEM_BLOCK_SIZE;
new->used = __HAS_NOT_USED;
new->size = current->size - size - MEM_BLOCK_SIZE;
new->prev = current;
new->next = next;
current->next = new;
current->size = size;
next->prev = new;
}
/**
* malloc - 分配一块内存
* @size: 要分配的内存的大小
*
* 在堆中分配一块内存，如果没有空闲堆了，就调用sbrk扩展内存堆
*/
void *malloc(size_t size)
{
struct __memory_block *current_block;
struct __memory_block *prev_block;
void *memory_location = NULL;
unsigned int block_size = size + MEM_BLOCK_SIZE;
struct __memory_block *alloc_block = NULL;
size = ALIGN4(size);
if(size <= 0)
return NULL;
/* 尝试初始化 */
if(!__had_initialized){
if (__init_memory_alloctor() == -1)
return NULL;
}
/* 当前块指向flag后，就会循环每一个block */
current_block = flag;
while(current_block){
if(!current_block->used){
if(current_block->size >= size){ /*将current_block标记为已分配*/
current_block->used = __HAS_USED;
memory_location = (void*) current_block + MEM_BLOCK_SIZE;
//printf("malloc: found a block %x\n", memory_location);
/* 判断是否需要分割当前块，至少要有16字节区域，才尝试把block细分*/
if(current_block->size - size > MEM_BLOCK_SIZE + 4){
__split_block(current_block, size);
}
break;
}
}
current_block = current_block->next;
if(current_block == flag)
break;
}
flag = current_block;
/*没有找到合适的块，申请新的空间*/
/*这一步很关键，必须注意将tail块放置到最后才能保证链表中块的地址顺序*/
if(!memory_location){
prev_block = tail->prev;
/* 先把tail占用的内存释放 */
sbrk(-1*MEM_BLOCK_SIZE);
/* 再分配新的内存给请求大小 */
alloc_block = sbrk(block_size);
if(alloc_block == (void *)-1){
printf("sbrk failed!\n");
return NULL;
}
/* 再分配新的内存给tail */
tail = sbrk(MEM_BLOCK_SIZE);
alloc_block->size = size;
alloc_block->used = __HAS_USED;
alloc_block->next = tail;
alloc_block->prev = prev_block;
prev_block->next = alloc_block;
tail->prev = alloc_block;
tail->next = head;
tail->used = __HAS_USED;
tail->size = 0;
head->prev = tail;
//printf("malloc: sbrk addr %x\n", alloc_block);
memory_location = (void *) alloc_block + sizeof(struct __memory_block);
}
return memory_location;
}
static void __merge_prev(struct __memory_block *current)
{
struct __memory_block *prev = current->prev;
/* 要加上当前地址的size和结构体所占的size */
prev->size = prev->size + current->size + MEM_BLOCK_SIZE;
prev->next = current->next;
current->next->prev = prev;
}
static void __merge_next(struct __memory_block *current)
{
struct __memory_block *next = current->next;
/* 要加上后一个地址的size和结构体所占的size */
current->size = current->size + next->size + MEM_BLOCK_SIZE;
current->next = next->next;
next->next->prev = current;
}
/**
* free - 释放一个内存地址
* @ptr: 需要释放的内存地址
*
* 释放内存并尝试和相邻的内存块合并，减小系统开销
*/
void free(void *ptr)
{
if(!ptr)
return;
struct __memory_block *current = __get_block(ptr);
/* 判断是否合并，四种情况，1.不合并。2.前合并。3.后合并。4.前后同时合并 */
/* 边界上的问题已经通过初始化解决了，合并完后prev是一直在前面的，所以涉及到
prev的都可以不用设置used状态，不然就需要设置未使用标志*/
struct __memory_block *prev = current->prev;
struct __memory_block *next = current->next;
/* 前后都在使用，不合并 */
if(prev->used && next->used){
current->used = __HAS_NOT_USED;
} else if(!prev->used && next->used){
/* 和前面合并 */
__merge_prev(current);
/* 标记块 */
flag = prev;
} else if(prev->used && !next->used){
/* 和后面合并 */
/* 要设置成未使用 */
current->used = __HAS_NOT_USED;
__merge_next(current);
/* 标记块 */
flag = current;
} else if(!prev->used && !next->used){
/* 前后都合并 */
/* 先和后面的合并 */
__merge_next(current);
/* 在和前面的合并 */
__merge_prev(current);
/* 标记块 */
flag = prev;
}
}
/**
* calloc - 分配内存并置0
* numitems: 有多少项
* size: 每项的大小
*
* 分配内存后，置0
*/
void *calloc(int n,size_t size)
{
size_t *new;
size_t s, i;
new = malloc(n * size);
if(new)
{
//因为申请的内存总是4的倍数，所以这里我们以4字节为单位初始化
s = ALIGN4(n * size) >> 2;
for(i = 0; i < s; ++i)
new[i] = 0;
}
return new;
}
/**
* realloc - 重新分配内存，扩大或者缩小当前区域
* @ptr: 指针
* @size: 要重新获取的大小
*
* 1.如果ptr为空，那么就相当于malloc，分配size大小内存
* 2.如果ptr不为空，size为0，那么就相当于free
* 3.如果size比原来的小就缩小内存，并尝试分裂
* 4.如果size比原来的大，就尝试寻找附近block，看能否合并，
* 合并后能否满足size需求
* 5.如果size比原来大，且不能合并，那么就分配一块新的内存，并且复制数据
*/
void *realloc(void *ptr, size_t size)
{
size_t _size;
struct __memory_block *block, *newBlock;
void *newPtr;
/* 如果ptr为NULL，size为0，就啥也不做，返回ptr */
if (!ptr && !size)
return ptr;
/* 如果ptr为NULL */
if (!ptr) {
//printf("realloc: alloc memory\n");
return malloc(size);
}
/* 如果size未0，并且ptr存在，那么就释放内存 */
if (!size && ptr != NULL) {
//printf("realloc: free memory %x\n");
free(ptr);
return ptr;
}
_size = ALIGN4(size);
//得到对应的block
block = __get_block(ptr);
//如果size变小了，考虑收缩内存
if(block->size >= _size) {
/* 如果block的大小比内存块结构体+4都大，说明可以分裂一个新的块出来 */
if(block->size - _size >= (sizeof(struct __memory_block) + 4)) {
//printf("realloc: shrik-> block size %d size %d\n", block->size, size);
__split_block(block, _size);
/* 标记块 */
flag = block;
}
/* 收缩完后，还是返回原来的空间 */
} else { //如果当前block的数据区不能满足size
/*如果前继是unused的，后继是used的，并且如果合并后大小满足size，考虑合并 */
if(!block->prev->used && block->next->used &&
(block->size + MEM_BLOCK_SIZE + block->prev->size) >= _size) {
__merge_prev(block);
/* 合并后block就消失了，但是还是可以使用它的结构，
如果prev满足size，再看能不能split*/
if(block->prev->size - _size >= (MEM_BLOCK_SIZE + 4))
__split_block(block->prev, _size);
/* 标记块 */
flag = block->prev;
/* 因为把block合并到prev中去了，所以要修改成prev的地址 */
ptr = (struct __memory_block *)block->prev + 1;
//printf("realloc: merge prev size %d size %d\n", block->prev->size, _size);
/* 与此同时还需要复制数据 */
__copy_block_data(block, block->prev);
} else if(block->prev->used && !block->next->used &&
(block->size + MEM_BLOCK_SIZE + block->next->size) >= _size) {
/*如果前继是used的，后继是unused的，并且如果合并后大小满足size，考虑合并 */
__merge_next(block);
/* 合并后如果满足size，再看能不能split */
if(block->size - _size >= (MEM_BLOCK_SIZE + 4))
__split_block(block, _size);
//printf("realloc: merge next size %d size %d\n", block->size, _size);
/* 标记块 */
flag = block;
/* 因为block还在，所以不需要复制数据 */
} else if(!block->prev->used && !block->next->used &&
(block->size + block->prev->size + block->next->size + MEM_BLOCK_SIZE*2) >= _size){
/*如果前继和后继都是unused的，并且如果合并后大小满足size，考虑合并 */
__merge_next(block);
__merge_prev(block);
/* 合并后block就消失了，但是还是可以使用它的结构，
如果prev满足size，再看能不能split*/
if(block->prev->size - _size >= (MEM_BLOCK_SIZE + 4))
__split_block(block->prev, _size);
/* 标记块 */
flag = block->prev;
/* 因为把block合并到prev中去了，所以要修改成prev的地址 */
ptr = (struct __memory_block *)block->prev + 1;
//printf("realloc: merge both size %d size %d\n", block->prev->size, _size);
/* 与此同时还需要复制数据 */
__copy_block_data(block, block->prev);
} else { /* 以上都不满足，则malloc新区域 */
newPtr = malloc(_size);
if(!newPtr)
return NULL;
//内存复制
newBlock = __get_block(newPtr);
__copy_block_data(block, newBlock);
free(ptr);//释放old
//printf("realloc: block size %d size %d\n", newBlock->size, _size);
/* 标记块 */
flag = newBlock;
return newPtr;
}
}
return ptr;//当前block数据区大于size时
}
/**
* memory_state - 读取内存管理的状态
*/
void memory_state()
{
struct __memory_block *current_block = head;
while(current_block){
printf("size: %x, used: %d,address: %x\n",current_block->size,current_block->used,current_block);
current_block = current_block->next;
if(current_block == head)
break;
}
printf("\n");
}
/**
* malloc_usable_size - 获取一块内存占用的大小
* @ptr: 内存地址指针
*
* 占用大小 = 内存地址 + 内存块结构体
*/
int malloc_usable_size(void *ptr)
{
struct __memory_block *current_block = (struct __memory_block *)(ptr - sizeof(struct __memory_block));
/* 返回块的大小和结构体的大小 */
return current_block->size + sizeof(struct __memory_block);
}
size_t getmsz(void *ptr)
{
if (!ptr) {
return 0;
}
struct __memory_block *block;
//得到对应的block
block = __get_block(ptr);
return block->size;
}
int setmsz(void *ptr, size_t size)
{
if (!ptr || !size) {
return -1;
}
struct __memory_block *block;
//得到对应的block
block = __get_block(ptr);
block->size = size;
return 0;
}
|
NightfallDM/xbook2
|
src/vmm/vmm.c
|
<reponame>NightfallDM/xbook2
#include <arch/pmem.h>
#include <xbook/vmm.h>
#include <xbook/debug.h>
#include <xbook/vmspace.h>
void vmm_init(vmm_t *vmm)
{
vmm->page_storage = copy_kernel_page_storge();
if (vmm->page_storage == NULL) {
panic(KERN_EMERG "task_init_vmm: kmalloc for page_storege failed!\n");
}
vmm->vmspace_head = NULL;
/* 其它参数 */
}
int sys_mstate(mstate_t *ms)
{
ms->ms_total = get_total_page_nr() * PAGE_SIZE;
ms->ms_free = get_free_page_nr() * PAGE_SIZE;
ms->ms_used = ms->ms_total - ms->ms_free;
if (ms->ms_used < 0)
ms->ms_used = 0;
return 0;
}
void dump_vmm(vmm_t *vmm)
{
printk(KERN_DEBUG "code: start=%x, end=%x\n", vmm->code_start, vmm->code_end);
printk(KERN_DEBUG "data: start=%x, end=%x\n", vmm->data_start, vmm->data_end);
printk(KERN_DEBUG "heap: start=%x, end=%x\n", vmm->heap_start, vmm->heap_end);
printk(KERN_DEBUG "map: start=%x, end=%x\n", vmm->map_start, vmm->map_end);
printk(KERN_DEBUG "stack: start=%x, end=%x\n", vmm->stack_start, vmm->stack_end);
}
void vmm_active(vmm_t *vmm)
{
if (vmm == NULL) {
page_dir_active(0, 0);
} else {
page_dir_active(v2p(vmm->page_storage), 1);
}
}
/**
* vmm_release_space - 释放掉进程空间管理
* @vmm: 虚拟内存管理
*
* 以及释放对应的空间
* 额外需要释放共享空间
*
* @return: 成功返回0， 失败返回-1
*/
int vmm_release_space(vmm_t *vmm)
{
if (vmm == NULL)
return -1;
/* 释放虚拟空间地址描述 */
vmspace_t *space = (vmspace_t *)vmm->vmspace_head;
vmspace_t *p;
while (space != NULL) {
p = space;
space = space->next;
vmspace_free(p); /* 释放空间 */
}
vmm->vmspace_head = NULL;
vmm->code_start = 0;
vmm->code_end = 0;
vmm->data_start = 0;
vmm->data_end = 0;
vmm->heap_start = 0;
vmm->heap_end = 0;
vmm->map_start = 0;
vmm->map_end = 0;
vmm->stack_start = 0;
vmm->stack_end = 0;
return 0;
}
/**
* vmm_unmap_space - 取消虚拟空间映射
* @vmm: 虚拟内存管理
*
* 取消虚拟地址映射
* 额外需要释放共享空间
*
* @return: 成功返回0， 失败返回-1
*/
int vmm_unmap_space(vmm_t *vmm)
{
if (vmm == NULL)
return -1;
/* 释放虚拟空间地址描述 */
vmspace_t *space = (vmspace_t *)vmm->vmspace_head;
/* 取消虚拟空间的地址映射 */
while (space != NULL) {
/* 由于内存区域可能不是连续的，所以需要用安全的方式来取消映射 */
unmap_pages_safe(space->start, space->end - space->start, space->flags & VMS_MAP_SHARED);
space = space->next;
}
return 0;
}
/**
* vmm_unmap_space_maparea - 释放映射区域
* @vmm: 虚拟内存管理
*
* 取消虚拟区域地址映射
*
* @return: 成功返回0， 失败返回-1
*/
int vmm_unmap_space_maparea(vmm_t *vmm)
{
if (vmm == NULL)
return -1;
/* 释放虚拟空间地址描述 */
vmspace_t *space = (vmspace_t *)vmm->vmspace_head;
/* 取消虚拟空间的地址映射 */
while (space != NULL) {
if (space->start >= VMS_MAP_START_ADDR &&
space->end <= VMS_MAP_START_ADDR + MAX_VMS_MAP_SIZE) {
unmap_pages_safe(space->start, space->end - space->start, space->flags & VMS_MAP_SHARED);
}
space = space->next;
}
return 0;
}
int vmm_exit(vmm_t *vmm)
{
if (vmm == NULL)
return -1;
if (vmm->vmspace_head == NULL)
return -1;
/* 取消虚拟空间映射 */
if (vmm_unmap_space(vmm)) {
return -1;
}
/* 释放虚拟空间描述 */
if (vmm_release_space(vmm)) {
return -1;
}
return 0;
}
|
NightfallDM/xbook2
|
src/gui/console/console.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include <sys/input.h>
#include <sys/trigger.h>
/// 程序本地头文件
#include <gui/console/cursor.h>
#include <gui/console/console.h>
#include <gui/console/clipboard.h>
#include <gui/screen.h>
#include <gui/keyboard.h>
#include <gui/mouse.h>
#include <sys/input.h>
#include <gui/rect.h>
#include <gui/text.h>
#include <gui/event.h>
/* 控制台全局变量 */
con_screen_t gui_con_screen;
void con_set_chars(char ch, int counts, int x, int y)
{
int cx = x, cy = y;
while (counts > 0) {
con_set_char(ch, cx, cy);
cx++;
if (cx >= gui_con_screen.columns) {
cx = 0;
cy++;
/*if (cy >= gui_con_screen.rows) {
cy = gui_con_screen.rows;
}*/
}
counts--;
}
}
void con_get_chars(char *buf, int counts, int x, int y)
{
int cx = x, cy = y;
char *p = buf;
while (counts > 0) {
con_get_char(p, cx, cy);
cx++;
if (cx >= gui_con_screen.columns) {
cx = 0;
cy++;
/*if (cy >= gui_con_screen.rows) {
cy = gui_con_screen.rows;
}*/
}
counts--;
if (*p) /* 非结束字符才继续往后移动 */
p++;
}
}
void con_select_char(int cx, int cy)
{
char ch;
con_get_char(&ch, cx, cy);
int x = cx * gui_con_screen.char_width, y = cy * gui_con_screen.char_height;
GUI_COLOR bgcolor = (0xffffff - (gui_con_screen.background_color & 0xffffff)) | (0xff << 24);
GUI_COLOR fontcolor = (0xffffff - (gui_con_screen.font_color & 0xffffff)) | (0xff << 24);
/* 绘制背景 */
gui_draw_rect_fill(x, y,
gui_con_screen.char_width, gui_con_screen.char_height, bgcolor);
if (0x20 <= ch && ch <= 0x7e) {
/* 绘制字符 */
gui_draw_word(x, y, ch, fontcolor);
}
}
void con_region_chars(int x0, int y0, int x1, int y1)
{
int x, y;
int cx, cy; // 字符坐标
/* 计算刷新区域 */
int left, right, top, bottom;
top = min(y0, y1);
bottom = max(y0, y1);
/* 取整对齐 */
top = top / gui_con_screen.char_height * gui_con_screen.char_height;
bottom = bottom / gui_con_screen.char_height * gui_con_screen.char_height + gui_con_screen.char_height;
/* 计算行数 */
int lines = (bottom - top) / gui_con_screen.char_height;
if (lines > 1) { /* 选取多行，就需要刷新多行 */
if (y1 > y0) { /* 第一个点位于上方，那么，第一行的左边就是第一个点 */
left = x0;
} else { /* 第二个点位于上方，那么，第一行的左边就是第二个点 */
left = x1;
}
/* 第一行从左最小到右边框 */
right = gui_con_screen.width;
left = left / gui_con_screen.char_width * gui_con_screen.char_width;
y = top;
for (x = left; x < right; x += gui_con_screen.char_width) {
cx = x / gui_con_screen.char_width;
cy = y / gui_con_screen.char_height;
/* 选中某个字符 */
con_select_char(cx, cy);
}
y += gui_con_screen.char_height;
if (lines > 2) { /* 大于2行 */
/* 整行都选择 */
left = 0;
right = gui_con_screen.width;
while (lines > 2) {
for (x = left; x < right; x += gui_con_screen.char_width) {
cx = x / gui_con_screen.char_width;
cy = y / gui_con_screen.char_height;
/* 选中某个字符 */
con_select_char(cx, cy);
}
y += gui_con_screen.char_height;
lines--;
}
}
if (y1 > y0) {
right = x1; /* 第二个点位于下方，那么，最后一行的右边就是第二个点 */
} else {
right = x0; /* 第一个点位于下方，那么，最后一行的右边就是第一个点 */
}
/* 从左边框到最右最大 */
left = 0;
right = right / gui_con_screen.char_width * gui_con_screen.char_width + gui_con_screen.char_width;
/* 最后一行 */
for (x = left; x < right; x += gui_con_screen.char_width) {
cx = x / gui_con_screen.char_width;
cy = y / gui_con_screen.char_height;
/* 选中某个字符 */
con_select_char(cx, cy);
}
} else {
/* 最左到最右 */
left = min(x0, x1);
right = max(x0, x1);
left = left / gui_con_screen.char_width * gui_con_screen.char_width;
right = right / gui_con_screen.char_width * gui_con_screen.char_width + gui_con_screen.char_width;
/* 向下对齐 */
for (y = top; y < bottom; y += gui_con_screen.char_height) {
for (x = left; x < right; x += gui_con_screen.char_width) {
cx = x / gui_con_screen.char_width;
cy = y / gui_con_screen.char_height;
/* 选中某个字符 */
con_select_char(cx, cy);
}
}
}
if (bottom - top > gui_con_screen.char_height) { /* 选取多行，就需要刷新多行 */
left = 0;
right = gui_con_screen.width;
} else {
left = min(x0, x1);
right = max(x0, x1);
left = left / gui_con_screen.char_width * gui_con_screen.char_width;
right = right / gui_con_screen.char_width * gui_con_screen.char_width + gui_con_screen.char_width;
}
}
void gui_draw_char(char ch)
{
int x = cursor.x * gui_con_screen.char_width;
int y = cursor.y * gui_con_screen.char_height;
/* 绘制背景 */
gui_draw_rect_fill(x, y,
gui_con_screen.char_width, gui_con_screen.char_height, gui_con_screen.background_color);
/* 绘制字符 */
gui_draw_word(x, y, ch, gui_con_screen.font_color);
}
void load_char_buffer()
{
int bx, by, x, y;
char ch;
for (by = 0; by < gui_con_screen.rows; by++) {
for (bx = 0; bx < gui_con_screen.columns; bx++) {
con_get_char(&ch, bx, by);
if (0x20 <= ch && ch <= 0x7e) {
x = bx * gui_con_screen.char_width;
y = by * gui_con_screen.char_height;
/* 绘制字符 */
gui_draw_word(x,
y, ch, gui_con_screen.font_color);
}
}
}
}
static int can_scroll_up()
{
if (gui_con_screen.cur_pos > gui_con_screen.buffer) {
return 1;
}
return 0;
}
static int can_scroll_down()
{
if (gui_con_screen.cur_pos < (gui_con_screen.buffer + gui_con_screen.buflen) - \
gui_con_screen.rows * gui_con_screen.columns) {
return 1;
}
return 0;
}
/**
* con_flush - 刷新屏幕
*
*/
void con_flush()
{
//清空背景
gui_draw_rect_fill(0, 0,
gui_con_screen.width, gui_con_screen.height, gui_con_screen.background_color);
//把字符全部加载到窗口
load_char_buffer();
draw_cursor();
}
/**
* con_flush_area - 刷新屏幕区域
*/
void con_flush_area(int x0, int y0, int x1, int y1)
{
//清空背景
gui_draw_rect_fill(x0, y0,
x1 - x0, y1 - y0, gui_con_screen.background_color);
//把字符全部加载到窗口
load_char_buffer();
draw_cursor();
}
/**
* con_flush_rect - 刷新屏幕区域
*/
void con_flush_rect(int x, int y, int w, int h)
{
//清空背景
gui_draw_rect_fill(x, y,
w, h, gui_con_screen.background_color);
//把字符全部加载到窗口
load_char_buffer();
draw_cursor();
}
/**
* con_flush2 - 根据鼠标移动位置来刷新
* 如果鼠标移动的时候跨越字符后，就需要重新刷新，不然就不刷新
*/
void con_flush2(int mx0, int my0, int mx1, int my1)
{
int cx0, cy0, cx1, cy1;
cx0 = mx0 / gui_con_screen.char_width;
cy0 = my0 / gui_con_screen.char_height;
cx1 = mx1 / gui_con_screen.char_width;
cy1 = my1 / gui_con_screen.char_height;
/* 鼠标移动以单个字符为单位进行判断，在单个字符内移动就不刷新 */
if ((cx0 != cx1) || (cy0 != cy1)) {
/* 选取一个合适的范围 */
con_flush_rect(0, min(cy0, cy1) * gui_con_screen.char_height,
gui_con_screen.width, (abs(cy1 - cy0) + 1) * gui_con_screen.char_height);
}
}
/**
* scroll_screen - 向上或者向下滚动屏幕
* @dir: 滚动方向
* @lines 滚动几行
* @cursorx: 滚动后光标x是否改变
* @cursory: 滚动后光标y是否改变
*
*/
void scroll_screen(int dir, int lines, int cursorx, int cursory)
{
if (dir == CON_SCROLL_UP) {
//判断是否能滚屏
if (!can_scroll_up()) {
//如果不能向下滚屏就返回
return;
}
//清空背景
gui_draw_rect_fill(0, 0,
gui_con_screen.width, gui_con_screen.height, gui_con_screen.background_color);
//修改显存起始位置
gui_con_screen.cur_pos -= gui_con_screen.columns * lines;
//把字符全部加载到窗口
load_char_buffer();
if (cursorx)
cursor.x = 0;
if (cursory) {
cursor.y += lines;
if (cursor.y > gui_con_screen.rows - 1) {
//cursor.y = gui_con_screen.rows - 1;
cursor.visual = 0;
} else {
cursor.visual = 1;
}
}
//修改光标位置
draw_cursor();
} else if (dir == CON_SCROLL_DOWN) {
//判断是否能滚屏
if (!can_scroll_down()) {
//如果不能向下滚屏就返回
return;
}
//清空背景
gui_draw_rect_fill(0, 0,
gui_con_screen.width, gui_con_screen.height, gui_con_screen.background_color);
//修改显存起始位置
gui_con_screen.cur_pos += gui_con_screen.columns * lines;
//把字符全部加载到窗口
load_char_buffer();
//if (!accord) {
if (cursorx)
cursor.x = 0;
if (cursory) {
cursor.y -= lines;
if (cursor.y < 0) {
//cursor.y = 0;
cursor.visual = 0;
} else {
cursor.visual = 1;
}
}
//}
//绘制光标
draw_cursor();
}
/* 滚屏时，要把鼠标上次的颜色设置成背景色 */
gui_mouse.old_color = gui_screen.gui_to_screen_color(gui_con_screen.background_color);
gui_mouse.show(gui_mouse.x, gui_mouse.y);
}
/*
显示一个可见字符
*/
void con_ouput_visual(char ch, int x, int y)
{
if (0x20 <= ch && ch <= 0x7e) {
/* 绘制字符 */
gui_draw_word(x,
y, ch, gui_con_screen.font_color);
}
}
void con_out_char(char ch)
{
//先把光标去除
clean_cursor();
int counts;
//对字符进行设定，如果是可显示字符就显示
switch (ch) {
case '\n':
//光标的位置设定一个字符
con_set_char('\n', cursor.x, cursor.y);
//能否回车
if (can_scroll_down())
move_cursor(0, cursor.y + 1);
break;
case '\b':
con_set_char(' ', cursor.x, cursor.y);
//改变位置
cursor.x--;
//改变位置后需要做检测，因为要写入字符
cursor_pos_check();
con_set_char(0, cursor.x, cursor.y);
draw_cursor();
break;
case '\t':
/* 离当前位置有多少个字符 */
counts = ((cursor.x + 4) & (~(4 - 1))) - cursor.x;
while (counts--) {
con_set_char(' ', cursor.x, cursor.y);
move_cursor(cursor.x + 1, cursor.y);
}
break;
case '\r': /* 不处理 */
break;
default :
con_set_char(ch, cursor.x, cursor.y);
move_cursor(cursor.x + 1, cursor.y);
break;
}
}
void con_out_str(char *str)
{
while (*str)
{
con_out_char(*str);
str++;
}
}
/*
清除屏幕上的所有东西，
字符缓冲区里面的文字
*/
static void con_clear()
{
//清空字符缓冲区
memset(gui_con_screen.buffer, 0, gui_con_screen.buflen);
//修改字符缓冲区指针
gui_con_screen.cur_pos = gui_con_screen.buffer;
//重置光标
cursor.x = 0;
cursor.y = 0;
//清空背景
gui_draw_rect_fill(0, 0,
gui_con_screen.width, gui_con_screen.height, gui_con_screen.background_color);
//绘制光标
//draw_cursor();
/* 显示鼠标 */
gui_mouse.old_color = gui_screen.gui_to_screen_color(gui_con_screen.background_color);
gui_mouse.show(gui_mouse.x, gui_mouse.y);
}
/*
清除屏幕上的所有东西，
字符缓冲区里面的文字
*/
static void con_clear_area(int x, int y, unsigned int width, unsigned int height)
{
//清空背景
gui_draw_rect_fill(x, y,
width, height, gui_con_screen.background_color);
/* 显示鼠标 */
gui_mouse.old_color = gui_screen.gui_to_screen_color(gui_con_screen.background_color);
gui_mouse.show(gui_mouse.x, gui_mouse.y);
}
void con_set_back_color(GUI_COLOR color)
{
gui_con_screen.background_color = color;
}
void con_set_font_color(GUI_COLOR color)
{
gui_con_screen.font_color = color;
}
int cprintf(const char *fmt, ...)
{
char buf[BUFSIZ];
va_list arg = (va_list)((char*)(&fmt) + 4); /*4是参数fmt所占堆栈中的大小*/
vsprintf(buf, fmt, arg);
/* 输出到控制台 */
gui_con_screen.outs(buf);
return 0;
}
int con_loop()
{
gui_event e;
while (1) {
/* 获取事件 */
if (!gui_event_poll(&e)) {
switch (e.type)
{
case GUI_NOEVENT:
break;
case GUI_EVENT_MOUSE_BUTTON:
if (e.button.state == GUI_PRESSED) { // 按下
if (e.button.button == 0) {
//printf("[%s] left button pressed.\n", SRV_NAME);
clipboard_start_select(e.button.x, e.button.y);
} else if (e.button.button == 2) {
clipboard_copy_select();
}
} else {
if (e.button.button == 0) {
//printf("[%s] left button released.\n", SRV_NAME);
clipboard_end_select(e.button.x, e.button.y);
}
}
break;
case GUI_EVENT_MOUSE_MOTION:
clipboard_move_select(e.motion.x, e.motion.y);
break;
case GUI_EVENT_KEY:
if (e.key.state == GUI_PRESSED) {
/* 组合按键 */
if (e.key.modify & GUI_KMOD_CTRL) {
if (e.key.code == KEY_UP) {
scroll_screen(CON_SCROLL_UP, 1, 0, 1);
break;
} else if (e.key.code == KEY_DOWN) {
scroll_screen(CON_SCROLL_DOWN, 1, 0, 1);
break;
}
}
/* save key data */
fifo_io_put(gui_con_screen.keyfifo, e.key.code);
fifo_io_put(gui_con_screen.keyfifo, e.key.modify);
break;
}
break;
default:
break;
}
}
}
return 0;
}
/**
* 从控制台获取按键
* @key: 按键缓冲区
* @flags: 标志
*
* 成功返回0，失败返回-1
*/
int sys_xcon_get(int *key, int flags)
{
if (flags > 0) {
if (fifo_io_len(gui_con_screen.keyfifo) <= 0) /* no data, return */
return -1;
}
*key++ = fifo_io_get(gui_con_screen.keyfifo); /* keycode */
*key = fifo_io_get(gui_con_screen.keyfifo); /* modify */
return 0;
}
/* 获取按键 */
void sys_xcon_clear()
{
gui_con_screen.clear();
}
/**
* 往控制台输出数据
* @buf: 按键缓冲区
* @len: 标志
*
* 成功返回0，失败返回-1
*/
int sys_xcon_put(void *buf, int len)
{
char *str = (char *) buf;
while (*str && len > 0) {
gui_con_screen.outc(*str);
str++;
len--;
}
return len;
}
int gui_init_console()
{
gui_con_screen.width = gui_screen.width;
gui_con_screen.height = gui_screen.height;
gui_con_screen.char_width = CON_CHAR_WIDTH;
gui_con_screen.char_height = CON_CHAR_HEIGHT;
gui_con_screen.rows = gui_con_screen.height / gui_con_screen.char_height;
gui_con_screen.columns = gui_con_screen.width / gui_con_screen.char_width;
gui_con_screen.columns_width = gui_con_screen.columns * gui_con_screen.char_width;
gui_con_screen.rows_height = gui_con_screen.rows * gui_con_screen.char_height;
gui_con_screen.codepage = CON_CODEPAGE;
gui_con_screen.background_color = CON_SCREEN_BG_COLOR;
gui_con_screen.font_color = CON_SCREEN_FONT_COLOR;
gui_con_screen.mouse_color = CON_MOUSE_COLOR;
gui_con_screen.outc = con_out_char;
gui_con_screen.outs = con_out_str;
gui_con_screen.clear = con_clear;
gui_con_screen.clear_area = con_clear_area;
gui_con_screen.buflen = gui_con_screen.rows * gui_con_screen.columns * CON_FRAME_NR;
printf("[gui]: alloc console screen buffer rows %d columns %d frames %d size %x!\n",
gui_con_screen.rows ,gui_con_screen.columns, CON_FRAME_NR,gui_con_screen.buflen);
gui_con_screen.buffer = kmalloc(gui_con_screen.buflen);
if (gui_con_screen.buffer == NULL)
return -1;
memset(gui_con_screen.buffer, 0, gui_con_screen.buflen);
gui_con_screen.cur_pos = gui_con_screen.buffer;
gui_draw_rect(0, 0, gui_screen.width, gui_screen.height, COLOR_BLACK);
init_con_cursor();
if (init_clipboard() < 0) {
kfree(gui_con_screen.buffer);
return -1;
}
gui_con_screen.keyfifo = fifo_io_alloc(64);
if (gui_con_screen.keyfifo == NULL) {
kfree(gui_con_screen.buffer);
exit_clipboard();
return -1;
}
/* 显示鼠标光标 */
gui_mouse.old_color = gui_screen.gui_to_screen_color(gui_con_screen.background_color);
gui_mouse.show(gui_mouse.x, gui_mouse.y);
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/hwinfo.h
|
#ifndef _X86_HWINFO_H
#define _X86_HWINFO_H
#include <arch/config.h>
#include <arch/cmos.h>
/* hardware info */
#endif /* _X86_HWINFO_H */
|
NightfallDM/xbook2
|
library/xlibc/stdio/setvbuf.c
|
<reponame>NightfallDM/xbook2
/*
* libc/stdio/setvbuf.c
*/
#include <stdio.h>
int setvbuf(FILE * f, char * buf, int mode, size_t size)
{
f->rwflush(f);
f->mode = mode;
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/vmm.c
|
#include <arch/page.h>
#include <arch/vmm.h>
#include <xbook/kmalloc.h>
#include <xbook/debug.h>
#include <xbook/vmspace.h>
#include <xbook/vmm.h>
#include <string.h>
#define DEBUG_LOCAL 0
static int do_copy_share_page(addr_t vaddr, vmm_t *child, vmm_t *parent)
{
/* 保存物理地址 */
addr_t paddr = addr_v2p(vaddr);
#if DEBUG_LOCAL == 1
pr_dbg("[vmm]: copy share page at vaddr %x phy addr %x\n", vaddr, paddr);
#endif
/* 2.切换到子进程空间 */
vmm_active(child);
// 根据空间的保护来设定页属性
page_link(vaddr, paddr, PG_RW_W | PG_US_U);
/* 5.恢复父进程内存空间 */
vmm_active(parent);
return 0;
}
static int do_copy_normal_page(addr_t vaddr, void *buf, vmm_t *child, vmm_t *parent)
{
addr_t paddr;
/* 1.将进程空间中的数据复制到内核空间，切换页表后，
还能访问到父进程中的数据 */
memcpy(buf, (void *)vaddr, PAGE_SIZE);
/* 2.切换进程空间 */
vmm_active(child);
/* 3.映射虚拟地址 */
// 分配一个物理页
paddr = alloc_page();
if (!paddr) {
printk(KERN_ERR "copy_vm_mapping: alloc_page for vaddr failed!\n");
/* 激活父进程并返回 */
vmm_active(parent);
return -1;
}
// 根据空间的保护来设定页属性
page_link(vaddr, paddr, PG_RW_W | PG_US_U);
/* 4.从内核复制数据到进程 */
memcpy((void *)vaddr, buf, PAGE_SIZE);
/* 5.恢复父进程内存空间 */
vmm_active(parent);
return 0;
}
/* 复制进程虚拟内存的映射 */
int __copy_vm_mapping(task_t *child, task_t *parent)
{
/* 开始内存的复制 */
void *buf = kmalloc(PAGE_SIZE);
if (buf == NULL) {
printk(KERN_ERR "copy_vm_mapping: kmalloc buf for data transform failed!\n");
return -1;
}
/* 获取父目录的虚拟空间 */
vmspace_t *space = parent->vmm->vmspace_head;
addr_t prog_vaddr = 0;
/* 当空间不为空时就一直获取 */
while (space != NULL) {
/* 获取空间最开始地址 */
prog_vaddr = space->start;
// printk(KERN_DEBUG "the space %x start %x end %x\n", space, space->start, space->end);
/* 在空间中进行复制 */
while (prog_vaddr < space->end) {
/* 如果是共享内存，就只复制页映射，而不创建新的页 */
if (space->flags & VMS_MAP_SHARED) {
if (do_copy_share_page(prog_vaddr, child->vmm, parent->vmm) < 0) {
kfree(buf);
return -1;
}
} else {
if (do_copy_normal_page(prog_vaddr, buf, child->vmm, parent->vmm) < 0) {
kfree(buf);
return -1;
}
}
// printk(KERN_DEBUG "copy at virtual address %x\n", prog_vaddr);
/* 指向下一个页 */
prog_vaddr += PAGE_SIZE;
}
/* 指向下一个空间 */
space = space->next;
}
kfree(buf);
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/vmm.h
|
#ifndef _X86_VMM_H
#define _X86_VMM_H
#include <xbook/task.h>
int __copy_vm_mapping(task_t *child, task_t *parent);
#define copy_vm_mapping __copy_vm_mapping
#endif /*_X86_VMM_H */
|
NightfallDM/xbook2
|
src/include/xbook/fs.h
|
#ifndef _XBOOK_FS_H
#define _XBOOK_FS_H
#define LOCAL_FILE_OPEN_NR 128
#include <stddef.h>
#include <stdint.h>
#include <types.h>
#define FILE_FD_ALLOC 0X01 /* alloced */
#define FILE_FD_NORMAL 0X02 /* is normal file */
#define FILE_FD_DEVICE 0X04 /* is a device */
#define FILE_FD_SOCKET 0X08 /* is a socket */
#define FILE_FD_FIFO 0X10 /* is a fifo */
#define FILE_FD_PIPE0 0X20 /* is a pipe0: read */
#define FILE_FD_PIPE1 0X40 /* is a pipe1: write */
typedef struct {
int handle; /* 对象句柄 */
uint32_t flags; /* 对象的标志 */
off_t offset; /* 数据偏移 */
} file_fd_t;
typedef struct {
file_fd_t fds[LOCAL_FILE_OPEN_NR];
char cwd[MAX_PATH];
} file_man_t;
int init_fs();
/// syscall
int sys_open(const char *path, int flags, int mode);
int sys_close(int fd);
int sys_read(int fd, void *buffer, size_t nbytes);
int sys_write(int fd, void *buffer, size_t nbytes);
int sys_ioctl(int fd, int cmd, unsigned long arg);
int sys_fcntl(int fd, int cmd, long arg);
int sys_lseek(int fd, off_t offset, int whence);
int sys_access(const char *path, int mode);
int sys_unlink(const char *path);
int sys_ftruncate(int fd, off_t offset);
int sys_fsync(int fd);
int sys_chmod(const char *path, mode_t mode);
int sys_fchmod(int fd, mode_t mode);
int sys_mkdir(const char *path, mode_t mode);
int sys_rmdir(const char *path);
int sys_rename(const char *source, const char *target);
int sys_chdir(const char *path);
int sys_getcwd(char *buf, int bufsz);
long sys_tell(int fd);
int sys_dup(int oldfd);
int sys_dup2(int oldfd, int newfd);
int sys_pipe(int fd[2]);
int fsif_grow(int fd);
#endif /* _XBOOK_FS_H */
|
NightfallDM/xbook2
|
src/vmm/vmspace.c
|
<gh_stars>0
#include <xbook/vmspace.h>
#include <xbook/task.h>
#include <xbook/debug.h>
#define DEBUG_LOCAL 0
void dump_vmspace(vmm_t *vmm)
{
if (vmm == NULL)
return;
vmspace_t *space = vmm->vmspace_head;
while (space != NULL) {
printk(KERN_INFO "space: start=%x end=%x prot=%x flags:%x\n",
space->start, space->end, space->page_prot, space->flags);
space = space->next;
}
}
/* 虚拟空间的插入。*/
void vmspace_insert(vmm_t *vmm, vmspace_t *space)
{
vmspace_t *prev = NULL;
vmspace_t *p = (vmspace_t *)vmm->vmspace_head;
while (p != NULL) {
/* 查找在space后面的空间 */
if (space->end <= p->start)
break;
prev = p;
p = p->next;
}
/* p是space的后一个 */
space->next = p;
if (prev) /* 把space插入到prev和p中间 */
prev->next = space;
else /* 如果前一个是空，说明插入到队首 */
vmm->vmspace_head = (void *)space;
space->vmm = vmm; /* 绑定空间的虚拟内存管理 */
/* 合并相邻的空间 */
/* merge prev and space */
if (prev != NULL && prev->end == space->start) {
if (prev->page_prot == space->page_prot && prev->flags == space->flags) {
prev->end = space->end;
prev->next = p;
vmspace_free(space);
space = prev;
}
}
/* merge space and p */
if (p != NULL && space->end == p->start) {
if (space->page_prot == p->page_prot && space->flags == p->flags) {
space->end = p->end;
space->next = p->next;
vmspace_free(space);
}
}
}
/**
* vmspace_get_unmaped - 获取一个没有映射的空闲空间
* @mm: 内存管理器
* @len: 要获取的长度
*
* 查找一个没有映射的空间并返回其地址
*/
unsigned long vmspace_get_unmaped(vmm_t *vmm, unsigned len)
{
/* 地址指向没有映射的空间的最开始处 */
unsigned long addr = vmm->map_start;
// 根据地址获取一个space
vmspace_t *space = vmspace_find(vmm, addr);
// 循环查找长度符合的空间
while (space != NULL) {
/* 如果到达最后，就退出查找 */
if (USER_VMM_SIZE - len < addr)
return -1;
/* 如果超过可映射胡最大范围，也退出 */
if (addr + len >= vmm->map_end)
return -1;
/* 如果要查找的区域在链表中间就直接返回地址 */
if (addr + len <= space->start)
return addr;
/* 获取下一个地址 */
addr = space->end;
/* 获取下一个空间 */
space = space->next;
}
/* 地址空间在链表的最后面 */
return addr;
}
/**
* do_vmspace_map - 映射地址
* @addr: 虚拟地址
* @paddr: 虚拟地址
* @len: 长度
* @prot: 页保护
* @flags: 空间的标志
*
* 做地址映射，进程才可以读写空间
*/
int do_vmspace_map(vmm_t *vmm, unsigned long addr, unsigned long paddr,
unsigned long len, unsigned long prot, unsigned long flags)
{
if (vmm == NULL || !prot) {
printk(KERN_ERR "do_vmspace_map: failed!\n");
return -1;
}
// printk(KERN_DEBUG "do_vmspace_map: %x, %x, %x, %x\n", addr, len, prot, flags);
/* 让长度和页大小PAGE_SIZE对齐 */
len = PAGE_ALIGN(len);
/* 如果长度为0，什么也不做 */
if (!len) {
printk(KERN_ERR "do_vmspace_map: len is zero!\n");
return -1;
}
/* 越界就返回 */
if (len > USER_VMM_SIZE || addr > USER_VMM_SIZE || addr > USER_VMM_SIZE - len) {
printk(KERN_ERR "do_vmspace_map: addr and len out of range!\n");
return -1;
}
//printk(KERN_DEBUG "len right\n");
/* 如果是MAP_FIXED, 地址就要和页大小PAGE_SIZE对齐
也就是说，传入的地址是多少就是多少，不用去自动协调
*/
if (flags & VMS_MAP_FIXED) {
// 地址需要是页对齐的
if (addr & ~PAGE_MASK)
return -1;
/* 检测地址不在空间里面，也就是说 [addr, addr+len] */
vmspace_t* p = vmspace_find(vmm, addr);
// 存在这个空间，并且地址在这个空间中就返回。不能对这段空间映射
if (p != NULL && addr + len > p->start) {
printk(KERN_ERR "do_vmspace_map: this FIXED space had existed!\n");
return -1;
}
} else {
// 获取一个没有映射的空间，等会儿用来进行映射
addr = vmspace_get_unmaped(vmm, len);
if (addr == -1) {
printk(KERN_ERR "do_vmspace_map: GetUnmappedVMSpace failed!\n");
return -1;
}
}
if (flags & VMS_MAP_REMAP) {
prot |= PROT_REMAP;
}
/* 从slab中分配一块内存来当做VMSpace结构 */
vmspace_t *space = vmspace_alloc();
if (!space) {
printk(KERN_ERR "do_vmspace_map: kmalloc for space failed!\n");
return -1;
}
vmspace_init(space, addr, addr + len, prot, flags);
/* 插入空间到链表中，并且尝试合并 */
vmspace_insert(vmm, space);
//printk(KERN_DEBUG "map virtual from %x to %x\n", space->start, space->end);
/* 创建空间后，需要做虚拟地址映射 */
if (flags & VMS_MAP_SHARED) { /* 如果是共享映射，就映射成共享的地址 */
//printk(KERN_DEBUG "do_vmspace_map: shared at %x:%x %x\n", addr, paddr, len);
map_pages_fixed(addr, paddr, len, prot);
} else {
map_pages_safe(addr, len, prot);
}
return addr;
}
/**
* do_vmspace_unmap - 取消一个空间的映射
* @mm: 内存管理器
* @addr: 空间的地址
* @len: 空间的长度
*
* 取消空间的映射，用于进程退出时使用，
* 成功返回0，失败返回-1和-2。检测空间范围失败返回-2
*/
int do_vmspace_unmap(vmm_t *vmm, unsigned long addr, unsigned long len)
{
/* 地址要和页大小PAGE_SIZE对齐 */
if ((addr & ~PAGE_MASK) || addr > USER_VMM_SIZE || len > USER_VMM_SIZE-addr) {
printk(KERN_ERR "do_vmspace_unmap: addr and len error!\n");
return -1;
}
/* 让长度和页大小PAGE_SIZE对齐 */
len = PAGE_ALIGN(len);
/* 如果长度为0，什么也不做 */
if (!len) {
printk(KERN_ERR "do_vmspace_unmap: len is zero!\n");
return -1;
}
/* 找到addr < space->end 的空间 */
vmspace_t* prev = NULL;
vmspace_t* space = vmspace_find_prev(vmm, addr, &prev);
/* 没找到空间就返回 */
if (space == NULL) {
printk(KERN_ERR "do_vmspace_unmap: not found the space!\n");
return -1;
}
/* 保证地址是在空间范围内
在do_vmspace_heap中，我们要执行do_vmspace_unmap。如果是第一次执行，那么do_vmspace_unmap就会失败而退出，
那么我们do_vmspace_heap就不会成功，因此，在这里，我们返回-2，而在do_vmspace_heap中判断返回-1才失败。
在其它情况下，我们判断不是0就说明do_vmspace_map失败，这是一个特例
*/
if (addr < space->start || addr + len > space->end) {
/*printk(KERN_NOTICE "do_vmspace_unmap: addr out of space!\n");
printk(KERN_NOTICE "do_vmspace_unmap: space start %x end %x\n", addr, addr + len);
printk(KERN_NOTICE "do_vmspace_unmap: space start %x end %x\n", space->start, space->end);*/
return -2;
}
unmap_pages_safe(addr, len, space->flags & VMS_MAP_SHARED);
/* 分配一个新的空间，有可能要unmap的空间会分成2个空间，例如：
[start, addr, addr+len, end] => [start, addr], [addr+len, end]
*/
vmspace_t* space_new = vmspace_alloc();
if (!space_new) {
printk(KERN_ERR "do_vmspace_unmap: kmalloc for space_new failed!\n");
return -1;
}
/* 把新空间链接到链表，新空间位于旧空间后面 */
space_new->start = addr + len;
space_new->end = space->end;
space->end = addr;
space_new->next = space->next;
space->next = space_new;
/* 检查是否是第一部分需要移除 */
if (space->start == space->end) {
vmspace_remove(vmm, space, prev);
space = prev;
}
/* 检查是否是第二部分需要移除 */
if (space_new->start == space_new->end) {
vmspace_remove(vmm, space_new, space);
}
return 0;
}
/**
* vmspace_mmap - 内存映射
* @addr: 虚拟地址
* @paddr: 物理地址
* @len: 长度
* @prot: 页保护
* @flags: 空间的标志
*/
void *vmspace_mmap(uint32_t addr, uint32_t paddr, uint32_t len, uint32_t prot, uint32_t flags)
{
task_t *current = current_task;
return (void *)do_vmspace_map(current->vmm, addr, paddr, len, prot, flags);
}
/**
* vmspace_unmmap - 取消内存映射
* @addr: 地址
* @len: 长度
*/
int vmspace_unmmap(uint32_t addr, uint32_t len)
{
task_t *current = current_task;
return do_vmspace_unmap(current->vmm, addr, len);
}
/**
* do_vmspace_heap - 添加新的堆空间
* @addr: 地址
* @len: 长度
*
* 把地址和长度范围内的空间纳入堆的管理。
*/
static unsigned long do_vmspace_heap(vmm_t *vmm, unsigned long addr, unsigned long len)
{
/* 页对齐后检查长度，如果为0就返回 */
len = PAGE_ALIGN(len);
if (!len)
return addr;
//printk(KERN_DEBUG "do_vmspace_heap: addr %x len %x\n", addr, len);
vmspace_t *space;
unsigned long flags, ret;
/* 先清除旧的空间，再进行新的映射 */
ret = do_vmspace_unmap(vmm, addr, len);
/* 如果返回值是-1，就说明取消映射失败 */
if (ret == -1)
return ret;
/* 检测映射空间的数量是否超过最大数量 */
flags = VMS_MAP_HEAP;
/* 查看是否可以和原来的空间进行合并 */
if (addr) {
/* 查找一个比自己小的临近空间 */
space = vmspace_find(vmm, addr - 1);
/* 如果空间的结束和当前地址一样，并且flags也是一样的，就说明他们可以合并 */
if (space && space->end == addr && space->flags == flags) {
/*printk(KERN_DEBUG "do_vmspace_heap: space can merge. old space [%x-%x], new space [%x-%x]\n",
space->start, space->end, addr, addr + len);*/
space->end = addr + len;
goto the_end;
}
}
/* 创建一个space，用来保存新的地址空间 */
space = vmspace_alloc();
if (space == NULL)
return -1;
vmspace_init(space, addr, addr + len, PROT_USER | PROT_WRITE | PROT_EXEC, flags);
vmspace_insert(vmm, space);
/*printk(KERN_DEBUG "do_vmspace_heap: insert space sucess! space [%x-%x]\n",
space->start, space->end);*/
the_end:
return addr;
}
/**
* sys_vmspace_heap - 设置堆的结束值
* @heap: 堆值
*
* 返回扩展的前一个地址
* 如果heap为0，就返回当前heap
* 如果大于vmm->heap_end，就向后扩展
* 小于就向前缩小
* 总是返回当前heap最新值
*/
unsigned long sys_vmspace_heap(unsigned long heap)
{
unsigned long ret;
unsigned long old_heap, new_heap;
vmm_t *vmm = current_task->vmm;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "%s: task %s pid %d vmm heap start %x end %x new %x\n",
__func__, current_task->name, current_task->pid, vmm->heap_start, vmm->heap_end, heap);
#endif
/* 如果堆比开始位置都小就退出 */
if (heap < vmm->heap_start) {
//printk(KERN_DEBUG "sys_vmspace_heap: new heap too low!\n");
goto the_end;
}
/* 使断点值和页对齐 */
new_heap = PAGE_ALIGN(heap);
old_heap = PAGE_ALIGN(vmm->heap_end);
/* 如果新旧堆值在同一个页内，就设置新的堆值然后返回 */
if (new_heap == old_heap) {
//printk(KERN_DEBUG "sys_vmspace_heap: both in a page!\n");
goto set_heap;
}
/* 如果heap小于当前vmm的heap_end，就说明是收缩内存 */
if (heap <= vmm->heap_end && heap >= vmm->heap_start) {
//printk(KERN_DEBUG "sys_vmspace_heap: shrink mm.\n");
/* 收缩地址就取消映射，如果成功就去设置新的断点值 */
if (!do_vmspace_unmap(vmm, new_heap, old_heap - new_heap))
goto set_heap;
printk(KERN_ERR "sys_vmspace_heap: do_vmspace_unmap failed!\n");
goto the_end;
}
/* 检查是否超过堆的空间限制 */
if (heap > vmm->heap_start + MAX_VMS_HEAP_SIZE) {
printk(KERN_ERR "%s: %x out of heap boundary!\n", __func__, heap);
goto the_end;
}
vmspace_t *find;
/* 检查是否和已经存在的空间发生重叠 */
if ((find = vmspace_find_intersection(vmm, old_heap, new_heap + PAGE_SIZE))) {
printk(KERN_ERR "%s: space intersection! old=%x, new=%x, end=%x\n",
__func__, old_heap, new_heap, new_heap + PAGE_SIZE);
#if DEBUG_LOCAL == 1
printk(KERN_ERR "%s: find: start=%x, end=%x\n",
__func__, find->start, find->end);
printk(KERN_ERR "task=%d.\n", current_task->pid);
#endif
goto the_end;
}
/* 检查是否有足够的内存可以进行扩展堆 */
/* 堆新的断点进行空间映射 */
if (do_vmspace_heap(vmm, old_heap, new_heap - old_heap) != old_heap) {
printk(KERN_ERR "sys_vmspace_heap: do_heap failed! addr %x len %x\n",
old_heap, new_heap - old_heap);
goto the_end;
}
set_heap:
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_vmspace_heap: set new heap %x old is %x\n",
heap, vmm->heap_end);
#endif
vmm->heap_end = heap; /* 记录新的堆值 */
the_end:
/* 获取mm中的heap值 */
ret = vmm->heap_end;
//printk(KERN_DEBUG "ret heap is %x\n", ret);
return ret;
}
|
NightfallDM/xbook2
|
src/ipc/sem.c
|
<reponame>NightfallDM/xbook2
#include <xbook/memcache.h>
#include <xbook/debug.h>
#include <string.h>
#include <string.h>
#include <xbook/sem.h>
#include <sys/ipc.h>
/* debug sem : 1 enable, 0 disable */
#define DEBUG_SEM 0
sem_t *sem_table;
/* 保护信号量的分配与释放 */
DEFINE_SEMAPHORE(sem_mutex, 1);
/**
* sem_find_by_name - 通过名字查找信号量
* @name: 信号量的名字
*
* @return: 如果信号量已经在信号量表中，就返回信号量指针，
* 没有则返回NULL
*/
static sem_t *sem_find_by_name(char *name)
{
sem_t *sem;
int i;
for (i = 0; i < SEM_MAX_NR; i++) {
sem = &sem_table[i];
if (sem->name[0] != '\0') { /* 有名字才进行比较 */
if (!strcmp(sem->name, name)) {
return sem;
}
}
}
return NULL;
}
/**
* sem_find_by_id - 通过id查找信号量
* @id: 信号量的id
*
* @return: 如果信号量已经在信号量表中，就返回信号量指针，
* 没有则返回NULL
*/
static sem_t *sem_find_by_id(int semid)
{
sem_t *sem;
int i;
for (i = 0; i < SEM_MAX_NR; i++) {
sem = &sem_table[i];
/* id相同并且正在使用，才找到 */
if (sem->id == semid && sem->name[0] != '\0') {
return sem;
}
}
return NULL;
}
/**
* sem_alloc - 分配一个信号量
* @name: 名字
* @size: 大小
*
* 从信号量表中分配一个信号量
*
* @return: 成功返回信号量结构的地址，失败返回NULL
*/
sem_t *sem_alloc(char *name, int value)
{
sem_t *sem;
int i;
for (i = 0; i < SEM_MAX_NR; i++) {
sem = &sem_table[i];
if (sem->name[0] == '\0') { /* 没有名字才使用 */
semaphore_init(&sem->sema, value);
/* 设置信号量名字 */
memcpy(sem->name, name, SEM_NAME_LEN);
sem->name[SEM_NAME_LEN - 1] = '\0';
#if DEBUG_SEM == 1
printk(KERN_DEBUG "sem_alloc: sem id=%d\n", sem->id);
#endif
return sem; /* 返回信号量 */
}
}
return NULL;
}
/**
* sem_free - 释放一个信号量
* @sem: 信号量
*
* @return: 成功返回0，失败返回-1
*/
int sem_free(sem_t *sem)
{
#if DEBUG_SEM == 1
printk(KERN_DEBUG "sem_free: sem id=%d\n",sem->id);
#endif
memset(sem->name, 0, SEM_NAME_LEN);
return 0;
}
/**
* sem_get - 获取一个信号量
*
* @name: 信号量名
* @value: 信号量大小
* @semflg: 获取标志
* IPC_CREAT: 如果信号量不存在，则创建一个新的信号量，否则就打开
* IPC_EXCL: 和CREAT一起使用，则要求创建一个新的信号量，若已存在，就返回-1。
* 相当于在CREAT上面加了一个必须不存在的限定。
*
* @return: 成功返回信号量id，失败返回-1
*/
int sem_get(char *name, int value, int semflg)
{
/* 检测参数 */
if (name == NULL)
return -1;
char craete_new = 0; /* 是否需要创建一个新的信号量 */
int retval = -1;
sem_t *sem;
semaphore_down(&sem_mutex);
/* 有创建标志 */
if (semflg & IPC_CREAT) { /* 创建一个新的信号量 */
if (semflg & IPC_EXCL) { /* 必须不存在才行 */
craete_new = 1; /* 需要创建一个新的信号量 */
}
sem = sem_find_by_name(name);
if (sem) { /* 信号量已经存在 */
if (craete_new) /* 必须创建一个新的，不能是已经存在的，故错误 */
goto err;
printk(KERN_DEBUG "sem_get: find a exist sem %d.\n", sem->id);
/* 已经存在，那么就返回已经存在的信号量的id */
retval = sem->id;
} else { /* 不存在则创建一个新的 */
sem = sem_alloc(name, value);
if (sem == NULL)
goto err;
printk(KERN_DEBUG "sem_get: alloc a new sem %d.\n", sem->id);
retval = sem->id; /* 返回信号量id */
}
}
err:
semaphore_up(&sem_mutex);
/* 没有创建标志，直接返回错误 */
return retval;
}
/**
* sem_put - 释放一个信号量
*
* @semid: 信号量id
*
* @return: 成功返回0，失败返回-1
*/
int sem_put(int semid)
{
sem_t *sem;
semaphore_down(&sem_mutex);
sem = sem_find_by_id(semid);
if (sem) { /* 信号量存在 */
#if DEBUG_SEM == 1
printk(KERN_INFO "sem value %d.\n", atomic_get(&sem->sema.counter));
#endif
sem_free(sem);
semaphore_up(&sem_mutex);
return 0;
}
semaphore_up(&sem_mutex);
/* 没有找到信号量 */
return -1;
}
/**
* sem_down - 减少信号量
* @semid: 信号量的id
* @semflg: 操作标志。
* IPC_NOWAIT: 如果没有资源，就直接返回-1，不阻塞
*
* @return: 成功返回0，失败返回-1
*/
int sem_down(int semid, int semflg)
{
sem_t *sem;
semaphore_down(&sem_mutex);
sem = sem_find_by_id(semid);
semaphore_up(&sem_mutex);
if (sem == NULL) { /* not found sem */
return -1;
}
if (semflg & IPC_NOWAIT) { /* 尝试down */
if (semaphore_try_down(&sem->sema))
return -1;
} else { /* 一般的down */
semaphore_down(&sem->sema);
}
return 0;
}
/**
* sem_up - 增加信号量
* @semid: 信号量的id
*
* @return: 成功返回0，失败返回-1
*/
int sem_up(int semid)
{
sem_t *sem;
semaphore_down(&sem_mutex);
sem = sem_find_by_id(semid);
semaphore_up(&sem_mutex);
if (sem == NULL) { /* not found sem */
return -1;
}
semaphore_up(&sem->sema);
return 0;
}
/**
* init_sem - 初始化信号量
*/
void init_sem()
{
sem_table = (sem_t *)kmalloc(sizeof(sem_t) * SEM_MAX_NR);
if (sem_table == NULL) /* must be ok! */
panic(KERN_EMERG "init_sem: alloc mem for sem_table failed! :(\n");
//printk(KERN_DEBUG "init_sem: alloc mem table at %x\n", sem_table);
int i;
for (i = 0; i < SEM_MAX_NR; i++) {
sem_table[i].id = 1 + i + i * 2; /* 信号量id */
semaphore_init(&sem_table[i].sema, 0);
memset(sem_table[i].name, 0, SEM_NAME_LEN);
}
#if 0
int semid = sem_get("test", 1, IPC_CREAT);
if (semid == -1)
printk(KERN_ERR "get sem failed!\n");
printk(KERN_DEBUG "get sem %d.\n", semid);
semid = sem_get("test", 1, IPC_CREAT);
if (semid == -1)
printk(KERN_ERR "get sem failed!\n");
printk(KERN_DEBUG "get sem %d.\n", semid);
sem_put(semid);
semid = sem_get("test", 1, IPC_CREAT | IPC_EXCL);
if (semid == -1)
printk(KERN_ERR "get sem failed!\n");
printk(KERN_DEBUG "get sem %d.\n", semid);
#endif
// spin(":)");
}
int sys_sem_get(char *name, int value, int semflg)
{
return sem_get(name, value, semflg);
}
int sys_sem_put(int semid)
{
return sem_put(semid);
}
int sys_sem_down(int semid, int semflg)
{
return sem_down(semid, semflg);
}
int sys_sem_up(int semid)
{
return sem_up(semid);
}
|
NightfallDM/xbook2
|
src/kernel/ktime.c
|
#include <xbook/ktime.h>
#include <xbook/clock.h>
#include <xbook/task.h>
#include <xbook/debug.h>
ktime_t ktime;
/* 每月对应的天数，2月的会在闰年是加1 */
const char month_day[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
void loop_delay(int t)
{
long i, j;
for (i = 0; i < 100 * t; i++)
for (j = 0; j < 10000; j++);
}
/**
* is_leap - 判断是否是闰年
* @year: 传入的年份
*
* 四年一闰，百年不闰，四百年再闰
*/
int is_leap(int year)
{
if (year % 4) return 0;
if (year % 400) return 1;
if (year % 100) return 0;
return 1;
}
/**
* get_week_day - 返回某天是周几
* @year: 年
* @month: 月
* @day: 日
*
* 返回周几（0-6）
*/
static int get_week_day(int year, int month, int day)
{
int c, y, week;
if (month == 1 || month == 2) { //判断month是否为1或2
year--;
month+=12;
}
c = year / 100;
y = year - c * 100;
week = (c / 4) - 2 * c + (y + y / 4) + (13 * (month + 1) / 5) + day - 1;
while(week < 0)
week += 7;
week %= 7;
return week;
}
static int get_month_day()
{
/* 如果是2月，就需要判断是否是闰年 */
if (ktime.month == 2) {
/* 如果是闰年就要加1 */
return month_day[ktime.month] + is_leap(ktime.year);
} else {
return month_day[ktime.month];
}
}
static int get_year_days()
{
int i;
int sum = 0;
/* 计算前几个月的日数 */
for (i = 1; i < ktime.month; i++) {
if (i == 2) /* 对于2月份，都要判断闰年 */
sum += month_day[i] + is_leap(ktime.year);
else
sum += month_day[i];
}
/* 计算当前月的日数 */
sum += ktime.day;
/* 如果是2月以上的，才进行闰年检测 */
if (ktime.month >= 2) {
/* 2月只有day是28的时候，才进行检测 */
if (ktime.month == 2) {
if (ktime.day == 28)
sum += is_leap(ktime.year);
} else {
sum += is_leap(ktime.year);
}
}
return sum;
}
/**
* update_ktime - 改变系统的时间
*/
void update_ktime()
{
ktime.second++;
if(ktime.second > 59){
ktime.minute++;
ktime.second = 0;
if(ktime.minute > 59){
ktime.hour++;
ktime.minute = 0;
if(ktime.hour > 23){
ktime.day++;
ktime.hour = 0;
ktime.week_day++;
/* 如果大于1-6是周一到周六，0是周日 */
if (ktime.week_day > 6)
ktime.week_day = 0;
/* 获取是今年的多少个日子 */
ktime.year_day = get_year_days();
//现在开始就要判断平年和闰年，每个月的月数之类的
if(ktime.day > get_month_day()){
ktime.month++;
ktime.day = 1;
if(ktime.month > 12){
ktime.year++; //到年之后就不用调整了
ktime.month = 1;
}
}
}
}
}
}
/**
* sys_get_ktime - 获取获取内核时间
* @time: 时间结构体
*/
void sys_get_ktime(ktime_t *time)
{
*time = ktime;
}
/* 这个算法来自linux内核 */
#define MINUTE 60
#define HOUR (60*MINUTE)
#define DAY (24*HOUR)
#define YEAR (365*DAY)
/* interestingly, we assume leap-years */
static int month[12] = {
0,
DAY*(31),
DAY*(31+29),
DAY*(31+29+31),
DAY*(31+29+31+30),
DAY*(31+29+31+30+31),
DAY*(31+29+31+30+31+30),
DAY*(31+29+31+30+31+30+31),
DAY*(31+29+31+30+31+30+31+31),
DAY*(31+29+31+30+31+30+31+31+30),
DAY*(31+29+31+30+31+30+31+31+30+31),
DAY*(31+29+31+30+31+30+31+31+30+31+30)
};
/**
* make_timestamp - 生成时间戳
* @tm: 时间结构
*
* 返回时间戳，单位是秒(s)
*/
long make_timestamp(ktime_t * tm)
{
long res;
int year;
year = tm->year - 70;
/* magic offsets (y+1) needed to get leapyears right.*/
res = YEAR*year + DAY*((year+1)/4);
res += month[tm->month];
/* and (y+2) here. If it wasn't a leap-year, we have to adjust */
if (tm->month>1 && ((year+2)%4))
res -= DAY;
res += DAY*(tm->day-1);
res += HOUR*tm->hour;
res += MINUTE*tm->minute;
res += tm->second;
return res;
}
/**
* sys_gettimeofday - 获取时间
* @tv: 时间
* @tz: 时区
*
* 成功返回0，失败返回-1
*/
int sys_gettimeofday(struct timeval *tv, struct timezone *tz)
{
if (!tv && !tv)
return -1;
if (tv) {
tv->tv_sec = make_timestamp(&ktime); /* 生成秒数 */
tv->tv_usec = ((systicks % HZ) * MS_PER_TICKS) * 1000; /* 微秒 */
}
if (tz) {
tz->tz_dsttime = 0;
tz->tz_minuteswest = 0;
}
return 0;
}
int sys_clock_gettime(clockid_t clockid, struct timespec *ts)
{
if (!ts)
return -1;
switch (clockid)
{
case CLOCK_REALTIME: /* 系统统当前时间，从1970年1.1日算起 */
ts->tv_sec = make_timestamp(&ktime); /* 生成秒数 */
ts->tv_nsec = ((systicks % HZ) * MS_PER_TICKS) * 1000000; /* 纳秒 */
break;
case CLOCK_MONOTONIC: /*系统的启动时间，不能被设置*/
ts->tv_sec = (systicks / HZ); /* 生成秒数 */
ts->tv_nsec = ((systicks % HZ) * MS_PER_TICKS) * 1000000; /* 纳秒 */
break;
case CLOCK_PROCESS_CPUTIME_ID: /* 本进程运行时间*/
ts->tv_sec = current_task->elapsed_ticks / HZ; /* 生成秒数 */
ts->tv_nsec = ((current_task->elapsed_ticks % HZ) * MS_PER_TICKS) * 1000000; /* 纳秒 */
break;
case CLOCK_THREAD_CPUTIME_ID: /*本线程运行时间*/
ts->tv_sec = current_task->elapsed_ticks / HZ; /* 生成秒数 */
ts->tv_nsec = ((current_task->elapsed_ticks % HZ) * MS_PER_TICKS) * 1000000; /* 纳秒 */
break;
default:
return -1;
}
return 0;
}
/**
* 转换的ticks值得最大值
*/
#define MAX_SYSTICKS_VALUE ((~0UL >> 1) -1)
/**
* 将timeval格式的时间转换成systicks
*/
unsigned long timeval_to_systicks(struct timeval *tv)
{
unsigned long sec = tv->tv_sec;
unsigned long usec = tv->tv_usec;
if (sec >= (MAX_SYSTICKS_VALUE / HZ)) /* 超过秒的ticks的最大值，就直接返回最大值 */
return MAX_SYSTICKS_VALUE;
usec -= 1000000L / HZ - 1; /* 向下对齐微妙秒数 */
usec /= 1000000L / HZ; /* 秒/HZ=1秒的ticks数 */
return HZ * sec + usec;
}
/**
* 将systicks转换成timeval格式的时间
*/
void systicks_to_timeval(unsigned long ticks, struct timeval *tv)
{
unsigned long sec = ticks / HZ; /* 获取秒数 */
unsigned long usec = (ticks % HZ) * MS_PER_TICKS; /* 获取毫秒数 */
usec *= 1000L; /* 获取微秒数 */
if (sec >= (MAX_SYSTICKS_VALUE / HZ)) /* 超过秒的ticks的最大值，就修复它 */
sec = MAX_SYSTICKS_VALUE;
tv->tv_sec = sec;
tv->tv_usec = usec;
}
/**
* 将timespec格式的时间转换成systicks
*/
unsigned long timespec_to_systicks(struct timespec *ts)
{
unsigned long sec = ts->tv_sec;
unsigned long nsec = ts->tv_nsec;
if (sec >= (MAX_SYSTICKS_VALUE / HZ)) /* 超过秒的ticks的最大值，就直接返回最大值 */
return MAX_SYSTICKS_VALUE;
nsec -= 1000000000L / HZ - 1; /* 向下对齐纳妙秒数 */
nsec /= 1000000000L / HZ; /* 秒/HZ=1秒的ticks数 */
return HZ * sec + nsec;
}
/**
* 将systicks转换成timespec格式的时间
*/
void systicks_to_timespec(unsigned long ticks, struct timespec *ts)
{
unsigned long sec = ticks / HZ; /* 获取秒数 */
unsigned long nsec = (ticks % HZ) * MS_PER_TICKS; /* 获取毫秒数 */
nsec *= 1000000L; /* 获取纳秒数 */
if (sec >= (MAX_SYSTICKS_VALUE / HZ)) /* 超过秒的ticks的最大值，就修复它 */
sec = MAX_SYSTICKS_VALUE;
ts->tv_sec = sec;
ts->tv_nsec = nsec;
}
/**
* print_ktime - 打印系统时间
*/
void print_ktime()
{
printk(KERN_INFO "time:%d:%d:%d date:%d/%d/%d\n", \
ktime.hour, ktime.minute, ktime.second,\
ktime.year, ktime.month, ktime.day);
char *week_day[7];
week_day[0] = "Sunday";
week_day[1] = "Monday";
week_day[2] = "Tuesday";
week_day[3] = "Wednesday";
week_day[4] = "Thursday";
week_day[5] = "Friday";
week_day[6] = "Saturday";
printk(KERN_INFO "week day:%d %s year day:%d\n", ktime.week_day, week_day[ktime.week_day], ktime.year_day);
}
void init_ktime()
{
/* 初始化系统时间 */
//用一个循环让秒相等
do{
ktime.year = get_time_year();
ktime.month = get_time_month();
ktime.day = get_time_day();
ktime.hour = get_time_hour();
ktime.minute = get_time_minute();
ktime.second = get_time_second();
/* 转换成本地时间 */
/* 自动转换时区 */
#if CONFIG_TIMEZONE_AUTO == 1
if(ktime.hour >= 16){
ktime.hour -= 16;
}else{
ktime.hour += 8;
}
#endif /* CONFIG_TIMEZONE_AUTO */
}while(ktime.second != get_time_second());
ktime.week_day = get_week_day(ktime.year, ktime.month, ktime.day);
ktime.year_day = get_year_days();
print_ktime();
}
|
NightfallDM/xbook2
|
src/include/gui/color.h
|
#ifndef __GRAPH_COLOR_H__
#define __GRAPH_COLOR_H__
#include <stdint.h>
#define SCREEN_COLOR uint32_t
#define GUI_COLOR uint32_t
#define COLOR_NO_ALPHA 255
#define __ARGB(a, r, g, b) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
#define COLOR_ARGB(a, r, g, b) __ARGB((a) & 0xff, (r) & 0xff, (g) & 0xff, (b) & 0xff)
#define COLOR_RGB(r, g, b) COLOR_ARGB(COLOR_NO_ALPHA, r, g, b)
/* 常用颜色 */
#define COLOR_RED COLOR_RGB(255, 0, 0)
#define COLOR_GREEN COLOR_RGB(0, 255, 0)
#define COLOR_BLUE COLOR_RGB(0, 0, 255)
#define COLOR_WHITE COLOR_RGB(255, 255, 255)
#define COLOR_BLACK COLOR_RGB(0, 0, 0)
#define COLOR_GRAY COLOR_RGB(195, 195, 195)
#define COLOR_LEAD COLOR_RGB(127, 127, 127)
#define COLOR_YELLOW COLOR_RGB(255, 255, 0)
#define COLOR_NONE COLOR_ARGB(0, 0, 0, 0)
#endif /* __GRAPH_COLOR_H__ */
|
NightfallDM/xbook2
|
src/task/mutexlock.c
|
#include <xbook/mutexlock.h>
#include <xbook/schedule.h>
/**
* mutex_lock - 互斥锁加锁
* @mutex: 锁对象
*/
void mutex_lock(mutexlock_t *mutex)
{
do {
/* 保证整个函数是原子的 */
disable_intr();
/* 循环+等待，做更深的判断 */
if (!atomic_xchg(&mutex->count, 1)) {
/* 如果获取到锁，直接返回 */
enable_intr();
return;
}
mutex->waiters++;
task_t *task = current_task;
list_add_tail(&task->list, &mutex->wait_list);
/*
SET_TASK_STATUS(task, TASK_BLOCKED);
enable_intr();
schedule();*/
task_block(TASK_BLOCKED);
} while (1);
}
/**
* mutex_unlock - 互斥锁解锁
* @mutex: 锁对象
*/
void mutex_unlock(mutexlock_t *mutex)
{
/* 保证整个函数是原子的 */
disable_intr();
atomic_set(&mutex->count, 0); /* set lock unused */
if (mutex->waiters == 0) {
enable_intr();
return;
}
/* 获取第一个等待者 */
task_t *task = list_first_owner(&mutex->wait_list, task_t, list);
list_del_init(&task->list);
mutex->waiters--;
enable_intr();
task_wakeup(task);
}
|
NightfallDM/xbook2
|
src/include/xbook/net.h
|
<gh_stars>0
#ifndef _XBOOK_NET_H
#define _XBOOK_NET_H
#include <lwip/sockets.h>
void init_net(void);
/* 套接字参数传递 */
struct _sockarg {
void *buf; /* 缓冲区 */
int len; /* 缓冲区长度 */
unsigned int flags; /* 标志 */
struct sockaddr *to_from; /* 传输目的地或者传输源 */
socklen_t tolen; /* 套接字结构长度 */
socklen_t *fromlen; /* 来源套接字结构长度 */
};
struct _sockfd_set {
fd_set *readfds;
fd_set *writefds;
fd_set *errorfds;
};
int sys_socket(int domain, int type, int protocol);
int sys_bind(int sockfd, struct sockaddr *my_addr, int addrlen);
int sys_connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
int sys_listen(int sockfd, int backlog);
int sys_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int sys_send(int sockfd, const void *buf, int len, int flags);
int sys_recv(int sockfd, void *buf, int len, unsigned int flags);
int sys_sendto(int sockfd, struct _sockarg *arg);
int sys_recvfrom(int sockfd, struct _sockarg *arg);
int sys_shutdown(int sockfd, int how);
int sys_getpeername(int sockfd, struct sockaddr *serv_addr, socklen_t *addrlen);
int sys_getsockname(int sockfd, struct sockaddr *my_addr, socklen_t *addrlen);
int sys_getsockopt(int sockfd, unsigned int flags, void *optval, socklen_t *optlen);
int sys_setsockopt(int sockfd, unsigned int flags, const void *optval, socklen_t optlen);
int sys_ioctlsocket(int sockfd, int request, void *arg);
int sys_select(int maxfdp, struct _sockfd_set *fd_sets, struct timeval *timeout);
#endif /* _XBOOK_NET_H */
|
NightfallDM/xbook2
|
library/xlibc/math/frexp.c
|
/*
File: frexp.c
Contains: Split a float into mantissa and exponent
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT frexp(double x, int *exptr) {
union {
double* _x;
double_t* x;
} ux;
ux._x = &x;
if (exptr != NULL)
*exptr = ux.x->exponent - 0x3fe;
ux.x->exponent = 0x3fe;
return x;
}
|
NightfallDM/xbook2
|
library/xlibc/stdlib/abs.c
|
#include<stdlib.h>
int abs(int const i)
{
return i>0?i:-i;
}
|
NightfallDM/xbook2
|
src/include/gui/text.h
|
#ifndef __GRAPH_TEXT_H__
#define __GRAPH_TEXT_H__
#include "color.h"
#include "font.h"
void gui_draw_word_ex(
int x,
int y,
char word,
GUI_COLOR color,
gui_font_t *font
);
void gui_draw_text_ex(
int x,
int y,
char *text,
GUI_COLOR color,
gui_font_t *font
);
void gui_draw_word(
int x,
int y,
char ch,
GUI_COLOR color
);
void gui_draw_text(
int x,
int y,
char *text,
GUI_COLOR color
);
#endif /* __GRAPH_TEXT_H__ */
|
NightfallDM/xbook2
|
src/lib/trigger.c
|
<reponame>NightfallDM/xbook2<gh_stars>0
#include <xbook/trigger.h>
/**
* trigaddset - 触发器集添加一个触发器
* @set: 触发器集
* @trig: 触发器
*/
int trigaddset(trigset_t *set,int trig)
{
if (IS_BAD_TRIGGER(trig))
return -1;
*set |= (1 << trig);
return 0;
}
/**
* trigdelset - 触发器集删除一个触发器
* @set: 触发器集
* @trig: 触发器
*/
int trigdelset(trigset_t *set,int trig)
{
if (IS_BAD_TRIGGER(trig))
return -1;
*set &= ~(1 << trig);
return 0;
}
/**
* trigemptyset - 触发器集置空
* @set: 触发器集
*/
int trigemptyset(trigset_t *set)
{
*set = 1; /* 把第一位置1 */
return 0;
}
/**
* trigfillset - 触发器集置满
* @set: 触发器集
*/
int trigfillset(trigset_t *set)
{
*set = 0xffffffffUL; /* 全部置1 */
return 0;
}
/**
* trigismember - 判断触发器是否置1
* @set: 触发器集
*/
int trigismember(trigset_t *set,int trig)
{
if (IS_BAD_TRIGGER(trig))
return 0;
return (*set & (1 << trig));
}
/**
* trigismember - 判断触发器是否置1
* @set: 触发器集
*/
int trigorset(trigset_t *set, trigset_t *setb)
{
*set |= *setb;
return 0;
}
/**
* trigisempty - 判断触发器集是空集
* @set: 触发器集
*/
int trigisempty(trigset_t *set)
{
if (*set > 1) {
return 0;
} else {
return 1;
}
}
/**
* trigisfull - 判断触发器集是满集
* @set: 触发器集
*/
int trigisfull(trigset_t *set)
{
if (*set == 0xffffffffUL) {
return 1;
} else {
return 0;
}
}
int trigmask(int trig)
{
if (IS_BAD_TRIGGER(trig))
return -1;
return (1 << trig);
}
|
NightfallDM/xbook2
|
library/xlibc/math/pow.c
|
<reponame>NightfallDM/xbook2
/*
File: pow.c
Contains: For x^y
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT pow(double x, double y) {
union {
double d;
int x[2];
} u = { x };
u.x[1] = (int)(y * (u.x[1] - 1072632447) + 1072632447);
u.x[0] = 0;
return u.d;
}
|
NightfallDM/xbook2
|
tools/fatfs/main.c
|
<filename>tools/fatfs/main.c
#include <stdio.h>
#include <string.h>
#include "driver.h"
#include <stdlib.h>
#ifdef WIN32
#include <io.h>
#else
#include <sys/dir.h>
#include <dirent.h>
#include <unistd.h>
#endif
#include "ff.h"
#define DEBUG_LOCAL 0
/* 磁盘驱动，把镜像文件模拟成一个磁盘设备 */
/* 镜像目录 */
//#define IMAGE_FILE "D:/Developmemts/github/xbook2/develop/image/hd.img"
#define IMAGE_FILE "../../develop/image/d.img"
/* 主机rom目录 */
//#define ROM_DIR "D:/Developmemts/github/xbook2/tools/rom"
#define ROM_DIR "../../develop/rom"
/* 磁盘是否为ROM */
#define ROM_DIS 0
/* 默认磁盘大小 */
#define DISK_SIZE (10*1024*1024)
extern int mkfs_flags;
int rom_disk; /* rom is always new */
FRESULT scan_files (
char* path /* Start node to be scanned (***also used as work area***) */
);
int scan_host_files(char *host_path, char *custom_path);
/**
* 参数：
* fatfs 磁盘镜像路径 rom目录 磁盘大小（MB）
*
*/
int main(int argc, char *argv[])
{
#if DEBUG_LOCAL == 1
printf("==== FATFS MANAGMENT ====\n");
printf("args:\n");
int i;
for (i = 0; i < argc; i++) {
printf("argv[%d]=%s\n", i, argv[i]);
}
#endif
if (argc > 4) {
printf("fatfs: args error!\n");
printf("usage: fatfs [image file] [rom dir] disksz\n");
return -1;
}
char *image_file;
char *rom_dir;
int disk_sz;
if (argc >= 3) {
image_file = argv[1];
rom_dir = argv[2];
disk_sz = atoi(argv[3]); /* 单位是MB */
if (disk_sz <= 0)
disk_sz = DISK_SIZE;
else
disk_sz *= (1024*1024); /* 转换成MB */
} else {
image_file = IMAGE_FILE;
rom_dir = ROM_DIR;
disk_sz = DISK_SIZE;
}
#if DEBUG_LOCAL == 1
printf("fatfs: image file: %s\n", image_file);
printf("fatfs: rom dir: %s\n", rom_dir);
#endif
rom_disk = ROM_DIS;
int retval = 0;
/* 初始化驱动 */
if (drv_init(image_file, disk_sz) < 0) {
printf("fatfs: init driver failed!\n");
return -1;
}
FATFS fs; /* Filesystem object */
FIL fil; /* File object */
FRESULT res; /* API result code */
UINT bw; /* Bytes written */
BYTE work[FF_MAX_SS]; /* Work area (larger is better for processing time) */
if (mkfs_flags) {
#if DEBUG_LOCAL == 1
printf("fatfs: make a new fs on the disk.\n");
#endif
//MKFS_PARM opt = {FM_FAT32, 0, 0, 0, 0};
/* Format the default drive with default parameters */
res = f_mkfs("", 0, work, sizeof work);
if (res) {
printf("fatfs: f_mkfs error with %d\n", res);
retval = -1;
goto scroll_close_driver;
}
}
/* Gives a work area to the default drive */
if (f_mount(&fs, "", 0) != FR_OK) {
printf("fatfs: mount fs on disk failed!\n");
retval = -1;
goto scroll_close_driver;
}
/* 打印rom目录内容 */
#if DEBUG_LOCAL == 1
printf("==== HOST ROM FILES ====\n");
#endif
scan_host_files(rom_dir, "0:");
/* 打印磁盘文件上的文件信息 */
#if DEBUG_LOCAL == 1
printf("==== FILES ====\n");
#endif
char dir_buf[256] = {0};
strcpy(dir_buf, "0:");
scan_files(dir_buf);
/* Unregister work area */
f_mount(0, "", 0);
printf("fatfs: write rom files success.\n");
scroll_close_driver:
/* 关闭驱动 */
drv_close();
return retval;
}
FRESULT scan_files (
char* path /* Start node to be scanned (***also used as work area***) */
)
{
FRESULT res;
FDIR dir;
UINT i;
static FILINFO fno;
res = f_opendir(&dir, path); /* Open the directory */
if (res == FR_OK) {
for (;;) {
res = f_readdir(&dir, &fno); /* Read a directory item */
if (res != FR_OK || fno.fname[0] == 0) break; /* Break on error or end of dir */
if (fno.fattrib & AM_FDIR) { /* It is a directory */
#if DEBUG_LOCAL == 1
printf("%s/%s\n", path, fno.fname);
#endif
char sub_path[256];
memset(sub_path, 0, 256);
strcat(sub_path, path);
if (sub_path[strlen(path) - 1] != '/') {
strcat(sub_path, "/");
}
strcat(sub_path,fno.fname);
//i = strlen(path);
//sprintf(&path[i], "/%s", fno.fname);
res = scan_files(sub_path); /* Enter the directory */
if (res != FR_OK) break;
//path[i] = 0;
} else { /* It is a file. */
#if DEBUG_LOCAL == 1
printf("%s/%s size: %d\n", path, fno.fname, fno.fsize);
#endif
}
}
f_closedir(&dir);
}
return res;
}
/**
* copy_file_to_custom - 复制文件到客机
*
*/
int copy_file_to_custom(char *host_path, char *custom_path)
{
#if DEBUG_LOCAL == 1
printf("fatfs: copy file from %s to %s\n", host_path, custom_path);
#endif
FILE *fp = fopen(host_path, "rb+");
if (fp == NULL) {
printf("fatfs: error: open host file %s failed!\n", host_path);
return -1;
}
fseek(fp, 0, SEEK_END);
int filesz = ftell(fp);
#if DEBUG_LOCAL == 1
printf("fatfs: host file size:%d\n", filesz);
#endif
if (filesz <= 0) { /* empty file */
fclose(fp);
return -1;
}
FIL fil;
FRESULT fr;
fr = f_open(&fil, custom_path, FA_CREATE_ALWAYS | FA_WRITE);
if (fr != FR_OK) {
printf("fatfs: error: open custom file %s failed!\n",custom_path);
fclose(fp);
return -1;
}
fseek(fp, 0, SEEK_SET);
void *buf = malloc(filesz + 1);
if (buf == NULL) {
printf("fatfs: error: malloc for file buf about %s bytes failed!\n", filesz);
f_close(&fil);
fclose(fp);
return -1;
}
size_t read_bytes;
memset(buf, 0, filesz + 1);
read_bytes = fread(buf, 1, filesz, fp);
#if DEBUG_LOCAL == 1
printf("fatfs: read %d bytes.\n", read_bytes);
#endif
if (read_bytes != filesz || read_bytes <= 0) {
printf("fatfs: error: read file from %s failed!\n", host_path);
free(buf);
f_close(&fil);
fclose(fp);
return -1;
}
unsigned int fw;
f_lseek(&fil, 0);
fr = f_write(&fil, buf, filesz, &fw);
if (fr != FR_OK || fw != filesz) {
printf("fatfs: error: write data to custom file %s failed!\n", custom_path);
free(buf);
f_close(&fil);
fclose(fp);
return -1;
}
free(buf);
f_close(&fil);
fclose(fp);
return 0;
}
#ifdef WIN32
/**
* scan_host_files - 扫描主机上面的目录
*
*/
int scan_host_files(char *host_path, char *custom_path)
{
int rv = 0;
#if 0
/* 改变当前工作目录 */
rv = chdir(host_path);
if (0 != rv) {
printf("fatfs: scan_host_files: call chdir() failed!\n");
rv = -1;
return rv;
}
#endif
/* 打印客机目录 */
#if DEBUG_LOCAL == 1
printf("[custom path] %s\n", custom_path);
#endif
struct _finddata_t data;
long handle;
char path_buf[1024] = {0};
memset(path_buf, 0, 1024);
strcpy(path_buf, host_path);
strcat(path_buf, "/*");
if (-1L == (handle = _findfirst(path_buf, &data)))//成功返回唯一的搜索句柄, 出错返回-1
return rv;
do {
char host_buf[1024];
memset(host_buf, 0, 1024);
char custom_buf[256] = {0};
memset(custom_buf, 0, 256);
if (data.attrib == _A_SUBDIR ) {//目录类型
if (strcmp(data.name, ".") != 0 && strcmp(data.name, "..") != 0) {
/* 在客机中创建一个目录 */
strcat(custom_buf, custom_path);
if (custom_buf[strlen(custom_path)-1] != '/') {
strcat(custom_buf, "/");
}
strcat(custom_buf, data.name);
//sprintf(custom_buf, "%s/%s", custom_path, data.name);
#if DEBUG_LOCAL == 1
printf("[custom dir] %s -> %s\n", custom_buf, data.name);
#endif
//memcpy(custom_path, custom_buf, 256);
f_mkdir(custom_buf);
/* 打印主机路径 */
sprintf(host_buf, "%s/%s", host_path, data.name);
#if DEBUG_LOCAL == 1
printf("[host dir] %s -> %s\n", host_buf, data.name);
#endif
scan_host_files(host_buf, custom_buf);
}
} else {//单个文件
/* 打印主机路径 */
sprintf(host_buf, "%s/%s", host_path, data.name);
#if DEBUG_LOCAL == 1
printf("[host file] %s -> %s\n", host_buf, data.name);
#endif
/* 在客机中创建一个文件 */
sprintf(custom_buf, "%s/%s", custom_path, data.name);
#if DEBUG_LOCAL == 1
printf("[custom file] %s -> %s\n", custom_buf, data.name);
#endif
copy_file_to_custom(host_buf, custom_buf);
}
} while(_findnext( handle, &data ) == 0); //成功返回0 , 出错返回-1
_findclose( handle ); // 关闭当前句柄
return rv;
}
#else
/**
* scan_host_files - 扫描主机上面的目录
*
*/
int scan_host_files(char *host_path, char *custom_path)
{
int rv = 0;
/* 打印客机目录 */
#if DEBUG_LOCAL == 1
printf("[custom path] %s\n", custom_path);
#endif
DIR *dir;
struct dirent *de;
//struct _finddata_t data;
long handle;
char path_buf[1024] = {0};
memset(path_buf, 0, 1024);
strcpy(path_buf, host_path);
dir = opendir(host_path);
if (dir == NULL) {
return -1;
}
do {
de = readdir(dir);
if (de == NULL)
break;
char host_buf[1024];
memset(host_buf, 0, 1024);
char custom_buf[256] = {0};
memset(custom_buf, 0, 256);
if (de->d_type == 4) {//目录类型
if (strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..") != 0) {
/* 在客机中创建一个目录 */
strcat(custom_buf, custom_path);
if (custom_buf[strlen(custom_path)-1] != '/') {
strcat(custom_buf, "/");
}
strcat(custom_buf, de->d_name);
//sprintf(custom_buf, "%s/%s", custom_path, de->d_name);
#if DEBUG_LOCAL == 1
printf("[custom dir] %s -> %s\n", custom_buf, de->d_name);
#endif
//memcpy(custom_path, custom_buf, 256);
f_mkdir(custom_buf);
/* 打印主机路径 */
sprintf(host_buf, "%s/%s", host_path, de->d_name);
#if DEBUG_LOCAL == 1
printf("[host dir] %s -> %s\n", host_buf, de->d_name);
#endif
scan_host_files(host_buf, custom_buf);
}
} else {//单个文件
/* 打印主机路径 */
sprintf(host_buf, "%s/%s", host_path, de->d_name);
#if DEBUG_LOCAL == 1
printf("[host file] %s -> %s\n", host_buf, de->d_name);
#endif
/* 在客机中创建一个文件 */
sprintf(custom_buf, "%s/%s", custom_path, de->d_name);
#if DEBUG_LOCAL == 1
printf("[custom file] %s -> %s\n", custom_buf, de->d_name);
#endif
copy_file_to_custom(host_buf, custom_buf);
}
} while(1); //成功返回0 , 出错返回-1
closedir(dir); // 关闭当前句柄
return rv;
}
#endif
|
NightfallDM/xbook2
|
library/xlibc/console/xcons.c
|
#include <sys/syscall.h>
#include <xcons.h>
int xcons_clear()
{
syscall0(int, SYS_XCONCLEAR);
return 0;
}
int xcons_getkey(int *buf, int flags)
{
return syscall2(int, SYS_XCONGET, buf, flags);
}
int xcons_putstr(void *buf, int len)
{
return syscall2(int, SYS_XCONPUT, buf, len);
}
|
NightfallDM/xbook2
|
src/include/xbook/rawblock.h
|
<reponame>NightfallDM/xbook2
#ifndef _XBOOK_RAW_BLOCK_H
#define _XBOOK_RAW_BLOCK_H
#include "driver.h"
#include <list.h>
#include <xbook/config.h>
#define RAW_BLOCK_NAME_LEN 24
#define RB_SEEK_SET 0
#define RB_SEEK_CUR 1
#define RB_SEEK_END 2
#define RB_BLOCK_NR 256
#define RB_DEVICE "vfloppy"
#define RB_USERSRV "filesrv"
typedef struct raw_block {
list_t list; /* 所有块构成一个链表 */
dev_t handle; /* 设备号 */
unsigned long offset; /* 设备中的偏移 */
unsigned long count; /* 占用块的数量 */
unsigned char *vaddr; /* 所在的虚拟地址 */
unsigned long memsz; /* 占用内存大小 */
unsigned long pos; /* 数据访问位置 */
char name[RAW_BLOCK_NAME_LEN]; /* 块名字标识 */
} raw_block_t;
raw_block_t *raw_block_alloc(handle_t handle, char *name);
void raw_block_free(raw_block_t *block);
raw_block_t *raw_block_get_by_name(char *name);
int raw_block_init(raw_block_t *block, unsigned long off, unsigned long count,
unsigned long memsz);
int raw_block_upload(raw_block_t *block);
int raw_block_download(raw_block_t *block);
void raw_block_seek(raw_block_t *block, unsigned long pos, unsigned char seek);
long raw_block_read(raw_block_t *block, void *buffer, unsigned long size);
long raw_block_write(raw_block_t *block, void *buffer, unsigned long size);
int raw_block_read_off(raw_block_t *rb, void *buffer, unsigned long offset, unsigned long size);
int raw_block_write_off(raw_block_t *rb, void *buffer, unsigned long offset, unsigned long size);
int raw_block_tmp_add(raw_block_t *block, unsigned char *buf, unsigned long size);
void raw_block_tmp_del(raw_block_t *block);
void init_raw_block();
#endif /*_XBOOK_RAW_BLOCK_H*/
|
NightfallDM/xbook2
|
src/include/gui/rect.h
|
<filename>src/include/gui/rect.h
#ifndef __GRAPH_RECT_H__
#define __GRAPH_RECT_H__
#include "color.h"
void gui_draw_rect_fill(int x, int y, int width, int height, GUI_COLOR color);
void gui_draw_rect(int x, int y, int width, int height, GUI_COLOR color);
#endif /* __GRAPH_RECT_H__ */
|
NightfallDM/xbook2
|
src/gui/gui.c
|
#include <gui/screen.h>
#include <gui/keyboard.h>
#include <gui/mouse.h>
#include <gui/event.h>
#include <gui/font.h>
#include <gui/text.h>
#include <gui/rect.h>
#include <gui/console/console.h>
#include <xbook/debug.h>
#include <xbook/gui.h>
#include <xbook/task.h>
/* 主要是处理输入事件 */
void kgui_thread(void *arg)
{
con_loop();
}
void init_gui()
{
if (gui_init_screen() < 0)
panic("init gui screen failed!\n");
if (gui_init_keyboard() < 0)
panic("init gui keyboard failed!\n");
if (gui_init_mouse() < 0)
panic("init gui keyboard failed!\n");
if (gui_init_event() < 0)
panic("init gui event failed!\n");
gui_init_font();
if (gui_screen.open() < 0)
panic("open gui screen failed!\n");
if (gui_keyboard.open() < 0)
panic("open gui keyboard failed!\n");
if (gui_mouse.open() < 0)
panic("open gui keyboard failed!\n");
pr_info("[gui]: init done.\n");
if (gui_init_console() < 0)
panic("init gui console failed!\n");
if (kthread_start("kgui", TASK_PRIO_USER, kgui_thread, NULL) == NULL)
panic("start kgui thread failed!\n");
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/bootmem.h
|
<filename>src/arch/x86/include/arch/bootmem.h
#ifndef _X86_BOOTMEM_H
#define _X86_BOOTMEM_H
#include <stddef.h>
/*
bootmem是用于初始化内核内存空间以及其数据结构的一个简单
分配器。在这里，我们尽量做得简单。
*/
typedef struct boot_mem
{
unsigned int start_addr; // 记录从哪个地方开始进行分配
unsigned int cur_addr; // 当前分配到的位置的地址
unsigned int top_addr; // 引导内存的界限
} boot_mem_t;
void init_boot_mem(unsigned int start, unsigned int limit);
void *boot_mem_alloc(size_t size);
unsigned int boot_mem_pos();
unsigned int boot_mem_size();
#endif /* _X86_BOOTMEM_H */
|
NightfallDM/xbook2
|
src/include/fsal/dir.h
|
#ifndef __FILESRV_FSAL_DIR_H__
#define __FILESRV_FSAL_DIR_H__
#include "fsal.h"
#include "../../fs/fatfs/ff.h"
#include <stdint.h>
#include <types.h>
/* 允许打开的目录数量 */
#define FSAL_DIR_OPEN_NR 128
#define FSAL_DIR_USED 0X01
/* 目录结构 */
typedef int dir_t;
typedef struct {
char flags; /* 文件标志 */
fsal_t *fsal; /* 文件系统抽象 */
union {
DIR fatfs; /* fatfs目录结构 */
} dir;
} fsal_dir_t;
#define fstate_t dirent_t
extern fsal_dir_t *fsal_dir_table;
/* 文件指针转换成在表中的索引 */
#define FSAL_D2I(dir) ((int) ((dir) - fsal_dir_table))
/* 在表中的索引转换成文件指针 */
#define FSAL_I2D(idx) ((fsal_dir_t *)(&fsal_dir_table[(idx)]))
#define ISBAD_FSAL_DIDX(idx) ((idx) < 0 || (idx) >= FSAL_DIR_OPEN_NR)
int init_fsal_dir_table();
fsal_dir_t *fsal_dir_alloc();
int fsal_dir_free(fsal_dir_t *dir);
void build_path(const char *path, char *out_path);
void wash_path(char *old_path, char *new_path);
#endif /* __FILESRV_FSAL_DIR_H__ */
|
NightfallDM/xbook2
|
src/task/waitqueue.c
|
<filename>src/task/waitqueue.c<gh_stars>0
#include <xbook/waitqueue.h>
#include <xbook/task.h>
/**
* wait_queue_add - 把进程添加到等待队列中
* @wait_queue: 等待队列
* @task: 要添加的任务
*/
void wait_queue_add(wait_queue_t *wait_queue, void *_task)
{
task_t *task = (task_t *) _task;
/* 添加到队列时，需要关闭中断 */
unsigned long flags;
spin_lock_irqsave(&wait_queue->lock, flags);
/* 确保任务不在等待队列中 */
ASSERT(!list_find(&task->list, &wait_queue->wait_list));
/* 添加到等待队列中，添加到最后 */
list_add_tail(&task->list, &wait_queue->wait_list);
spin_unlock_irqrestore(&wait_queue->lock, flags);
}
/**
* wait_queue_remove - 把进程从等待队列中移除
* @wait_queue: 等待队列
* @task: 要移除的任务
*/
void wait_queue_remove(wait_queue_t *wait_queue, void *_task)
{
task_t *task = (task_t *) _task;
/* 添加到队列时，需要关闭中断 */
unsigned long flags;
spin_lock_irqsave(&wait_queue->lock, flags);
task_t *target, *next;
/* 在队列中寻找任务，找到后就把任务从队列中删除 */
list_for_each_owner_safe (target, next, &wait_queue->wait_list, list) {
if (target == task) {
/* 把任务从等待队列中删除 */
list_del_init(&target->list);
break;
}
}
spin_unlock_irqrestore(&wait_queue->lock, flags);
}
/**
* wait_queue_wakeup - 唤醒等待队列中的一个任务
* @wait_queue: 等待队列
*/
void wait_queue_wakeup(wait_queue_t *wait_queue)
{
/* 添加到队列时，需要关闭中断 */
unsigned long flags;
spin_lock_irqsave(&wait_queue->lock, flags);
/* 不是空队列就获取第一个等待者 */
if (!list_empty(&wait_queue->wait_list)) {
/* 获取任务 */
task_t *task = list_first_owner(&wait_queue->wait_list, task_t, list);
/* 从当前队列删除 */
list_del(&task->list);
/* 唤醒任务 */
task_wakeup(task);
}
spin_unlock_irqrestore(&wait_queue->lock, flags);
}
/**
* wait_queue_wakeup_all - 唤醒等待队列中的全部任务
* @wait_queue: 等待队列
*/
void wait_queue_wakeup_all(wait_queue_t *wait_queue)
{
/* 添加到队列时，需要关闭中断 */
unsigned long flags;
spin_lock_irqsave(&wait_queue->lock, flags);
task_t *task, *next;
list_for_each_owner_safe (task, next, &wait_queue->wait_list, list) {
/* 从当前队列删除 */
list_del(&task->list);
/* 唤醒任务 */
task_wakeup(task);
}
spin_unlock_irqrestore(&wait_queue->lock, flags);
}
|
NightfallDM/xbook2
|
library/xlibc/stdio/printf.c
|
/*
* libc/stdio/printf.c
*/
#include <stdarg.h>
#include <sizes.h>
#include <stdio.h>
int printf(const char * fmt, ...)
{
va_list ap;
char buf[SZ_1K] = {0};
int rv;
va_start(ap, fmt);
rv = vsnprintf(buf, SZ_4K, fmt, ap);
va_end(ap);
rv = (fputs(buf, stdout) < 0) ? 0 : rv;
fflush(stdout);
return rv;
}
|
NightfallDM/xbook2
|
library/xlibc/include/sys/mount.h
|
<reponame>NightfallDM/xbook2
#ifndef _SYS_MOUNT_H
#define _SYS_MOUNT_H
int mount(
const char *source,
const char *target,
const char *fstype,
unsigned long flags
);
int unmount(const char *source, unsigned long flags);
int mkfs(
const char *source,
const char *fstype,
unsigned long flags
);
#endif /* _SYS_MOUNT_H */
|
NightfallDM/xbook2
|
library/xlibc/math/exp.c
|
<gh_stars>0
/*
File: exp.c
Contains: For e^x
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT exp(M_FLOAT x) {
/* It's not important */
if (fabs(x) < EPSILON)
return (1.0);
x = 1.0 + x / 16384; /* set exactness */
x *= x; /* exactness = 2 */
x *= x; /* exactness = 4 */
x *= x; /* exactness = 8 */
x *= x; /* exactness = 16 */
x *= x; /* exactness = 32 */
x *= x; /* exactness = 64 */
x *= x; /* exactness = 128 */
x *= x; /* exactness = 256 */
x *= x; /* exactness = 512 */
x *= x; /* exactness = 1024 */
x *= x; /* exactness = 2048 */
x *= x; /* exactness = 4096 */
x *= x; /* exactness = 8192 */
x *= x; /* exactness = 16384 */
return x;
}
|
NightfallDM/xbook2
|
user/tests/xlibc_test.c
|
<reponame>NightfallDM/xbook2<gh_stars>0
#include"test.h"
int xlibc_test(int argc,char *argv[])
{
puts("-----------xlibc_test------------");
puts("time");
printf("%lu\n",time(NULL));
puts("stdlib");
srand(time(NULL));
for(int count=0;count<10;count++)
{
printf("%d ",rand());
}
putchar('\n');
for(int count=0;count<10;count++)
{
int num=rand()+rand();
printf("%d:%d ",count,abs(num));
}
putchar('\n');
for(int count=0;count<10;count++)
{
/* Get a 32-bit integer */
long int num=((rand()+rand())<<16)+rand()+rand();
printf("%ld:%ld ",num,labs(num));
}
putchar('\n');
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/atomic.h
|
<reponame>NightfallDM/xbook2
#ifndef _ARCH_ATOMIC_H
#define _ARCH_ATOMIC_H
#include <arch/instruction.h>
/* 原子变量结构体 */
typedef struct {
int value; // 变量的值
} atomic_t;
#define atomic_get(atomic) ((atomic)->value)
#define atomic_set(atomic,val) (((atomic)->value) = (val))
#define ATOMIC_INIT(val) {val}
void __atomic_add(int *a, int b);
void __atomic_sub(int *a, int b);
void __atomic_inc(int *a);
void __atomic_dec(int *a);
void __atomic_or(int *a, int b);
void __atomic_and(int *a, int b);
/**
* atomic_add - 原子加运算
* @atomic: 原子结构
* @value: 数值
*/
static inline void atomic_add(atomic_t *atomic, int value)
{
__atomic_add(&atomic->value, value);
}
/**
* atomic_sub - 原子减运算
* @atomic: 原子结构
* @value: 数值
*/
static inline void atomic_sub(atomic_t *atomic, int value)
{
__atomic_sub(&atomic->value, value);
}
/**
* atomic_inc - 原子增运算
* @atomic: 原子结构
*/
static inline void atomic_inc(atomic_t *atomic)
{
__atomic_inc(&atomic->value);
}
/**
* atomic_dec - 原子减运算
* @atomic: 原子结构
*/
static inline void atomic_dec(atomic_t *atomic)
{
__atomic_dec(&atomic->value);
}
/**
* atomic_set_mask - 设置位
* @atomic: 原子结构
* @mask: 位值
*/
static inline void atomic_set_mask(atomic_t *atomic, int mask)
{
__atomic_or(&atomic->value, mask);
}
/**
* atomic_clear_mask - 清除位
* @atomic: 原子结构
* @mask: 位值
*/
static inline void atomic_clear_mask(atomic_t *atomic, int mask)
{
__atomic_and(&atomic->value, ~mask);
}
#define atomic_xchg(v, new) (xchg(&((v)->value), new))
#endif /* _ARCH_ATOMIC_H */
|
NightfallDM/xbook2
|
src/include/gui/event.h
|
<reponame>NightfallDM/xbook2
#ifndef __GUISRV_EVENT_H__
#define __GUISRV_EVENT_H__
/* 图形事件状态 */
typedef enum _gui_event_state {
GUI_NOSTATE = 0, /* 无状态 */
GUI_PRESSED, /* 按下状态 */
GUI_RELEASED, /* 释放状态 */
GUI_ENTER, /* 进入状态 */
GUI_LEAVE, /* 离开状态 */
} gui_event_state;
/* 图形键盘输入 */
typedef struct _gui_keyboard_event {
unsigned char type; /* 键盘事件类型：gui_KEY_DOWN, gui_KEY_UP */
unsigned char state; /* 按钮状态 */
unsigned int code;
unsigned int modify;
} gui_keyboard_event;
/* 图形鼠标移动 */
typedef struct _gui_mouse_motion_event {
unsigned char type; /* 鼠标移动事件类型：gui_MOUSE_MOTION */
unsigned char state; /* 移动状态： */
int x; /* x横坐标 */
int y; /* y纵坐标 */
} gui_mouse_motion_event;
/* 图形鼠标按扭 */
typedef struct _gui_mouse_button_event {
unsigned char type; /* 鼠标按钮事件类型：gui_MOUSE_DOWN, gui_MOUSE_UP */
unsigned char state; /* 按钮状态 */
unsigned char button; /* 按钮值 */
int x; /* x横坐标 */
int y; /* y纵坐标 */
} gui_mouse_button_event;
/* 图形的事件类型 */
typedef enum _gui_event_type {
GUI_NOEVENT = 0, /* 未使用 */
GUI_EVENT_KEY, /* 按键事件 */
GUI_EVENT_MOUSE_MOTION, /* 鼠标移动 */
GUI_EVENT_MOUSE_BUTTON, /* 鼠标按钮事件 */
GUI_EVENT_QUIT, /* 退出事件 */
GUI_EVENT_NR, /* 最大的事件数量 */
} gui_event_type;
typedef union _gui_event {
unsigned char type; /* 输入类型，由于下面每一个成员的第一个成员都是type，所以次type就是该成员的type */
gui_keyboard_event key;
gui_mouse_motion_event motion;
gui_mouse_button_event button;
} gui_event;
/* 事件数量 */
#define GUI_EVENT_NR 32
#define GUI_EVENT_POOL_EMPTY(pool) \
((pool)->head == (pool)->tail)
/* 由于事件池是在单个进程中使用，所以不需要互斥 */
typedef struct {
gui_event events[GUI_EVENT_NR];
int head; /* 头位置 */
int tail; /* 尾位置 */
} gui_event_pool;
int gui_event_add(gui_event *ev);
int gui_event_del(gui_event *ev);
int gui_event_poll(gui_event *ev);
int gui_init_event();
#endif /* __GUISRV_EVENT_H__ */
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/pic.c
|
<gh_stars>0
#include <arch/pic.h>
#include <arch/io.h>
#include <arch/interrupt.h>
#include <arch/interrupt.h>
/**
* InitPic - 初始化pic
*/
void init_pic(void)
{
/* mask all intr */
__out8(PIC_MASTER_CTLMASK, 0xff );
__out8(PIC_SLAVE_CTLMASK, 0xff );
/* set master pic */
__out8(PIC_MASTER_CTL, 0x11 );
__out8(PIC_MASTER_CTLMASK, 0x20 );
__out8(PIC_MASTER_CTLMASK, 1 << 2);
__out8(PIC_MASTER_CTLMASK, 0x01 );
/* set slave pic */
__out8(PIC_SLAVE_CTL, 0x11 );
__out8(PIC_SLAVE_CTLMASK, 0x28 );
__out8(PIC_SLAVE_CTLMASK, 2 );
__out8(PIC_SLAVE_CTLMASK, 0x01 );
/* mask all intr */
__out8(PIC_MASTER_CTLMASK, 0xff );
__out8(PIC_SLAVE_CTLMASK, 0xff );
}
/**
* PicEnable - PIC中断打开irq
* irq: 中断irq号
*/
static void pic_enable(unsigned int irq)
{
/* bit clear means enable intr */
if(irq < 8){ /* clear master */
__out8(PIC_MASTER_CTLMASK, __in8(PIC_MASTER_CTLMASK) & ~(1 << irq));
} else {
/* clear irq 2 first, then clear slave */
__out8(PIC_MASTER_CTLMASK, __in8(PIC_MASTER_CTLMASK) & ~(1 << IRQ2_CONNECT));
__out8(PIC_SLAVE_CTLMASK, __in8(PIC_SLAVE_CTLMASK) & ~ (1 << (irq - 8)));
}
}
/**
* PicDisable - PIC中断关闭irq
* irq: 中断irq号
*/
static void pic_disable(unsigned int irq)
{
/* bit set means disable intr */
if(irq < 8){ /* set master */
__out8(PIC_MASTER_CTLMASK, __in8(PIC_MASTER_CTLMASK) | (1 << irq));
} else {
/* set slave */
__out8(PIC_SLAVE_CTLMASK, __in8(PIC_SLAVE_CTLMASK) | (1 << (irq - 8)));
}
}
/**
* PicInstall - PIC安装一个中断
* irq: 中断irq号
* arg: 安装传入的参数，一般是中断处理函数的地址
*/
static unsigned int pic_install(unsigned int irq, void * arg)
{
__register_irq_handler((char )irq, (intr_handler_t)arg);
return 1;
}
/**
* PicInstall - PIC安装一个中断
* irq: 中断irq号
* arg: 安装传入的参数，一般是中断处理函数的地址
*/
static void pic_uninstall(unsigned int irq)
{
__unregister_irq_handler((char )irq);
}
/**
* PicInstall - PIC安装一个中断
* irq: 中断irq号
* arg: 安装传入的参数，一般是中断处理函数的地址
*/
static void pic_ack(unsigned int irq)
{
/* 从芯片 */
if (irq >= 8) {
__out8(PIC_SLAVE_CTL, PIC_EIO);
}
/* 主芯片 */
__out8(PIC_MASTER_CTL, PIC_EIO);
}
/* kernel will use var：hardware_intr_contorller */
struct hardware_intr_controller hardware_intr_contorller = {
.install = pic_install,
.uninstall = pic_uninstall,
.enable = pic_enable,
.disable = pic_disable,
.ack = pic_ack,
};
/**
* do_irq - 处理irq中断
* @frame: 获取的中断栈
*
* 在保存环境之后，就执行这个操作，尝试执行中断
*/
int do_irq(trap_frame_t *frame)
{
unsigned int irq;
/* 中断向量号减去异常占用的向量号，就是IRQ号 */
irq = frame->vec_no - 0x20;
/* 处理具体的中断 */
if (!handle_irq(irq, frame)) {
return -1;
}
return 0;
}
|
NightfallDM/xbook2
|
library/xlibc/math/log10.c
|
<gh_stars>0
/*
File: log10.c
Contains: For log(10)(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT log10(M_FLOAT x) {
return (LOG_MULTIPLE / MATH_LN10 * log2(x));
}
|
NightfallDM/xbook2
|
library/xlibc/syslib/trigger.c
|
#include <sys/trigger.h>
#include <sys/syscall.h>
/**
* trigaddset - 触发器集添加一个触发器
* @set: 触发器集
* @trig: 触发器
*/
int trigaddset(trigset_t *set,int trig)
{
if (IS_BAD_TRIGGER(trig))
return -1;
*set |= (1 << trig);
return 0;
}
/**
* trigdelset - 触发器集删除一个触发器
* @set: 触发器集
* @trig: 触发器
*/
int trigdelset(trigset_t *set,int trig)
{
if (IS_BAD_TRIGGER(trig))
return -1;
*set &= ~(1 << trig);
return 0;
}
/**
* trigemptyset - 触发器集置空
* @set: 触发器集
*/
int trigemptyset(trigset_t *set)
{
*set = 1; /* 把第一位置1 */
return 0;
}
/**
* trigfillset - 触发器集置满
* @set: 触发器集
*/
int trigfillset(trigset_t *set)
{
*set = 0xffffffff; /* 全部置1 */
return 0;
}
/**
* trigismember - 判断触发器是否置1
* @set: 触发器集
*/
int trigismember(trigset_t *set,int trig)
{
if (IS_BAD_TRIGGER(trig))
return 0;
return (*set & (1 << trig));
}
/**
* trigisempty - 判断触发器集是空集
* @set: 触发器集
*/
int trigisempty(trigset_t *set)
{
if (*set > 1) {
return 0;
} else {
return 1;
}
}
/**
* trigisfull - 判断触发器集是满集
* @set: 触发器集
*/
int trigisfull(trigset_t *set)
{
if (*set == 0xffffffff) {
return 1;
} else {
return 0;
}
}
int trigger(int trig, trighandler_t handler)
{
return syscall2(int, SYS_TRIGGER, trig, handler);
}
int trigger_action(int trig, trig_action_t *act, trig_action_t *oldact)
{
return syscall3(int, SYS_TRIGGERACT, trig, act, oldact);
}
int triggeron(int trig, pid_t pid)
{
return syscall2(int, SYS_TRIGGERON, trig, pid);
}
int trigprocmask(int how, trigset_t *set, trigset_t *oldset)
{
return syscall3(int, SYS_TRIGPROCMASK, how, set, oldset);
}
int trigpending(trigset_t *set)
{
return syscall1(int, SYS_TRIGPENDING, set);
}
int trigmask(int trig)
{
if (IS_BAD_TRIGGER(trig))
return -1;
return (1 << trig);
}
|
NightfallDM/xbook2
|
src/include/fcntl.h
|
#ifndef _XLIBC_FCNTL_H
#define _XLIBC_FCNTL_H
#include <stdint.h>
enum {
F_SETFL = 1,
F_GETFL,
};
#endif /* _XLIBC_FCNTL_H */
|
NightfallDM/xbook2
|
user/tests/test_jpg.c
|
<filename>user/tests/test_jpg.c
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <jpeglib.h>
#include <jmorecfg.h>
#include <jconfig.h>
#include "test.h"
int jpg_display(char * path)// **指定图片的路径就可以调用这个jpg的解析。**
{
//LCD_init();
/*
１. 分配并初始化一个jpeg解压对象
*/
struct jpeg_decompress_struct dinfo; //定义了一个jpeg的解压对象
struct jpeg_error_mgr jerr; //定义一个错误变量
dinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&dinfo); //初始化这个解压对象
/*
2. 指定要解压缩的图像文件
*/
FILE *infile;
infile = fopen(path, "r");
if (infile == NULL)
{
printf("fopen error!");
return -1;
}
jpeg_stdio_src(&dinfo, infile); //为解压对象dinfo指定要解压的文件
/*
3. 调用jpeg_read_header()获取图像信息
*/
if (jpeg_read_header(&dinfo, TRUE) != JPEG_HEADER_OK) {
fclose(infile);
return -1;
}
/*
4. 设置jpeg解压缩对象dinfo的一些参数，可采用默认参数
*/
/*
5.调用jpeg_start_decompress()启动解压过程
jpeg_start_decompress(&dinfo);
调用jpeg_start_decompress(&dinfo);函数之后，JPEG解压对象dinfo中下面这几个成员变量
将会比较有用：
output_width: 图像的输出宽度
output_height： 图像的输出高度
output_component： 每个像素的分量数，也即字节数，3/4字节
在调用jpeg_start_decompress(&dinfo); 之后往往需要为解压后的扫描线上的所有像素点分配存储空间，
output_width * output_components(一行的字节数，output_height行)
*/
jpeg_start_decompress(&dinfo);
unsigned char *buffer = malloc(dinfo.output_width * dinfo.output_components);
if (buffer == NULL) {
fclose(infile);
jpeg_destroy_decompress(&dinfo);
return -1;
}
printf("width %d, height %d, components %d.\n", dinfo.output_width, dinfo.output_height, dinfo.output_components);
/*
６. 读取一行或者多行扫描线数据并处理，通常的代码是这样的：
//output_scanline表示扫描的总行数
//output_height表示图像的总行数
while (dinfo.output_scanline < dinfo.output_height)
{
jpeg_read_scanlines(&dinfo, &buffer, 1);
//deal with scanlines . RGB/ARGB
}
*/
//output_scanline表示扫描的总行数
//output_height表示图像的总行数
while (dinfo.output_scanline < dinfo.output_height)
{
unsigned char *buf1[1];
buf1[0] = buffer;
jpeg_read_scanlines(&dinfo, buf1, 1); //dinfo.output_scanline + 1
//deal with scanlines . RGB/ARGB
int x; //一行的像素点数量
unsigned char *p = buf1[0];
for (x = 0; x < dinfo.output_width; x++)
{
unsigned char r, g, b, a = 255;
uint32_t color;
if (dinfo.output_components == 3)
{
r = *p++;
g = *p++;
b = *p++;
} else if (dinfo.output_components == 4)
{
a = *p++;
r = *p++;
g = *p++;
b = *p++;
}
color = (a << 24) | (r << 16) | (g << 8) |(b) ;
screen_output_pixel(x, dinfo.output_scanline - 1 , color);
//LCD_DrawPoint(x, dinfo.output_scanline - 1 , color);
//SGI_DrawPixel(display, win, x, dinfo.output_scanline - 1, color);
}
}
/*
7. 调用 jpeg_finish_decompress()完成解压过程
*/
jpeg_finish_decompress(&dinfo);
//jpeg_abort(&dinfo);
/*
８.调用jpeg_destroy_decompress()释放jpeg解压对象dinfo
jpeg_destroy_decompress(&dinfo);
*/
jpeg_destroy_decompress(&dinfo);
return 0;
}
|
NightfallDM/xbook2
|
src/gui/event.c
|
<filename>src/gui/event.c
#include <xbook/kmalloc.h>
#include <stddef.h>
#include <gui/event.h>
#include <gui/keyboard.h>
#include <gui/mouse.h>
gui_event_pool *event_pool;
/* 添加一个事件 */
int gui_event_add(gui_event *ev)
{
/* 检查事件池满 */
int next = (event_pool->head + 1) % GUI_EVENT_NR;
if (next == event_pool->tail) { /* 事件池满，丢弃 */
return -1;
}
/* 放入事件 */
gui_event *tmp = &event_pool->events[event_pool->head];
*tmp = *ev;
event_pool->head = (event_pool->head + 1) % GUI_EVENT_NR;
return 0;
}
/* 添加一个事件 */
int gui_event_del(gui_event *ev)
{
/* 判断事件池情况 */
if (GUI_EVENT_POOL_EMPTY(event_pool)) {
return -1;
}
/* 放入事件 */
gui_event *tmp = &event_pool->events[event_pool->tail];
*ev = *tmp;
event_pool->tail = (event_pool->tail + 1) % GUI_EVENT_NR;
return 0;
}
/* 轮询事件 */
int gui_event_poll(gui_event *ev)
{
/* 读取事件 */
gui_keyboard.read();
gui_mouse.read();
/* 从事件池中删除一个事件，并传输 */
return gui_event_del(ev);
}
int gui_init_event()
{
event_pool = kmalloc(sizeof(gui_event_pool));
if (event_pool == NULL) {
return -1;
}
event_pool->head = event_pool->tail = 0;
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/segment.c
|
#include <arch/registers.h>
#include <arch/segment.h>
#include <arch/tss.h>
/*
* Global descriptor table
*/
struct segment_descriptor *gdt;
static void set_segment_descriptor(struct segment_descriptor *descriptor, unsigned int limit, \
unsigned int base, unsigned int attributes)
{
descriptor->limit_low = limit & 0xffff;
descriptor->base_low = base & 0xffff;
descriptor->base_mid = (base >> 16) & 0xff;
descriptor->access_right = attributes & 0xff;
descriptor->limit_high = ((limit >> 16) & 0x0f) | ((attributes >> 8) & 0xf0);
descriptor->base_high = (base >> 24) & 0xff;
}
void init_segment_descriptor()
{
/* the new gdt */
gdt = (struct segment_descriptor *) GDT_VADDR;
int i;
for (i = 0; i <= GDT_LIMIT/8; i++) {
set_segment_descriptor(gdt + i, 0, 0, 0);
}
// 内核代码段和数据段
set_segment_descriptor(gdt + INDEX_KERNEL_C, 0xffffffff, 0x00000000, DA_CR | DA_DPL0 | DA_32 | DA_G);
set_segment_descriptor(gdt + INDEX_KERNEL_RW, 0xffffffff, 0x00000000, DA_DRW | DA_DPL0 | DA_32 | DA_G);
tss_t *tss = get_tss();
// tss 段
set_segment_descriptor(gdt + INDEX_TSS, sizeof(tss_t) - 1, (uint32_t )tss, DA_386TSS);
// 用户代码段和数据段
set_segment_descriptor(gdt + INDEX_USER_C, 0xffffffff, 0x00000000, DA_CR | DA_DPL3 | DA_32 | DA_G);
set_segment_descriptor(gdt + INDEX_USER_RW, 0xffffffff, 0x00000000, DA_DRW | DA_DPL3 | DA_32 | DA_G);
// 服务代码段和数据段
set_segment_descriptor(gdt + INDEX_SERVE_C, 0xffffffff, 0x00000000, DA_CR | DA_DPL1 | DA_32 | DA_G);
set_segment_descriptor(gdt + INDEX_SERVE_RW, 0xffffffff, 0x00000000, DA_DRW | DA_DPL1 | DA_32 | DA_G);
/* load new gdtr */
load_gdtr(GDT_LIMIT, GDT_VADDR);
}
|
NightfallDM/xbook2
|
src/include/fsal/fatfs.h
|
<filename>src/include/fsal/fatfs.h
#ifndef __FILESRV_FSAL_FATFS_H__
#define __FILESRV_FSAL_FATFS_H__
#include "fsal.h"
extern fsal_t fatfs_fsal;
#endif /* __FILESRV_FSAL_FATFS_H__ */
|
NightfallDM/xbook2
|
library/xlibc/include/sys/time.h
|
<gh_stars>0
#ifndef _SYS_TIME_H
#define _SYS_TIME_H
#include "ktime.h"
#include <types.h>
//#include <time.h>
#define CLOCK_REALTIME 1 /*系统统当前时间，从1970年1.1日算起*/
#define CLOCK_MONOTONIC 2 /*系统的启动时间，不能被设置*/
#define CLOCK_PROCESS_CPUTIME_ID 3 /* 本进程运行时间*/
#define CLOCK_THREAD_CPUTIME_ID 4 /*本线程运行时间*/
#define CLOCKS_PER_SEC (100 * 5) /* 1秒的时钟数 */
#define HZ_PER_CLOCKS (CLOCKS_PER_SEC / 100) /* 每个时钟的HZ数 */
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};
struct timezone{
int tz_minuteswest; //miniutes west of Greenwich
int tz_dsttime; //type of DST correction
};
#ifndef _TIMESPEC
#define _TIMESPEC
struct timespec {
time_t tv_sec; // seconds
long tv_nsec; // and nanoseconds
};
#endif
int gettimeofday(struct timeval *tv, struct timezone *tz);
int clock_gettime(clockid_t clockid, struct timespec *ts);
unsigned long alarm(unsigned long second);
unsigned long ktime(ktime_t *ktm);
//clock_t clock();
/* 获取文件的日期 */
#define FILE_TIME_HOU(data) ((unsigned int)((data >> 11) & 0x1f))
#define FILE_TIME_MIN(data) ((unsigned int)((data >> 5) & 0x3f))
#define FILE_TIME_SEC(data) ((unsigned int)((data & 0x1f) *2))
#define FILE_TIME_YEA(data) ((unsigned int)(((data >> 9) & 0x7f)+1980))
#define FILE_TIME_MON(data) ((unsigned int)((data >> 5) & 0xf))
#define FILE_TIME_DAY(data) ((unsigned int)(data & 0x1f))
#endif /* _SYS_TIME_H */
|
NightfallDM/xbook2
|
src/task/schedule.c
|
#include <xbook/schedule.h>
#include <xbook/task.h>
#include <assert.h>
#include <xbook/debug.h>
#include <arch/interrupt.h>
#include <arch/task.h>
#define DEBUG_LOCAL 0
extern task_t *task_idle;
/* 优先级队列 */
priority_queue_t priority_queue[MAX_PRIORITY_NR];
/* 最高等级的队列 */
priority_queue_t *highest_prio_queue;
task_t *task_priority_queue_fetch_first()
{
task_t *task;
//printk(KERN_NOTICE "highest prio=%d\n", highest_prio_queue->priority);
//highest_prio_queue = &priority_queue[0];
/* 从最高优先级开始寻找一个最近的有任务的低优先级 */
ADJUST_HIGHEST_PRIO(highest_prio_queue);
/* get first task */
task = list_first_owner(&highest_prio_queue->list, task_t, list);
--highest_prio_queue->length; /* sub a task */
task->prio_queue = NULL;
list_del_init(&task->list);
return task;
}
task_t *get_next_task(task_t *task)
{
//printk("cur %s-%d ->", task->name, task->pid);
/* 1.如果是时间片到了就插入到就绪队列，准备下次调度，如果是其他状态就不插入就绪队列 */
if (task->state == TASK_RUNNING) {
/* 时间片到了，加入就绪队列 */
task_priority_queue_add_tail(task);
// 更新信息
task->ticks = task->timeslice;
task->state = TASK_READY;
/* 如果是主动让出cpu，那么就只插入就绪队列，不修改ticks */
} else if (task->state == TASK_READY) {
/* 让出cpu，加入就绪队列 */
task_priority_queue_add_tail(task);
}
/* 2.从就绪队列中获取一个任务 */
/* 一定能够找到一个任务，因为最后的是idle任务 */
task_t *next;
next = task_priority_queue_fetch_first();
return next;
}
void set_next_task(task_t *next)
{
task_current = next;
task_activate(task_current);
}
/**
* Schedule - 任务调度
*
* 把自己放入队列末尾。
* 从优先级最高的队列中选取一个任务来执行。
*/
void schedule()
{
unsigned long flags;
save_intr(flags);
task_t *cur = current_task;
task_t *next = get_next_task(cur);
set_next_task(next);
#if DEBUG_LOCAL == 1
printk(KERN_INFO "schedule: switch from %s-%d-%x-%d to %s-%d-%x-%d\n",
cur->name, cur->pid, cur, cur->priority, next->name, next->pid, next, next->priority);
#endif
/*dump_task_kstack(next->kstack);
dump_task(next);*/
switch_to(cur, next);
restore_intr(flags);
}
void print_priority_queue(int prio)
{
if (prio < 0 || prio >= MAX_PRIORITY_NR) {
return;
}
printk("print_priority_queue: list\n");
priority_queue_t *queue = &priority_queue[prio];
task_t *task;
list_for_each_owner (task, &queue->list, list) {
printk("task=%s pid=%d prio=%d vmm=%x\n", task->name, task->pid, task->priority, task->vmm);
}
}
void init_schedule()
{
/* 初始化特权队列 */
int i;
for (i = 0; i < MAX_PRIORITY_NR; i++) {
INIT_LIST_HEAD(&priority_queue[i].list);
priority_queue[i].length = 0;
priority_queue[i].priority = i;
}
/* 指向最高级的队列 */
highest_prio_queue = &priority_queue[0];
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/ards.c
|
#include <xbook/debug.h>
#define ARDS_ADDR 0x80001000 //ARDS结构从哪儿开始储存
#define MAX_ARDS_NR 12 //最大有12个ards结构
/*
ards结构体
*/
struct ards_struct {
unsigned int baseLow; //基址低32位
unsigned int base_high;
unsigned int lengthLow; //长度低32位
unsigned int length_high;
unsigned int type; //该结构的类型(1可以被系统使用)
};
unsigned int get_memory_size_from_hardware()
{
unsigned int totalSize = 0;
unsigned int ardsNum = *((unsigned int *)ARDS_ADDR); //ards 结构数
if (ardsNum > MAX_ARDS_NR) {
ardsNum = MAX_ARDS_NR;
}
struct ards_struct *ards = (struct ards_struct *) (ARDS_ADDR+4); //ards 地址
int i;
for(i = 0; i < ardsNum; i++){
//寻找可用最大内存
if(ards->type == 1){
//冒泡排序获得最大内存
if(ards->baseLow+ards->lengthLow > totalSize){
totalSize = ards->baseLow+ards->lengthLow;
}
}
//printk("base %8x length %8x type:%d\n",ards->baseLow, ards->lengthLow, ards->type);
ards++;
}
printk(KERN_INFO "memory total:%x byte %d MB\n", totalSize, totalSize / (1024*1024));
return totalSize;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/interrupt.h
|
#ifndef _ARCH_INTERRUPT_H
#define _ARCH_INTERRUPT_H
#include "atomic.h"
#include "registers.h"
void __disable_intr(void);
void __enable_intr(void);
/* save intr status and disable intr */
#define __save_intr(flags) \
do { \
flags = (unsigned int)load_eflags();\
__disable_intr(); \
} while (0)
/* restore intr status and enable intr */
#define __restore_intr(flags) \
do { \
store_eflags((unsigned int)flags);\
} while (0)
/* 中断分配管理 */
/* IRQ */
#define IRQ0_CLOCK 0 // 时钟
#define IRQ1_KEYBOARD 1 // 键盘
#define IRQ2_CONNECT 2 // 连接从片
#define IRQ3_SERIAL2 3 // 串口2
#define IRQ4_SERIAL1 4 // 串口1
#define IRQ5_PARALLEL2 5 // 并口2
#define IRQ6_FLOPPY 6 // 软盘
#define IRQ7_PARALLEL1 7 // 并口1
#define IRQ8_RTCLOCK 8 // 实时时钟（real-time clock）
#define IRQ9_REDIRECT 9 // 重定向的IRQ2
#define IRQ10_RESERVE 10 // 保留
#define IRQ11_RESERVE 11 // 保留
#define IRQ12_MOUSE 12 // PS/2鼠标
#define IRQ13_FPU 13 // FPU异常
#define IRQ14_HARDDISK 14 // 硬盘
#define IRQ15_RESERVE 15 // 保留
//EFLAGS
#define EFLAGS_MBS (1<<1)
#define EFLAGS_IF_1 (1<<9)
#define EFLAGS_IF_0 0
#define EFLAGS_IOPL_3 (3<<12)
#define EFLAGS_IOPL_1 (1<<12)
#define EFLAGS_IOPL_0 (0<<12)
/* IF 位是在 eflags寄存器的低9位 */
#define EFLAGS_IF (EFLAGS_IF_1 << 9)
enum {
EP_DIVIDE = 0, /* 除法错误：DIV和IDIV指令 */
EP_DEBUG, /* 调试异常：任何代码和数据的访问 */
EP_INTERRUPT, /* 非屏蔽中断：非屏蔽外部中断 */
EP_BREAKPOINT, /* 调试断点：指令INT3 */
EP_OVERFLOW, /* 溢出：指令INTO */
EP_BOUND_RANGE, /* 越界：指令BOUND */
EP_INVALID_OPCODE, /* 无效（未定义）的操作码：指令UD2或者无效指令 */
EP_DEVICE_NOT_AVAILABLE, /* 设备不可用（无数学处理器）：浮点或WAIT/FWAIT指令 */
EP_DOUBLE_FAULT, /* 双重错误：所有能产生异常或NMI或INTR的指令 */
EP_COPROCESSOR_SEGMENT_OVERRUN, /* 协助处理器段越界：浮点指令（386之后的IA32处理器不再产生此种异常） */
EP_INVALID_TSS, /* 无效TSS：任务切换或访问TSS时 */
EP_SEGMENT_NOT_PRESENT, /* 段不存在：加载段寄存器或访问系统段时 */
EP_STACK_FAULT, /* 堆栈段错误：堆栈操作或加载SS时 */
EP_GENERAL_PROTECTION, /* 常规保护错误：内存或其它保护检验 */
EP_PAGE_FAULT, /* 页故障：内存访问 */
EP_RESERVED, /* INTEL保留，未使用 */
EP_X87_FLOAT_POINT, /* X87FPU浮点错（数学错）：X87FPU浮点指令或WAIT/FWAIIT指令 */
EP_ALIGNMENT_CHECK, /* 对齐检验：内存中的数据访问（486开始支持） */
EP_MACHINE_CHECK, /* Machine Check：错误码（如果有的话）和源依赖于具体模式（奔腾CPU开始支持） */
EP_SIMD_FLOAT_POINT, /* SIMD浮点异常：SSE和SSE2浮点指令（奔腾III开始支持） */
};
/* IRQ中断在idt中的起始位置 */
#define IRQ_START 0X20
// 目前需要支持的中断数
#define MAX_INTERRUPT_NR 0x81
typedef struct trap_frame {
unsigned int vec_no; // kernel.S 宏VECTOR中push %1压入的中断号
unsigned int edi;
unsigned int esi;
unsigned int ebp;
unsigned int esp_dummy; // 虽然pushad把esp也压入,但esp是不断变化的,所以会被popad忽略
unsigned int ebx;
unsigned int edx;
unsigned int ecx;
unsigned int eax;
unsigned int gs;
unsigned int fs;
unsigned int es;
unsigned int ds;
unsigned int error_code; // errorCode会被压入在eip之后
unsigned int eip;
unsigned int cs;
unsigned int eflags;
/* 以下由cpu从低特权级进入高特权级时压入 */
unsigned int esp;
unsigned int ss;
} __attribute__((packed)) trap_frame_t;
//中断处理函数的类型
typedef void* intr_handler_t;
void __register_intr_handler(unsigned char interrupt, intr_handler_t function);
void __unregister_intr_handler(unsigned char interrupt);
void __register_irq_handler(unsigned char irq, intr_handler_t function);
void __unregister_irq_handler(unsigned char irq);
void dump_trap_frame(trap_frame_t *frame);
void init_intr_expection(void);
#define enable_intr __enable_intr
#define disable_intr __disable_intr
#define save_intr __save_intr
#define restore_intr __restore_intr
/* ----中断上半部分---- */
/* IRQ 编号 */
enum {
IRQ0 = 0,
IRQ1,
IRQ2,
IRQ3,
IRQ4,
IRQ5,
IRQ6,
IRQ7,
IRQ8,
IRQ9,
IRQ10,
IRQ11,
IRQ12,
IRQ13,
IRQ14,
IRQ15,
NR_IRQS
};
#define IRQF_DISABLED 0x01
#define IRQF_SHARED 0x02
#define IRQF_TIMER 0x03
/* hardware interrupt controller */
struct hardware_intr_controller {
void (*enable)(unsigned int irq);
void (*disable)(unsigned int irq);
unsigned int (*install)(unsigned int irq, void *arg);
void (*uninstall)(unsigned int irq);
/* 接收到中断后确定中断已经接收 */
void (*ack)(unsigned int irq);
};
/* irq对应的处理 */
typedef struct irq_action {
unsigned long data;
int (*handler)(unsigned long, unsigned long);
unsigned long flags;
struct irq_action *next; // 指向下一个行动
/* 表示设备名字 */
char *name;
} irq_action_t;
typedef struct irq_description {
/* 硬件控制器，用来控制中断的硬件底层操作 */
struct hardware_intr_controller *controller;
struct irq_action *action;
unsigned long flags;
atomic_t device_count; // 记录注册的设备数量
/* 表示irq名字 */
char *irqname;
} irq_description_t;
int register_irq(unsigned long irq,
int (*handler)(unsigned long, unsigned long),
unsigned long flags,
char *irqname,
char *devname,
unsigned long data);
int unregister_irq(unsigned long irq, void *data);
int handle_irq(unsigned long irq, trap_frame_t *frame);
void init_irq_description();
#endif /* _ARCH_INTERRUPT_H */
|
NightfallDM/xbook2
|
library/xlibc/syslib/srvcall.c
|
<gh_stars>0
#include <sys/syscall.h>
#include <sys/srvcall.h>
int srvcall_bind(int port)
{
return syscall1(int, SYS_SRVCALL_BIND, port);
}
int srvcall_unbind(int port)
{
return syscall1(int, SYS_SRVCALL_UNBIND, port);
}
int srvcall_listen(int port, srvarg_t *arg)
{
return syscall2(int, SYS_SRVCALL_LISTEN, port, arg);
}
int srvcall_ack(int port, srvarg_t *arg)
{
return syscall2(int, SYS_SRVCALL_ACK, port, arg);
}
int srvcall(int port, srvarg_t *arg)
{
return syscall2(int, SYS_SRVCALL, port, arg);
}
int srvcall_fetch(int port, srvarg_t *arg)
{
return syscall2(int, SYS_SRVCALL_FETCH, port, arg);
}
/**
* srvcall_inbuffer - 检测参数是否有缓冲区
*
*/
int srvcall_inbuffer(srvarg_t *arg)
{
int i;
for (i = 0; i < SRVARG_NR; i++) {
if (arg->size[i] > 0) { /* 非0长度 */
if (!(arg->io & (1 << i))) { /* SRVIO_SERVICE */
return 0;
}
}
}
return -1;
}
|
NightfallDM/xbook2
|
library/xlibc/include/sys/filedes.h
|
<reponame>NightfallDM/xbook2<filename>library/xlibc/include/sys/filedes.h<gh_stars>0
#ifndef _SYS_FILEDES_H
#define _SYS_FILEDES_H
#endif /* _SYS_FILEDES_H */
|
NightfallDM/xbook2
|
src/fs/fsal/dir.c
|
<reponame>NightfallDM/xbook2
#include <fsal/dir.h>
#include <string.h>
#include <assert.h>
#include <xbook/kmalloc.h>
/* 目录表指针 */
fsal_dir_t *fsal_dir_table;
/**
* init_fsal_dir_table - 初始化目录表
*
* 分配目录表内存，并清空
*/
int init_fsal_dir_table()
{
fsal_dir_table = kmalloc(FSAL_DIR_OPEN_NR * sizeof(fsal_dir_t));
if (fsal_dir_table == NULL)
return -1;
memset(fsal_dir_table, 0, FSAL_DIR_OPEN_NR * sizeof(fsal_dir_t));
return 0;
}
/**
* fsal_dir_alloc - 从表中分配一个目录
*
*/
fsal_dir_t *fsal_dir_alloc()
{
int i;
for (i = 0; i < FSAL_DIR_OPEN_NR; i++) {
if (!fsal_dir_table[i].flags) {
/* 清空目录表的内容 */
memset(&fsal_dir_table[i], 0, sizeof(fsal_dir_t));
/* 记录使用标志 */
fsal_dir_table[i].flags = FSAL_DIR_USED;
return &fsal_dir_table[i];
}
}
return NULL;
}
/**
* fsal_dir_free - 释放一个目录
*
*/
int fsal_dir_free(fsal_dir_t *dir)
{
if (!dir->flags)
return -1;
dir->flags = 0;
return 0;
}
/* 将最上层路径名称解析出来 */
/**
* __parse_path_afterward - 朝后解析路径
* @path: 路径名
* @name: 储存名字的地址
*
* 成功返回解析到的位置，失败返回NULL
*/
static char *__parse_path_afterward(char *path, char *name)
{
if (path[0] == '/') { // 根目录不需要单独解析
/* 路径中出现1个或多个连续的字符'/',将这些'/'跳过,如"///a/b" */
while(*(++path) == '/');
}
/* 开始一般的路径解析 */
while (*path != '/' && *path != 0) {
*name++ = *path++;
}
if (path[0] == 0) { // 若路径字符串为空则返回NULL
return NULL;
}
return path;
}
/**
* wash_path - 对路径进行清洗
* @old_path: 旧的路径
* @new_path: 新的路径
*
* 转换路径中的.和..，使路径没有这些，并且是一个正确的路径
* 转换后的路径存放到new_path中
*/
void wash_path(char *old_path, char *new_path)
{
ASSERT(old_path[0] == '/');
char name[MAX_PATH] = {0};
char* sub_path = old_path;
sub_path = __parse_path_afterward(sub_path, name);
if (name[0] == 0) { // 若只有"/",直接将"/"存入new_path后返回
new_path[0] = '/';
new_path[1] = 0;
return;
}
new_path[0] = 0; // 避免传给new_path的缓冲区不干净
strcat(new_path, "/");
while (name[0]) {
/* 如果是上一级目录“..” */
if (!strcmp("..", name)) {
char* slash_ptr = strrchr(new_path, '/');
/*如果未到new_path中的顶层目录,就将最右边的'/'替换为0,
这样便去除了new_path中最后一层路径,相当于到了上一级目录 */
if (slash_ptr != new_path) { // 如new_path为“/a/b”,".."之后则变为“/a”
*slash_ptr = 0;
} else { // 如new_path为"/a",".."之后则变为"/"
/* 若new_path中只有1个'/',即表示已经到了顶层目录,
就将下一个字符置为结束符0. */
*(slash_ptr + 1) = 0;
}
} else if (strcmp(".", name)) { // 如果路径不是‘.’,就将name拼接到new_path
if (strcmp(new_path, "/")) { // 如果new_path不是"/",就拼接一个"/",此处的判断是为了避免路径开头变成这样"//"
strcat(new_path, "/");
}
strcat(new_path, name);
} // 若name为当前目录".",无须处理new_path
/* 继续遍历下一层路径 */
memset(name, 0, MAX_PATH);
if (sub_path) {
sub_path = __parse_path_afterward(sub_path, name);
}
}
}
/**
* __make_abs_path - 根据路径名生成绝对路径
* @path: 路径名
* @abspath: 绝对路径存放的地址
*
* 有可能路径名是相对路径，所以需要进行路径合并处理
*/
static void __make_abs_path(const char *path, char *abspath)
{
/*
判断是否有磁盘符，如果有，就说明是绝对路径，不然就是相对路径。
如果是相对路径，那么就需要读取当前的工作目录
*/
if (*path != '/') { /* 不是'/'，表明不是绝对路径 */
/* 获取当前工作目录 */
if (!sys_getcwd(abspath, MAX_PATH)) {
//printf("cwd:%s\n", abspath);
/* 检测当前工作目录是否是合格的目录
必须要有一个'/'，表明是根目录 */
char *p = strchr(abspath, '/');
if (p != NULL) { /* 找到一个'/' */
if (!((p[0] == '/') && (p[1] == 0))) { /* 在'/'后面还有内容 */
strcat(abspath, "/");
}
}
//printf("getcwd done!\n");
}
}
/* 想要直接进入根目录'/' */
if (path[0] == '/' && path[1] == '\0') {
abspath[0] = '/';
abspath[1] = '\0';
} else {
/* 不是进入根目录。如果是相对路径，就会和工作路径拼合，
不是的话就是绝对路径。
*/
strcat(abspath, path);
/* 没有'/'，那么就需要在这个后面添加一个'/' */
if (strchr(abspath, '/') == NULL) {
//printf("path %s only drive, add a '/'.\n", pathname);
strcat(abspath, "/");
}
}
}
/**
* build_path - 构建完整的目录
* @path: 输入路径
* @out_path: 输出路径
*
* 把传入的一个路径经过转换后，获取一个完整的路径
*
*/
void build_path(const char *path, char *out_path)
{
/* 生成绝对路径测试 */
char abs_path[MAX_PATH] = {0};
__make_abs_path(path, abs_path);
/* 移动到第一个'/'处，也就是根目录处 */
char *p = strchr(abs_path, '/');
wash_path(p, out_path);
}
|
NightfallDM/xbook2
|
library/xlibc/math/asin.c
|
<filename>library/xlibc/math/asin.c
/*
File: asin.c
Contains: For arcsin(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT asin(M_FLOAT x) {
return atan2(x, sqrt(1.0 - x * x));
}
|
NightfallDM/xbook2
|
src/fs/diskman.c
|
<gh_stars>0
#include <list.h>
#include <xbook/diskman.h>
#include <xbook/resource.h>
#include <xbook/kmalloc.h>
#include <string.h>
#include <stdio.h>
LIST_HEAD(disk_list_head);
static int next_disk_solt = 0;
static int disk_solt_cache[DISK_SOLT_NR];
#define IS_BAD_SOLT(solt) \
(solt < 0 || solt >= DISK_SOLT_NR)
#define SOLT_TO_HANDLE(solt) disk_solt_cache[solt]
disk_drvier_t drv_disk;
/**
* disk_probe_device - 探测设备
* @type: 设备的类型
*
*/
int disk_probe_device(device_type_t type)
{
/* 磁盘设备 */
devent_t *p = NULL;
devent_t devent;
disk_info_t *disk;
do {
if (sys_devscan(p, type, &devent))
break;
/* 添加到磁盘数组 */
/* 创建一个设备信息 */
disk = kmalloc(sizeof(disk_info_t));
if (disk == NULL)
return -1;
/* 填信息并添加到链表 */
disk->devent = devent;
disk->handle = -1;
atomic_set(&disk->ref, 0);
/* 设置虚拟磁盘名字 */
sprintf(disk->virname, "disk%d", next_disk_solt);
disk->solt = next_disk_solt++;
list_add_tail(&disk->list, &disk_list_head);
p = &devent;
} while (1);
return 0;
}
/**
* disk_print - 打印磁盘信息
*
*/
void disk_info_print()
{
disk_info_t *disk;
list_for_each_owner (disk, &disk_list_head, list) {
pr_info("[diskman]: probe device:%s -> vir:%s type:%d\n",
disk->devent.de_name, disk->virname, disk->devent.de_type);
}
}
/**
* disk_res_find - 查找磁盘
*
*/
int disk_res_find(char *name)
{
disk_info_t *disk;
list_for_each_owner (disk, &disk_list_head, list) {
if (!strcmp(disk->virname, name)) {
return disk->solt;
}
}
return -1;
}
/**
* disk_res_find - 查找磁盘
*
*/
disk_info_t *disk_res_find_info(char *name)
{
disk_info_t *disk;
list_for_each_owner (disk, &disk_list_head, list) {
if (!strcmp(disk->virname, name)) {
return disk;
}
}
return NULL;
}
static int __open(int solt)
{
if (IS_BAD_SOLT(solt))
return -1;
disk_info_t *disk;
list_for_each_owner (disk, &disk_list_head, list) {
if (disk->solt == solt) {
if (atomic_get(&disk->ref) == 0) {
disk->handle = device_open(disk->devent.de_name, 0);
if (disk->handle < 0)
return -1;
//printk("[diskman]: %s: get disk handle %d\n", __func__, disk->handle);
/* 添加到插槽缓存 */
disk_solt_cache[solt] = disk->handle;
}
atomic_inc(&disk->ref);
return 0;
}
}
return -1;
}
static int __close(int solt)
{
if (IS_BAD_SOLT(solt))
return -1;
disk_info_t *disk;
list_for_each_owner (disk, &disk_list_head, list) {
if (disk->solt == solt) {
if (atomic_get(&disk->ref) == 1) {
/* 关闭设备 */
if (device_close(disk->handle) != 0)
return -1;
/* 从缓存中删除 */
int i;
for (i = 0; i < DISK_SOLT_NR; i++) {
if (disk_solt_cache[i] == disk->handle) {
disk_solt_cache[i] = -1;
break;
}
}
disk->handle = -1;
} else if (atomic_get(&disk->ref) == 0) {
pr_dbg("[diskman]: close device %d without open!\n", solt);
return -1;
}
atomic_dec(&disk->ref);
return 0;
}
}
return -1;
}
static int __read(int solt, off_t off, void *buffer, size_t size)
{
if (IS_BAD_SOLT(solt))
return -1;
if (device_read(SOLT_TO_HANDLE(solt), buffer, size, off) < 0)
return -1;
return 0;
}
static int __write(int solt, off_t off, void *buffer, size_t size)
{
if (IS_BAD_SOLT(solt))
return -1;
if (device_write(SOLT_TO_HANDLE(solt), buffer, size, off) < 0)
return -1;
return 0;
}
static int __ioctl(int solt, unsigned int cmd, unsigned long arg)
{
if (IS_BAD_SOLT(solt))
return -1;
if (device_devctl(SOLT_TO_HANDLE(solt), cmd, arg) < 0)
return -1;
return 0;
}
int init_disk_driver()
{
if (disk_probe_device(DEVICE_TYPE_DISK) < 0)
return -1;
if (disk_probe_device(DEVICE_TYPE_VIRTUAL_DISK) < 0)
return -1;
int i;
for (i = 0; i < DISK_SOLT_NR; i++)
disk_solt_cache[i] = -1;
disk_info_print();
drv_disk.open = __open;
drv_disk.close = __close;
drv_disk.read = __read;
drv_disk.write = __write;
drv_disk.ioctl = __ioctl;
return 0;
}
|
NightfallDM/xbook2
|
src/include/xbook/waitque.h
|
<filename>src/include/xbook/waitque.h
#ifndef _XBOOK_WAIT_QUE_H
#define _XBOOK_WAIT_QUE_H
/* 用户态使用的等待队列 */
#include "waitqueue.h"
#define WAITQUE_USING (1 << 0)
/* 用户态等待队列 */
typedef struct __waitque {
wait_queue_t wait_queue; /* 等待队列 */
unsigned int flags; /* 标志 */
} waitque_t;
/* 内核支持的用户等待队列数量 */
#define WAITQUE_NR 128
#define IS_BAD_WAITQUE(handle) \
((handle) < 0 || (handle) >= WAITQUE_NR)
void init_waitque();
int sys_waitque_wake(int handle, void *addr, unsigned int wqflags, unsigned long value);
int sys_waitque_wait(int handle, void *addr, unsigned int wqflags, unsigned long value);
int sys_waitque_destroy(int handle);
int sys_waitque_create();
#endif /* _XBOOK_WAIT_QUE_H */
|
NightfallDM/xbook2
|
library/xlibc/math/atan2.c
|
<gh_stars>0
/*
File: atan2.c
Contains: For arctan2(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
#define DBL_EPSILON 2.2204460492503131e-016
#ifdef __LIB_32B__
#define PI M_PI
#else
#define PI M_PIl
#endif
static const float atan2_p1 = 0.9997878412794807f * (float)(180 / PI);
static const float atan2_p3 = -0.3258083974640975f * (float)(180 / PI);
static const float atan2_p5 = 0.1555786518463281f * (float)(180 / PI);
static const float atan2_p7 = -0.04432655554792128f * (float)(180 / PI);
M_FLOAT atan2(M_FLOAT x, M_FLOAT y) {
float ax = fabs(x), ay = fabs(y);
float a, c, c2;
if(ax >= ay) {
c = ay / (ax + (float)DBL_EPSILON);
c2 = c*c;
a = (((atan2_p7*c2 + atan2_p5) * c2 + atan2_p3) * c2 + atan2_p1) * c;
} else {
c = ax / (ay + (float)DBL_EPSILON);
c2 = c*c;
a = 90.f - (((atan2_p7 * c2 + atan2_p5) * c2 + atan2_p3) * c2 + atan2_p1) * c;
}
if( x < 0 )
a = 180.f - a;
if( y < 0 )
a = 360.f - a;
return a;
}
|
NightfallDM/xbook2
|
library/xlibc/include/math.h
|
#ifndef _XLIBC_MATH_H
#define _XLIBC_MATH_H
#include <arch/config.h>
#include <stddef.h>
/* max() & min() */
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
/* 除后上入 */
#define DIV_ROUND_UP(X, STEP) ((X + STEP - 1) / (STEP))
/* 除后下舍 */
#define DIV_ROUND_DOWN(X, STEP) ((X) / (STEP))
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
#endif
/*
File: math.h
Contains: Define math type, functions and macros
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
/* IEEE ISO */
typedef struct {
unsigned int mantissa:23;
unsigned int exponent:8;
unsigned int sign:1;
} float_t;
typedef struct {
unsigned int mantissal:32;
unsigned int mantissah:20;
unsigned int exponent:11;
unsigned int sign:1;
} double_t;
typedef struct {
unsigned int mantissal:32;
unsigned int mantissah:32;
unsigned int exponent:15;
unsigned int sign:1;
unsigned int empty:16;
} long_double_t;
/* IEEE ISO */
#define M_E 2.7182818284590452354 /* e */
#define M_LOG2E 1.4426950408889634074 /* log_2 e */
#define M_LOG10E 0.43429448190325182765 /* log_10 e */
#define M_LN2 0.69314718055994530942 /* log_e 2 */
#define M_LN10 2.30258509299404568402 /* log_e 10 */
#define M_PI 3.14159265358979323846 /* pi */
#define M_PI_D 6.28318530717958646692 /* pi*2 */
#define M_PI_2 1.57079632679489661923 /* pi/2 */
#define M_PI_4 0.78539816339744830962 /* pi/4 */
#define M_1_PI 0.31830988618379067154 /* 1/pi */
#define M_2_PI 0.63661977236758134308 /* 2/pi */
#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
#ifdef __LIB_64B__
#define M_El 2.7182818284590452353602874713526625L /* e */
#define M_LOG2El 1.4426950408889634073599246810018922L /* log_2 e */
#define M_LOG10El 0.4342944819032518276511289189166051L /* log_10 e */
#define M_LN2l 0.6931471805599453094172321214581766L /* log_e 2 */
#define M_LN10l 2.3025850929940456840179914546843642L /* log_e 10 */
#define M_PIl 3.1415926535897932384626433832795029L /* pi */
#define M_PI_Dl 6.2831853071795864669252867665590058L /* pi*2 */
#define M_PI_2l 1.5707963267948966192313216916397514L /* pi/2 */
#define M_PI_4l 0.7853981633974483096156608458198757L /* pi/4 */
#define M_1_PIl 0.3183098861837906715377675267450287L /* 1/pi */
#define M_2_PIl 0.6366197723675813430755350534900574L /* 2/pi */
#define M_2_SQRTPIl 1.1283791670955125738961589031215452L /* 2/sqrt(pi) */
#define M_SQRT2l 1.4142135623730950488016887242096981L /* sqrt(2) */
#define M_SQRT1_2l 0.7071067811865475244008443621048490L /* 1/sqrt(2) */
#endif /* __LIB_64B__ */
#ifdef __LIB_32B__
#define M_FLOAT float
#else
#define M_FLOAT double
#endif /* __LIB_32B__ */
M_FLOAT acos(M_FLOAT);
M_FLOAT asin(M_FLOAT);
M_FLOAT atan(M_FLOAT);
M_FLOAT atan2(M_FLOAT, M_FLOAT);
M_FLOAT ceil(M_FLOAT);
M_FLOAT cos(M_FLOAT);
M_FLOAT cosh(M_FLOAT);
M_FLOAT exp(M_FLOAT);
M_FLOAT fabs(M_FLOAT);
M_FLOAT floor(M_FLOAT);
M_FLOAT fmod(M_FLOAT, M_FLOAT);
M_FLOAT frexp(double, int *);
M_FLOAT ldexp(M_FLOAT, int);
M_FLOAT log(M_FLOAT);
M_FLOAT log2(float);
M_FLOAT log10(M_FLOAT);
double modf(double , double *);
M_FLOAT pow(double, double);
M_FLOAT round(M_FLOAT);
M_FLOAT sin(M_FLOAT);
M_FLOAT sinh(M_FLOAT);
M_FLOAT sqrt(float);
M_FLOAT tan(M_FLOAT);
M_FLOAT tanh(M_FLOAT);
#ifdef __LIB_32B__
#define acosf(x) acos(x)
#define asinf(x) asin(x)
#define atanf(x) atan(x)
#define atan2f(x,y) atan2(x,y)
#define ceilf(x) ceil(x)
#define cosf(x) cos(x)
#define coshf(x) cosh(x)
#define expf(x) exp(x)
#define fabsf(x) fabs(x)
#define floorf(x) floor(x)
#define fmodf(x,y) fmod(x,y)
#define frexpf(x,y) frexp(x,y)
#define ldexpf(x,y) ldexp(x,y)
#define logf(x) log(x)
#define log2f(x) log2(x)
#define log10f(x) log10(x)
#define powf(x,y) pow(x,y)
#define roundf(x) round(x)
#define sinf(x) sin(x)
#define sinhf(x) sinh(x)
#define sqrtf(x) sqrt(x)
#define tanf(x) tan(x)
#define tanhf(x) tanh(x)
#endif /* __LIB_32B__ */
extern const M_FLOAT MATH_PI;
extern const M_FLOAT MATH_PI_D;
extern const M_FLOAT MATH_PI_2;
extern const M_FLOAT MATH_PI_4;
extern const M_FLOAT MATH_LN10;
extern const float EPSILON;
extern const M_FLOAT LOG_MULTIPLE;
#define FP_NAN 0
#define FP_INFINITE 1
#define FP_ZERO 2
#define FP_SUBNORMAL 3
#define FP_NORMAL 4
#define NAN __builtin_nan("")
#define INFINITY __builtin_inf()
#define HUGE_VALF __builtin_huge_valf()
#define HUGE_VAL __builtin_huge_val()
#define HUGE_VALL __builtin_huge_vall()
#define isgreater(x, y) __builtin_isgreater((x), (y))
#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
#define isless(x, y) __builtin_isless((x), (y))
#define islessequal(x, y) __builtin_islessequal((x), (y))
#define islessgreater(x, y) __builtin_islessgreater((x), (y))
#define isunordered(x, y) __builtin_isunordered((x), (y))
#endif /* _XLIBC_MATH_H */
|
NightfallDM/xbook2
|
library/xlibc/math/math.c
|
/*
File: math.c
Contains: For all math const data
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
#ifdef __LIB_32B__
const M_FLOAT MATH_PI = M_PI;
const M_FLOAT MATH_PI_D = M_PI_D;
const M_FLOAT MATH_PI_2 = M_PI_2;
const M_FLOAT MATH_PI_4 = M_PI_4;
const M_FLOAT MATH_LN10 = M_LN10;
#else
const M_FLOAT MATH_PI = M_PIl;
const M_FLOAT MATH_PI_D = M_PI_Dl;
const M_FLOAT MATH_PI_2 = M_PI_2l;
const M_FLOAT MATH_PI_4 = M_PI_4l;
const M_FLOAT MATH_LN10 = M_LN10l;
#endif
const float EPSILON = 0.000001;
const M_FLOAT LOG_MULTIPLE = 0.69314718f;
|
NightfallDM/xbook2
|
user/tests/socket_test.c
|
<filename>user/tests/socket_test.c<gh_stars>0
#include "test.h"
#include <arpa/inet.h>
#define MAXLINE 4096
int socket_test(int argc, char *argv[])
{
int sockfd;
char sendline[4096];
struct sockaddr_in servaddr;
if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
exit(0);
}
printf("socket fd: %d\n", sockfd);
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port =htons(8080);
servaddr.sin_addr.s_addr = inet_addr("192.168.0.104");
if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
{
printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
exit(0);
}
printf("send msg to server: \n");
strcpy(sendline, "helllo!\n");
if( send(sockfd, sendline, strlen(sendline), 0) < 0)
{
printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
exit(0);
}
memset(sendline, 0, 4096);
if (recv(sockfd, sendline, 4096, 0) < 0) {
printf("recv msg error: %s(errno: %d)\n", strerror(errno), errno);
exit(0);
}
printf("recv: %s\n", sendline);
close(sockfd);
exit(0);
return 0;
}
int socket_test2(int argc, char *argv[])
{
printf("socket2 test start!\n");
int err;
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
printf("create socket failed!\n");
return -1;
}
printf("create socket %d\n", fd);
struct sockaddr_in myaddr;
memset(&myaddr, 0, sizeof(struct sockaddr_in));
myaddr.sin_addr.s_addr = htonl(0);
myaddr.sin_port = htons(8080);
myaddr.sin_family = AF_INET;
err = bind(fd, (struct sockaddr *) &myaddr, sizeof(struct sockaddr));
if (err < 0) {
printf("socket bind failed!\n");
return -1;
}
err = listen(fd, 5);
if (err < 0) {
printf("socket listen failed!\n");
return -1;
}
int client_fd;
while (1) {
client_fd = accept(fd, NULL, NULL);
printf("accept %d done!\n", client_fd);
if (client_fd >= 0) {
char buf[512];
memset(buf, 0, 512);
read(client_fd, buf, 512);
printf("recv done %s!\n", buf);
write(client_fd, buf, strlen(buf));
printf("send done!\n");
close(client_fd);
}
}
return 0;
}
#define SERVER_IP "192.168.0.104"
#define BUF_LEN 512
int socket_test3(int argc, char *argv[])
{
printf("socket3 test start!\n");
/* udp连接 */
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0) {
printf("create socket failed!\n");
return -1;
}
printf("create socket %d\n", fd);
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(struct sockaddr_in));
serv_addr.sin_addr.s_addr = htonl(IPADDR_ANY);
serv_addr.sin_port = htons(8080);
serv_addr.sin_family = AF_INET;
serv_addr.sin_len = sizeof(struct sockaddr_in);
bind(fd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr_in));
memset(&serv_addr, 0, sizeof(struct sockaddr_in));
serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
serv_addr.sin_port = htons(8080);
serv_addr.sin_family = AF_INET;
serv_addr.sin_len = sizeof(struct sockaddr_in);
struct sockaddr src;
socklen_t len;
while (1) {
char buf[BUF_LEN] = "hello! Test!\n";
len = sizeof(struct sockaddr_in);
sendto(fd, buf, BUF_LEN, 0, (struct sockaddr *)&serv_addr, len);
printf("client: %s\n", buf);
memset(buf, 0, BUF_LEN);
recvfrom(fd, buf, BUF_LEN, 0, &src, &len);
printf("server: %s\n", buf);
break;
}
close(fd);
return 0;
}
#define MAX_SERV 5 /* Maximum number of chargen services. Don't need too many */
#define CHARGEN_THREAD_NAME "chargen"
#define CHARGEN_PRIORITY 254 /* Really low priority */
#define CHARGEN_THREAD_STACKSIZE 0
#define SEND_SIZE 512 /* If we only send this much, then when select
says we can send, we know we won't block */
struct charcb
{
struct charcb *next;
int socket;
struct sockaddr_in cliaddr;
socklen_t clilen;
char nextchar;
};
static struct charcb *charcb_list = 0;
static int do_read(struct charcb *p_charcb);
static void close_chargen(struct charcb *p_charcb);
/**************************************************************
* void chargen_thread(void *arg)
*
* chargen task. This server will wait for connections on well
* known TCP port number: 19. For every connection, the server will
* write as much data as possible to the tcp port.
**************************************************************/
int socket_test4(int argc, char *argv[])
{
int listenfd;
struct sockaddr_in chargen_saddr;
fd_set readset;
fd_set writeset;
int i, maxfdp1;
struct charcb *p_charcb;
/* First acquire our socket for listening for connections */
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd < 0)
printf("chargen_thread(): Socket create failed.\n");
memset(&chargen_saddr, 0, sizeof(chargen_saddr));
chargen_saddr.sin_family = AF_INET;
chargen_saddr.sin_addr.s_addr = htonl(INADDR_ANY);
chargen_saddr.sin_port = htons(19); /* Chargen server port */
if (bind(listenfd, (struct sockaddr *) &chargen_saddr, sizeof(chargen_saddr)) == -1) {
printf("chargen_thread(): Socket bind failed.\n");
return -1;
}
/* Put socket into listening mode */
if (listen(listenfd, MAX_SERV) == -1) {
printf("chargen_thread(): Listen failed.\n");
return -1;
}
/* Wait forever for network input: This could be connections or data */
for (;;)
{
maxfdp1 = listenfd+1;
/* Determine what sockets need to be in readset */
FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_SET(listenfd, &readset);
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next)
{
if (maxfdp1 < p_charcb->socket + 1)
maxfdp1 = p_charcb->socket + 1;
FD_SET(p_charcb->socket, &readset);
FD_SET(p_charcb->socket, &writeset);
}
/* Wait for data or a new connection */
i = select(maxfdp1, &readset, &writeset, 0, 0);
if (i == 0)
continue;
/* At least one descriptor is ready */
if (FD_ISSET(listenfd, &readset))
{
/* We have a new connection request!!! */
/* Lets create a new control block */
p_charcb = (struct charcb *)malloc(sizeof(struct charcb));
if (p_charcb)
{
p_charcb->socket = accept(listenfd,
(struct sockaddr *) &p_charcb->cliaddr,
&p_charcb->clilen);
if (p_charcb->socket < 0)
free(p_charcb);
else
{
/* Keep this tecb in our list */
p_charcb->next = charcb_list;
charcb_list = p_charcb;
p_charcb->nextchar = 0x21;
}
} else {
/* No memory to accept connection. Just accept and then close */
int sock;
struct sockaddr cliaddr;
socklen_t clilen;
sock = accept(listenfd, &cliaddr, &clilen);
if (sock >= 0)
close(sock);
}
}
/* Go through list of connected clients and process data */
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next)
{
if (FD_ISSET(p_charcb->socket, &readset))
{
/* This socket is ready for reading. This could be because someone typed
* some characters or it could be because the socket is now closed. Try reading
* some data to see. */
if (do_read(p_charcb) < 0)
break;
}
if (FD_ISSET(p_charcb->socket, &writeset))
{
char line[80];
char setchar = p_charcb->nextchar;
for( i = 0; i < 59; i++)
{
line[i] = setchar;
if (++setchar == 0x7f)
setchar = 0x21;
}
line[i] = 0;
strcat(line, "\n\r");
if (write(p_charcb->socket, line, strlen(line)) < 0)
{
close_chargen(p_charcb);
break;
}
if (++p_charcb->nextchar == 0x7f)
p_charcb->nextchar = 0x21;
}
}
}
return 0;
}
/**************************************************************
* void close_chargen(struct charcb *p_charcb)
*
* Close the socket and remove this charcb from the list.
**************************************************************/
static void close_chargen(struct charcb *p_charcb)
{
struct charcb *p_search_charcb;
/* Either an error or tcp connection closed on other
* end. Close here */
close(p_charcb->socket);
/* Free charcb */
if (charcb_list == p_charcb)
charcb_list = p_charcb->next;
else
for (p_search_charcb = charcb_list; p_search_charcb; p_search_charcb = p_search_charcb->next)
{
if (p_search_charcb->next == p_charcb)
{
p_search_charcb->next = p_charcb->next;
break;
}
}
free(p_charcb);
}
/**************************************************************
* void do_read(struct charcb *p_charcb)
*
* Socket definitely is ready for reading. Read a buffer from the socket and
* discard the data. If no data is read, then the socket is closed and the
* charcb is removed from the list and freed.
**************************************************************/
static int do_read(struct charcb *p_charcb)
{
char buffer[80];
int readcount;
/* Read some data */
readcount = read(p_charcb->socket, &buffer, 80);
if (readcount <= 0)
{
close_chargen(p_charcb);
return -1;
}
printf("recv data len = %d\n", readcount);
return 0;
}
|
NightfallDM/xbook2
|
library/xlibc/include/sys/input.h
|
#ifndef _SYS_INPUT_H
#define _SYS_INPUT_H
#include <stdint.h>
typedef struct input_event {
uint16_t type;
uint16_t code;
uint32_t value;
} input_event_t;
#define EV_SYN 0x00
#define EV_KEY 0x01
#define EV_REL 0x02
#define EV_ABS 0x03 //绝对坐标
#define EV_MSC 0x04 //其他
/* 按键 */
enum input_key_code {
KEY_UNKNOWN = 0, /* unknown keycode */
KEY_FIRST, /* first key */
KEY_CLEAR, /* clear */
KEY_PAUSE, /* pause */
KEY_UP, /* up arrow */
KEY_DOWN, /* down arrow */
KEY_RIGHT, /* right arrow */
KEY_LEFT, /* left arrow */
KEY_BACKSPACE, /* backspace */
KEY_TAB, /* 9: tab */
KEY_ENTER, /* 10: enter */
KEY_INSERT, /* insert */
KEY_HOME, /* home */
KEY_END, /* end */
KEY_PAGEUP, /* page up */
KEY_PAGEDOWN, /* page down */
KEY_F1, /* F1 */
KEY_F2, /* F2 */
KEY_F3, /* F3 */
KEY_F4, /* F4 */
KEY_F5, /* F5 */
KEY_F6, /* F6 */
KEY_F7, /* F7 */
KEY_F8, /* F8 */
KEY_F9, /* F9 */
KEY_F10, /* F10 */
KEY_F11, /* F11 */
KEY_ESCAPE, /* 27: escape */
KEY_F12, /* F12 */
KEY_F13, /* F13 */
KEY_F14, /* F14 */
KEY_F15, /* F15 */
/* 可显示字符按照ascill码排列 */
KEY_SPACE, /* space */
KEY_EXCLAIM, /* ! exclamation mark */
KEY_QUOTEDBL, /*" double quote */
KEY_HASH, /* # hash */
KEY_DOLLAR, /* $ dollar */
KEY_PERSENT, /* % persent */
KEY_AMPERSAND, /* & ampersand */
KEY_QUOTE, /* ' single quote */
KEY_LEFTPAREN, /* ( left parenthesis */
KEY_RIGHTPAREN, /* ) right parenthesis */
KEY_ASTERISK, /* * asterisk */
KEY_PLUS, /* + plus sign */
KEY_COMMA, /* , comma */
KEY_MINUS, /* - minus sign */
KEY_PERIOD, /* . period/full stop */
KEY_SLASH, /* / forward slash */
KEY_0, /* 0 */
KEY_1, /* 1 */
KEY_2, /* 2 */
KEY_3, /* 3 */
KEY_4, /* 4 */
KEY_5, /* 5 */
KEY_6, /* 6 */
KEY_7, /* 7 */
KEY_8, /* 8 */
KEY_9, /* 9 */
KEY_COLON, /* : colon */
KEY_SEMICOLON, /* ;semicolon */
KEY_LESS, /* < less-than sign */
KEY_EQUALS, /* = equals sign */
KEY_GREATER, /* > greater-then sign */
KEY_QUESTION, /* ? question mark */
KEY_AT, /* @ at */
KEY_A, /* A */
KEY_B, /* B */
KEY_C, /* C */
KEY_D, /* D */
KEY_E, /* E */
KEY_F, /* F */
KEY_G, /* G */
KEY_H, /* H */
KEY_I, /* I */
KEY_J, /* J */
KEY_K, /* K */
KEY_L, /* L */
KEY_M, /* M */
KEY_N, /* N */
KEY_O, /* O */
KEY_P, /* P */
KEY_Q, /* Q */
KEY_R, /* R */
KEY_S, /* S */
KEY_T, /* T */
KEY_U, /* U */
KEY_V, /* V */
KEY_W, /* W */
KEY_X, /* X */
KEY_Y, /* Y */
KEY_Z, /* Z */
KEY_LEFTSQUAREBRACKET, /* [ left square bracket */
KEY_BACKSLASH, /* \ backslash */
KEY_RIGHTSQUAREBRACKET, /* ]right square bracket */
KEY_CARET, /* ^ caret */
KEY_UNDERSCRE, /* _ underscore */
KEY_BACKQUOTE, /* ` grave */
KEY_a, /* a */
KEY_b, /* b */
KEY_c, /* c */
KEY_d, /* d */
KEY_e, /* e */
KEY_f, /* f */
KEY_g, /* g */
KEY_h, /* h */
KEY_i, /* i */
KEY_j, /* j */
KEY_k, /* k */
KEY_l, /* l */
KEY_m, /* m */
KEY_n, /* n */
KEY_o, /* o */
KEY_p, /* p */
KEY_q, /* q */
KEY_r, /* r */
KEY_s, /* s */
KEY_t, /* t */
KEY_u, /* u */
KEY_v, /* v */
KEY_w, /* w */
KEY_x, /* x */
KEY_y, /* y */
KEY_z, /* z */
KEY_LEFTBRACKET, /* { left bracket */
KEY_VERTICAL, /* | vertical virgul */
KEY_RIGHTBRACKET, /* } left bracket */
KEY_TILDE, /* ~ tilde */
KEY_DELETE, /* 127 delete */
KEY_KP0, /* keypad 0 */
KEY_KP1, /* keypad 1 */
KEY_KP2, /* keypad 2 */
KEY_KP3, /* keypad 3 */
KEY_KP4, /* keypad 4 */
KEY_KP5, /* keypad 5 */
KEY_KP6, /* keypad 6 */
KEY_KP7, /* keypad 7 */
KEY_KP8, /* keypad 8 */
KEY_KP9, /* keypad 9 */
KEY_KP_PERIOD, /* keypad period '.' */
KEY_KP_DIVIDE, /* keypad divide '/' */
KEY_KP_MULTIPLY, /* keypad multiply '*' */
KEY_KP_MINUS, /* keypad minus '-' */
KEY_KP_PLUS, /* keypad plus '+' */
KEY_KP_ENTER, /* keypad enter '\r'*/
KEY_KP_EQUALS, /* !keypad equals '=' */
KEY_NUMLOCK, /* numlock */
KEY_CAPSLOCK, /* capslock */
KEY_SCROLLOCK, /* scrollock */
KEY_RSHIFT, /* right shift */
KEY_LSHIFT, /* left shift */
KEY_RCTRL, /* right ctrl */
KEY_LCTRL, /* left ctrl */
KEY_RALT, /* right alt / alt gr */
KEY_LALT, /* left alt */
KEY_RMETA, /* right meta */
KEY_LMETA, /* left meta */
KEY_RSUPER, /* right windows key */
KEY_LSUPER, /* left windows key */
KEY_MODE, /* mode shift */
KEY_COMPOSE, /* compose */
KEY_HELP, /* help */
KEY_PRINT, /* print-screen */
KEY_SYSREQ, /* sys rq */
KEY_BREAK, /* break */
KEY_MENU, /* menu */
KEY_POWER, /* power */
KEY_EURO, /* euro */
KEY_UNDO, /* undo */
BTN_LEFT, /* mouse left */
BTN_RIGHT, /* mouse right */
BTN_MIDDLE, /* mouse middle */
KEY_LAST /* last one */
};
/* 相对坐标 */
enum input_rel_code {
REL_MISC = 0,
REL_X,
REL_Y,
REL_WHEEL
};
#endif /* _SYS_INPUT_H */
|
NightfallDM/xbook2
|
library/xlibc/stdlib/abort.c
|
#include <stdlib.h>
#include <sys/trigger.h>
#include <sys/proc.h>
void abort(void)
{
triggeron(TRIGHSOFT, getpid());
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/registers.h
|
#ifndef _X86_REGISTERS_H
#define _X86_REGISTERS_H
void load_tr(unsigned int tr);
void load_gdtr(unsigned int limit, unsigned int addr);
void load_idtr(unsigned int limit, unsigned int addr);
unsigned int load_eflags(void);
void store_gdtr(unsigned int gdtr);
void store_idtr(unsigned int idtr);
void store_eflags(unsigned int eflags);
unsigned int read_cr0(void );
unsigned int read_cr2(void );
unsigned int read_cr3(void );
void write_cr0(unsigned int address);
void write_cr3(unsigned int address);
#endif /* _X86_REGISTERS_H */
|
NightfallDM/xbook2
|
src/include/xbook/vmspace.h
|
<reponame>NightfallDM/xbook2
#ifndef _XBOOK_VMSPACE_H
#define _XBOOK_VMSPACE_H
#include "vmm.h"
#include "memcache.h"
#include <stddef.h>
#include <stdint.h>
#include <types.h>
#include <arch/page.h>
/* map flags */
#define VMS_MAP_FIXED 0x10 /* 映射固定位置 */
#define VMS_MAP_STACK 0x20 /* 映射成栈，会动态变化 */
#define VMS_MAP_HEAP 0x40 /* 映射成堆，会动态变化 */
#define VMS_MAP_SHARED 0x80 /* 映射成共享内存 */
#define VMS_MAP_REMAP 0x100 /* 强制重写映射 */
#define MAX_VMS_STACK_SIZE (16 * MB) /* 最大栈拓展大小 */
#define DEFAULT_STACK_SIZE (PAGE_SIZE * 4) /* 默认栈大小 */
/* 最大可扩展的堆的大小,默认512MB */
#define MAX_VMS_HEAP_SIZE (512 * MB)
/* 可映射起始地址 */
#define VMS_MAP_START_ADDR 0x60000000
/* 最大可映射的内存的大小,默认256MB */
#define MAX_VMS_MAP_SIZE (256 * MB)
/* 虚拟内存地址空间描述 */
typedef struct vmspace {
unsigned long start; /* 空间开始地址 */
unsigned long end; /* 空间结束地址 */
unsigned long page_prot; /* 空间保护 */
unsigned long flags; /* 空间的标志 */
vmm_t *vmm; /* 空间对应的虚拟内存管理 */
struct vmspace *next; /* 所有控件构成单向链表 */
} vmspace_t;
#define vmspace_alloc() kmalloc(sizeof(vmspace_t))
#define vmspace_free kfree
void dump_vmspace(vmm_t *vmm);
void vmspace_insert(vmm_t *vmm, vmspace_t *space);
int do_vmspace_unmap(vmm_t *vmm, unsigned long addr, unsigned long len);
int do_vmspace_map(vmm_t *vmm, unsigned long addr, unsigned long paddr,
unsigned long len, unsigned long prot, unsigned long flags);
void *vmspace_mmap(uint32_t addr, uint32_t paddr, uint32_t len, uint32_t prot,
uint32_t flags);
int vmspace_unmmap(uint32_t addr, uint32_t len);
unsigned long sys_vmspace_heap(unsigned long heap);
unsigned long vmspace_get_unmaped(vmm_t *vmm, unsigned len);
#define sys_munmap vmspace_unmmap
/**
* vmspace_init - 初始化虚拟空间
*
*/
static inline void vmspace_init(vmspace_t *space, unsigned long start,
unsigned long end, unsigned long page_prot, unsigned long flags)
{
space->start = start;
space->end = end;
space->page_prot = page_prot;
space->flags = flags;
space->vmm = NULL;
space->next = NULL;
}
static inline void vmspace_remove(vmm_t *vmm, vmspace_t *space, vmspace_t *prev)
{
if (prev) /* 没在链表头，位于中间或者后面 */
prev->next = space->next;
else /* 前面没有空间，说明在链表头 */
vmm->vmspace_head = space->next;
vmspace_free(space);
}
static inline vmspace_t *vmspace_find(vmm_t *vmm, unsigned long addr)
{
vmspace_t *space = vmm->vmspace_head;
while (space != NULL) {
if (addr < space->end) /* 地址小于某个控件结束位置就返回该空间 */
return space;
space = space->next;
}
return NULL;
}
static inline vmspace_t *vmspace_find_prev(vmm_t *vmm, unsigned long addr, vmspace_t **prev)
{
*prev = NULL; /* prev save prev space ptr, set NULL first */
vmspace_t *space = vmm->vmspace_head;
while (space != NULL) {
if (addr < space->end) /* 地址小于某个控件结束位置就返回该空间 */
return space;
*prev = space; /* save prev */
space = space->next;
}
return NULL;
}
/**
* vmspace_find_intersection - 查找在指定范围内是否有空间和它相交
* @vmm: 虚拟内存管理器
* @start: 起始地址
* @end: 结束地址
*
* @return: 如果有空间和传入的区域相交，返回对应的空间，没有则返回NULL
*/
static inline vmspace_t *vmspace_find_intersection(vmm_t *vmm,
unsigned long start, unsigned long end)
{
vmspace_t *space = vmspace_find(vmm, start);
if (space && space->start >= end) /* 如果第一个空间的开始大于第二个空间的结束，说明不相交 */
space = NULL;
return space;
}
#endif /* _XBOOK_VMSPACE_H */
|
NightfallDM/xbook2
|
src/include/sys/kfile.h
|
<reponame>NightfallDM/xbook2
#ifndef _SYS_KFILE_H
#define _SYS_KFILE_H
typedef struct {
unsigned char *file;
unsigned long size;
} kfile_t;
#endif /* _SYS_KFILE_H */
|
NightfallDM/xbook2
|
user/bosh/shell.c
|
<reponame>NightfallDM/xbook2
#include <stdio.h>
#include <xcons.h>
#include <string.h>
#include <sys/input.h>
#include <sys/trigger.h>
#include "cmd.h"
#include "shell.h"
int shell_event_poll(char *buf, int pid)
{
int keybuf[2];
*buf = 0;
/* 获取事件 */
if (xcons_getkey(keybuf, 1) < 0)
return -1;
*buf = keybuf[0];
/* 组合按键 */
if (keybuf[1] & XCONS_KMOD_CTRL) {
/* ctrl + c -> 打断进程 */
if (keybuf[0] == KEY_C || keybuf[0] == KEY_c) {
/* 激活pid的轻软件触发器，可捕捉 */
triggeron(TRIGLSOFT, pid);
}
if (keybuf[0] == KEY_Z || keybuf[0] == KEY_z) {
/* 激活pid的轻软件触发器，可捕捉 */
triggeron(TRIGPAUSE, pid);
}
if (keybuf[0] == KEY_X || keybuf[0] == KEY_x) {
/* 激活pid的轻软件触发器，可捕捉 */
triggeron(TRIGRESUM, pid);
}
}
return 0;
}
int shell_readline()
{
cmdman->cmd_pos = cmdman->cmd_line;
cmdman->cmd_len = 0;
char *buf = cmdman->cmd_line;
int keybuf[2];
while ((cmdman->cmd_pos - buf) < CMD_LINE_LEN) {
if (xcons_getkey(keybuf, 0) < 0)
continue;
/* 过滤一些按键 */
switch (keybuf[0]) {
case KEY_UP:
case KEY_DOWN:
case KEY_LEFT:
case KEY_RIGHT:
case KEY_NUMLOCK:
case KEY_CAPSLOCK:
case KEY_SCROLLOCK:
case KEY_RSHIFT:
case KEY_LSHIFT:
case KEY_RCTRL:
case KEY_LCTRL:
case KEY_RALT:
case KEY_LALT:
break;
case KEY_ENTER:
shell_putchar('\n');
buf[cmdman->cmd_len] = 0;
/* 发送给命令行 */
return 0; /* 执行命令 */
case KEY_BACKSPACE:
if(cmdman->cmd_pos > buf){
--cmdman->cmd_pos;
*cmdman->cmd_pos = '\0';
shell_putchar('\b');
}
break;
default:
*cmdman->cmd_pos = keybuf[0];
shell_putchar(keybuf[0]);
cmdman->cmd_pos++;
cmdman->cmd_len++;
break;
}
}
return 0;
}
void shell_putchar(char ch)
{
char s[2] = {ch, 0};
//xcons_xmit_data(s, 1);
xcons_putstr(s, 1);
}
int shell_printf(const char *fmt, ...)
{
char buf[BUFSIZ];
va_list arg = (va_list)((char*)(&fmt) + 4); /*4是参数fmt所占堆栈中的大小*/
vsprintf(buf, fmt, arg);
/* 输出到控制台 */
//xcons_xmit_data(buf, strlen(buf));
xcons_putstr(buf, strlen(buf));
return 0;
}
|
NightfallDM/xbook2
|
user/socket_server/main.c
|
<reponame>NightfallDM/xbook2<filename>user/socket_server/main.c
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/ioctl.h>
#include<string.h>
int main()
{
//创建一个socket
int listenSocket=socket(AF_INET,SOCK_STREAM,0);
//配置ip port 协议
struct sockaddr_in addrSrc,addrClient;
addrSrc.sin_family=AF_INET;
addrSrc.sin_port=htons(6666);
addrSrc.sin_addr.s_addr=INADDR_ANY;
//绑定
bind(listenSocket,(struct sockaddr*)&addrSrc,sizeof(struct sockaddr_in));
//监听
listen(listenSocket,5);
int connfd=0;
socklen_t len=sizeof(struct sockaddr_in);
connfd=accept(listenSocket,(struct sockaddr*)&addrClient,&len);
char *ipStr=inet_ntoa(addrClient.sin_addr);
printf("connect is %s\n",ipStr);
char sendBuf[100]="hello client!";
//发送信息到客户端
send(connfd,sendBuf,strlen(sendBuf)+1,0);
while(1)
{
//接收客户端信息
char recvBuf[100]={0};
int ret=recv(connfd,recvBuf,sizeof(recvBuf)-1,0);
if(0==ret)
{
printf("%s is leave!\n",ipStr);
break;
}
char printBuf[1024]={0};
//字符串拼接
sprintf(printBuf,"from %s: %s",ipStr,recvBuf);
puts(printBuf);
}
//关闭套接字
close(connfd);
close(listenSocket);
return 0;
}
|
NightfallDM/xbook2
|
src/include/xbook/process.h
|
#ifndef _XBOOK_PROCESS_H
#define _XBOOK_PROCESS_H
#include "task.h"
#include "elf32.h"
#include <sys/kfile.h>
task_t *start_process(char *name, char **argv);
int proc_destroy(task_t *task, int thread);
int proc_vmm_init(task_t *task);
int proc_vmm_exit(task_t *task);
int proc_build_arg(unsigned long arg_top, unsigned long *arg_bottom, char *argv[], char **dest_argv[]);
void proc_heap_init(task_t *task);
void proc_map_space_init(task_t *task);
int proc_load_image(vmm_t *vmm, struct Elf32_Ehdr *elf_header, int fd);
void proc_make_trap_frame(task_t *task);
int proc_release(task_t *task);
int proc_trigger_init(task_t *task);
int proc_pthread_init(task_t *task);
int proc_res_init(task_t *task);
int proc_res_exit(task_t *task);
int thread_release_resource(task_t *task);
int sys_fork();
void sys_exit(int status);
pid_t sys_waitpid(pid_t pid, int *status, int options);
int sys_execve(const char *pathname, const char *argv[], const char *envp[]);
#endif /* _XBOOK_PROCESS_H */
|
NightfallDM/xbook2
|
library/xlibc/include/utime.h
|
<filename>library/xlibc/include/utime.h
#ifndef _XLIBC_UTIME_H
#define _XLIBC_UTIME_H
#include <types.h>
#include <stddef.h>
struct utimbuf {
time_t actime; /* access time */
time_t modtime; /* modification time */
};
int utime(const char *pathname, const struct utimbuf *times);
#endif /* _XLIBC_UTIME_H */
|
NightfallDM/xbook2
|
src/include/xbook/byteorder.h
|
<filename>src/include/xbook/byteorder.h<gh_stars>0
/*
字序转换，大端字序和小端字序
*/
#ifndef _XBOOK_BYTEORDER_H
#define _XBOOK_BYTEORDER_H
#include <stdint.h>
/**
* swap16 - 16位的字节交换
* @data: 需要交换的数据
*
* 返回交换后的数据
*/
static inline uint16_t swap16(uint16_t data)
{
return (uint16_t)((data & 0xFF) << 8) | ((data & 0xFF00) >> 8);
}
/**
* swap32 - 32位的字节交换
* @data: 需要交换的数据
*
* 返回交换后的数据
*/
static inline uint32_t swap32(uint32_t data)
{
return (uint32_t)((data & 0xFF) << 24) | ((data & 0xFF00) << 8) | \
((data & 0xFF0000) >> 8) | ((data & 0xFF000000) >> 24);
}
/**
* GetEndianness - 获取CPU字序
*
* 是0就是小端，是1就是大端
*/
static inline int get_cpu_endian()
{
short s = 0x0110;
char *p = (char *) &s;
if (p[0] == 0x10)
return 0; // 小端格式
else
return 1; // 大端格式
}
/**
* cpu_to_le16 - cpu字序转换成小端字序
* data: 需要转换的数据
*/
static inline uint16_t cpu_to_le16(uint16_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return swap16(data); /* 返回交换后的数据 */
} else { /* 是小端 */
return data; /* 已经是小端了，就不用转换，直接返回 */
}
}
/**
* cpu_to_le32 - cpu字序转换成小端字序
* data: 需要转换的数据
*/
static inline uint32_t cpu_to_le32(uint32_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return swap32(data); /* 返回交换后的数据 */
} else { /* 是小端 */
return data; /* 已经是小端了，就不用转换，直接返回 */
}
}
/**
* cpu_to_be16 - cpu字序转换成大端字序
* data: 需要转换的数据
*/
static inline uint16_t cpu_to_be16(uint16_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return data; /* 已经是大端了，就不用转换，直接返回 */
} else { /* 是小端 */
return swap16(data); /* 返回交换后的数据 */
}
}
/**
* cpu_to_be32 - cpu字序转换成大端字序
* data: 需要转换的数据
*/
static inline uint32_t cpu_to_be32(uint32_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return data; /* 已经是大端了，就不用转换，直接返回 */
} else { /* 是小端 */
return swap32(data); /* 返回交换后的数据 */
}
}
/**
* be16_to_cpu - 大端字序转换成cpu字序
* data: 需要转换的数据
*/
static inline uint16_t be16_to_cpu(uint16_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return data; /* 已经是大端了，就不用转换，直接返回 */
} else { /* 是小端 */
return swap16(data); /* 返回交换后的数据 */
}
}
/**
* be32_to_cpu - 大端字序转换成cpu字序
* data: 需要转换的数据
*/
static inline uint32_t be32_to_cpu(uint32_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return data; /* 已经是大端了，就不用转换，直接返回 */
} else { /* 是小端 */
return swap32(data); /* 返回交换后的数据 */
}
}
/**
* le16_to_cpu - 小端字序转换成cpu字序
* data: 需要转换的数据
*/
static inline uint16_t le16_to_cpu(uint16_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return swap16(data); /* 返回交换后的数据 */
} else { /* 是小端 */
return data; /* 已经是小端了，就不用转换，直接返回 */
}
}
/**
* le32_to_cpu - 小端字序转换成cpu字序
* data: 需要转换的数据
*/
static inline uint32_t le32_to_cpu(uint32_t data)
{
/* 如果是大端 */
if (get_cpu_endian()) {
return swap32(data); /* 返回交换后的数据 */
} else { /* 是小端 */
return data; /* 已经是小端了，就不用转换，直接返回 */
}
}
#endif /* _XBOOK_BYTEORDER_H */
|
NightfallDM/xbook2
|
src/vmm/vmarea.c
|
<gh_stars>0
#include <arch/interrupt.h>
#include <arch/ioremap.h>
#include <xbook/vmarea.h>
#include <xbook/debug.h>
#include <xbook/bitmap.h>
#include <xbook/memcache.h>
#include <string.h>
/* vir addr management bitmap */
static bitmap_t vaddr_bitmap;
/* vaddr start base */
static unsigned long vaddr_base;
/* 正在使用中的vmarea */
static list_t using_vmarea_list;
/* 处于空闲状态的vmarea，成员根据大小进行排序，越小的就靠在前面 */
static list_t free_vmarea_list;
/**
* alloc_vaddr - 分配一块空闲的虚拟地址
* @size: 请求的大小
*
* @return: 失败返回0，成功返回内核虚拟地址
*/
unsigned long alloc_vaddr(size_t size)
{
size = PAGE_ALIGN(size);
if (!size)
return 0;
long pages = size / PAGE_SIZE;
/* 扫描获取请求的页数 */
long idx = bitmap_scan(&vaddr_bitmap, pages);
if (idx == -1)
return 0;
long i;
/* 把已经扫描到的位置1，表明已经分配了 */
for (i = 0; i < pages; i++) {
bitmap_set(&vaddr_bitmap, idx + i, 1);
}
/* 返还转换好的虚拟地址 */
return vaddr_base + idx * PAGE_SIZE;
}
/**
* free_vaddr - 释放一块空闲的虚拟地址
* @vaddr: 虚拟地址
* @size: 占用的大小
*/
unsigned long free_vaddr(unsigned long vaddr, size_t size)
{
if (!size)
return -1;
size = PAGE_ALIGN(size);
long pages = size / PAGE_SIZE;
/* 扫描获取请求的页数 */
long idx = (vaddr - vaddr_base) / PAGE_SIZE;
if (idx == -1)
return -1;
long i;
/* 把地址对应的位图到的位置0，表明已经释放了 */
for (i = 0; i < pages; i++) {
bitmap_set(&vaddr_bitmap, idx + i, 0);
}
return 0;
}
static void *__vmalloc(size_t size)
{
/* 创建一个新的区域 */
unsigned long start = alloc_vaddr(size);
if (!start)
return NULL;
vmarea_t *area;
/* 创建一个虚拟区域 */
area = kmalloc(sizeof(vmarea_t));
if (area == NULL) {
free_vaddr(start, size);
return NULL;
}
area->addr = start;
area->size = size;
unsigned long flags;
save_intr(flags);
/* 添加到虚拟区域的链表上 */
list_add_tail(&area->list, &using_vmarea_list);
if (map_pages(start, size, PROT_KERN | PROT_WRITE)) {
free_vaddr(start, size);
kfree(area);
restore_intr(flags);
return NULL;
}
restore_intr(flags);
//printk("vmalloc: create a area %x/%x\n", area->addr, area->size);
return (void *)area->addr;
}
/**
* vmalloc - 分配空间
* @size: 空间的大小
*/
void *vmalloc(size_t size)
{
size = PAGE_ALIGN(size);
if (!size)
return NULL;
/* 中间用一个页隔离 */
size += PAGE_SIZE;
//printk("size %d\n", size);
vmarea_t *target = NULL, *area;
/* 先从空闲链表中查找 */
list_for_each_owner(area, &free_vmarea_list, list) {
/* 如果找到了大小合适的区域 */
if (size >= area->size) {
target = area;
break;
}
}
/* 找到一个合适大小的area，就使用它 */
if (target != NULL) {
//printk("vmalloc: find a free area %x/%x\n", target->addr, target->size);
unsigned long flags;
save_intr(flags);
/* 先脱离原来的空闲链表，并添加到使用链表中去 */
list_del(&target->list);
list_add_tail(&target->list, &using_vmarea_list);
restore_intr(flags);
return (void *)target->addr;
}
return (void *)__vmalloc(size);
}
static int __vfree(vmarea_t *target)
{
vmarea_t *area;
//printk("vfree: find a using area %x/%x\n", target->addr, target->size);
/* 先脱离原来的使用链表，并添加到空闲链表中去 */
list_del(&target->list);
/* 成功插入标志 */
char insert = 0;
/* 这里要根据area大小进行排序，把最小的排在最前面 */
if (list_empty(&free_vmarea_list)) {
//printk("vfree: free area is empty %x/%x\n", target->addr, target->size);
/* 链表是空，直接添加到最前面 */
list_add(&target->list, &free_vmarea_list);
} else {
//printk("vfree: free area is not empty %x/%x\n", target->addr, target->size);
/* 获取第一个宿主 */
area = list_first_owner(&free_vmarea_list, vmarea_t, list);
do {
/* 根据大小来判断插入位置，小的在前面，大的在后面 */
if (target->size > area->size) {
/*printk("target %x/%x area %x/%x\n",
target->addr, target->size, area->addr, area->size);*/
/* 不满足条件，需要继续往后查找 */
if (area->list.next == &free_vmarea_list) {
/* 如果到达了最后面，也就是说下一个就是链表头了
直接把target添加到队列的最后面
*/
list_add_tail(&target->list, &free_vmarea_list);
insert = 1;
//printk("vfree: insert tail %x/%x\n");
break;
}
/* 获取下一个宿主 */
area = list_owner(area->list.next, vmarea_t, list);
} else {
/* 插入到中间的情况 */
/* 把新节点添加到旧节点前面 */
list_add_before(&target->list, &area->list);
insert = 1;
//printk("vfree: insert before area %x/%x\n", area->addr, area->size);
break;
}
} while (&area->list != &free_vmarea_list);
}
return insert;
}
/**
* vfree - 释放空间
* @ptr: 空间所在的地址
*/
int vfree(void *ptr)
{
if (ptr == NULL)
return -1;
unsigned long addr = (unsigned long)ptr;
if (addr < vaddr_base || addr >= VMAREA_END)
return -1;
vmarea_t *target = NULL, *area;
unsigned long flags;
save_intr(flags);
list_for_each_owner(area, &using_vmarea_list, list) {
/* 如果找到了对应的区域 */
if (area->addr == addr) {
target = area;
break;
}
}
/* 找到一个合适要释放的area，就释放它 */
if (target != NULL) {
if (__vfree(target)) {
restore_intr(flags);
return 0;
}
}
/* 没找到，释放失败 */
restore_intr(flags);
return -1;
}
/**
* ioremap - io内存映射
* @paddr: 物理地址
* @size: 映射的大小
*
* @return: 成功返回映射后的地址，失败返回NULL
*/
void *ioremap(unsigned long paddr, size_t size)
{
/* 对参数进行检测,地址不能是0，大小也不能是0 */
if (!paddr || !size) {
return NULL;
}
/* 分配虚拟地址 */
unsigned long vaddr = alloc_vaddr(size);
if (vaddr == -1) {
printk("alloc virtual addr for IO remap failed!\n");
return NULL;
}
//printk("alloc a virtual addr at %x\n", vaddr);
/* 创建一个虚拟区域 */
vmarea_t *area;
/* 创建一个虚拟区域 */
area = kmalloc(sizeof(vmarea_t));
if (area == NULL) {
free_vaddr(vaddr, size);
return NULL;
}
/* 设置虚拟区域参数 */
area->addr = vaddr;
area->size = size;
unsigned long flags;
save_intr(flags);
/* 添加到虚拟区域的链表上 */
list_add_tail(&area->list, &using_vmarea_list);
/* 进行io内存映射，如果失败就释放资源 */
if (__ioremap(paddr, vaddr, size)) {
/* 释放分配的资源 */
list_del(&area->list);
kfree(area);
free_vaddr(vaddr, size);
/* 指向0，表示空 */
vaddr = 0;
}
restore_intr(flags);
return (void *)vaddr;
}
/**
* iounmap - 取消io内存映射
* @vaddr: 虚拟地址地址
*
* @return: 成功返回映射后的地址，失败返回NULL
*/
int iounmap(void *vaddr)
{
if (vaddr == NULL) {
return -1;
}
unsigned long addr = (unsigned long )vaddr;
if (addr < vaddr_base || addr >= VMAREA_END)
return -1;
vmarea_t *target = NULL, *area;
unsigned long flags;
save_intr(flags);
list_for_each_owner(area, &using_vmarea_list, list) {
/* 如果找到了对应的区域 */
if (area->addr == addr) {
target = area;
break;
}
}
/* 找到一个合适要释放的area，就释放它 */
if (target != NULL) {
if (__iounmap(target->addr, target->size)) {
/* 取消IO映射并释放area */
list_del(&target->list);
free_vaddr(addr, target->size);
kfree(target);
restore_intr(flags);
return 0;
}
}
/* 没找到，释放失败 */
restore_intr(flags);
return -1;
}
/**
* init_vmarea - 初始化虚拟区域
*/
void init_vmarea()
{
/* 每一位代表1个页的分配状态 */
vaddr_bitmap.byte_length = HIGH_MEM_SIZE / (PAGE_SIZE * 8);
/* 为位图分配空间 */
vaddr_bitmap.bits = kmalloc(vaddr_bitmap.byte_length);
bitmap_init(&vaddr_bitmap);
vaddr_base = VMAREA_BASE;
/* 初始化使用中的区域链表 */
INIT_LIST_HEAD(&using_vmarea_list);
/* 初始化空闲的区域链表 */
INIT_LIST_HEAD(&free_vmarea_list);
#if 0
char *a = vmalloc(PAGE_SIZE);
if (a == NULL)
printk("vmalloc failed!\n");
memset(a, 0, PAGE_SIZE);
char *b = vmalloc(PAGE_SIZE* 10);
if (b == NULL)
printk("vmalloc failed!\n");
memset(b, 0, PAGE_SIZE *10);
char *c = vmalloc(PAGE_SIZE *100);
if (c == NULL)
printk("vmalloc failed!\n");
memset(c, 0, PAGE_SIZE *100);
char *d = vmalloc(PAGE_SIZE *1000);
if (d == NULL)
printk("vmalloc failed!\n");
memset(d, 0, PAGE_SIZE *1000);
printk("%x %x %x %x\n", a, b, c, d);
vfree(a);
vfree(b);
vfree(c);
vfree(d);
a = vmalloc(PAGE_SIZE);
if (a == NULL)
printk("vmalloc failed!\n");
memset(a, 0, PAGE_SIZE);
b = vmalloc(PAGE_SIZE* 10);
if (b == NULL)
printk("vmalloc failed!\n");
memset(b, 0, PAGE_SIZE *10);
c = vmalloc(PAGE_SIZE *100);
if (c == NULL)
printk("vmalloc failed!\n");
memset(c, 0, PAGE_SIZE *100);
d = vmalloc(PAGE_SIZE *1000);
if (d == NULL)
printk("vmalloc failed!\n");
memset(d, 0, PAGE_SIZE *1000);
printk("%x %x %x %x\n", a, b, c, d);
vfree(c);
vfree(b);
vfree(d);
vfree(a);
void *mapa;
if ((mapa = ioremap(0xeff00000, 1 * MB)) == NULL) {
printk("ioremap failed!");
}
memset(mapa, 0, 1 * MB);
printk("ioremap ok!\n");
iounmap(mapa);
printk("iounmap ok!\n");
memset(mapa, 0, 1 * MB);
#endif
}
|
NightfallDM/xbook2
|
user/tests/libvideo.c
|
#include "test.h"
static video_info_t video_info;
/* R5G6B5 color helper */
static uint32_t GUI_TO_R5G6B5(uint32_t gui_color)
{
uint32_t r, g, b;
b = gui_color&0xF8;
g = gui_color&0xFC00;
r = gui_color&0xF80000;
return (b>>3)|(g>>5)|(r>>8);
}
static unsigned int video_ram_size = 0;
static unsigned char *video_ram_start = NULL;
int screen_output_pixel(int x, int y, uint32_t color)
{
/* User must write the right code */
int offset = 0;
if ( x > (video_info.x_resolution-1) )
return -1;
if ( y > (video_info.y_resolution-1) )
return -1;
color = GUI_TO_R5G6B5(color);
/* Output pixel */
switch( (video_info.bits_per_pixel) )
{
case 8:
offset = (video_info.x_resolution)*y+x;
if ( offset >= ((video_info.x_resolution)*(video_info.y_resolution)-1))
return -1;
*(video_ram_start+offset) = (unsigned char)color;
break;
case 15:
offset = 2*((video_info.x_resolution)*y+x);
if ( offset >= ((video_info.x_resolution)*(video_info.y_resolution)*2-2))
return -1;
*((short int*)((video_ram_start) + offset)) = (short int)color;
break;
case 16:
offset = 2*((video_info.x_resolution)*y+x);
if ( offset >= ((video_info.x_resolution)*(video_info.y_resolution)*2-2))
return -1;
*((short int*)((video_ram_start) + offset)) = (short int)color;
break;
case 24:
offset = 3*((video_info.x_resolution)*y+x);
if ( offset >= ((video_info.x_resolution)*(video_info.y_resolution)*3-3))
return -1;
*((video_ram_start) + offset + 0) = color&0xFF;
*((video_ram_start) + offset + 1) = (color&0xFF00) >> 8;
*((video_ram_start) + offset + 2) = (color&0xFF0000) >> 16;
break;
case 32:
offset = 4*((video_info.x_resolution)*y+x);
if ( offset >= ((video_info.x_resolution)*(video_info.y_resolution)*4-4))
return -1;
*((int*)((video_ram_start) + offset)) = (int)color;
break;
default:
break;
}
return 0;
}
int video_res;
int init_libvideo()
{
/* 映射显存 */
int video_res = res_open("video", RES_DEV, 0 );
if ( video_res < 0 )
return -1;
int ret = res_ioctl(video_res, VIDEOIO_GETINFO, (unsigned long) &video_info);
if ( ret < 0 ) {
res_close(video_res);
return -1;
}
video_ram_size = video_info.bytes_per_scan_line * video_info.y_resolution;
video_ram_start = res_mmap(video_res, video_ram_size, 0);
if (video_ram_start == NULL) {
printf("test: video mapped failed!\n");
res_close(video_res);
return -1;
}
return 0;
}
int video_test(int argc, char *argv[])
{
if (argc < 3) {
printf("please input file type 'jpg' or 'png' + file.\n");
return -1;
}
int pic_type = -1;
if (!strcmp(argv[1], "jpg")) {
pic_type = 0;
} else if (!strcmp(argv[1], "png")) {
pic_type = 1;
} else {
printf("please input file type error!\n");
return - 1;
}
if (init_libvideo() < 0)
return -1;
if (pic_type == 0) {
if (jpg_display(argv[2]) < 0)
printf("display failed!\n");
} else {
if (test_png_main(argc, argv) < 0)
printf("display failed!\n");
}
munmap(video_ram_start, video_ram_size);
res_close(video_res);
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/page.c
|
<reponame>NightfallDM/xbook2<filename>src/arch/x86/mach-i386/page.c
#include <arch/page.h>
#include <arch/pmem.h>
#include <arch/instruction.h>
#include <arch/registers.h>
#include <arch/tss.h>
#include <xbook/debug.h>
#include <math.h>
#include <string.h>
#include <assert.h>
#include <xbook/task.h>
#include <xbook/vmspace.h>
extern mem_node_t *mem_node_table;
extern unsigned int mem_node_count;
extern unsigned int mem_node_base;
unsigned long __alloc_pages(unsigned long count)
{
mem_node_t *node = get_free_mem_node();
if (node == NULL)
return 0;
int index = node - mem_node_table;
/* 如果分配的页数超过范围 */
if (index + count > mem_node_count)
return 0;
/* 第一次分配的时候设置引用为1 */
node->reference = 1;
node->count = (unsigned int)count;
node->flags = 0;
node->cache = NULL;
node->group = NULL;
return (long)__mem_node2page(node);
}
int __free_pages(unsigned long page)
{
mem_node_t *node = __page2mem_node((unsigned long)page);
if (node == NULL)
return -1;
__atomic_dec(&node->reference);
if (node->reference == 0) {
node->count = 0;
node->flags = 0;
return 0;
}
return -1;
}
/*
* __page_link - 物理地址和虚拟地址链接起来
* @va: 虚拟地址
* @pa: 物理地址
* @prot: 页的保护
*
* 把虚拟地址和物理地址连接起来，这样就能访问物理地址了
*/
void __page_link(unsigned long va, unsigned long pa, unsigned long prot)
{
unsigned long vaddr = (unsigned long )va;
unsigned long paddr = (unsigned long )pa;
/* get page dir and page table */
pde_t *pde = get_pde_ptr(vaddr);
pte_t *pte = get_pte_ptr(vaddr);
/* if page table exist. */
if (*pde & PG_P_1) {
/* phy page must not exist! */
ASSERT(!(*pte & PG_P_1));
/* make sure phy page not exist! */
if (!(*pte & PG_P_1)) {
*pte = (paddr | prot | PG_P_1);
} else {
/* phy page exist! */
panic("pte %x has exist!\n", *pte);
*pte = (paddr | prot | PG_P_1);
}
} else { /* no page table, need create a new one. */
unsigned long page_table = __alloc_pages(1);
if (!page_table) {
/* no page left */
panic("kernel no page left!\n");
/* we can goto free some pages and try it again,
but now we just stop! */
}
//printk(KERN_DEBUG "page_link -> new page table %x\n", page_table);
/* add page table to page dir */
*pde = (page_table | prot | PG_P_1);
/* clear page to avoid dirty data */
memset((void *)((unsigned long)pte & PAGE_ADDR_MASK), 0, PAGE_SIZE);
/* make sure phy page not exist! */
ASSERT(!(*pte & PG_P_1));
*pte = (paddr | prot | PG_P_1);
}
}
/*
* __page_link_unsafe - 物理地址和虚拟地址链接起来
* @va: 虚拟地址
* @pa: 物理地址
* @prot: 页的保护
*
* 把虚拟地址和物理地址连接起来，这样就能访问物理地址了
*/
void __page_link_unsafe(unsigned long va, unsigned long pa, unsigned long prot)
{
unsigned long vaddr = (unsigned long )va;
unsigned long paddr = (unsigned long )pa;
/* get page dir and page table */
pde_t *pde = get_pde_ptr(vaddr);
pte_t *pte = get_pte_ptr(vaddr);
/* if page table exist. */
if (*pde & PG_P_1) {
/* phy page must not exist! */
//ASSERT(!(*pte & PG_P_1));
if ((*pte & PG_P_1)) {
free_page(*pte & PAGE_ADDR_MASK);
*pte = 0;
}
/* make sure phy page not exist! */
if (!(*pte & PG_P_1)) {
*pte = (paddr | prot | PG_P_1);
} else {
/* phy page exist! */
panic("pte %x has exist!\n", *pte);
*pte = (paddr | prot | PG_P_1);
}
} else { /* no page table, need create a new one. */
unsigned long page_table = __alloc_pages(1);
if (!page_table) {
/* no page left */
panic("kernel no page left!\n");
/* we can goto free some pages and try it again,
but now we just stop! */
}
//printk(KERN_DEBUG "page_link -> new page table %x\n", page_table);
/* add page table to page dir */
*pde = (page_table | prot | PG_P_1);
/* clear page to avoid dirty data */
memset((void *)((unsigned long)pte & PAGE_ADDR_MASK), 0, PAGE_SIZE);
/* make sure phy page not exist! */
//ASSERT(!(*pte & PG_P_1));
if ((*pte & PG_P_1)) {
free_page(*pte & PAGE_ADDR_MASK);
*pte = 0;
}
*pte = (paddr | prot | PG_P_1);
}
}
/*
* __page_unlink - 取消虚拟地址对应的物理链接
* @vaddr: 虚拟地址
*
* 取消虚拟地址和物理地址链接。
* 在这里我们不删除页表项映射，只删除物理页，这样在以后映射这个地址的时候，
* 可以加速运行。但是弊端在于，内存可能会牺牲一些。
* 也消耗不了多少，4G内存才4MB。
*/
void __page_unlink(unsigned long vaddr)
{
pte_t *pte = get_pte_ptr(vaddr);
// 如果页表项存在物理页
if (*pte & PG_P_1) {
//printk(KERN_DEBUG "unlink vaddr:%x pte:%x\n", vaddr, *pte);
// 清除页表项的存在位，相当于删除物理页
*pte &= ~PG_P_1;
/* flush vaddr tbl cache */
flush_tbl(vaddr);
}
}
/**
* __map_pages - 映射页面
*
* 非连续内存使用，可以提高分配效率
*/
int __map_pages(unsigned long start, unsigned long len, unsigned long prot)
{
unsigned long first = start & PAGE_MASK; /* 页地址对齐 */
// 长度和页对齐
len = PAGE_ALIGN(len);
/* set page attr */
unsigned long attr = 0;
if (prot & PROT_USER)
attr |= PG_US_U;
else
attr |= PG_US_S;
if (prot & PROT_WRITE)
attr |= PG_RW_W;
else
attr |= PG_RW_R;
/* 判断长度是否超过剩余内存大小 */
//printk("len %d pages %d\n", len, len / PAGE_SIZE);
/* 分配物理页 */
unsigned long pages = __alloc_pages(len / PAGE_SIZE);
if (!pages) {
printk(KERN_ERR "map_pages -> map without free pages!\n");
return -1;
}
unsigned long end = first + len;
//printk(KERN_DEBUG "map_pages -> start%x->%x len %x\n", first, pages, len);
while (first < end)
{
// 对单个页进行链接
__page_link(first, pages, attr);
first += PAGE_SIZE;
pages += PAGE_SIZE;
}
return 0;
}
/**
* __map_pages_fixed - 映射固定页面
* @start: 起始虚拟地址
* @addr: 物理地址
* @len: 映射长度
* @prot: 映射的属性
*
* 固定的物理地址和虚拟地址映射
*
* @return: 成功返回0，失败返回-1
*/
int __map_pages_fixed(unsigned long start, unsigned long addr, unsigned long len, unsigned long prot)
{
unsigned long first = start & PAGE_MASK; /* 页地址对齐 */
// 长度和页对齐
len = PAGE_ALIGN(len);
/* set page attr */
unsigned long attr = 0;
if (prot & PROT_USER)
attr |= PG_US_U;
else
attr |= PG_US_S;
if (prot & PROT_WRITE)
attr |= PG_RW_W;
else
attr |= PG_RW_R;
/* 判断长度是否超过剩余内存大小 */
//printk("len %d pages %d\n", len, len / PAGE_SIZE);
/* 获取物理页地址 */
unsigned long pages = addr;
unsigned long end = first + len;
//printk(KERN_DEBUG "map_pages -> start%x->%x len %x\n", first, pages, len);
while (first < end)
{
if (prot & PROT_REMAP) {
__page_link_unsafe(first, pages, attr);
} else {
// 对单个页进行链接
__page_link(first, pages, attr);
}
first += PAGE_SIZE;
pages += PAGE_SIZE;
}
return 0;
}
/**
* __addr_v2p - 虚拟地址转换为物理地址
*
* 用于非连续地址转换。
*/
unsigned long __addr_v2p(unsigned long vaddr)
{
pte_t* pte = get_pte_ptr(vaddr);
/*
(*pte)的值是页表所在的物理页框地址,
去掉其低12位的页表项属性+虚拟地址vaddr的低12位
*/
return ((*pte & 0xfffff000) + (vaddr & 0x00000fff));
}
/**
* __unmap_pages - 取消页映射
* @vaddr: 虚拟地址
* @len: 内存长度
*
* 和map_pages配合使用，同使用于非连续内存
*/
int __unmap_pages(unsigned long vaddr, unsigned long len)
{
if (!len)
return -1;
len = PAGE_ALIGN(len);
/* 判断长度是否超过剩余内存大小 */
unsigned long paddr, start = (unsigned long)vaddr & PAGE_MASK; /* 页地址对齐 */
unsigned long end = start + len;
/* 不能通过__v2p来获取，需要从页表映射中解析获取 */
paddr = __addr_v2p(start);
//printk("unmap pages:%x->%x len %x\n", vaddr, paddr, len);
while (start < end)
{
__page_unlink(start);
start += PAGE_SIZE;
}
// 释放物理页
__free_pages(paddr);
return 0;
}
/**
* __map_pages_safe - 安全地映射页
*
* 如果页已经映射，就不覆盖，直接跳过
* 每次映射单个页，效率较低，不过比较安全
* 用于进程地址空间
*/
int __map_pages_safe(unsigned long start, unsigned long len, unsigned long prot)
{
unsigned long vaddr = (unsigned long )start & PAGE_MASK; /* 页地址对齐 */
len = PAGE_ALIGN(len);
unsigned long pages = DIV_ROUND_UP(len, PAGE_SIZE);
unsigned long page_idx = 0;
unsigned long page_addr;
/* set page attr */
unsigned long attr = 0;
if (prot & PROT_USER)
attr |= PG_US_U;
else
attr |= PG_US_S;
if (prot & PROT_WRITE)
attr |= PG_RW_W;
else
attr |= PG_RW_W;
while (page_idx < pages) {
/* get page dir and page table */
pde_t *pde = get_pde_ptr(vaddr);
pte_t *pte = get_pte_ptr(vaddr);
if (!(*pde & PG_P_1) || !(*pte & PG_P_1)) {
page_addr = __alloc_pages(1);
if (!page_addr) {
printk("error: user_map_vaddr -> map pages failed!\n");
return -1;
}
__page_link(vaddr, page_addr, attr);
//printk("info: map_pages_safe -> start%x->%x\n", vaddr, page_addr);
}
vaddr += PAGE_SIZE;
page_idx++;
}
return 0;
}
static int is_page_table_empty(pte_t *page_table)
{
int i;
for (i = 0; i < 0; i++) {
/* if some one exist, not empty */
if (page_table[i] & PG_P_1)
return 0;
}
return 1; /* empty */
}
/**
* __unmap_pages_safe - 安全地取消映射页
* @start: 起始地址
* @len: 范围长度
* @fixed: 是否为固定页，0不是，1是。
*
* 如果页已经映射，就不覆盖，直接跳过，每次释放单个页，可以释放所有资源。
* 用于进程地址释放。
* fixed用于判断是否是固定页，固定页的意思是，映射的时候，虚拟地址和一个显示的指出物理地址
* 进行映射。非固定页就是，映射的时候只指定了虚拟地址，而物理地址是随机分配的。
*
* @return: 成功返回0，失败返回-1
*/
int __unmap_pages_safe(unsigned long start, unsigned long len, char fixed)
{
unsigned long vaddr = (unsigned long )start & PAGE_MASK; /* 页地址对齐 */
len = PAGE_ALIGN(len);
unsigned long pages = DIV_ROUND_UP(len, PAGE_SIZE);
unsigned long pte_idx; /* pte -> physic page */
pde_t *pde;
pte_t *pte;
/*if (fixed)
printk(KERN_NOTICE "__unmap_pages_safe: fixed %d %x!\n", current_task->pid, start);
*/
while (pages > 0) {
pde = get_pde_ptr(vaddr); /* get pde from vaddr */
if ((*pde & PG_P_1)) { /* page table exist */
/* when page tabel entry nr < 1024, continue free */
while ((pte_idx = PTE_IDX(vaddr)) < 1024) {
//printk("info: unmap_pages_safe -> pte idx %d\n", pte_idx);
pte = get_pte_ptr(vaddr); /* get pte from vaddr */
if (*pte & PG_P_1) {
//printk("info: unmap_pages_safe -> start%x->%x\n", vaddr, *pte & PAGE_ADDR_MASK);
/* free physic page if not fixed */
if (!fixed)
__free_pages(*pte & PAGE_ADDR_MASK);
/* del page entry */
*pte &= ~PG_P_1;
}
vaddr += PAGE_SIZE;
pages--;
if (!pages) { /* no page left */
/* check page table */
if (is_page_table_empty((pte_t *)((unsigned long)pte & PAGE_ADDR_MASK))) {
//printk("info: unmap_pages_safe -> del page table %x\n", *pde & PAGE_ADDR_MASK);
/* free page table */
__free_pages(*pde & PAGE_ADDR_MASK);
}
goto end;
}
/* if at last one, break out */
if (pte_idx == 1023)
break;
}
//printk("info: unmap_pages_safe -> del page table %x\n", *pde & PAGE_ADDR_MASK);
/* free page dir table */
__free_pages(*pde & PAGE_ADDR_MASK);
/* del page entry */
*pde &= ~PG_P_1;
} else {
vaddr += PAGE_SIZE;
pages--;
if (!pages) { /* no page left */
goto end;
}
}
}
end:
return 0;
}
/* 复制一份内核页，并清空用户态数据 */
unsigned long *__copy_kernel_page_dir()
{
unsigned long page = __alloc_pages(1);
unsigned int *vaddr = (unsigned int *)__va(page);
memset(vaddr, 0, PAGE_SIZE);
memcpy((void *)((unsigned char *)vaddr + PAGE_SIZE / 2),
(void *)((unsigned char *)PAGE_DIR_VIR_ADDR + PAGE_SIZE / 2),
PAGE_SIZE / 2);
vaddr[1023] = page | PG_P_1 | PG_US_S | PG_RW_W;
return (unsigned long *)vaddr;
}
/*
* mem_self_mapping - 内存自映射
* @start: 开始物理地址
* @end: 结束物理地址
*
* 把物理和内核虚拟地址进行映射
*/
int mem_self_mapping(unsigned int start, unsigned int end)
{
/* ----映射静态内存---- */
//把页目录表设置
unsigned int *pdt = (unsigned int *)PAGE_DIR_VIR_ADDR;
// 求出目录项数量
unsigned int pde_nr = (end - start) / (1024 * PAGE_SIZE);
// 先获取的页数
unsigned int pte_nr = (end-start)/PAGE_SIZE;
// 获取页数中余下的数量，就是页表项剩余数
pte_nr = pte_nr % 1024;
//跳过页表区域中的第一个页表
unsigned int *pte_addr = (unsigned int *) (PAGE_TABLE_PHY_ADDR +
PAGE_SIZE * PAGE_TABLE_PHY_NR);
int i, j;
// 根据页目录项来填写
for (i = 0; i < pde_nr; i++) {
//填写页目录表项
//把页表地址和属性放进去
pdt[512 + PAGE_TABLE_PHY_NR + i] = (unsigned int)pte_addr | PG_P_1 | PG_RW_W | PG_US_S;
for (j = 0; j < PAGE_ENTRY_NR; j++) {
//填写页页表项
//把物理地址和属性放进去
pte_addr[j] = start | PG_P_1 | PG_RW_W | PG_US_S;
//指向下一个物理页
start += PAGE_SIZE;
}
//指向下一个页表
pte_addr += PAGE_SIZE;
}
// 根据剩余的页表项填写
//有剩余的我们才填写
if (pte_nr > 0) {
// i 和 pte_addr 的值在上面的循环中已经设置
pdt[512 + PAGE_TABLE_PHY_NR + i] = (unsigned int)pte_addr | PG_P_1 | PG_RW_W | PG_US_S;
// 填写剩余的页表项数量
for (j = 0; j < pte_nr; j++) {
//填写页页表项
//把物理地址和属性放进去
pte_addr[j] = start | PG_P_1 | PG_RW_W | PG_US_S;
//指向下一个物理页
start += PAGE_SIZE;
}
}
/* 在开启分页模式之后，我们的内核就运行在高端内存，
那么，现在我们不能通过低端内存访问内核，所以，我们在loader
中初始化的0~8MB低端内存的映射要取消掉才行。
我们把用户内存空间的页目录项都清空 */
for (i = 0; i < 512; i++) {
pdt[i] = 0;
}
/* ----映射完毕---- */
return 0;
}
static inline int handle_no_page(unsigned long addr, unsigned long prot)
{
/* 映射一个物理页 */
return __map_pages(addr, PAGE_SIZE, prot);
}
/**
* make_page_writable - 让pte有写属性
* @addr: 要设置的虚拟地址
*/
static int make_page_writable(unsigned long addr)
{
if (addr > USER_VMM_SIZE)
return -1;
pde_t *pde = get_pde_ptr(addr);
pte_t *pte = get_pte_ptr(addr);
/* 虚拟地址的pde和pte都要存在才能去设置属性 */
if (!(*pde & PG_P_1))
return -1;
if (!(*pte & PG_P_1))
return -1;
/* 标记写属性 */
*pte |= PG_RW_W;
return 0;
}
static inline void do_vmarea_fault(unsigned long addr)
{
/* 如果是在vmarea区域中，就进行页复制，不是的话，就发出段信号。 */
panic("do_vmarea_fault: at %x not support now!\n", addr);
}
static inline void do_expand_stack(vmspace_t *space, unsigned long addr)
{
/* 地址和页向下对齐 */
addr &= PAGE_MASK;
/* 修改为新的空间开始 */
space->start = addr;
}
static inline int do_protection_fault(vmspace_t * space, unsigned long addr, int write)
{
/* 没有写标志，说明该段内存不支持内存写入，就直接返回吧 */
if (write) {
printk(KERN_DEBUG "have write protection.\n");
/* 只有设置写属性正确才能返回 */
int ret = make_page_writable(addr);
if (ret) {
printk(KERN_ALTER "do_protection_fault: touch TRIGSYS trigger because page not writable!");
trigger_force(TRIGSYS, current_task->pid);
return -1;
}
/* 虽然写入的写标志，但是还是会出现缺页故障，在此则处理一下缺页 */
if (handle_no_page(addr, space->page_prot)) {
printk(KERN_ALTER "do_protection_fault: touch TRIGSYS trigger because hand no page failed!");
trigger_force(TRIGSYS, current_task->pid);
return -1;
}
return 0;
} else {
printk(KERN_DEBUG "no write protection\n");
}
//ForceSignal(SIGSEGV, SysGetPid());
printk(KERN_ALTER "do_protection_fault: touch TRIGSYS trigger because page protection!");
trigger_force(TRIGSYS, current_task->pid);
//panic(KERN_ERR "page protection fault!\n");
return -1;
}
/**
* do_page_fault - 处理页故障
*
* 错误码的内容
* bit 0: 0 no page found, 1 protection fault
* bit 1: 0 read, 1 write
* bit 2: 0 kernel, 1 user
*
* 如果是来自内核的页故障，就会打印信息并停机。
* 如果是来自用户的页故障，就会根据地址来做处理。
*/
int do_page_fault(trap_frame_t *frame)
{
task_t *cur = current_task;
unsigned long addr = 0x00;
addr = read_cr2(); /* cr2 saved the fault addr */
//printk(KERN_DEBUG "page fault addr:%x\n", addr);
/* in kernel page fault */
if (!(frame->error_code & PG_ERR_USER) && addr >= PAGE_OFFSET) {
printk("task name=%s pid=%d\n", cur->name, cur->pid);
printk(KERN_EMERG "a memory problem had occured in kernel, please check your code! :(\n");
printk(KERN_EMERG "page fault at %x.\n", addr);
dump_trap_frame(frame);
panic("halt...");
}
/* 如果故障地址位于内核中， */
if (addr >= USER_VMM_SIZE) {
/* 故障源是用户，说明用户需要访问非连续内存区域，于是复制一份给用户即可 */
printk(KERN_DEBUG "user pid=%d name=%s access unmaped vmarea area .\n", cur->pid, cur->name);
dump_trap_frame(frame);
print_task();
do_vmarea_fault(addr);
return -1;
}
/* 故障地址在用户空间 */
vmspace_t *space = vmspace_find(cur->vmm, addr);
/* 没找到空间，说明是一个未知区域 */
if (space == NULL) {
/* 故障源是用户 */
printk(KERN_ALTER "do_page_fault: user access user unknown space .\n");
printk(KERN_ALTER "page fault addr:%x\n", addr);
dump_vmspace(cur->vmm);
print_task();
trigger_force(TRIGSYS, cur->pid);
/* 发出信号退出 */
//panic("send a signal SIGSEGV because unknown space!");
return -1;
}
/* 找到空间，判断空间类型，根据不同的空间，进行不同的处理。 */
if (space->start > addr) { /* 故障地址在空间前，说明是栈向下拓展，那么尝试拓展栈。 */
if (frame->error_code & PG_ERR_USER) { /* 故障源是用户 */
/* 可拓展栈：有栈标志，在可拓展限定内， */
if ((space->flags & VMS_MAP_STACK) &&
((space->end - space->start) < MAX_VMS_STACK_SIZE) &&
(addr + 32 >= frame->esp)) {
/* 向下扩展栈 */
do_expand_stack(space, addr);
//printk(KERN_DEBUG "expand stack at %x\n", addr);
} else { /* 不是可拓展栈 */
printk("task name=%s pid=%d\n", cur->name, cur->pid);
printk(KERN_ALTER "do_page_fault: touch TRIGSYS trigger because unknown space!\n");
printk(KERN_ALTER "page fault addr:%x\n", addr);
dump_trap_frame(frame);
//dump_vmspace(cur->vmm);
trigger_force(TRIGSYS, cur->pid);
/* 发出信号退出 */
//panic("send a signal SIGSEGV because addr %x without space!", addr);
return -1;
}
}
}
/* 故障地址在空间里面，情况如下：
1.读写保护故障（R/W）
2.缺少物理页和虚拟地址的映射。（堆的向上拓展或者栈的向下拓展）
*/
if (frame->error_code & PG_ERR_PROTECT) {
return do_protection_fault(space, addr, frame->error_code & PG_ERR_WRITE);
}
/* 处理缺页 */
handle_no_page(addr, space->page_prot);
//printk(KERN_DEBUG "handle_no_page at %x success!\n", addr);
/* 执行完缺页故障处理后，会到达这里表示成功！ */
return 0;
}
void __page_dir_active(unsigned int page, int on)
{
unsigned long paddr = PAGE_DIR_PHY_ADDR;
if (on) {
paddr = page;
}
write_cr3(paddr);
update_tss_info((unsigned long )current_task);
}
|
NightfallDM/xbook2
|
src/gui/lowlevel/screen.c
|
<filename>src/gui/lowlevel/screen.c<gh_stars>0
#include <string.h>
#include <stdio.h>
#include <xbook/driver.h>
#include <sys/ioctl.h>
#include <xbook/kmalloc.h>
#include <xbook/vmarea.h>
/// 程序本地头文件
#include <gui/screen.h>
#define DEBUG_LOCAL 0
#ifndef GUI_SCREEN_DEVICE_NAME
#define GUI_SCREEN_DEVICE_NAME "video"
#endif
gui_screen_t gui_screen = {0};
/*
* Color conversion interfaces
*
* User maybe rewrite these interfaces according to your screen type
*/
/* R3G3B2 color helper */
static SCREEN_COLOR GUI_TO_R3G3B2(GUI_COLOR gui_color)
{
SCREEN_COLOR r, g, b;
b = gui_color&0xC0;
g = gui_color&0xE000;
r = gui_color&0xE00000;
return (b>>6)|(g>>11)|(r>>16);
}
static GUI_COLOR R3G3B2_TO_GUI(SCREEN_COLOR screen_color)
{
GUI_COLOR r, g, b;
b = screen_color&0x03;
g = screen_color&0x1C;
r = screen_color&0xE0;
return (b<<6)|(g<<11)|(r<<16);
}
/* R5G5B5 color helper */
static SCREEN_COLOR GUI_TO_R5G5B5(GUI_COLOR gui_color)
{
SCREEN_COLOR r, g, b;
b = gui_color&0xF8;
g = gui_color&0xF800;
r = gui_color&0xF80000;
return (b>>3)|(g>>6)|(r>>9);
}
static GUI_COLOR R5G5B5_TO_GUI(SCREEN_COLOR screen_color)
{
GUI_COLOR r, g, b;
b = screen_color&0x1F;
g = screen_color&0x03E0;
r = screen_color&0x7C00;
return (b<<3)|(g<<6)|(r<<9);
}
/* R5G6B5 color helper */
static SCREEN_COLOR GUI_TO_R5G6B5(GUI_COLOR gui_color)
{
SCREEN_COLOR r, g, b;
b = gui_color&0xF8;
g = gui_color&0xFC00;
r = gui_color&0xF80000;
return (b>>3)|(g>>5)|(r>>8);
}
static GUI_COLOR R5G6B5_TO_GUI(SCREEN_COLOR screen_color)
{
GUI_COLOR r, g, b;
b = screen_color&0x1F;
g = screen_color&0x07E0;
r = screen_color&0xF800;
return (b<<3)|(g<<5)|(r<<8);
}
/* R8G8B8 color helper */
static SCREEN_COLOR GUI_TO_R8G8B8(GUI_COLOR gui_color)
{
return gui_color & 0xffffff;
}
static GUI_COLOR R8G8B8_TO_GUI(SCREEN_COLOR screen_color)
{
return screen_color | (0xff << 24);
}
/* R8G8B8 color helper */
static SCREEN_COLOR GUI_TO_A8R8G8B8(GUI_COLOR gui_color)
{
return gui_color;
}
static GUI_COLOR A8R8G8B8_TO_GUI(SCREEN_COLOR screen_color)
{
return screen_color;
}
static video_info_t video_info;
static int video_handle = -1;
static unsigned int video_ram_size = 0;
static unsigned char *video_ram_start = NULL;
static unsigned int bits_per_pixel = 0;
static unsigned int bytes_per_pixel = 0;
static unsigned int screen_width = 0;
static unsigned int screen_height = 0;
static int screen_detect_var(gui_screen_t *screen)
{
int ret = 0;
video_handle = device_open( GUI_SCREEN_DEVICE_NAME, 0 );
if ( video_handle < 0 )
return -1;
ret = device_devctl(video_handle, VIDEOIO_GETINFO, (unsigned long) &video_info);
if ( ret < 0 )
return -1;
screen->width = video_info.x_resolution;
screen->height = video_info.y_resolution;
bits_per_pixel = video_info.bits_per_pixel;
bytes_per_pixel = (video_info.bits_per_pixel+7)/8;
screen_width = screen->width;
screen_height = screen->height;
#if DEBUG_LOCAL == 1
printf("video info: w:%d h:%d bpp:%d \n", screen->width, screen->height, video_info.bits_per_pixel);
#endif
switch (video_info.bits_per_pixel)
{
case 8:
screen->gui_to_screen_color = GUI_TO_R3G3B2;
screen->screen_to_gui_color = R3G3B2_TO_GUI;
break;
case 15:
screen->gui_to_screen_color = GUI_TO_R5G5B5;
screen->screen_to_gui_color = R5G5B5_TO_GUI;
break;
case 16:
screen->gui_to_screen_color = GUI_TO_R5G6B5;
screen->screen_to_gui_color = R5G6B5_TO_GUI;
break;
case 24:
screen->gui_to_screen_color = GUI_TO_R8G8B8;
screen->screen_to_gui_color = R8G8B8_TO_GUI;
break;
case 32:
screen->gui_to_screen_color = GUI_TO_A8R8G8B8;
screen->screen_to_gui_color = A8R8G8B8_TO_GUI;
break;
default:
break;
}
device_close(video_handle);
video_handle = -1;
return 0;
}
static int screen_open(void)
{
video_handle = device_open( GUI_SCREEN_DEVICE_NAME, 0 );
if ( video_handle < 0 )
return -1;
video_ram_size = video_info.bytes_per_scan_line * video_info.y_resolution;
#if DEBUG_LOCAL == 1
printf("%s: screen memory map size %x\n", SRV_NAME, video_ram_size);
#endif
video_ram_start = device_mmap(video_handle, video_ram_size, IO_KERNEL);
if (video_ram_start == NULL) {
printf("[gui]: video mapped failed!\n");
return -1;
}
#if DEBUG_LOCAL == 1
printf("[gui]: mapped addr %x\n", video_ram_start);
#endif
return 0;
}
static int screen_close(void)
{
iounmap(video_ram_start);
device_close(video_handle);
video_ram_start = NULL;
video_handle = -1;
return 1;
}
static int screen_output_pixel(int x, int y, SCREEN_COLOR color)
{
/* User must write the right code */
int offset = 0;
if ( x > (screen_width-1) )
return -1;
if ( y > (screen_height-1) )
return -1;
/* Output pixel */
switch( (bits_per_pixel) )
{
case 8:
offset = (screen_width)*y+x;
if ( offset >= ((screen_width)*(screen_height)-1))
return -1;
*(video_ram_start+offset) = (unsigned char)color;
break;
case 15:
offset = 2*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
*((short int*)((video_ram_start) + offset)) = (short int)color;
break;
case 16:
offset = 2*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
*((short int*)((video_ram_start) + offset)) = (short int)color;
break;
case 24:
offset = 3*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*3-3))
return -1;
*((video_ram_start) + offset + 0) = color&0xFF;
*((video_ram_start) + offset + 1) = (color&0xFF00) >> 8;
*((video_ram_start) + offset + 2) = (color&0xFF0000) >> 16;
break;
case 32:
offset = 4*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*4-4))
return -1;
*((int*)((video_ram_start) + offset)) = (int)color;
break;
default:
break;
}
return 0;
}
static int screen_input_pixel(int x, int y, SCREEN_COLOR *color)
{
/* Maybe have code or maybe have not code */
int offset = 0;
SCREEN_COLOR tmp_color = 0;
if ( color == NULL )
return -1;
if ( x > (screen_width-1) )
return -1;
if ( y > (screen_height-1) )
return -1;
/* Get pixel */
switch( (bits_per_pixel) )
{
case 8:
offset = (screen_width)*y+x;
if ( offset >= ((screen_width)*(screen_height)-1))
return -1;
*color = *(video_ram_start+offset);
break;
case 15:
offset = 2*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
*color = *((short int*)(video_ram_start + offset));
break;
case 16:
offset = 2*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
*color = *((short int*)(video_ram_start + offset));
break;
case 24:
offset = 3*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*3-3))
return -1;
tmp_color = *(video_ram_start + offset + 0)&0xFF;
tmp_color |= ((*(video_ram_start + offset + 1))&0xFF00) >> 8;
tmp_color |= ((*(video_ram_start + offset + 2))&0xFF0000) >> 16;
*color = tmp_color;
break;
case 32:
offset = 4*((screen_width)*y+x);
if ( offset >= ((screen_width)*(screen_height)*4-4))
return -1;
*color = *((int*)(video_ram_start + offset));
break;
default:
break;
}
return 0;
}
/* Hardware accelerbrate interface */
static int screen_output_hline(int left, int right, int top, SCREEN_COLOR color)
{
SCREEN_COLOR a_color;
SCREEN_COLOR b_color;
SCREEN_COLOR c_color;
int offset = 0;
int i = 0;
if ( left > (screen_width-1) )
return -1;
if ( right > (screen_width-1) )
return -1;
if ( top > (screen_height-1) )
return -1;
switch( (bits_per_pixel) )
{
case 8:
offset = (screen_width)*top+left;
if ( offset >= ((screen_width)*(screen_height)-1))
return -1;
for ( i = 0; i <= right - left; i++ )
*(video_ram_start+offset+i) = (unsigned char)color;
break;
case 15:
offset = 2*((screen_width)*top+left);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
for ( i = 0; i <= right - left; i++ )
*((short int*)((video_ram_start) + offset + 2*i)) = (short int)color;
break;
case 16:
offset = 2*((screen_width)*top+left);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
for ( i = 0; i <= right - left; i++ )
*((short int*)((video_ram_start) + offset + 2*i)) = (short int)color;
break;
case 24:
offset = 3*((screen_width)*top+left);
if ( offset >= ((screen_width)*(screen_height)*3-3))
return -1;
a_color = color&0xFF;
b_color = (color&0xFF00) >> 8;
c_color = (color&0xFF0000) >> 16;
for ( i = 0; i <= right - left; i++ )
{
*((video_ram_start) + offset + 3*i + 0) = a_color;
*((video_ram_start) + offset + 3*i + 1) = b_color;
*((video_ram_start) + offset + 3*i + 2) = c_color;
}
break;
case 32:
offset = 4*((screen_width)*top+left);
if ( offset >= ((screen_width)*(screen_height)*4-4))
return -1;
for ( i = 0; i <= right - left; i++ )
*((int*)((video_ram_start) + offset + 4*i)) = (int)color;
break;
default:
break;
}
return 0;
}
/* Hardware accelerbrate interface */
static int screen_output_vline(int left, int top, int bottom, SCREEN_COLOR color)
{
SCREEN_COLOR a_color;
SCREEN_COLOR b_color;
SCREEN_COLOR c_color;
int offset = 0;
int i = 0;
if ( left > (screen_width-1) )
return -1;
if ( top > (screen_height-1) )
return -1;
if ( bottom > (screen_height-1) )
return -1;
switch( (bits_per_pixel) )
{
case 8:
for ( i = 0; i <= bottom - top; i++ )
{
offset = (screen_width)*(top+i)+left;
if ( offset >= ((screen_width)*(screen_height)-1))
return -1;
*(video_ram_start+offset) = (unsigned char)color;
}
break;
case 15:
for ( i = 0; i <= bottom - top; i++ )
{
offset = 2*((screen_width)*(top+i)+left);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
*((short int*)((video_ram_start) + offset)) = (short int)color;
}
break;
case 16:
for ( i = 0; i <= bottom - top; i++ )
{
offset = 2*((screen_width)*(top+i)+left);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
*((short int*)((video_ram_start) + offset)) = (short int)color;
}
break;
case 24:
a_color = color&0xFF;
b_color = (color&0xFF00) >> 8;
c_color = (color&0xFF0000) >> 16;
for ( i = 0; i <= bottom - top; i++ )
{
offset = 3*((screen_width)*(top+i)+ left);
if ( offset >= ((screen_width)*(screen_height)*3-3))
return -1;
*((video_ram_start) + offset + 0) = a_color;
*((video_ram_start) + offset + 1) = b_color;
*((video_ram_start) + offset + 2) = c_color;
}
break;
case 32:
for ( i = 0; i <= bottom - top; i++ )
{
offset = 4*((screen_width)*(top+i)+left);
if ( offset >= ((screen_width)*(screen_height)*4-4))
return -1;
*((int*)((video_ram_start) + offset)) = (int)color;
}
break;
default:
break;
}
return 0;
}
/* Hardware accelerbrate interface */
static int screen_output_rect_fill(int left, int top, int right, int bottom, SCREEN_COLOR color)
{
SCREEN_COLOR a_color;
SCREEN_COLOR b_color;
SCREEN_COLOR c_color;
int offset = 0;
int i = 0;
int j = 0;
if ( left > (screen_width-1) )
return -1;
if ( right > (screen_width-1) )
right = (screen_width-1);
if ( top > (screen_height-1) )
return -1;
switch( (bits_per_pixel) )
{
case 8:
for ( j = 0; j <= bottom - top; j++ )
{
offset = (screen_width)*(top+j)+left;
if ( offset >= ((screen_width)*(screen_height)-1))
return -1;
for ( i = 0; i <= right - left; i++ )
*(video_ram_start+offset+i) = (unsigned char)color;
}
break;
case 15:
for ( j = 0; j <= bottom - top; j++ )
{
offset = 2*((screen_width)*(top+j)+left);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
for ( i = 0; i <= right - left; i++ )
*((short int*)((video_ram_start) + offset + 2*i)) = (short int)color;
}
break;
case 16:
for ( j = 0; j <= bottom - top; j++ )
{
offset = 2*((screen_width)*(top+j)+left);
if ( offset >= ((screen_width)*(screen_height)*2-2))
return -1;
for ( i = 0; i <= right - left; i++ )
*((short int*)((video_ram_start) + offset + 2*i)) = (short int)color;
}
break;
case 24:
a_color = color&0xFF;
b_color = (color&0xFF00) >> 8;
c_color = (color&0xFF0000) >> 16;
for ( j = 0; j <= bottom - top; j++ )
{
offset = 3*((screen_width)*(top+j)+left);
if ( offset >= ((screen_width)*(screen_height)*3-3))
return -1;
for ( i = 0; i <= right - left; i++ )
{
*((video_ram_start) + offset + 3*i + 0) = a_color;
*((video_ram_start) + offset + 3*i + 1) = b_color;
*((video_ram_start) + offset + 3*i + 2) = c_color;
}
}
break;
case 32:
for ( j = 0; j <= bottom - top; j++ )
{
offset = 4*((screen_width)*(top+j)+left);
if ( offset >= ((screen_width)*(screen_height)*4-4))
return -1;
for ( i = 0; i <= right - left; i++ )
*((int*)((video_ram_start) + offset + 4*i)) = (int)color;
}
break;
default:
break;
}
return 1;
}
int gui_init_screen()
{
int ret = 0;
memset(&gui_screen, 0, sizeof(gui_screen));
ret = screen_detect_var(&gui_screen);
if (ret < 0)
return -1;
gui_screen.open = screen_open;
gui_screen.close = screen_close;
gui_screen.output_pixel = screen_output_pixel;
gui_screen.input_pixel = screen_input_pixel;
gui_screen.output_hline = screen_output_hline;
gui_screen.output_vline = screen_output_vline;
gui_screen.output_hline = screen_output_hline;
gui_screen.output_rect_fill = screen_output_rect_fill;
return 0;
}
|
NightfallDM/xbook2
|
src/gui/graph/text.c
|
<gh_stars>0
#include <gui/screen.h>
#include <gui/text.h>
static void gui_draw_word_bit(
int x,
int y,
GUI_COLOR color,
uint8_t *data
) {
unsigned int i;
uint8_t d /* data */;
for (i = 0; i < 16; i++) {
d = data[i];
if ((d & 0x80) != 0)
gui_screen.output_pixel(x + 0, y + i, color);
if ((d & 0x40) != 0)
gui_screen.output_pixel(x + 1, y + i, color);
if ((d & 0x20) != 0)
gui_screen.output_pixel(x + 2, y + i, color);
if ((d & 0x10) != 0)
gui_screen.output_pixel(x + 3, y + i, color);
if ((d & 0x08) != 0)
gui_screen.output_pixel(x + 4, y + i, color);
if ((d & 0x04) != 0)
gui_screen.output_pixel(x + 5, y + i, color);
if ((d & 0x02) != 0)
gui_screen.output_pixel(x + 6, y + i, color);
if ((d & 0x01) != 0)
gui_screen.output_pixel(x + 7, y + i, color);
}
}
void gui_draw_word_ex(
int x,
int y,
char word,
GUI_COLOR color,
gui_font_t *font
) {
if (!font)
return;
gui_draw_word_bit(x, y, color, font->addr + word * font->height);
}
void gui_draw_text_ex(
int x,
int y,
char *text,
GUI_COLOR color,
gui_font_t *font
) {
if (!font)
return;
while (*text) {
gui_draw_word_ex(x, y, *text, color, font);
x += font->width;
text++;
}
}
void gui_draw_word(
int x,
int y,
char ch,
GUI_COLOR color
) {
gui_draw_word_ex(x, y, ch, color, current_font);
}
void gui_draw_text(
int x,
int y,
char *text,
GUI_COLOR color
) {
gui_draw_text_ex(x, y, text, color, current_font);
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/bootmem.c
|
#include <xbook/debug.h>
#include <math.h>
#include <arch/bootmem.h>
static boot_mem_t boot_mem_alloctor;
/*
* init_boot_mem - 初始化引导内存分配器
*
* 初始化后就可以进行简单粗暴的内存分配了。
*/
void init_boot_mem(unsigned int start, unsigned int end)
{
boot_mem_alloctor.start_addr = start;
boot_mem_alloctor.cur_addr = boot_mem_alloctor.start_addr;
boot_mem_alloctor.top_addr = end;
}
/*
* boot_mem_alloc - 分配内存
* @size: 分配多大的空间
*
* 返回的是一个地址指针
*/
void *boot_mem_alloc(size_t size)
{
// 获取要分配的地址
unsigned int addr = boot_mem_alloctor.cur_addr;
//修改分配地址
boot_mem_alloctor.cur_addr += size;
//对地址进行对齐
boot_mem_alloctor.cur_addr = ALIGN_WITH(boot_mem_alloctor.cur_addr, 32);
if (boot_mem_alloctor.cur_addr >= boot_mem_alloctor.top_addr) {
return NULL;
}
return (void *)addr;
}
/*
* boot_mem_pos - 返回当前分配的地址
*/
unsigned int boot_mem_pos()
{
return boot_mem_alloctor.cur_addr;
}
/*
* boot_mem_size - 获取已经分配了多大的空间
*/
unsigned int boot_mem_size()
{
return boot_mem_alloctor.cur_addr - boot_mem_alloctor.start_addr;
}
|
NightfallDM/xbook2
|
src/include/xbook/config.h
|
#ifndef _XBOOK_CONFIG_H
#define _XBOOK_CONFIG_H
/* config architecture */
#define CONFIG_ARCH_X86
/* #define CONFIG_ARCH_X64 */
/* #define CONFIG_ARCH_ARM32 */
/* #define CONFIG_ARCH_ARM64 */
/* config address width */
#define CONFIG_32BIT
/* #define CONFIG_64BIT */
/* config large alloc size in memcache */
#define CONFIG_LARGE_ALLOCS
/* auto select timezone */
#define CONFIG_TIMEZONE_AUTO 0
/* ahci */
#define CONFIG_AHCI
#endif /* _XBOOK_CONFIG_H */
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.