FROM ubuntu:20.04
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update
RUN apt-get install -y build-essential gcc-multilib qemu-system strace gdb sudo python3 libsdl2-dev libreadline-dev llvm-11 gcc-riscv64-linux-gnu
RUN useradd -ms /bin/bash user
USER user
WORKDIR /home/user

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [

        {
            "name": "debug",
            "type": "cppdbg",
            "request": "launch",
            "stopAtEntry": true,
            "program": "${workspaceFolder}/kernel/build/kernel-x86_64-qemu.elf",
            "cwd": "${workspaceFolder}",
            "miDebuggerServerAddress": "localhost:1234",
            "miDebuggerPath": "/usr/bin/gdb",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "pretty printing",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "logging": {
                // "engineLogging": true,
                // "programOutput": true
            }
        }
    ]
}

git pull origin L0

sudo apt-get install qemu-system-x86

# Building amgame-image [x86_64-qemu]
+ CC src/video.c
+ CC src/game.c
+ CC src/keyboard.c
# Building am-archive [x86_64-qemu]
+ AS src/x86/qemu/start64.S
+ AS src/x86/qemu/trap64.S
+ CC src/x86/qemu/trm.c
+ CC src/x86/qemu/cte.c
+ CC src/x86/qemu/ioe.c
+ CC src/x86/qemu/vme.c
+ CC src/x86/qemu/mpe.c
+ AR -> build/am-x86_64-qemu.a
# Building klib-archive [x86_64-qemu]
+ CC src/cpp.c
+ CC src/string.c
+ CC src/stdlib.c
+ CC src/stdio.c
+ CC src/int64.c
+ AR -> build/klib-x86_64-qemu.a
+ LD -> build/amgame-x86_64-qemu.elf
# Creating image [x86_64-qemu]
+ CC start.S main.c
+ CREATE -> build/amgame-x86_64-qemu

x86_64-linux-gnu-gcc -std=gnu11 -O2 -MMD -Wall -Werror -I/home/vgalaxy/os-workbench-2022/amgame/include -I/home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/am/include/ -I/home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/klib/include/ -D__ISA__=\"x86_64\" -D__ISA_X86_64__ -D__ARCH__=x86_64-qemu -D__ARCH_X86_64_QEMU -D__PLATFORM__=qemu -D__PLATFORM_QEMU -DARCH_H=\"arch/x86_64-qemu.h\" -fno-asynchronous-unwind-tables -fno-builtin -fno-stack-protector -Wno-main -U_FORTIFY_SOURCE -m64 -fPIC -mno-sse -c -o /home/vgalaxy/os-workbench-2022/amgame/build/x86_64-qemu/./src/video.o /home/vgalaxy/os-workbench-2022/amgame/src/video.c

x86_64-linux-gnu-gcc -MMD -I/home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/am/src -I/home/vgalaxy/os-workbench-2022/abstract-machine/am/include -I/home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/am/include/ -I/home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/klib/include/ -m64 -fPIC -c -o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/start64.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/src/x86/qemu/start64.S

ar rcs /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/am-x86_64-qemu.a /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/start64.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/trap64.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/trm.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/cte.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/ioe.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/vme.o /home/vgalaxy/os-workbench-2022/abstract-machine/am/build/x86_64-qemu/src/x86/qemu/mpe.o

x86_64-linux-gnu-ld -melf_x86_64 -N -Ttext-segment=0x00100000 -o /home/vgalaxy/os-workbench-2022/amgame/build/amgame-x86_64-qemu.elf --start-group /home/vgalaxy/os-workbench-2022/amgame/build/x86_64-qemu/./src/video.o /home/vgalaxy/os-workbench-2022/amgame/build/x86_64-qemu/./src/game.o /home/vgalaxy/os-workbench-2022/amgame/build/x86_64-qemu/./src/keyboard.o /home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/am/build/am-x86_64-qemu.a /home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/klib/build/klib-x86_64-qemu.a --end-group

x86_64-linux-gnu-gcc -static -m32 -fno-pic -Os -nostdlib -Ttext 0x7c00 -I/home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/am/src -o bootblock.o start.S main.c

( cat /home/vgalaxy/os-workbench-2022/amgame/../abstract-machine/am/src/x86/qemu/boot/bootblock.o; head -c 1024 /dev/zero; cat /home/vgalaxy/os-workbench-2022/amgame/build/amgame-x86_64-qemu.elf ) > /home/vgalaxy/os-workbench-2022/amgame/build/amgame-x86_64-qemu

( echo -n ; ) | dd if=/dev/stdin of=/home/vgalaxy/os-workbench-2022/amgame/build/amgame-x86_64-qemu bs=512 count=2 seek=1 conv=notrunc status=none
qemu-system-x86_64 -serial mon:stdio -machine accel=tcg -smp "" -drive format=raw,file=/home/vgalaxy/os-workbench-2022/amgame/build/amgame-x86_64-qemu

qemu-system-x86_64 -S -s -serial none -nographic -machine accel=tcg -smp "" -drive format=raw,file=/home/vgalaxy/os-workbench-2022/amgame/build/amgame-x86_64-qemu

WARNING:
Image format was not specified for 'build/amgame-x86_64-qemu' and probing guessed raw.
Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted.
Specify the 'raw' format explicitly to remove the restrictions.

typedef void (*handler_t)(void *buf);
static void *lut[128] = {
  [AM_UART_CONFIG ] = uart_config,
  [AM_UART_TX     ] = uart_tx,
  [AM_UART_RX     ] = uart_rx,
  [AM_TIMER_CONFIG] = timer_config,
  [AM_TIMER_RTC   ] = timer_rtc,
  [AM_TIMER_UPTIME] = timer_uptime,
  [AM_INPUT_CONFIG] = input_config,
  [AM_INPUT_KEYBRD] = input_keybrd,
  [AM_GPU_CONFIG  ] = gpu_config,
  [AM_GPU_FBDRAW  ] = gpu_fbdraw,
  [AM_GPU_STATUS  ] = gpu_status,
  [AM_GPU_MEMCPY  ] = gpu_memcpy,
  [AM_GPU_RENDER  ] = gpu_render,
  [AM_AUDIO_CONFIG] = audio_config,
  [AM_DISK_CONFIG ] = disk_config,
  [AM_DISK_STATUS ] = disk_status,
  [AM_DISK_BLKIO  ] = disk_blkio,
  [AM_NET_CONFIG  ] = net_config,
};

#define io_read(reg) \
  ({ reg##_T __io_param; \
    ioe_read(reg, &__io_param); \
    __io_param; })

#define io_write(reg, ...) \
  ({ reg##_T __io_param = (reg##_T) { __VA_ARGS__ }; \
    ioe_write(reg, &__io_param); })

bool ioe_init() {
  panic_on(cpu_current() != 0, "init IOE in non-bootstrap CPU");

  for (int i = 0; i < LENGTH(lut); i++)
    if (!lut[i]) lut[i] = fail;

  uart_init();
  timer_init();
  gpu_init();

  return true;
}

void putch(char ch) {
  #define COM1 0x3f8
  outb(COM1, ch);
}

ifeq ($(ARCH),)
export ARCH := x86_64-qemu

make run mainargs=xxx ARCH=xxx

  while (1) {
    srand(io_read(AM_TIMER_RTC).second);
    start();
    logic();
  }

void redraw() {
  for (int x = 0; x < w_side; x++) {
    for (int y = 0; y < h_side; y++) {
      draw_tile(x * SIDE, y * SIDE, SIDE, SIDE, palette[x][y]);
    }
  }
}

static void draw_tile(int x, int y, int w, int h, uint32_t color) {
  uint32_t pixels[w * h]; // WARNING: large stack-allocated memory
  AM_GPU_FBDRAW_T event = {
      .x = x,
      .y = y,
      .w = w,
      .h = h,
      .sync = 1,
      .pixels = pixels,
  };
  for (int i = 0; i < w * h; i++) {
    pixels[i] = color;
  }
  ioe_write(AM_GPU_FBDRAW, &event);
}

MODULE(os) {
  void (*init)();
  void (*run)();
};

MODULE(pmm) {
  void  (*init)();
  void *(*alloc)(size_t size);
  void  (*free)(void *ptr);
};

MODULE_DEF(os) = {
  .init = os_init,
  .run  = os_run,
};

MODULE_DEF(pmm) = {
  .init  = pmm_init,
  .alloc = kalloc,
  .free  = kfree,
};

typedef struct mod_os_t mod_os_t;
extern mod_os_t *os;
struct mod_os_t {
  void (*init)();
  void (*run)();
};

typedef struct mod_pmm_t mod_pmm_t;
extern mod_pmm_t *pmm;
struct mod_pmm_t {
  void (*init)();
  void *(*alloc)(size_t size);
  void (*free)(void *ptr);
};

extern mod_os_t __os_obj;
mod_os_t *os = &__os_obj;
mod_os_t __os_obj = {
  .init = os_init,
  .run = os_run,
};

extern mod_pmm_t __pmm_obj;
mod_pmm_t *pmm = &__pmm_obj;
mod_pmm_t __pmm_obj = {
  .init = pmm_init,
  .alloc = kalloc,
  .free = kfree,
};

// ---------------------- MPE: Multi-Processing ----------------------
bool     mpe_init    (void (*entry)());
int      cpu_count   (void);
int      cpu_current (void);
int      atomic_xchg (int *addr, int newval);

static void call_user_entry() {
  user_entry();
  panic("MPE entry should not return");
}

bool mpe_init(void (*entry)()) {
  user_entry = entry;
  boot_record()->jmp_code = 0x000bfde9; // (16-bit) jmp (0x7c00)
  for (int cpu = 1; cpu < __am_ncpu; cpu++) {
    boot_record()->is_ap = 1;
    __am_lapic_bootap(cpu, (void *)boot_record());
    while (xchg(&ap_ready, 0) != 1) {
      pause();
    }
  }
  call_user_entry();
  return true;
}

int cpu_count() {
  return __am_ncpu;
}

int cpu_current(void) {
  return __am_lapic[8] >> 24;
}

int atomic_xchg(int *addr, int newval) {
  return xchg(addr, newval);
}

static inline int xchg(int *addr, int newval) {
  int result;
  asm volatile ("lock xchg %0, %1":
    "+m"(*addr), "=a"(result) : "1"(newval) : "cc", "memory");
  return result;
}

#include <kernel.h>
#include <klib.h>

int main() {
  os->init();
  mpe_init(os->run);
  return 1;
}

qemu-system-x86_64 -serial mon:stdio -machine accel=tcg -smp "" -drive format=raw,file=/home/vgalaxy/os-workbench-2022/kernel/build/kernel-x86_64-qemu

-smp [cpus=]n[,cores=cores][,threads=threads][,dies=dies][,sockets=sockets][,maxcpus=maxcpus]

qemu-system-x86_64: warning: This family of AMD CPU doesn't support hyperthreading(2)

qemu-system-x86_64 -serial mon:stdio -machine accel=tcg -smp 4,cores=1,threads=1,sockets=4 -drive format=raw,file=/home/vgalaxy/os-workbench-2022/kernel/build/kernel-x86_64-qemu

make run smp=8

#define MAX_CPU       8

Got 125 MiB heap: [0x300000, 0x8000000)

int      atomic_xchg (int *addr, int newval);

typedef struct {
  int flag;
} lock_t;

static inline void init_lock(lock_t *lock) {
  atomic_xchg(&lock->flag, 0);
  // lock->flag = 0;
  // panic_on(lock->flag == 1, "Broken invariant.");
}

static inline void lock(lock_t *lock) {
  while (atomic_xchg(&lock->flag, 1) == 1)
    ;
  // panic_on(lock->flag == 0, "Broken invariant.");
}

static inline void unlock(lock_t *lock) {
  atomic_xchg(&lock->flag, 0);
  // lock->flag = 0;
  // panic_on(lock->flag == 1, "Broken invariant.");
}

static inline void try_lock(lock_t *lock) {
  return !atomic_xchg(&lock->flag, 1);
}

buddy_a - 1048576 unit(s)
buddy_b - 2097152 unit(s)
...
buddy_a - 524288 unit(s)
buddy_b - 1048576 unit(s)

.
├── framework  -> 框架代码；可以在本地修改，但 Online Judge 评测时会被替换成我们的版本
│   ├── kernel.h
│   └── main.c
├── include    -> 头文件；可以自由修改/创建文件 (Online Judge 会复制)
│   └── common.h
├── Makefile
└── src        -> 源文件；可以自由修改/创建文件 (Online Judge 会复制)
    ├── os.c
    └── pmm.c

.
├── am.h
├── common.h
├── test.c
└── thread.h

test: git
  @gcc $(shell find src/ -name "pmm.c")  \
       $(shell find test/ -name "*.c") \
       -g -Wall -Werror \
       -Iframework -Itest\
       -DTEST -lpthread \
       -o build/test
  @build/test

bool cte_init(Context *(*handler)(Event, Context *)) {
  panic_on(cpu_current() != 0, "init CTE in non-bootstrap CPU");
  panic_on(!handler, "no interrupt handler");

  for (int i = 0; i < NR_IRQ; i ++) {
    idt[i]  = GATE(STS_TG, KSEL(SEG_KCODE), __am_irqall,  DPL_KERN);
  }
#define IDT_ENTRY(id, dpl, err) \
    idt[id] = GATE(STS_TG, KSEL(SEG_KCODE), __am_irq##id, DPL_##dpl);
  IRQS(IDT_ENTRY)

  user_handler = handler;
  return true;
}

void yield() {
  interrupt(0x81);
}

bool ienabled() {
  return (get_efl() & FL_IF) != 0;
}

void iset(bool enable) {
  if (enable) sti();
  else cli();
}

Context* kcontext(Area kstack, void (*entry)(void *), void *arg) {
  Context *ctx = kstack.end - sizeof(Context);
  *ctx = (Context) { 0 };

#if __x86_64__
  ctx->cs     = KSEL(SEG_KCODE);
  ctx->rip    = (uintptr_t)__am_kcontext_start;
  ctx->rflags = FL_IF;
  ctx->rsp    = (uintptr_t)kstack.end;
#else
  ctx->ds     = KSEL(SEG_KDATA);
  ctx->cs     = KSEL(SEG_KCODE);
  ctx->eip    = (uintptr_t)__am_kcontext_start;
  ctx->eflags = FL_IF;
  ctx->esp    = (uintptr_t)kstack.end;
#endif

  ctx->GPR1 = (uintptr_t)arg;
  ctx->GPR2 = (uintptr_t)entry;

  return ctx;
}

//////////////////////////////////

static inline void cli() {
  asm volatile ("cli");
}

static inline void sti() {
  asm volatile ("sti");
}

#define interrupt(id) \
  asm volatile ("int $" #id);

static inline uint32_t get_efl() {
  volatile uintptr_t efl;
  asm volatile ("pushf; pop %0": "=r"(efl));
  return efl;
}

#define FL_IF          0x00000200  // Interrupt Enable

void __am_irq_handle(struct trap_frame *tf);

#if __x86_64__
struct trap_frame {
  Context saved_context;
  uint64_t irq, errcode;
  uint64_t rip, cs, rflags, rsp, ss;
};
#else
struct trap_frame {
  Context saved_context;
  uint32_t irq, errcode;
  uint32_t eip, cs, eflags, esp, ss;
};
#endif

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

// 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;

struct Context {
  void    *cr3;
  uint64_t rax, rbx, rcx, rdx,
           rbp, rsi, rdi,
           r8, r9, r10, r11,
           r12, r13, r14, r15,
           rip, cs, rflags,
           rsp, ss, rsp0;
};


#define GPR1 rdi
#define GPR2 rsi
#define GPR3 rdx
#define GPR4 rcx
#define GPRx rax

struct Context {
  void    *cr3;
  uint32_t ds, eax, ebx, ecx, edx,
           esp0, esi, edi, ebp,
           eip, cs, eflags, esp, ss3;
};

#define GPR1 eax
#define GPR2 ebx
#define GPR3 ecx
#define GPR4 edx
#define GPRx eax

symbol-file /home/vgalaxy/os-workbench-2022/kernel/build/kernel-x86_64-qemu.elf

symbol-file /home/vgalaxy/os-workbench-2022/abstract-machine/am/src/x86/qemu/boot/bootblock.symbol

SRCS := start.S main.c
bootblock.o: $(SRCS) Makefile
  @echo + CC $(SRCS)
  @$(CROSS_COMPILE)gcc -static -m32 -fno-pic -Os -nostdlib -Ttext 0x7c00 -I$(AM_HOME)/am/src -o bootblock.o $(SRCS)
  @python3 genboot.py bootblock.o
  @$(CROSS_COMPILE)gcc -static -m32 -fno-pic -Os -g -nostdlib -Ttext 0x7c00 -I$(AM_HOME)/am/src -o bootblock.symbol $(SRCS)

clean:
  rm -rf *.o

# 输出信息多时不会暂停输出
set pagination off

# 退出时不显示提示信息
set confirm off

# 按照派生类型打印对象
set print object on

# 打印数组的索引下标
set print array-indexes on

# 每行打印一个结构体成员
set print pretty on

import sys

limit = int(sys.argv[1])
count, n = 0, 100000
while True:
    for ch in sys.stdin.read(n):
        if ch == '(': count += 1
        if ch == ')': count -= 1
        assert 0 <= count <= limit
    print(f'{n} Ok.')

$ make qemu

struct device {
  const char *name;
  int id;
  void *ptr;
  devops_t *ops;
};

typedef struct devops {
  int (*init)(device_t *dev);
  int (*read) (device_t *dev, int offset, void *buf, int count);
  int (*write)(device_t *dev, int offset, const void *buf, int count);
} devops_t;

void dev_input_task(void *args) {
  device_t *in = dev->lookup("input");
  uint32_t known_time = io_read(AM_TIMER_UPTIME).us;

  while (1) {
    uint32_t time;
    AM_INPUT_KEYBRD_T key;
    while ((key = io_read(AM_INPUT_KEYBRD)).keycode != 0) {
      input_keydown(in, key);
    }
    time = io_read(AM_TIMER_UPTIME).us;
    if ((time - known_time) / 1000 > 100 && is_empty(in->ptr)) {
      push_event(in->ptr, event(0, 0, 0));
      known_time = time;
    }
    kmt->sem_wait(&sem_kbdirq);
  }
}

static void push_event(input_t *in, struct input_event ev) {
  kmt->spin_lock(&in->lock);
  in->events[in->rear] = ev;
  in->rear = (in->rear + 1) % NEVENTS;
  panic_on(is_empty(in), "input queue full");
  kmt->spin_unlock(&in->lock);
  kmt->sem_signal(&in->event_sem);
}

static struct input_event pop_event(input_t *in) {
  kmt->sem_wait(&in->event_sem);
  kmt->spin_lock(&in->lock);
  panic_on(is_empty(in), "input queue empty");
  int idx = in->front;
  in->front = (in->front + 1) % NEVENTS;
  struct input_event ret = in->events[idx];
  kmt->spin_unlock(&in->lock);
  return ret;
}

-smp 2

-smp sockets=2

 $ qemu-system-x86_64 -d help

-d cpu_reset

(qemu) log cpu_reset

% qemu-system-x86_64 --version
QEMU emulator version 2.11.1(Debian 1:2.11+dfsg-1ubuntu7.39)
Copyright (c) 2003-2017 Fabrice Bellard and the QEMU Project developers

% sudo apt-get install gcc-multilib

Area stack = (Area){&task->u.context + 1, task + 1};

.globl __am_irq##id; __am_irq##id: cli;      err; push $id; jmp trap;

void mp_entry() {
  iset(false);
  yield();
}

struct Context {
  void    *cr3;
  uint64_t rax, rbx, rcx, rdx,
           rbp, rsi, rdi,
           r8, r9, r10, r11,
           r12, r13, r14, r15,
           rip, cs, rflags,
           rsp, ss, rsp0;
};

struct trap_frame {
  Context saved_context;
  uint64_t irq, errcode;
  uint64_t rip, cs, rflags, rsp, ss;
};

  saved_ctx->rip    = tf->rip;
  saved_ctx->cs     = tf->cs;
  saved_ctx->rflags = tf->rflags;
  saved_ctx->rsp    = tf->rsp;
  saved_ctx->rsp0   = CPU->tss.rsp0;
  saved_ctx->ss     = tf->ss;

Hello World from CPU #0

$ install nasm
$ ndisasm -b 64 _init

[0x100000000000, 0x108000000000)

map: 0x100000000000 -> 0x102d000

x /fmt addr -- virtual memory dump starting at 'addr'
xp /fmt addr -- physical memory dump starting at 'addr'

(qemu) xp /4x 0x102d000
000000000102d000: 0x00044ee8 0xc7894800 0x03c0c748 0xcd000000
(qemu) xp /4x 0x100000000000
0000100000000000: Cannot access memory
(qemu) x /4x 0x100000000000
0000100000000000: 0x00044ee8 0xc7894800 0x03c0c748 0xcd000000

-exec help x
Examine memory: x/FMT ADDRESS.
ADDRESS is an expression for the memory address to examine.
FMT is a repeat count followed by a format letter and a size letter.
Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),
  t(binary), f(float), a(address), i(instruction), c(char), s(string)
  and z(hex, zero padded on the left).
Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).
The specified number of objects of the specified size are printed
according to the format.  If a negative number is specified, memory is
examined backward from the address.

Defaults for format and size letters are those previously used.
Default count is 1.  Default address is following last thing printed
with this command or "print".

-exec x/4 0x100000000000
0x100000000000:  0x00044ee8  0xc7894800  0x03c0c748  0xcd000000
-exec x/4 0x102d000
0x102d000:  0x00044ee8  0xc7894800  0x03c0c748  0xcd000000

*(outer_curr->wstate) = inner_curr->xstate;

map: 0x0 -> 0x1034000
AM Panic: mapping an invalid address @ /home/vgalaxy/Desktop/os-workbench-2022/abstract-machine/am/src/x86/qemu/vme.c:142

$ ndisasm -b 64 ./_init

00000B7D  48C1E209          shl rdx,byte 0x9
00000B81  488D0527080000    lea rax,[rel 0x13af]
00000B88  4801D0            add rax,rdx
00000B8B  803C082B          cmp byte [rax+rcx],0x2b

00000B7D  48C1E009          shl rax,byte 0x9
00000B81  48030560080000    add rax,[rel 0x13e8]
00000B88  803C102B          cmp byte [rax+rdx],0x2b

  if (ret == NULL) {  // ridiculousness
    while(1);
  }