vgalaxy@vgalaxy-VirtualBox:~/ics2021/nanos-lite$ make ARCH=riscv32-nemu run

# Building nanos-lite-run [riscv32-nemu]
# Building am-archive [riscv32-nemu]
# Building klib-archive [riscv32-nemu]
# Creating image [riscv32-nemu]

make -C /home/vgalaxy/ics2021/nemu ISA=riscv32 run ARGS="-b -l /home/vgalaxy/ics2021/nanos-lite/build/nemu-log.txt" IMG=/home/vgalaxy/ics2021/nanos-lite/build/nanos-lite-riscv32-nemu.bin
make[1]: Entering directory '/home/vgalaxy/ics2021/nemu'
+ LD /home/vgalaxy/ics2021/nemu/build/riscv32-nemu-interpreter
/home/vgalaxy/ics2021/nemu/build/riscv32-nemu-interpreter -b -l /home/vgalaxy/ics2021/nanos-lite/build/nemu-log.txt  /home/vgalaxy/ics2021/nanos-lite/build/nanos-lite-riscv32-nemu.bin

int main() {
  extern const char logo[];
  printf("%s", logo);
  Log("'Hello World!' from Nanos-lite");
  Log("Build time: %s, %s", __TIME__, __DATE__);

  init_mm();

  init_device();

  init_ramdisk();

#ifdef HAS_CTE
  init_irq();
#endif

  init_fs();

  init_proc();

  Log("Finish initialization");

#ifdef HAS_CTE
  yield();
#endif

  panic("Should not reach here");
}

SR[mepc] <- PC
SR[mcause] <- 一个描述失败原因的号码
PC <- SR[mtvec]

// An event of type @event, caused by @cause of pointer @ref
typedef struct {
  enum {
    EVENT_NULL = 0,
    EVENT_YIELD, EVENT_SYSCALL, EVENT_PAGEFAULT, EVENT_ERROR,
    EVENT_IRQ_TIMER, EVENT_IRQ_IODEV,
  } event;
  uintptr_t cause, ref;
  const char *msg;
} Event;

// Arch-dependent processor context
typedef struct Context Context;

struct Context {
  // TODO: fix the order of these members to match trap.S
  uintptr_t mepc, mcause, gpr[32], mstatus;
  void *pdir;
};

bool     cte_init    (Context *(*handler)(Event ev, Context *ctx));
void     yield       (void);

csrrw  rd, csr, rs1
t = CSRs[csr]; CSRs[csr] = x[rs1]; x[rd] = t

csrrs  rd, csr, rs1
t = CSRs[csr]; CSRs[csr] = t | x[rs1]; x[rd] = t

csrrc  rd, csr, rs1
t = CSRs[csr]; CSRs[csr] = t & ~x[rs1]; x[rd] = t

csrr  rd, csr
x[rd] = CSRs[csr]
i.e. csrrs  rd, csr, x0

csrw  csr, rs1
CSRs[csr] = x[rs1]
i.e. csrrs  x0, csr, rs1

ECALL and EBREAK cause the receiving privilege mode's epc register to be set to the address of the ECALL or EBREAK instruction itself, not the address of the following instruction.

xRET sets the pc to the value stored in the xepc register.

s0 - mstatus
t0 - mtvec
s1 - mepc
s2 - mcause

#include <isa.h>

vaddr_t* CSR_dispatch(uint32_t index) {
    switch (index) {
        case 0x300: return s0; // mstatus
        case 0x305: return t0; // mtvec
        case 0x341: return s1; // mepc
        case 0x342: return s2; // mcause
        default: panic("Unsupported CSR");
    }
}

def_EHelper(mret) {
    rtl_li(s, &s->dnpc, *s1);
}

def_EHelper(ecall) {
    word_t mtvec = isa_raise_intr(11, s->pc); // EVENT_YIELD
    rtl_li(s, &s->dnpc, mtvec);
}

def_EHelper(csrrw) {
    uint32_t index = id_src2->imm;
    vaddr_t* csr = CSR_dispatch(index);
    vaddr_t t = *csr;
    rtlreg_t rs1 = *dsrc1;
    *csr = rs1;
    *ddest = t;
}

def_EHelper(csrrs) {
    uint32_t index = id_src2->imm;
    vaddr_t* csr = CSR_dispatch(index);
    vaddr_t t = *csr;
    rtlreg_t rs1 = *dsrc1;
    *csr = t | rs1;
    *ddest = t;
}

def_EHelper(csrrc) {
    uint32_t index = id_src2->imm;
    vaddr_t* csr = CSR_dispatch(index);
    vaddr_t t = *csr;
    rtlreg_t rs1 = *dsrc1;
    *csr = t & ~rs1;
    *ddest = t;
}

The  standard  RISC-V  ISA  sets  aside  a  12-bit  encoding  space  (csr[11:0])  for  up  to  4,096  CSRs.

#include <rtl/rtl.h>

// s0 - mstatus
// t0 - mtvec
// s1 - mepc
// s2 - mcause

// 1. 将当前 PC 值保存到 mepc 寄存器
// 2. 在 mcause 寄存器中设置异常号
// 3. 从 mtvec 寄存器中取出异常入口地址
// 4. 跳转到异常入口地址
word_t isa_raise_intr(word_t NO, vaddr_t epc) {
  /* TODO: Trigger an interrupt/exception with ``NO''.
   * Then return the address of the interrupt/exception vector.
   */
  *s1 = epc;
  *s2 = NO;

  return *t0;
}

main -> init_irq -> cte_init

bool cte_init(Context*(*handler)(Event, Context*)) {
  // initialize exception entry
  asm volatile("csrw mtvec, %0" : : "r"(__am_asm_trap));

  // register event handler
  user_handler = handler;

  return true;
}

main -> yield

void yield() {
  asm volatile("li a7, -1; ecall");
}

#define CONTEXT_SIZE  ((32 + 3 + 1) * XLEN)
#define OFFSET_SP     ( 2 * XLEN)
#define OFFSET_CAUSE  (32 * XLEN)
#define OFFSET_STATUS (33 * XLEN)
#define OFFSET_EPC    (34 * XLEN)

.align 3
.globl __am_asm_trap
__am_asm_trap:
  addi sp, sp, -CONTEXT_SIZE

  MAP(REGS, PUSH)

  csrr t0, mcause
  csrr t1, mstatus
  csrr t2, mepc

  STORE t0, OFFSET_CAUSE(sp)
  STORE t1, OFFSET_STATUS(sp)
  STORE t2, OFFSET_EPC(sp)

  # set mstatus.MPRV to pass difftest
  li a0, (1 << 17)
  or t1, t1, a0
  csrw mstatus, t1

  mv a0, sp
  jal __am_irq_handle

  LOAD t1, OFFSET_STATUS(sp)
  LOAD t2, OFFSET_EPC(sp)
  csrw mstatus, t1
  csrw mepc, t2

  MAP(REGS, POP)

  addi sp, sp, CONTEXT_SIZE
  mret

struct Context {
  // TODO: fix the order of these members to match trap.S
  uintptr_t gpr[32], mcause, mstatus, mepc;
  void *pdir;
};

|         | <-- prev sp
|         |
| mepc    |
| mstatus |
| mcause  |
| x31     |
| x30     |
...
| x3      |
|         |
| x1      |
|         | <-- sp

Context* __am_irq_handle(Context *c) {
  printf("mepc: %x, mcause: %u, mstatus: %u\n", c->mepc, c->mcause, c->mstatus);
  if (user_handler) {
    Event ev = {0};
    switch (c->mcause) {
      case EVENT_YIELD: ev.event = EVENT_YIELD; break;
      case EVENT_SYSCALL: ev.event = EVENT_SYSCALL; break;
      case EVENT_PAGEFAULT: ev.event = EVENT_PAGEFAULT; break;
      default: ev.event = EVENT_ERROR; break;
    }

    c = user_handler(ev, c);
    assert(c != NULL);
  }

  return c;
}

static Context* do_event(Event e, Context* c) {
  switch (e.event) {
    case EVENT_YIELD: printf("EVENT_YIELD\n"); break;
    case EVENT_SYSCALL: printf("EVENT_SYSCALL\n"); break;
    case EVENT_PAGEFAULT: printf("EVENT_PAGEFAULT\n"); break;
    default: panic("Unhandled event ID = %d", e.event);
  }

  return c;
}

8000062c <__am_irq_handle>:
8000062c:   fd010113            addi    sp,sp,-48
80000630:   08452683            lw  a3,132(a0)
80000634:   08052603            lw  a2,128(a0)
80000638:   08852583            lw  a1,136(a0)
8000063c:   02812423            sw  s0,40(sp)
80000640:   00050413            mv  s0,a0
80000644:   80002537            lui a0,0x80002
80000648:   13850513            addi    a0,a0,312 # 80002138 <_end+0xfffec138>
8000064c:   02112623            sw  ra,44(sp)
80000650:   291000ef            jal ra,800010e0 <printf>
...

|         | <-- prev prev sp
|         |
| mepc    |
| mstatus |
| mcause  |
| x31     |
| x30     |
...
| x3      |
|         |
| x1      |
|         | <-- prev sp
...
|         | <-- sp

.globl  _start
_start:
  move s0, zero
  jal call_main

void call_main(uintptr_t *args) {
  char *empty[] =  {NULL };
  environ = empty;
  exit(main(0, empty, empty));
  assert(0);
}

int main() {
  return _syscall_(SYS_yield, 0, 0, 0);
}

CROSS_COMPILE = riscv64-linux-gnu-
LNK_ADDR = $(if $(VME), 0x40000000, 0x83000000)
CFLAGS  += -fno-pic -march=rv32g -mabi=ilp32
LDFLAGS += -melf32lriscv --no-relax -Ttext-segment $(LNK_ADDR)

make ISA=riscv32

make ARCH=riscv32-nemu

.section .data
.global ramdisk_start, ramdisk_end
ramdisk_start:
.incbin "build/ramdisk.img"
ramdisk_end:

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nanos-lite/build$ readelf -a ramdisk.img

ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           RISC-V
  Version:                           0x1
  Entry point address:               0x830003dc
  Start of program headers:          52 (bytes into file)
  Start of section headers:          27772 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         3
  Size of section headers:           40 (bytes)
  Number of section headers:         11
  Section header string table index: 10

Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  LOAD           0x000000 0x83000000 0x83000000 0x04df8 0x04df8 R E 0x1000
  LOAD           0x005000 0x83005000 0x83005000 0x00898 0x008d4 RW  0x1000
  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0x10

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nanos-lite/build$ hexdump ramdisk.img -n 52
0000000 457f 464c 0101 0001 0000 0000 0000 0000
0000010 0002 00f3 0001 0000 03dc 8300 0034 0000
0000020 6c7c 0000 0000 0000 0034 0020 0003 0028
0000030 000b 000a
0000034

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nanos-lite/build$ hexdump ramdisk.img -s 52 -n 96
0000034 0001 0000 0000 0000 0000 8300 0000 8300
0000044 4df8 0000 4df8 0000 0005 0000 1000 0000
0000054 0001 0000 5000 0000 5000 8300 5000 8300
0000064 0898 0000 08d4 0000 0006 0000 1000 0000
0000074 e551 6474 0000 0000 0000 0000 0000 0000
0000084 0000 0000 0000 0000 0006 0000 0010 0000
0000094

void naive_uload(PCB *pcb, const char *filename) {
  uintptr_t entry = loader(pcb, filename);
  Log("Jump to entry = %p", entry);
  ((void(*)())entry) ();
}

      +-------+---------------+-----------------------+
      |       |...............|                       |
      |       |...............|                       |  ELF file
      |       |...............|                       |
      +-------+---------------+-----------------------+
      0       ^               |
              |<------+------>|
              |       |       |
              |       |
              |       +----------------------------+
              |                                    |
   Type       |   Offset    VirtAddr    PhysAddr   |FileSiz  MemSiz   Flg  Align
   LOAD       +-- 0x001000  0x03000000  0x03000000 +0x1d600  0x27240  RWE  0x1000
                               |                       |       |
                               |   +-------------------+       |
                               |   |                           |
                               |   |     |           |         |
                               |   |     |           |         |
                               |   |     +-----------+ ---     |
                               |   |     |00000000000|  ^      |
                               |   | --- |00000000000|  |      |
                               |   |  ^  |...........|  |      |
                               |   |  |  |...........|  +------+
                               |   +--+  |...........|  |
                               |      |  |...........|  |
                               |      v  |...........|  v
                               +-------> +-----------+ ---
                                         |           |
                                         |           |
                                            Memory

// see /usr/include/elf.h to get the right type
// #define EM_RISCV    243 /* RISC-V */
// #define EM_X86_64   62  /* AMD x86-64 architecture */

#if defined(__ISA_AM_NATIVE__) || defined(__ISA_X86_64__)
# define EXPECT_TYPE EM_X86_64
#elif defined(__ISA_X86__)
# define EXPECT_TYPE panic("Unknown type")
#elif defined(__ISA_RISCV32__) || defined(__ISA_RISCV64__)
# define EXPECT_TYPE EM_RISCV
#elif defined(__ISA_MIPS32__)
# define EXPECT_TYPE panic("Unknown type")
#else
# error Unsupported ISA
#endif

size_t ramdisk_read(void *buf, size_t offset, size_t len);

static uintptr_t loader(PCB *pcb, const char *filename) {
  char buf[64];

  // check magic number
  ramdisk_read(buf, 0, 8);
  uint64_t magic_number = 0;
  for (int i = 0; i < 8; ++i) magic_number = magic_number * 256 + buf[i];
  assert(magic_number == 0x7f454c4601010100);

  // check machine architecture
  ramdisk_read(buf, 18, 2);
  uint16_t type = 0;
  for (int i = 1; i >= 0; --i) type = type * 256 + buf[i];
  EXPECT_TYPE; // trigger panic()
  assert(type == EXPECT_TYPE);

  // get entry point address
  uintptr_t entry_point_address = 0;
  ramdisk_read(buf, 24, 4);
  for (int i = 3; i >= 0; --i) entry_point_address = entry_point_address * 256 + buf[i];

  // get program header basic infos
  uint32_t program_header_index = 0;
  uint32_t program_header_length = 0; // the size of one section
  uint32_t program_header_number = 0;

  ramdisk_read(buf, 28, 4);
  for (int i = 3; i >= 0; --i) program_header_index  = program_header_index * 256 + buf[i];
  ramdisk_read(buf, 42, 2);
  for (int i = 1; i >= 0; --i) program_header_length = program_header_length * 256 + buf[i];
  ramdisk_read(buf, 44, 4);
  for (int i = 1; i >= 0; --i) program_header_number = program_header_number * 256 + buf[i];
  // Log("%u %u %u", program_header_index, program_header_length, program_header_number);

  // handle items of program header
  for (int i = 0; i < program_header_number; ++i) {
      uint32_t type = 0;
      uint32_t base = program_header_index + i * program_header_length;
      ramdisk_read(buf, base, 4);
      for (int i = 3; i >= 0; --i) type = type * 256 + buf[i];
      if (type == 1) { // LOAD
          uint32_t offset = 0;
          uint32_t virtAddr = 0;
          uint32_t fileSiz = 0;
          uint32_t memSiz = 0;

          ramdisk_read(buf, base + 4, 4);
          for (int i = 3; i >= 0; --i) offset = offset * 256 + buf[i];
          ramdisk_read(buf, base + 8, 4);
          for (int i = 3; i >= 0; --i) virtAddr = virtAddr * 256 + buf[i];
          ramdisk_read(buf, base + 16, 4);
          for (int i = 3; i >= 0; --i) fileSiz = fileSiz * 256 + buf[i];
          ramdisk_read(buf, base + 20, 4);
          for (int i = 3; i >= 0; --i) memSiz = memSiz * 256 + buf[i];

          // Log("0x%08x 0x%08x 0x%08x 0x%08x", offset, virtAddr, fileSiz, memSiz);

          char * buf_malloc = (char *)malloc(fileSiz * sizeof(char) + 1);
          ramdisk_read(buf_malloc, offset, fileSiz);
          memcpy((void *)virtAddr, buf_malloc, fileSiz);
          memset((void *)(virtAddr + fileSiz), 0, memSiz - fileSiz);
          free(buf_malloc);
      }
  }

  return entry_point_address;
}

main -> init_proc -> naive_uload -> loader

#define GPR1 gpr[17] // a7
#define GPR2 gpr[10] // a0
#define GPR3 gpr[11] // a1
#define GPR4 gpr[12] // a2
#define GPRx gpr[10] // a0

# define ARGS_ARRAY ("ecall", "a7", "a0", "a1", "a2", "a0")

#define EVENT_YIELD 1
#define EVENT_SYSCALL 2

def_EHelper(ecall) {
    rtlreg_t a7 = gpr(17);
    Log("GPR a7: %u", a7);
    word_t exception_code;
    switch (a7) {
        // void yield() { asm volatile("li a7, -1; ecall"); }
        case -1: exception_code = EVENT_YIELD; break;
        default: exception_code = EVENT_SYSCALL; break;
    }
    word_t mtvec = isa_raise_intr(exception_code, s->pc);
    rtl_li(s, &s->dnpc, mtvec);
#ifdef CONFIG_ETRACE
    Log("ecall at " FMT_WORD ", mstatus: " FMT_WORD ", mepc: " FMT_WORD ", mcause: " FMT_WORD, s->pc, *s0, *s1, *s2);
    Log("The machine trap-handler base address is " FMT_WORD, mtvec);
#endif
}

#define gpr(idx) (cpu.gpr[check_reg_idx(idx)]._32)

static Context* do_event(Event e, Context* c) {
  switch (e.event) {
    case EVENT_YIELD: Log("EVENT_YIELD"); break;
    case EVENT_SYSCALL: Log("EVENT_SYSCALL"); do_syscall(c); break;
    case EVENT_PAGEFAULT: Log("EVENT_PAGEFAULT"); break;
    default: panic("Unhandled event ID = %d", e.event);
  }
  return c;
}

void do_syscall(Context *c) {
  uintptr_t a[4];
  a[0] = c->GPR1;

  intptr_t ret;
  switch (a[0]) {
    case SYS_exit: sys_exit(c->GPR2); break;
    case SYS_yield: ret = sys_yield(); break;
    default: panic("Unhandled syscall ID = %d", a[0]);
  }

  c->GPRx = ret;
}

int sys_yield() {
    yield();
    return 0;
}

void sys_exit(int status) {
    halt(status);
}

intptr_t _syscall_(intptr_t type, intptr_t a0, intptr_t a1, intptr_t a2) {
  register intptr_t _gpr1 asm (GPR1) = type;
  register intptr_t _gpr2 asm (GPR2) = a0;
  register intptr_t _gpr3 asm (GPR3) = a1;
  register intptr_t _gpr4 asm (GPR4) = a2;
  register intptr_t ret asm (GPRx);
  asm volatile (SYSCALL : "=r" (ret) : "r"(_gpr1), "r"(_gpr2), "r"(_gpr3), "r"(_gpr4));
  return ret;
}

void _exit(int status) {
  _syscall_(SYS_exit, status, 0, 0);
  while (1);
}

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nanos-lite/build$ riscv64-linux-gnu-objdump -d ramdisk.img

ramdisk.img:     file format elf32-littleriscv


Disassembly of section .text:

83000094 <main>:
83000094:       00000693                li      a3,0
83000098:       00000613                li      a2,0
8300009c:       00000593                li      a1,0
830000a0:       00100513                li      a0,1
830000a4:       00000317                auipc   t1,0x0
830000a8:       00830067                jr      8(t1) # 830000ac <_syscall_>

830000ac <_syscall_>:
830000ac:       00050893                mv      a7,a0
830000b0:       00058513                mv      a0,a1
830000b4:       00060593                mv      a1,a2
830000b8:       00068613                mv      a2,a3
830000bc:       00000073                ecall
830000c0:       00008067                ret

830000c4 <_exit>:
830000c4:       00000893                li      a7,0
830000c8:       00000593                li      a1,0
830000cc:       00000613                li      a2,0
830000d0:       00000073                ecall
830000d4:       0000006f                j       830000d4 <_exit+0x10>

...

830003dc <_start>:
830003dc:       00000413                li      s0,0
830003e0:       004000ef                jal     ra,830003e4 <call_main>

830003e4 <call_main>:
830003e4:       fe010113                addi    sp,sp,-32
830003e8:       00c10613                addi    a2,sp,12
830003ec:       830067b7                lui     a5,0x83006
830003f0:       00060593                mv      a1,a2
830003f4:       00000513                li      a0,0
830003f8:       00112e23                sw      ra,28(sp)
830003fc:       88c7a423                sw      a2,-1912(a5) # 83005888 <__BSS_END__+0xffffffb4>
83000400:       00012623                sw      zero,12(sp)
83000404:       00000097                auipc   ra,0x0
83000408:       c90080e7                jalr    -880(ra) # 83000094 <main>
8300040c:       00000097                auipc   ra,0x0
83000410:       080080e7                jalr    128(ra) # 8300048c <exit>

...

8300048c <exit>:
8300048c:       ff010113                addi    sp,sp,-16
83000490:       00000593                li      a1,0
83000494:       00812423                sw      s0,8(sp)
83000498:       00112623                sw      ra,12(sp)
8300049c:       00050413                mv      s0,a0
830004a0:       00000097                auipc   ra,0x0
830004a4:       028080e7                jalr    40(ra) # 830004c8 <__call_exitprocs>
830004a8:       830067b7                lui     a5,0x83006
830004ac:       8847a503                lw      a0,-1916(a5) # 83005884 <__BSS_END__+0xffffffb0>
830004b0:       03c52783                lw      a5,60(a0)
830004b4:       00078463                beqz    a5,830004bc <exit+0x30>
830004b8:       000780e7                jalr    a5
830004bc:       00040513                mv      a0,s0
830004c0:       00000097                auipc   ra,0x0
830004c4:       c04080e7                jalr    -1020(ra) # 830000c4 <_exit>

[/home/vgalaxy/ics2021/nanos-lite/src/loader.c,100,naive_uload] Jump to entry = 0x830003dc
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:25 exec_ecall] GPR a7: 1
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:35 exec_ecall] ecall at 0x830000bc, mstatus: 0x00001800, mepc: 0x830000bc, mcause: 0x00000002
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:36 exec_ecall] The machine trap-handler base address is 0x80000b80
[/home/vgalaxy/ics2021/nanos-lite/src/irq.c,8,do_event] EVENT_SYSCALL
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:25 exec_ecall] GPR a7: -1
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:35 exec_ecall] ecall at 0x80000b74, mstatus: 0x00021800, mepc: 0x80000b74, mcause: 0x00000001
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:36 exec_ecall] The machine trap-handler base address is 0x80000b80
[/home/vgalaxy/ics2021/nanos-lite/src/irq.c,7,do_event] EVENT_YIELD
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:16 exec_mret] mret at 0x80000cb8, mstatus: 0x00021800, mepc: 0x80000b78, mcause: 0x00000001
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:16 exec_mret] mret at 0x80000cb8, mstatus: 0x00001800, mepc: 0x830000c0, mcause: 0x00000001
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:25 exec_ecall] GPR a7: 0
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:35 exec_ecall] ecall at 0x830000d0, mstatus: 0x00001800, mepc: 0x830000d0, mcause: 0x00000002
[/home/vgalaxy/ics2021/nemu/src/isa/riscv32/include/../instr/system.h:36 exec_ecall] The machine trap-handler base address is 0x80000b80
[/home/vgalaxy/ics2021/nanos-lite/src/irq.c,8,do_event] EVENT_SYSCALL
[src/cpu/cpu-exec.c:152 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000734

_start -> call_main -> main -> _syscall_(SYS_yield, 0, 0, 0) -> exit -> _exit

异常事件 EVENT_SYSCALL -> 系统调用事件 SYS_yield

ecall at 0x830000bc, mstatus: 0x00001800, mepc: 0x830000bc, mcause: 0x00000002

异常事件 EVENT_YIELD

ecall at 0x80000b74, mstatus: 0x00021800, mepc: 0x80000b74, mcause: 0x00000001

mret at 0x80000cb8, mstatus: 0x00021800, mepc: 0x80000b78, mcause: 0x00000001

mret at 0x80000cb8, mstatus: 0x00001800, mepc: 0x830000c0, mcause: 0x00000001

异常事件 EVENT_SYSCALL -> 系统调用事件 sys_exit

ecall at 0x830000d0, mstatus: 0x00001800, mepc: 0x830000d0, mcause: 0x00000002

no mret

int _write(int fd, void *buf, size_t count) {
  return _syscall_(SYS_write, fd, (intptr_t)buf, count);
}

int sys_write(int fd, void *buf, size_t count) {
    if (fd == 1 || fd == 2) {
        for (size_t i = 0; i < count; ++i) {
            putch(*((char *)buf + i));
        }
        return count;
    }
    return -1;
}

On success, the number of bytes written is returned.  On error, -1 is returned, and errno is set to indicate the cause of the error.

    case SYS_write:
        ret = sys_write(c->GPR2, (void *)c->GPR3, (size_t)c->GPR4);
        Log("sys_write(%d, %p, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;

#include <unistd.h>
#include <stdio.h>

int main() {
  write(1, "Hello World!\n", 13);
  int i = 2;
  volatile int j = 0;
  while (1) {
    j ++;
    if (j == 10000) {
      printf("Hello World from Navy-apps for the %dth time!\n", i ++);
      j = 0;
    }
  }
  return 0;
}

vgalaxy@vgalaxy-VirtualBox:~/ics2021/navy-apps/tests/hello/build$ cat hello-riscv32 > ../../../../nanos-lite/build/ramdisk.img

void* sbrk(intptr_t increment);

extern int _end;
int program_break = (int)(&_end);

void *_sbrk(intptr_t increment) {
  int program_break_prev = program_break;
  if (_syscall_(SYS_brk, program_break + increment, 0, 0) == 0) {
      program_break = program_break + increment;
      return (void *)program_break_prev;
  }
  return (void *)-1;
}

int sys_brk(void *addr) {
    return 0;
}

    case SYS_brk:
        ret = sys_brk((void *)c->GPR2);
        Log("sys_brk(%p, %d, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;

[/home/vgalaxy/ics2021/nanos-lite/src/syscall.c,43,do_syscall] sys_write(1, 0x8300567c, 13) = 13
[/home/vgalaxy/ics2021/nanos-lite/src/syscall.c,47,do_syscall] sys_brk(0x83006cf0, 0, 0) = 0
[/home/vgalaxy/ics2021/nanos-lite/src/syscall.c,47,do_syscall] sys_brk(0x83007000, 0, 0) = 0
[/home/vgalaxy/ics2021/nanos-lite/src/syscall.c,43,do_syscall] sys_write(1, 0x830068e0, 45) = 45
...

update:
    $(MAKE) -s -C $(NAVY_HOME) ISA=$(ISA) ramdisk
    @ln -sf $(NAVY_HOME)/build/ramdisk.img $(RAMDISK_FILE)
    @ln -sf $(NAVY_HOME)/build/ramdisk.h src/files.h
    @ln -sf $(NAVY_HOME)/libs/libos/src/syscall.h src/syscall.h

typedef struct {
  char *name;          // 文件名
  size_t size;         // 文件大小
  size_t disk_offset;  // 文件在 ramdisk 中的偏移
} Finfo;

#define FD_STDIN 0
#define FD_STDOUT 1
#define FD_STDERR 2

int fs_open(const char *pathname, int flags, int mode);
size_t fs_read(int fd, void *buf, size_t len);
size_t fs_write(int fd, const void *buf, size_t len);
size_t fs_lseek(int fd, size_t offset, int whence);
int fs_close(int fd);

man 2 open

typedef struct {
  size_t fd;
  size_t open_offset; // relative to disk_offset
} OFinfo;

static OFinfo open_file_table[LENGTH(file_table)];
static size_t open_file_table_index = 0;
static int get_open_file_index(int fd) { // return -1 on failure
    int target_index = -1;
    for (int i = 0; i < open_file_table_index; ++i) {
        if (open_file_table[i].fd == fd) {
            target_index = i;
            break;
        }
    }
    return target_index;
}

int fs_open(const char *pathname, int flags, int mode) {
    for (int i = 0; i < LENGTH(file_table); ++i) {
        if (strcmp(file_table[i].name, pathname) == 0) {
            if (i <= 2) {
                Log("ignore open %s", pathname);
                return i;
            }
            open_file_table[open_file_table_index].fd = i;
            open_file_table[open_file_table_index].open_offset = 0;
            open_file_table_index++;
            return i;
        }
    }
    panic("file %s not found", pathname);
    while (1);
}

size_t fs_read(int fd, void *buf, size_t len) {
    if (fd <= 2) {
        Log("ignore read %s", file_table[fd].name);
        return 0;
    }

    int target_index = get_open_file_index(fd);
    if (target_index == -1) {
        Log("file %s not open before read", file_table[fd].name);
        return -1;
    }

    size_t read_len = len;
    size_t open_offset = open_file_table[target_index].open_offset;
    size_t size = file_table[fd].size;
    size_t disk_offset = file_table[fd].disk_offset;

    if (open_offset > size) return 0;

    if (open_offset + len > size) read_len = size - open_offset;
    ramdisk_read(buf, disk_offset + open_offset, read_len);
    open_file_table[target_index].open_offset += read_len;
    return read_len;
}

size_t fs_write(int fd, const void *buf, size_t len) {
    if (fd == 0) {
        Log("ignore write %s", file_table[fd].name);
        return 0;
    }

    if (fd == 1 || fd == 2) {
        for (size_t i = 0; i < len; ++i)
            putch(*((char *)buf + i));
        return len;
    }

    int target_index = get_open_file_index(fd);
    if (target_index == -1) {
        Log("file %s not open before write", file_table[fd].name);
        return -1;
    }

    size_t write_len = len;
    size_t open_offset = open_file_table[target_index].open_offset;
    size_t size = file_table[fd].size;
    size_t disk_offset = file_table[fd].disk_offset;

    if (open_offset > size) return 0;

    if (open_offset + len > size) write_len = size - open_offset;
    ramdisk_write(buf, disk_offset + open_offset, write_len);
    open_file_table[target_index].open_offset += write_len;
    return write_len;
}

size_t fs_lseek(int fd, size_t offset, int whence) {
    if (fd <= 2) {
        Log("ignore lseek %s", file_table[fd].name);
        return 0;
    }

    int target_index = get_open_file_index(fd);
    if (target_index == -1) {
        Log("file %s not open before lseek", file_table[fd].name);
        return -1;
    }

    size_t new_offset = -1;
    size_t size = file_table[fd].size;
    size_t open_offset = open_file_table[target_index].open_offset;
    switch (whence) {
        case SEEK_SET:
            if (offset > size) new_offset = size;
            new_offset = offset;
            break;
        case SEEK_CUR:
            if (offset + open_offset > size) new_offset = size;
            new_offset = offset + open_offset;
            break;
        case SEEK_END:
            if (offset + size > size) new_offset = size;
            new_offset = offset + size;
            break;
        default:
            Log("Unknown whence %d", whence);
            return -1;
    }

    assert(new_offset >= 0);
    open_file_table[target_index].open_offset = new_offset;
    return new_offset;
}

int fs_close(int fd) {
    if (fd <= 2) {
        Log("ignore close %s", file_table[fd].name);
        return 0;
    }

    int target_index = get_open_file_index(fd);

    if (target_index >= 0) {
        for (int i = target_index; i < open_file_table_index - 1; ++i) {
            open_file_table[i] = open_file_table[i + 1];
        }
        open_file_table_index--;
        assert(open_file_table_index >= 0);
        return 0;
    }

    Log("file %s not open before close", file_table[fd].name);
    return -1;
}

    case SYS_open:
        ret = fs_open((const char *)c->GPR2, c->GPR3, c->GPR4);
        Log("fs_open(%s, %d, %d) = %d",(const char *)c->GPR2, c->GPR3, c->GPR4, ret);
        break;
    case SYS_read:
        ret = fs_read(c->GPR2, (void *)c->GPR3, (size_t)c->GPR4);
        Log("fs_read(%d, %p, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;
    case SYS_close:
        ret = fs_close(c->GPR2);
        Log("fs_close(%d, %d, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;
    case SYS_write:
        ret = fs_write(c->GPR2, (void *)c->GPR3, (size_t)c->GPR4);
        Log("fs_write(%d, %p, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;
    case SYS_lseek:
        ret = fs_lseek(c->GPR2, (size_t)c->GPR3, c->GPR4);
        Log("fs_lseek(%d, %d, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;

int fd = fs_open(filename, 0, 0);
assert(fd >= 2); // ignore stdin, stdout, stderr

assert(fs_lseek(fd, offset, SEEK_SET) >= 0);
assert(fs_read(fd, buf, len) >= 0);
...

assert(fs_close(fd) == 0);

  // load program here
  const char filename[] = "/bin/file-test";
  naive_uload(NULL, filename);

int _open(const char *path, int flags, mode_t mode) {
  return _syscall_(SYS_open, (intptr_t)path, flags, mode);
}

int _read(int fd, void *buf, size_t count) {
  return _syscall_(SYS_read, fd, (intptr_t)buf, count);
}

int _close(int fd) {
  return _syscall_(SYS_close, fd, 0, 0);
}

int _write(int fd, void *buf, size_t count) {
  return _syscall_(SYS_write, fd, (intptr_t)buf, count);
}

off_t _lseek(int fd, off_t offset, int whence) {
  return _syscall_(SYS_lseek, fd, offset, whence);
}

int main() {
  FILE *fp = fopen("/share/files/num", "r+");
  assert(fp);

  fseek(fp, 0, SEEK_END);
  long size = ftell(fp);
  assert(size == 5000);

  fseek(fp, 500 * 5, SEEK_SET);
  int i, n;
  for (i = 500; i < 1000; i ++) {
    fscanf(fp, "%d", &n);
    assert(n == i + 1);
  }

  fseek(fp, 0, SEEK_SET);
  for (i = 0; i < 500; i ++) {
    fprintf(fp, "%4d\n", i + 1 + 1000);
  }

  for (i = 500; i < 1000; i ++) {
    fscanf(fp, "%d", &n);
    assert(n == i + 1);
  }

  fseek(fp, 0, SEEK_SET);
  for (i = 0; i < 500; i ++) {
    fscanf(fp, "%d", &n);
    assert(n == i + 1 + 1000);
  }

  fclose(fp);

  printf("PASS!!!\n");

  return 0;
}

sys_brk(0x83009c10, 0, 0) = 0
sys_brk(0x8300a000, 0, 0) = 0

fs_open(/share/files/num, 2, 438) = 22
sys_brk(0x8300b000, 0, 0) = 0

fs_lseek(22, 0, 2) = 5000
fs_lseek(22, 2500, 0) = 2500

fs_read(22, 0x83009c08, 1024) = 1024
fs_read(22, 0x83009c08, 1024) = 1024
fs_read(22, 0x83009c08, 1024) = 452

fs_lseek(22, 4999, 0) = 4999
fs_lseek(22, 0, 0) = 0

fs_write(22, 0x83009c08, 1024) = 1024
fs_write(22, 0x83009c08, 1024) = 1024
fs_write(22, 0x83009c08, 452) = 452

fs_read(22, 0x83009c08, 1024) = 1024
fs_read(22, 0x83009c08, 1024) = 1024
fs_read(22, 0x83009c08, 1024) = 452

fs_lseek(22, 0, 1) = 5000
fs_lseek(22, 4999, 0) = 4999
fs_lseek(22, 0, 0) = 0

fs_read(22, 0x83009c08, 1024) = 1024
fs_read(22, 0x83009c08, 1024) = 1024
fs_read(22, 0x83009c08, 1024) = 1024

fs_lseek(22, 2499, 0) = 2499
fs_close(22, 0, 0) = 0

fs_write(1, 0x83009c08, 8) = 8

fs_close(0, 0, 0) = 0
fs_close(1, 0, 0) = 0
fs_close(2, 0, 0) = 0

sys_exit(0, 0, 0)

char* get_file_name(int fd) {
    return file_table[fd].name;
}

fopen -> _fopen_r -> _open_r -> _open

fseek -> _fseeko_r -> _ftello_r -> ...
                   -> _fflush_r -> ...

... -> __sseek -> _lseek_r -> _lseek

ftell -> _ftello_r -> ...

fscanf -> _vfscanf_r -> __svfscanf_r -> __srefill_r
                                     -> _fread_r -> memcpy -> ...

fprintf -> _vfprintf_r -> __sfputs_r -> _fputc_r -> _putc_r -> ...

fclose -> ...

int fs_open(const char *pathname, int flags, int mode);
size_t fs_read(int fd, void *buf, size_t len);
size_t fs_write(int fd, const void *buf, size_t len);
size_t fs_lseek(int fd, size_t offset, int whence);
int fs_close(int fd);

typedef struct {
  char *name;          // 文件名
  size_t size;         // 文件大小
  size_t disk_offset;  // 文件在 ramdisk 中的偏移
  ReadFn read;         // 读函数指针
  WriteFn write;       // 写函数指针
} Finfo;

size_t serial_write(const void *buf, size_t offset, size_t len) {
  for (size_t i = 0; i < len; ++i) putch(*((char *)buf + i));
  return len;
}

static Finfo file_table[] __attribute__((used)) = {
  [FD_STDIN]  = {"stdin", 0, 0, invalid_read, invalid_write},
  [FD_STDOUT] = {"stdout", 0, 0, invalid_read, serial_write},
  [FD_STDERR] = {"stderr", 0, 0, invalid_read, serial_write},
#include "files.h"
};

size_t fs_read(int fd, void *buf, size_t len) {
    ReadFn readFn = file_table[fd].read;
    if (readFn != NULL) {
        // TODO: prepare parameters
        return readFn(buf, 0, len);
    }
    ...
}

size_t fs_write(int fd, const void *buf, size_t len) {
    WriteFn writeFn = file_table[fd].write;
    if (writeFn != NULL) {
        // TODO: prepare parameters
        return writeFn(buf, 0, len);
    }
    ...
}

#define time_t uint64_t
#define suseconds_t uint64_t

struct timeval {
    time_t      tv_sec;     /* seconds */
    suseconds_t tv_usec;    /* microseconds */
};

struct timezone {
    int tz_minuteswest;     /* minutes west of Greenwich */
    int tz_dsttime;         /* type of DST correction */
};

int sys_gettimeofday(struct timeval *tv, struct timezone *tz) {
    uint64_t us = io_read(AM_TIMER_UPTIME).us;
    tv->tv_sec = us / 1000000;
    tv->tv_usec = us - us / 1000000 * 1000000;
    return 0;
}

The use of the timezone structure is obsolete; the tz argument should normally be specified as NULL.

    case SYS_gettimeofday:
        ret = sys_gettimeofday((struct timeval *)c->GPR2, (struct timezone *)c->GPR3);
        Log("sys_gettimeofday(%p, %p, %d) = %d", c->GPR2, c->GPR3, c->GPR4, ret);
        break;

int _gettimeofday(struct timeval *tv, struct timezone *tz) {
  return _syscall_(SYS_gettimeofday, (intptr_t)tv, (intptr_t)tz, 0);
}

#include <stdio.h>
#include <assert.h>
#include <sys/time.h>

int main() {
    struct timeval init;
    struct timeval now;

    assert(gettimeofday(&init, NULL) == 0);
    time_t init_sec = init.tv_sec;
    suseconds_t init_usec = init.tv_usec;

    size_t times = 1;

    while (1) {
        assert(gettimeofday(&now, NULL) == 0);
        time_t now_sec = now.tv_sec;
        suseconds_t now_usec = now.tv_usec;
        uint64_t time_gap = (now_sec - init_sec) * 1000000 + (now_usec - init_usec); // unit: us
        if (time_gap > 500000 * times) {
            printf("Half a second passed, %u time(s)\n", times);
            times++;
        }
    }
}

// 以毫秒为单位返回系统时间
uint32_t NDL_GetTicks();

#include <sys/time.h>
#include <assert.h>

uint32_t NDL_GetTicks() {
  struct timeval tv;
  assert(gettimeofday(&tv, NULL) == 0);
  return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

#include <stdio.h>

#define HAS_NDL

#ifndef HAS_NDL
#include <assert.h>
#include <sys/time.h>

void gettimeofday_test() {
    printf("gettimeofday test start...\n");

    struct timeval init;
    struct timeval now;

    assert(gettimeofday(&init, NULL) == 0);
    time_t init_sec = init.tv_sec;
    suseconds_t init_usec = init.tv_usec;

    size_t times = 1;

    while (1) {
        assert(gettimeofday(&now, NULL) == 0);
        time_t now_sec = now.tv_sec;
        suseconds_t now_usec = now.tv_usec;
        uint64_t time_gap = (now_sec - init_sec) * 1000000 + (now_usec - init_usec); // unit: us
        if (time_gap > 500000 * times) {
            printf("Half a second passed, %u time(s)\n", times);
            times++;
        }
    }
}
#else
#include <NDL.h>

void NDL_GetTicks_test() {
  NDL_Init(0);
    printf("NDL_GetTicks test start...\n");

    uint32_t init = NDL_GetTicks();
    size_t times = 1;

    while (1) {
        uint32_t now = NDL_GetTicks();
        uint32_t time_gap = now - init;
        if (time_gap > 500 * times) {
            printf("Half a second passed, %u time(s)\n", times);
            times++;
        }
    }
}
#endif

int main() {
#ifndef HAS_NDL
    gettimeofday_test();
#else
    NDL_GetTicks_test();
#endif

NAME = timer-test
SRCS = main.c
#ifdef HAS_NDL
LIBS = libndl
#endif
include $(NAVY_HOME)/Makefile

#define TEMP_BUF_SIZE 32
static char temp_buf[TEMP_BUF_SIZE]; // for events_read

size_t events_read(void *buf, size_t offset, size_t len) {
  memset(temp_buf, 0, TEMP_BUF_SIZE); // reset

  AM_INPUT_KEYBRD_T ev = io_read(AM_INPUT_KEYBRD);
  if (ev.keycode == AM_KEY_NONE) return 0;
  const char *name = keyname[ev.keycode];
  int ret = ev.keydown ? sprintf(temp_buf, "kd %s\n", name) : sprintf(temp_buf, "ku %s\n", name);
  // ret -> exclude terminating null character
  if (ret >= len) {
      strncpy(buf, temp_buf, len - 1);
      ret = len;
  } else {
      strncpy(buf, temp_buf, ret);
  }
  return ret; // ret -> include terminating null character
}

enum {FD_STDIN, FD_STDOUT, FD_STDERR, DEV_EVENTS, FD_FB};

static Finfo file_table[] __attribute__((used)) = {
  [FD_STDIN]  = {"stdin", 0, 0, invalid_read, invalid_write},
  [FD_STDOUT] = {"stdout", 0, 0, invalid_read, serial_write},
  [FD_STDERR] = {"stderr", 0, 0, invalid_read, serial_write},
  [DEV_EVENTS] = {"/dev/events", 0, 0, events_read, invalid_write},
#include "files.h"
};

int fs_open(const char *pathname, int flags, int mode) {
    for (int i = 0; i < LENGTH(file_table); ++i) {
        if (strcmp(file_table[i].name, pathname) == 0) {
            if (i < FD_FB) {
                Log("ignore open %s", pathname);
                return i;
            }
            open_file_table[open_file_table_index].fd = i;
            open_file_table[open_file_table_index].open_offset = 0;
            open_file_table_index++;
            return i;
        }
    }
    panic("file %s not found", pathname);
    while (1);
}

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int NDL_PollEvent(char *buf, int len) {
  int fd = open("/dev/events", 0, 0);
  int ret = read(fd, buf, len);
  assert(close(fd) == 0);
  return ret == 0 ? 0 : 1;
}

#include <stdio.h>
#include <NDL.h>

int main() {
  NDL_Init(0);
  while (1) {
    char buf[64];
    if (NDL_PollEvent(buf, sizeof(buf))) {
      printf("receive event: %s\n", buf);
    }
  }
  return 0;
}

fs_open(/dev/events, 0, 0) = 3
fs_read(/dev/events, 0x800a6f50, 64) = 0 -> miss
fs_close(/dev/events, 0, 0) = 0

fs_open(/dev/events, 0, 0) = 3
fs_read(/dev/events, 0x800a6f50, 64) = 5 -> hit
fs_close(/dev/events, 0, 0) = 0

sys_brk(0x83008cf0, 0, 0) = 0
sys_brk(0x83009000, 0, 0) = 0

fs_write(stdout, 0x830088e0, 20) = 20 -> receive event: kd Z
fs_write(stdout, 0x830088e0, 1) = 1 -> \n

fs_open(/dev/events, 0, 0) = 3
fs_read(/dev/events, 0x800a6f50, 64) = 5 -> hit
fs_close(/dev/events, 0, 0) = 0

fs_write(stdout, 0x830088e0, 20) = 20 -> receive event: ku Z
fs_write(stdout, 0x830088e0, 1) = 1 -> \n

...

// 打开一张 (*w) X (*h) 的画布
// 如果 *w 和 *h 均为 0，则将系统全屏幕作为画布，并将 *w 和 *h 分别设为系统屏幕的大小
void NDL_OpenCanvas(int *w, int *h);

// 向画布 `(x, y)` 坐标处绘制 `w*h` 的矩形图像，并将该绘制区域同步到屏幕上
// 图像像素按行优先方式存储在 `pixels` 中，每个像素用 32 位整数以 `00RRGGBB` 的方式描述颜色
void NDL_DrawRect(uint32_t *pixels, int x, int y, int w, int h);

size_t dispinfo_read(void *buf, size_t offset, size_t len) {
  memset(temp_buf, 0, TEMP_BUF_SIZE); // reset

  AM_GPU_CONFIG_T ev = io_read(AM_GPU_CONFIG);
  int width = ev.width;
  int height = ev.height;

  int ret = sprintf(temp_buf, "WIDTH : %d\nHEIGHT : %d", width, height);
  // ret -> exclude terminating null character
  if (ret >= len) {
      strncpy(buf, temp_buf, len - 1);
      ret = len;
  } else {
      strncpy(buf, temp_buf, ret);
  }
  return ret; // ret -> include terminating null character
}

  [PROC_DISPINFO] = {"/proc/dispinfo", 0, 0, dispinfo_read, invalid_write},

static void init_dispinfo() {
  int buf_size = 1024; // TODO: may be insufficient
  char * buf = (char *)malloc(buf_size * sizeof(char));
  int fd = open("/proc/dispinfo", 0, 0);
  int ret = read(fd, buf, buf_size);
  assert(ret < buf_size); // to be cautious...
  assert(close(fd) == 0);

  int i = 0;
  int width = 0, height = 0;

  assert(strncmp(buf + i, "WIDTH", 5) == 0);
  i += 5;
  for (; i < buf_size; ++i) {
      if (buf[i] == ':') { i++; break; }
      assert(buf[i] == ' ');
  }
  for (; i < buf_size; ++i) {
      if (buf[i] >= '0' && buf[i] <= '9') break;
      assert(buf[i] == ' ');
  }
  for (; i < buf_size; ++i) {
      if (buf[i] >= '0' && buf[i] <= '9') {
          width = width * 10 + buf[i] - '0';
      } else {
          break;
      }
  }
  assert(buf[i++] == '\n');

  assert(strncmp(buf + i, "HEIGHT", 6) == 0);
  i += 6;
  for (; i < buf_size; ++i) {
      if (buf[i] == ':') { i++; break; }
      assert(buf[i] == ' ');
  }
  for (; i < buf_size; ++i) {
      if (buf[i] >= '0' && buf[i] <= '9') break;
      assert(buf[i] == ' ');
  }
  for (; i < buf_size; ++i) {
      if (buf[i] >= '0' && buf[i] <= '9') {
          height = height * 10 + buf[i] - '0';
      } else {
          break;
      }
  }

  free(buf);

  screen_w = width;
  screen_h = height;
}

  if (*w == 0 && *h == 0) {
      *w = screen_w;
      *h = screen_h;
  }

  canvas_w = *w;
  canvas_h = *h;

  canvas_relative_screen_w = (screen_w - canvas_w) / 2;
  canvas_relative_screen_h = (screen_h - canvas_h) / 2;

  assert(canvas_w + canvas_relative_screen_w <= screen_w
          && canvas_h + canvas_relative_screen_h <= screen_h);
}

size_t fb_write(const void *buf, size_t offset, size_t len) {
  AM_GPU_CONFIG_T ev = io_read(AM_GPU_CONFIG);
  int width = ev.width;

  int y = offset / width;
  int x = offset - y * width;

  io_write(AM_GPU_FBDRAW, x, y, (void *)buf, len, 1, true);

  return len;
}

  [FD_FB] = {"/dev/fb", 0, 0, invalid_read, fb_write},

size_t fs_write(int fd, const void *buf, size_t len) {
    WriteFn writeFn = file_table[fd].write;
    if (writeFn != NULL && fd < FD_FB) {
        // ignore offset
        return writeFn(buf, 0, len);
    }

    ...

    writeFn ?
        writeFn      (buf, disk_offset + open_offset, write_len):
        ramdisk_write(buf, disk_offset + open_offset, write_len);
    open_file_table[target_index].open_offset += write_len;
    return write_len;
}

void init_fs() {
  // TODO: initialize the size of /dev/fb
  AM_GPU_CONFIG_T ev = io_read(AM_GPU_CONFIG);
  int width = ev.width;
  int height = ev.height;
  file_table[FD_FB].size = width * height * 4;
}

RAMDISK = build/ramdisk.img
RAMDISK_H = build/ramdisk.h
$(RAMDISK): fsimg
    $(eval FSIMG_FILES := $(shell find -L ./fsimg -type f))
    @mkdir -p $(@D)
    @cat $(FSIMG_FILES) > $@
    @truncate -s \%512 $@
    @echo "// file path, file size, offset in disk" > $(RAMDISK_H)
    @wc -c $(FSIMG_FILES) | grep -v 'total$$' | sed -e 's+ ./fsimg+ +' | awk -v sum=480000 '{print "\x7b\x22" $$2 "\x22\x2c " $$1 "\x2c " sum "\x7d\x2c";sum += $$1}' >> $(RAMDISK_H)

#define RAMDISK_SIZE ((&ramdisk_end) - (&ramdisk_start) + 480000)

void NDL_DrawRect(uint32_t *pixels, int x, int y, int w, int h) {
  int fd = open("/dev/fb", 0, 0);
  for (int i = 0; i < h && y + i < canvas_h; ++i) {
    lseek(fd, (y + canvas_relative_screen_h + i) * screen_w + (x + canvas_relative_screen_w), SEEK_SET);
    write(fd, pixels + i * w, w < canvas_w - x ? w : canvas_w - x);
  }
  assert(close(fd) == 0);
}

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <NDL.h>
#include <BMP.h>

int main() {
  NDL_Init(0);
  int w, h;
  void *bmp = BMP_Load("/share/pictures/projectn.bmp", &w, &h);
  // printf("width: %d, height: %d\n", w, h);
  assert(bmp);
  NDL_OpenCanvas(&w, &h);
  // printf("width: %d, height: %d\n", w, h);
  NDL_DrawRect(bmp, 0, 0, w, h);
  free(bmp);
  NDL_Quit();
  printf("Test ends! Spinning...\n");
  while (1);
  return 0;
}

ramdisk info: start = 0x8000423d, end = 0x8009de3d, size = 629760 bytes

sys_brk(0x8300ad20, 0, 0) = 0
sys_brk(0x8300b000, 0, 0) = 0

fs_open(/proc/dispinfo, 0, 0) = 4
fs_read(/proc/dispinfo, 0x8300a910, 1024) = 24
fs_close(/proc/dispinfo, 0, 0) = 0

fs_open(/share/pictures/projectn.bmp, 0, 438) = 29
fs_read(/share/pictures/projectn.bmp, 0x8300aac0, 1024) = 1024
sys_brk(0x8301c000, 0, 0) = 0
fs_lseek(/share/pictures/projectn.bmp, 0, 1) = 1024
fs_lseek(/share/pictures/projectn.bmp, 54, 0) = 54
fs_lseek(/share/pictures/projectn.bmp, 48906, 0) = 48906
fs_read(/share/pictures/projectn.bmp, 0x8300aac0, 1024) = 384
fs_lseek(/share/pictures/projectn.bmp, 48522, 0) = 48522
fs_read(/share/pictures/projectn.bmp, 0x8300aac0, 1024) = 768
fs_lseek(/share/pictures/projectn.bmp, 48906, 0) = 48906
fs_lseek(/share/pictures/projectn.bmp, 48138, 0) = 48138
fs_read(/share/pictures/projectn.bmp, 0x8300aac0, 1024) = 1024
fs_lseek(/share/pictures/projectn.bmp, 48522, 0) = 48522
fs_lseek(/share/pictures/projectn.bmp, 47754, 0) = 47754
fs_read(/share/pictures/projectn.bmp, 0x8300aac0, 1024) = 1024
...
fs_close(/share/pictures/projectn.bmp, 0, 0) = 0

fs_open(/dev/fb, 0, 0) = 5
fs_lseek(/dev/fb, 34536, 0) = 34536
fs_write(/dev/fb, 0x8300aec8, 128) = 128
fs_lseek(/dev/fb, 34936, 0) = 34936
fs_write(/dev/fb, 0x8300b0c8, 128) = 128
fs_lseek(/dev/fb, 35336, 0) = 35336
fs_write(/dev/fb, 0x8300b2c8, 128) = 128
fs_lseek(/dev/fb, 35736, 0) = 35736
fs_write(/dev/fb, 0x8300b4c8, 128) = 128
...
fs_lseek(/dev/fb, 85336, 0) = 85336
fs_write(/dev/fb, 0x8301acc8, 128) = 128
fs_close(/dev/fb, 0, 0) = 0

fs_write(stdout, 0x8300aac0, 23) = 23
^C

vgalaxy@vgalaxy-VirtualBox:~/ics2021/navy-apps/libs/libminiSDL$ tree
.
├── include
│   ├── sdl-audio.h
│   ├── sdl-event.h
│   ├── sdl-file.h
│   ├── sdl-general.h
│   ├── SDL.h
│   ├── sdl-timer.h
│   └── sdl-video.h
├── Makefile
└── src
    ├── audio.c
    ├── event.c
    ├── file.c
    ├── general.c
    ├── timer.c
    └── video.c

2 directories, 14 files

31  30                           8          0
+----+---------------------------+----------+
|sign|          integer          | fraction |
+----+---------------------------+----------+

/* Multiplies a fixedpt number with an integer, returns the result. */
static inline fixedpt fixedpt_muli(fixedpt A, int B) {
    return A * B;
}

/* Divides a fixedpt number with an integer, returns the result. */
static inline fixedpt fixedpt_divi(fixedpt A, int B) {
    return A / B;
}

/* Multiplies two fixedpt numbers, returns the result. */
static inline fixedpt fixedpt_mul(fixedpt A, fixedpt B) {
    return A * B / FIXEDPT_ONE;
}


/* Divides two fixedpt numbers, returns the result. */
static inline fixedpt fixedpt_div(fixedpt A, fixedpt B) {
    return (fixedpt)(((fixedptd) A * (fixedptd) FIXEDPT_ONE) / (fixedptd) B);
}

static inline fixedpt fixedpt_abs(fixedpt A) {
    return A >= 0 ? A : -A;
}

static inline fixedpt fixedpt_floor(fixedpt A) {
    if (fixedpt_fracpart(A) == 0) return A;
    if (A > 0) return A & ~FIXEDPT_FMASK;
    else return -((-A & ~FIXEDPT_FMASK) + FIXEDPT_ONE);
}

static inline fixedpt fixedpt_ceil(fixedpt A) {
    if (fixedpt_fracpart(A) == 0) return A;
    if (A > 0) return (A & ~FIXEDPT_FMASK) + FIXEDPT_ONE;
    else return -(-A & ~FIXEDPT_FMASK);
}

vgalaxy@vgalaxy-VirtualBox:~/ics2021/navy-apps/libs/libfixedptc$ tree
.
├── fixedptc.c
├── include
│   └── fixedptc.h
├── Makefile
└── test
    ├── Makefile
    └── test.c

2 directories, 5 files

#include "../include/fixedptc.h"
#include <stdio.h>
#include <math.h>

void fixedpt_DUT() {
    printf("*** demo:\n");
    fixedpt a = fixedpt_rconst(1.2);
    fixedpt b = fixedpt_fromint(10);
    int c = 0;
    if (b > fixedpt_rconst(7.9)) {
      c = fixedpt_toint(fixedpt_div(fixedpt_mul(a + FIXEDPT_ONE, b), fixedpt_rconst(2.3)));
    }
    printf("%d\n", c);
    ...
}

void float_REF() {
    printf("*** demo:\n");
    float a = 1.2;
    float b = 10;
    int c = 0;
    if (b > 7.9) {
      c = (a + 1) * b / 2.3;
    }
    printf("%d\n", c);
    ...
}

int main() {
    printf("--------- fixedpt_DUT ---------\n");
    fixedpt_DUT();
    printf("---------- float_REF ----------\n");
    float_REF();
}

|------|
| NEMU |
|------| <--- am_native for Navy, native for AM
|  AM  |
|  OS  |
|------| <--- native for Navy
| Navy |
|------|

void NDL_DrawRect(uint32_t *pixels, int x, int y, int w, int h) {
  int fd = open("/dev/fb", 0, 0);
  for (int i = 0; i < h && y + i < canvas_h; ++i) {
    lseek(fd, ((y + canvas_relative_screen_h + i) * screen_w + (x + canvas_relative_screen_w)) * 4, SEEK_SET);
    write(fd, pixels + i * w, 4 * (w < canvas_w - x ? w : canvas_w - x));
  }
  assert(close(fd) == 0);
}

size_t fb_write(const void *buf, size_t offset, size_t len) {
  AM_GPU_CONFIG_T ev = io_read(AM_GPU_CONFIG);
  int width = ev.width;

  offset /= 4;
  len /= 4;

  int y = offset / width;
  int x = offset - y * width;

  io_write(AM_GPU_FBDRAW, x, y, (void *)buf, len, 1, true);

  return len;
}

bmp-test-native: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=73fc7f8d1c78bc3994477bf41e3140fe225b0d40, for GNU/Linux 3.2.0, not stripped

bmp-test-am_native: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

bmp-test-riscv32: ELF 32-bit LSB executable, UCB RISC-V, version 1 (SYSV), statically linked, not stripped

int program_break = (int)(&_end);

int program_break;
int is_program_break_init = 0;

void *_sbrk(intptr_t increment) {
  if (!is_program_break_init) { program_break = (int)(&_end); is_program_break_init = 1; }
  ...
}

memcpy((void *)(uintptr_t)virtAddr, buf_malloc, fileSiz);
memset((void *)(uintptr_t)(virtAddr + fileSiz), 0, memSiz - fileSiz);

LD = $(CXX)

### Run an application with $(ISA)=native

env:
    $(MAKE) -C $(NAVY_HOME)/libs/libos ISA=native

run: app env
    @LD_PRELOAD=$(NAVY_HOME)/libs/libos/build/native.so $(APP) $(mainargs)

gdb: app env
    @LD_PRELOAD=$(NAVY_HOME)/libs/libos/build/native.so gdb --args $(APP) $(mainargs)

.PHONY: env run gdb

Redirecting file open: /share/pictures/projectn.bmp -> /home/vgalaxy/ics2021/navy-apps/fsimg/share/pictures/projectn.bmp

static inline void get_fsimg_path(char *newpath, const char *path) {
  sprintf(newpath, "%s%s", fsimg_path, path);
}

static const char* redirect_path(char *newpath, const char *path) {
  get_fsimg_path(newpath, path);
  if (0 == access(newpath, 0)) {
    fprintf(stderr, "Redirecting file open: %s -> %s\n", path, newpath);
    return newpath;
  }
  return path;
}

struct Init {
  Init() {
    glibc_fopen = (FILE*(*)(const char*, const char*))dlsym(RTLD_NEXT, "fopen");
    assert(glibc_fopen != NULL);
    glibc_open = (int(*)(const char*, int, ...))dlsym(RTLD_NEXT, "open");
    assert(glibc_open != NULL);
    glibc_read = (ssize_t (*)(int fd, void *buf, size_t count))dlsym(RTLD_NEXT, "read");
    assert(glibc_read != NULL);
    glibc_write = (ssize_t (*)(int fd, const void *buf, size_t count))dlsym(RTLD_NEXT, "write");
    assert(glibc_write != NULL);
    glibc_execve = (int(*)(const char*, char *const [], char *const []))dlsym(RTLD_NEXT, "execve");
    assert(glibc_execve != NULL);

    dummy_fd = memfd_create("dummy", 0);
    assert(dummy_fd != -1);
    dispinfo_fd = dummy_fd;

    char *navyhome = getenv("NAVY_HOME");
    assert(navyhome);
    sprintf(fsimg_path, "%s/fsimg", navyhome);

    char newpath[512];
    get_fsimg_path(newpath, "/bin");
    setenv("PATH", newpath, 1); // overwrite the current PATH

    SDL_Init(0);
    if (!getenv("NWM_APP")) {
      open_display();
      open_event();
    }
    open_audio();
  }
  ~Init() {
  }
};

Init init;

FILE *fopen(const char *path, const char *mode) {
  char newpath[512];
  return glibc_fopen(redirect_path(newpath, path), mode);
}

int open(const char *path, int flags, ...) {
  if (strcmp(path, "/proc/dispinfo") == 0) {
    return dispinfo_fd;
  } else if (strcmp(path, "/dev/events") == 0) {
    return evt_fd;
  } else if (strcmp(path, "/dev/fb") == 0) {
    return fb_memfd;
  } else if (strcmp(path, "/dev/sb") == 0) {
    return sb_fifo[1];
  } else if (strcmp(path, "/dev/sbctl") == 0) {
    return sbctl_fd;
  } else {
    char newpath[512];
    return glibc_open(redirect_path(newpath, path), flags);
  }
}

fopen -> redirect_path -> get_fsimg_path
      -> glibc_fopen

  fb_memfd = memfd_create("fb", 0);
  assert(fb_memfd != -1);
  int ret = ftruncate(fb_memfd, FB_SIZE);
  assert(ret == 0);
  fb = (uint32_t *)mmap(NULL, FB_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fb_memfd, 0);
  assert(fb != (void *)-1);
  memset(fb, 0, FB_SIZE);
  lseek(fb_memfd, 0, SEEK_SET);

memfd_create() creates an anonymous file and returns a file descriptor that refers to it. The file behaves like a regular file, and so can be modified, truncated, memory-mapped, and so on. However, unlike a regular file, it lives in RAM and has a volatile backing storage.

  <policy domain="coder" rights="none" pattern="PDF" />

  <policy domain="coder" rights="read|write" pattern="PDF" />

SDL_WaitEvent -> SDL_PollEvent -> NDL_PollEvent -> open / read / close `/dev/events`

int SDL_WaitEvent(SDL_Event *event) {
  SDL_PollEvent(event);
  return 1;
}

int SDL_PollEvent(SDL_Event *ev) {
  unsigned buf_size = 32;
  char *buf = (char *)malloc(buf_size * sizeof(char));
  if (NDL_PollEvent(buf, buf_size) == 1) {
      if (strncmp(buf, "kd", 2) == 0) {
          ev->key.type = SDL_KEYDOWN;
      } else {
          ev->key.type = SDL_KEYUP;
      }

      for (unsigned i = 0; i < sizeof(keyname) / sizeof(keyname[0]); ++i) {
          if (strncmp(buf + 3, keyname[i], strlen(buf) - 4) == 0) {
              ev->key.keysym.sym = i;
              break;
          }
      }

      free(buf);
      return 1;
  } else {
      ev->key.type = SDL_USEREVENT; // avoid too many `Redirecting file open ...`
      ev->key.keysym.sym = 0;
  }

  free(buf);
  return 0;
}

int NDL_PollEvent(char *buf, int len) {
  memset(buf, 0, len);
  int fd = open("/dev/events", 0, 0);
  int ret = read(fd, buf, len);
  close(fd); // for event-test on native, no assertion here
  return ret == 0 ? 0 : 1;
}

render -> SDL_LoadBMP
          SDL_UpdateRect -> NDL_DrawRect -> open / read / close `/dev/fb`

void SDL_UpdateRect(SDL_Surface *s, int x, int y, int w, int h) {
  if (x == 0 && y == 0 && w == 0 && h == 0) {
      NDL_DrawRect((uint32_t *)s->pixels, x, y, 400, 300); // assume the size of screen
      return;
  }
  NDL_DrawRect((uint32_t *)s->pixels, x, y, w, h);
}

void NDL_DrawRect(uint32_t *pixels, int x, int y, int w, int h) {
  int fd = open("/dev/fb", 0, 0);
  for (int i = 0; i < h && y + i < canvas_h; ++i) {
    lseek(fd, ((y + canvas_relative_screen_h + i) * screen_w + (x + canvas_relative_screen_w)) * 4, SEEK_SET);
    write(fd, pixels + i * w, 4 * (w < canvas_w - x ? w : canvas_w - x));
  }
  // close(fd);
  // 1. for NSlider on native, no assertion here
  // 2. if close, the slide cannot turn pages on native
}

void SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, uint32_t color) {
    uint32_t * base = (uint32_t *)dst->pixels;
    if (dstrect == NULL) {
        for (int i = 0; i < dst->w * dst->h; ++i) base[i] = color;
        return;
    }

    int rect_x = dstrect->x;
    int rect_y = dstrect->y;
    int rect_w = dstrect->w < (dst->w - dstrect->x) ? dstrect->w : (dst->w - dstrect->x);
    int rect_h = dstrect->h < (dst->h - dstrect->y) ? dstrect->h : (dst->h - dstrect->y);

    for (int i = 0; i < rect_h; ++i) {
        for (int j = 0; j < rect_w; ++j) {
            base[(rect_y + i) * dst->w + rect_x + j] = color;
        }
    }
    return;
}

void SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect) {
    assert(dst && src);
    assert(dst->format->BitsPerPixel == src->format->BitsPerPixel);

    uint32_t * data = (uint32_t *)src->pixels;
    uint32_t * base = (uint32_t *)dst->pixels;

    int src_w = src->w;
    int src_h = src->h;
    int dst_w = dst->w;
    int dst_h = dst->h;
    int dstrect_x = dstrect->x;
    int dstrect_y = dstrect->y;

    if (srcrect == NULL) {
        assert(src_w <= (dst_w - dstrect_x));
        assert(src_h <= (dst_h - dstrect_y));

        // int width = src_w < (dst_w - dstrect_x) ? src_w : (dst_w - dstrect_x);
        // int height = src_h < (dst_h - dstrect_y) ? src_h : (dst_h - dstrect_y);

        for (int i = 0; i < src_h; ++i) {
            for (int j = 0; j < src_w; ++j) {
                base[(dstrect_y + i) * dst_w + dstrect_x + j] = data[i * src_w + j];
            }
        }

        return;
    } else {
        assert(0);
    }
}

int SDL_PollEvent(SDL_Event *ev) {
  unsigned buf_size = 32;
  char *buf = (char *)malloc(buf_size * sizeof(char));
  if (NDL_PollEvent(buf, buf_size) == 1) {
      if (strncmp(buf, "kd", 2) == 0) {
          ev->key.type = SDL_KEYDOWN;
      } else {
          ev->key.type = SDL_KEYUP;
      }

      int flag = 0;
      for (unsigned i = 0; i < sizeof(keyname) / sizeof(keyname[0]); ++i) {
          if (strncmp(buf + 3, keyname[i], strlen(buf) - 4) == 0
                  && strlen(keyname[i]) == strlen(buf) - 4) {
              flag = 1;
              ev->key.keysym.sym = i;
              break;
          }
      }

      assert(flag == 1);

      free(buf);
      return 1;
  } else {
      return 0;
  }
}

int SDL_WaitEvent(SDL_Event *ev) {
    unsigned buf_size = 32;
    char *buf = (char *)malloc(buf_size * sizeof(char));

    while (NDL_PollEvent(buf, buf_size) == 0); // wait ...

    if (strncmp(buf, "kd", 2) == 0)
        ev->key.type = SDL_KEYDOWN;
    else
        ev->key.type = SDL_KEYUP;


    int flag = 0;
    for (unsigned i = 0; i < sizeof(keyname) / sizeof(keyname[0]); ++i) {
        if (strncmp(buf + 3, keyname[i], strlen(buf) - 4) == 0
                && strlen(keyname[i]) == strlen(buf) - 4) {
            flag = 1;
            ev->key.keysym.sym = i;
            break;
        }
    }

    assert(flag == 1);

    free(buf);
    return 1;
}

void SDL_UpdateRect(SDL_Surface *s, int x, int y, int w, int h) {
    if (x == 0 && y == 0 && w == 0 && h == 0) {
        NDL_DrawRect((uint32_t *)s->pixels, x, y, s->w, s->h);
        return;
    }
    NDL_DrawRect((uint32_t *)s->pixels, x, y, w, h);
}

├── include
│   └── nterm.h
├── Makefile
└── src
    ├── builtin-sh.cpp
    ├── extern-sh.cpp
    ├── main.cpp
    └── term.cpp

font -> w: 7; h: 13
win -> w: 336; h: 208

buf -> 字符
color -> 颜色
dirty -> 是否被修改

  struct Cursor {
    int x, y;
  } cursor, saved;

int main(int argc, char *argv[]) {
  SDL_Init(0);
  font = new BDF_Font(font_fname);

  // setup display
  int win_w = font->w * W;
  int win_h = font->h * H;

  screen = SDL_SetVideoMode(win_w, win_h, 32, SDL_HWSURFACE);

  term = new Terminal(W, H);

  if (argc < 2) { builtin_sh_run(); }
  else { extern_app_run(argv[1]); }

  // should not reach here
  assert(0);
}

SDL_Surface* SDL_SetVideoMode(int width, int height, int bpp, uint32_t flags) {
  if (flags & SDL_HWSURFACE) NDL_OpenCanvas(&width, &height);
  return SDL_CreateRGBSurface(flags, width, height, bpp,
      DEFAULT_RMASK, DEFAULT_GMASK, DEFAULT_BMASK, DEFAULT_AMASK);
}

static void sh_printf(const char *format, ...) {
  static char buf[256] = {};
  va_list ap;
  va_start(ap, format);
  int len = vsnprintf(buf, 256, format, ap);
  va_end(ap);
  term->write(buf, len);
}

static void sh_banner() {
  sh_printf("Built-in Shell in NTerm (NJU Terminal)\n\n");
}

static void sh_prompt() {
  sh_printf("sh> ");
}

void builtin_sh_run() {
  sh_banner();
  sh_prompt();

  while (1) {
    SDL_Event ev;
    if (SDL_PollEvent(&ev)) {
      if (ev.type == SDL_KEYUP || ev.type == SDL_KEYDOWN) {
        const char *res = term->keypress(handle_key(&ev));
        if (res) {
          sh_handle_cmd(res);
          sh_prompt();
        }
      }
    }
    refresh_terminal();
  }
}

sh_banner -> sh_printf -> write

void Terminal::write(const char *str, size_t count) {
  for (size_t i = 0; i != count && str[i]; ) {
    char ch = str[i];
    if (ch == '\033') {
        i += write_escape(&str[i], count - i);
    } else {
      switch (ch) {
        case '\x07':
          break;
        case '\n':
          cursor.x = 0;
          cursor.y ++;
          if (cursor.y >= h) {
            scroll_up();
            cursor.y --;
          }
          break;
        case '\t':
          // TODO: implement it.
          break;
        case '\r':
          cursor.x = 0;
          break;
        default:
          putch(cursor.x, cursor.y, ch);
          move_one();
      }
      i ++;
    }
  }
}

\033 -> ???
\t -> TAB?
\n -> 换行
\r -> 回车，即光标回到本行首位置

void Terminal::putch(int x, int y, char ch) {
  buf[x + y * w] = ch;
  color[x + y * w] = (col_f << 4) | col_b;
  dirty[x + y * w] = true;
}

void refresh_terminal() {
  int needsync = 0;
  for (int i = 0; i < W; i ++)
    for (int j = 0; j < H; j ++)
      if (term->is_dirty(i, j)) {
        draw_ch(i * font->w, j * font->h, term->getch(i, j), term->foreground(i, j), term->background(i, j));
        needsync = 1;
      }
  term->clear();

  static uint32_t last = 0;
  static int flip = 0;
  uint32_t now = SDL_GetTicks();
  if (now - last > 500 || needsync) {
    int x = term->cursor.x, y = term->cursor.y;
    uint32_t color = (flip ? term->foreground(x, y) : term->background(x, y));
    draw_ch(x * font->w, y * font->h, ' ', 0, color);
    SDL_UpdateRect(screen, 0, 0, 0, 0);
    if (now - last > 500) {
      flip = !flip;
      last = now;
    }
  }
}

static void draw_ch(int x, int y, char ch, uint32_t fg, uint32_t bg) {
  SDL_Surface *s = BDF_CreateSurface(font, ch, fg, bg);
  SDL_Rect dstrect = { .x = x, .y = y };
  SDL_BlitSurface(s, NULL, screen, &dstrect);
  SDL_FreeSurface(s);
}

char handle_key(SDL_Event *ev) {
  static int shift = 0;
  int key = ev->key.keysym.sym;
  if (key == SDLK_LSHIFT || key == SDLK_RSHIFT) { shift ^= 1; return '\0'; }

  if (ev->type == SDL_KEYDOWN) {
    for (auto item: SHIFT) {
      if (item.keycode == key) {
        if (shift) return item.shift;
        else return item.noshift;
      }
    }
  }
  return '\0';
}

const char *Terminal::keypress(char ch) {
  if (ch == '\0') return nullptr;
  if (mode == Mode::raw) {
    input[0] = ch;
    input[1] = '\0';
    return input;
  } else if (mode == Mode::cook) {
    const char *ret = nullptr;
    switch (ch) {
      case '\033':
        break;
      case '\n':
        strcpy(cooked, input);
        strcat(cooked, "\n");
        ret = cooked;
        write("\n", 1);
        inp_len = 0;
        break;
      case '\b':
        if (inp_len > 0) {
          inp_len --;
          backspace();
        }
        break;
      default:
        if (inp_len + 1 < sizeof(input)) {
          input[inp_len ++] = ch;
          write(&ch, 1);
        }
    }
    input[inp_len] = '\0';
    return ret;
  }
  return nullptr;
}

static void sh_handle_cmd(const char *cmd) {
    if (cmd == NULL) return;
    if (strncmp(cmd, "echo", 4) == 0) {
        if (strlen(cmd) == 5) sh_printf("\n");
        else sh_printf("%s", cmd + 5);
    } else {
        sh_printf("command not found\n");
    }
}

sudo apt-get install libsdl1.2-dev
sudo apt-get install libsdl-image1.2-dev

SDL_Surface* IMG_Load(const char *filename) {
    FILE * fp = fopen(filename, "r");
    if (!fp) return NULL;

    fseek(fp, 0L, SEEK_END);
    long size = ftell(fp);

    rewind(fp);
    unsigned char * buf = (unsigned char *)malloc(size * sizeof(unsigned char));
    assert(fread(buf, 1, size, fp) == size);

    SDL_Surface * surface = STBIMG_LoadFromMemory(buf, size);
    assert(surface != NULL);

    fclose(fp);
    free(buf);

    return surface;
}

void SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect) {
    assert(dst && src);
    assert(dst->format->BitsPerPixel == src->format->BitsPerPixel);

    uint32_t * data = (uint32_t *)src->pixels;
    uint32_t * base = (uint32_t *)dst->pixels;

    int src_w = src->w;
    int src_h = src->h;
    int dst_w = dst->w;
    int dst_h = dst->h;
    int dstrect_x = !dstrect ? 0 : dstrect->x;
    int dstrect_y = !dstrect ? 0 : dstrect->y;

    if (srcrect == NULL) {
        int width = src_w < (dst_w - dstrect_x) ? src_w : (dst_w - dstrect_x);
        int height = src_h < (dst_h - dstrect_y) ? src_h : (dst_h - dstrect_y);

        for (int i = 0; i < height; ++i) {
            for (int j = 0; j < width; ++j) {
                base[(dstrect_y + i) * dst_w + dstrect_x + j] = data[i * src_w + j];
            }
        }

        return;
    } else {
        int srcrect_x = srcrect->x;
        int srcrect_y = srcrect->y;
        int width = srcrect->w < (dst_w - dstrect_x) ? srcrect->w : (dst_w - dstrect_x);
        int height = srcrect->h < (dst_h - dstrect_y) ? srcrect->h : (dst_h - dstrect_y);

        for (int i = 0; i < height; ++i) {
            for (int j = 0; j < width; ++j) {
                base[(dstrect_y + i) * dst_w + dstrect_x + j] = data[(srcrect_y + i) * src_w + srcrect_x + j];
            }
        }

        return;
    }
}

├── include
│   ├── Audio.h
│   ├── BirdGame.h
│   ├── BirdMain.h
│   ├── Sprite.h
│   └── Video.h
├── Makefile
├── README.txt
├── res
│   ├── atlas.png
│   ├── atlas.txt
│   ├── sfx_die.wav
│   ├── sfx_hit.wav
│   ├── sfx_point.wav
│   ├── sfx_swooshing.wav
│   ├── sfx_wing.wav
│   └── splash.png
└── src
    ├── Audio.cpp
    ├── BirdGame.cpp
    ├── BirdMain.cpp
    ├── Sprite.cpp
    └── Video.cpp

int main(int argc, char *argv[])
{
  // initialize SDL
  if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO) < 0)
    {
      fprintf(stderr, "SDL_Init() failed: %s\n", SDL_GetError());
      return 255;
    }
  atexit(SDL_Quit);

  // initialize video
  if (!VideoInit())
    {
      fprintf(stderr, "VideoInit() failed: %s\n", SDL_GetError());
      return 255;
    }

  atexit(VideoDestroy);

  // initialize audio
  if (SOUND_OpenAudio(44100, 2, 1024) < 0)
    {
      fprintf(stderr, "InitSound() failed: %s\n", SDL_GetError());
      return 255;
    }

  return GameMain();
}

int GameMain()
{
  srand((unsigned int)time(NULL));

  gpSprite = new CSprite(gpRenderer, FILE_PATH("atlas.png"), FILE_PATH("atlas.txt"));

  atexit([](void) { delete gpSprite; });

  LoadWav();

  atexit(FreeWav);
  atexit(SOUND_CloseAudio);

  ShowTitle();

  ...

bg_day 288 512 0 0
bg_night 288 512 292 0
...

typedef struct tagSpritePart
{
  unsigned short usWidth;
  unsigned short usHeight;
  unsigned short X, Y;
  int hasAlpha;
} SpritePart_t;

CSprite::CSprite(SDL_Surface *pRenderer, const char *szImageFileName, const char *szTxtFileName)
{
  int ret = hcreate(512);
  assert(ret);
  Load(pRenderer, szImageFileName, szTxtFileName);
}

  g_GameState = GAMESTATE_INITIAL;

  unsigned int uiNextFrameTime = SDL_GetTicks();
  unsigned int uiCurrentTime = SDL_GetTicks();

  while (1)
    {
      // 60fps
      do
    {
      uiCurrentTime = SDL_GetTicks();
      UpdateEvents();
      SDL_Delay(1);
    } while (uiCurrentTime < uiNextFrameTime);

      if ((int)(uiCurrentTime - uiNextFrameTime) > 1000)
    {
      uiNextFrameTime = uiCurrentTime + 1000 / 60;
    }
      else
    {
      uiNextFrameTime += 1000 / 60;
    }

static void UpdateEvents()
{
  SDL_Event evt;

  while (SDL_PollEvent(&evt))
    {
      switch (evt.type)
    {
#ifndef __NAVY__
    case SDL_QUIT:
      exit(0);
      break;

    case SDL_MOUSEBUTTONDOWN:
      g_bMouseDown = true;
      g_iMouseX = evt.button.x;
      g_iMouseY = evt.button.y;
      break;

    case SDL_MOUSEBUTTONUP:
      g_bMouseDown = false;
      break;
#endif

    case SDL_KEYDOWN:
      g_bMouseDown = true;
      break;

    case SDL_KEYUP:
      g_bMouseDown = false;
      break;
    }
    }
}

if now - prev > 1000:
  prev = now + 1000 / 60
else:
  prev += 1000 / 60

      switch (g_GameState)
    {
    case GAMESTATE_INITIAL:
      GameThink_Initial();
      break;

    case GAMESTATE_GAMESTART:
      GameThink_GameStart();
      break;

    case GAMESTATE_GAME:
      GameThink_Game();
      break;

    case GAMESTATE_GAMEOVER:
      GameThink_GameOver();
      break;

    default:
      fprintf(stderr, "invalid game state: %d\n", (int)g_GameState);
      exit(255);
    }

      SDL_UpdateRect(gpRenderer, 0, 0, 0, 0);
    }

  return 255; // shouldn't really reach here
}

static enum { FLASH, DROP, SHOWTITLE, SHOWSCORE }

0x00007ffff7c3650f in unlink_chunk (p=p@entry=0x5555561d3cc0, av=0x7ffff7d83ba0 <main_arena>)
    at malloc.c:1607
1607  malloc.c: No such file or directory.
(gdb) bt
#0  0x00007ffff7c3650f in unlink_chunk (p=p@entry=0x5555561d3cc0,
    av=0x7ffff7d83ba0 <main_arena>) at malloc.c:1607
#1  0x00007ffff7c3864c in _int_malloc (av=av@entry=0x7ffff7d83ba0 <main_arena>,
    bytes=bytes@entry=1696) at malloc.c:4266
#2  0x00007ffff7c3a2f1 in __GI___libc_malloc (bytes=1696) at malloc.c:3237
#3  0x0000555555575113 in YJ1_Decompress ()
#4  0x000000000000010a in ?? ()
#5  0x00005555561fb8e0 in ?? ()
#6  0x00007ffff6a2b800 in ?? ()
#7  0x00000000f7cca313 in ?? ()
#8  0x0000000000000000 in ?? ()

address (0x44a1f9cb) is out of bound at pc = 0x8303421c

void SDL_UpdateRect(SDL_Surface *s, int x, int y, int w, int h) {
    assert(s);
    assert(s->format);
    if (s->format->palette == NULL) { // 32-bits
        if (x == 0 && y == 0 && w == 0 && h == 0) {
            NDL_DrawRect((uint32_t *)s->pixels, x, y, s->w, s->h);
            return;
        }
        NDL_DrawRect((uint32_t *)s->pixels, x, y, w, h);
    } else { // 8-bits
        assert(s->format->palette->colors);
        int W, H;
        if (x == 0 && y == 0 && w == 0 && h == 0) {
            W = s->w;
            H = s->h;
        } else {
            W = w;
            H = h;
        }
        uint8_t * pixels_index = (uint8_t *)s->pixels;
        uint32_t * pixels = (uint32_t *)malloc(W * H * sizeof(uint32_t *));
        for (int i = 0; i < W * H; ++i) {
            SDL_Color colors = s->format->palette->colors[pixels_index[i]];
            uint32_t p = (colors.a << 24) | (colors.r << 16) | (colors.g << 8) | (colors.b << 0);
            pixels[i] = p;
        }
        NDL_DrawRect(pixels, x, y, W, H);
        free(pixels);
    }
}

static unsigned char keystate[sizeof(keyname) / sizeof(keyname[0])];

uint8_t* SDL_GetKeyState(int *numkeys) {
    SDL_Event ev;
    if (SDL_PollEvent(&ev) == 1 && ev.key.type == SDL_KEYDOWN) {
        keystate[ev.key.keysym.sym] = 1;
    } else {
        memset(keystate, 0, sizeof(keystate));
    }
    return keystate;
}

(Navy) __am_timer_uptime -> gettimeofday -> sys_gettimeofday -> io_read -> ioe_read -> (AM) _am_timer_uptime

├── include
│   ├── amdev.h -> /home/vgalaxy/ics2021/abstract-machine/am/include/amdev.h
│   ├── am.h
│   ├── am-origin.h -> /home/vgalaxy/ics2021/abstract-machine/am/include/am.h
│   ├── klib.h -> /home/vgalaxy/ics2021/abstract-machine/klib/include/klib.h
│   ├── klib-macros.h -> /home/vgalaxy/ics2021/abstract-machine/klib/include/klib-macros.h
│   └── navy.h
├── Makefile
└── src
    ├── ioe.c
    └── trm.cpp

ifeq ($(wildcard include/am-origin.h),)
ifeq ($(wildcard $(AM_HOME)/am/include/am.h),)
  $(error $$AM_HOME/am/include/amdev.h will be used. Please set $$AM_HOME to an AbstractMachine repo)
else
  $(info Setup link to header files)
  $(shell ln -sf -T $(AM_HOME)/am/include/am.h include/am-origin.h)
  $(shell ln -sf -T $(AM_HOME)/am/include/amdev.h include/amdev.h)
  $(shell ln -sf -T $(AM_HOME)/klib/include/klib.h include/klib.h)
  $(shell ln -sf -T $(AM_HOME)/klib/include/klib-macros.h include/klib-macros.h)
endif
endif