void printk(const char* format, ...) {
void* cur_address = (char*)&format + sizeof(char**);
int i = 0;
while(format[i] != '\0') {
if(format[i] == '%') {
i++;
switch(format[i]) {
case 'd' :
{
int val = *((int*) cur_address);
cur_address = (char*)cur_address + sizeof(int);
printf_int(val);
break;
}
case 'x' :
{
unsigned int val = *((unsigned int*) cur_address);
cur_address = (char*)cur_address + sizeof(int);
printf_int_x(val);
break;
}
case 'c' :
{
char val = *((char*) cur_address);
cur_address = (char*)cur_address + sizeof(int);
serial_printc(val);
break;
}
case 's' :
{
char* str = (char*)(*((char**)cur_address));
while(*str != '\0') {
serial_printc(*str);
str++;
}
cur_address = (char*)cur_address + sizeof(char**);
break;
}
case '%' :
serial_printc('%');
break;
}
}
else {
serial_printc(format[i]);
}
i++;
}
}
static void sys_write(TrapFrame *tf) {
#ifdef HAS_DEVICE
int i;
for(i = 0; i < tf->edx; ++ i)
serial_printc(*(char *)(tf->ecx + i));
#else
asm volatile (".byte 0xd6" : : "a"(2), "c"(tf->ecx), "d"(tf->edx));
#endif
tf->eax = tf->edx;
/*int fd = tf -> ebx;
uint32_t buf = tf->ecx;
uint32_t len = tf->edx;
char *str;
str = (char *)buf;
if(!(fd == 1 || fd == 2)){ panic("fd is %d\n", fd); }
int i;
for(i=0; i<len; i++){
serial_printc(str[i]);
}
tf->eax = len;*/
}
void do_syscall(struct TrapFrame *tf) {
switch(tf->eax) {
case KEYCODE:
tf->eax = code;
code = 0;
break;
case VMEMORY: //绘制显存
memcpy(VMEM_ADDR, (void *)tf->ebx, SCR_SIZE);
break;
case SERIAL: //串口输出
serial_printc((char)tf->ebx);
break;
case FORK: //fork
// tf->eax = fork();
fork();
break;
case SLEEP: //sleep
sleep(tf->ebx);
break;
case EXIT:
Exit();
break;
case THREAD:
create_thread((uint32_t *)tf->ebx);
break;
case SEM_OPEN:
sem_open((sem_t *)tf->ebx, (int)tf->ecx, (bool)tf->edx);
break;
case SEM_WAIT:
sem_wait((sem_t *)tf->ebx);
break;
case SEM_POST:
sem_post((sem_t *)tf->ebx);
break;
case SEM_CLOSE:
sem_close((sem_t *)tf->ebx);
break;
case F_OPEN:
open((char *)tf->ebx, tf->ecx);
break;
case F_READ:
read(tf->ebx, (char *)tf->ecx, tf->edx);
break;
case F_WRITE:
write(tf->ebx, (char *)tf->ecx, tf->edx);
break;
case F_LSEEK:
lseek(tf->ebx, tf->ecx, tf->edx);
break;
case F_CLOSE:
close(tf->ebx);
break;
default: printk("Unhandled system call: id = %d", tf->eax);
}
}
int print(void *buf, int len)
{
char *str = buf;
int i;
for (i = 0; i < len; i ++) {
serial_printc(str[i]);
}
return len;
}
void printf_int_x(unsigned val) {
char num[15];
int top=-1;
if(val == 0) {
serial_printc('0');
return;
}
while(val != 0) {
if(val % 16 < 10) {
num[++top] = '0' + (val % 16);
}
else {
num[++top] = 'a' + (val % 16 -10);
}
val /= 16;
}
for(; top >= 0; top--)
serial_printc(num[top]);
}
static void sys_write (TrapFrame *tf) {
if (tf->ebx == 1 || tf->ebx == 2) {
// asm volatile (".byte 0xd6" : : "a"(2), "c"(tf->ecx), "d"(tf->edx));
uint8_t *addr = (uint8_t *)tf->ecx;
for (int i = 0; i < tf->edx; ++i)
serial_printc(*(addr + i));
tf->eax = tf->edx;
}
else
tf->eax = fs_write (tf->ebx, (void *) tf->ecx, tf->edx);
}
int fs_write(int fd, void *buf, int len) {
if ((fd == 1)||(fd == 2)) {
int i;
for (i = 0; i < len; i++)
serial_printc(((char*)buf)[i]);
}
if (fd < 3) return 0;
assert(file_state[fd].opened);
if (file_state[fd].offset+len >= file_table[fd-3].size)
len = file_table[fd-3].size-file_state[fd].offset-1;
if (len <= 0) return 0;
ide_write(buf, file_table[fd-3].disk_offset+file_state[fd].offset, len);
file_state[fd].offset += len;
return len;
}
void printf_int(int val) {
int flag = 0;
if(val == 0x80000000) {
val++;
flag = 1;
}
if(val < 0) {
serial_printc('-');
val = 0 - val;
}
char num[15];
int top = -1;
if(val == 0) {
serial_printc('0');
return;
}
while(val != 0) {
num[++top] = '0' + (val % 10);
val /= 10;
}
for(; top >= 1; top--)
serial_printc(num[top]);
serial_printc(num[0] + flag);
}
static void sys_write(TrapFrame *tf){
int fd = tf -> ebx;
uint32_t buf = tf->ecx;
uint32_t len = tf->edx;
char *str;
str = (char *)buf;
if(!(fd == 1 || fd == 2)){ panic("fd is %d\n", fd); }
//asm volatile (".byte 0xd6" : : "a"(2), "c"(buf), "d"(len));
int i;
for(i=0; i<len; i++){
serial_printc(str[i]);
}
tf->eax = len;
}
static void
putch(int ch, void *cnt){
serial_printc(ch);
(*((int *)cnt))++;
}
void do_syscall(TrapFrame *tf) {
switch(tf->eax) {
/* The ``add_irq_handle'' system call is artificial. We use it to
* let user program register its interrupt handlers. But this is
* very dangerous in a real operating system. Therefore such a
* system call never exists in GNU/Linux.
*/
case 0:
cli();
// Log("tf->ebx %x",tf->ebx);
add_irq_handle(tf->ebx, (void*)tf->ecx);
sti();
break;
case SYS_brk:
{
sys_brk(tf);
break;
}
/* TODO: Add more system calls. */
case SYS_write:
{
/* if(tf->ebx==1)
{
// asm volatile (".byte 0xd6" : : "a"(SYS_write), "c"(tf->ecx), "d"(tf->edx));
int i;
for(i=0; i<tf->edx; i++)
{
serial_printc(*(char *)(tf->ecx + i));
}
tf->eax = tf->edx;
break;
}
else
break;*/
uint32_t buf = tf->ecx;
uint32_t len = tf->edx;
if(tf->ebx == 1 || tf->ebx == 2)
{
int cnt =0;
while(cnt < len)
{
serial_printc(*((char*)buf++));
cnt++;
}
tf->eax = len;
}
else if(tf->ebx >=3)
tf->eax = fs_write(tf->ebx, (void*)buf, len);
else
tf->eax = -1;
break;
}
case SYS_open:
{
tf->eax = fs_open((char*)tf->ebx);
break;
}
case SYS_read:
{
tf->eax = fs_read(tf->ebx, (void*)tf->ecx, tf->edx);
break;
}
case SYS_lseek:
{
tf->eax = fs_lseek(tf->ebx, tf->ecx, tf->edx);
break;
}
case SYS_close:
{
tf->eax = fs_close(tf->ebx);
break;
}
default: panic("Unhandled system call: id = %d", tf->eax);
}
}