Record networking and DMA development progress

Add the current OS source tree, build scripts, system image layout, and development notes covering DMA page allocation, e1000 bring-up, net API dispatch, and DHCP work in progress.

CODE/UTSM/include/utsm/arena.h

@@ -0,0 +1,13 @@
+#ifndef UTSM_ARENA_H
+#define UTSM_ARENA_H
+
+#include <utsm/types.h>
+
+void arena_init(void);
+void *kmem_alloc(u64 size);
+void *kmem_alloc_aligned(u64 size, u64 alignment);
+void *kmem_alloc_page(u64 page_count);
+u64 kmem_arena_virtual_base(void);
+u64 kmem_arena_virtual_end(void);
+
+#endif

CODE/UTSM/include/utsm/assert.h

@@ -0,0 +1,8 @@
+#ifndef UTSM_ASSERT_H
+#define UTSM_ASSERT_H
+
+#include <utsm/log.h>
+
+#define UTSM_ASSERT(cond) do { if (!(cond)) { panic("assertion failed: " #cond); } } while (0)
+
+#endif

CODE/UTSM/include/utsm/block.h

@@ -0,0 +1,29 @@
+#ifndef UTSM_BLOCK_H
+#define UTSM_BLOCK_H
+
+#include <utsm/types.h>
+
+#define DKM_BLOCK_MAX_DEVICES 8u
+
+typedef int (*dkm_block_read_fn)(void *ctx, u64 lba, u32 count, void *buffer);
+
+typedef struct dkm_block_device_desc {
+    const char *name;
+    u64 sector_size;
+    u64 sector_count;
+    void *ctx;
+    dkm_block_read_fn read;
+} dkm_block_device_desc;
+
+typedef struct dkm_block_api {
+    int (*register_device)(const dkm_block_device_desc *desc);
+    u32 (*device_count)(void);
+    int (*read)(u32 index, u64 lba, u32 count, void *buffer);
+    u64 (*sector_size)(u32 index);
+    const char *(*device_name)(u32 index);
+} dkm_block_api;
+
+void block_init(void);
+const dkm_block_api *block_get_api(void);
+
+#endif

CODE/UTSM/include/utsm/capability.h

@@ -0,0 +1,26 @@
+#ifndef UTSM_CAPABILITY_H
+#define UTSM_CAPABILITY_H
+
+#include <utsm/types.h>
+#include <utsm/status.h>
+
+#define UTSM_RIGHT_READ  (1U << 0)
+#define UTSM_RIGHT_WRITE (1U << 1)
+#define UTSM_RIGHT_EXEC  (1U << 2)
+#define UTSM_RIGHT_SHARE (1U << 3)
+#define UTSM_RIGHT_DMA   (1U << 4)
+
+struct utsm_segment_desc;
+
+typedef struct {
+    u32 segment_slot;
+    u32 generation;
+    u32 rights;
+    u32 epoch;
+    u64 uuid_digest;
+    u64 auth_tag;
+} utsm_capability;
+
+int utsm_cap_validate(utsm_capability cap, u32 required_rights, u64 offset, u64 len, struct utsm_segment_desc **out_desc);
+
+#endif

CODE/UTSM/include/utsm/config.h

@@ -0,0 +1,13 @@
+#ifndef UTSM_CONFIG_H
+#define UTSM_CONFIG_H
+
+#define UTSM_CACHE_LINE_SIZE 64ULL
+#define UTSM_PAGE_SIZE 4096ULL
+#define UTSM_MAX_SEGMENTS 1024U
+#define UTSM_MAX_CAPABILITIES 256U
+#define UTSM_MAX_PCKC_KEYS 8U
+#define UTSM_ARENA_SIZE (16ULL * 1024ULL * 1024ULL)
+#define UTSM_DIRTY_SHARD_PAGES 1024ULL
+#define UTSM_KERNEL_STACK_SIZE 16384ULL
+
+#endif

CODE/UTSM/include/utsm/crypto.h

@@ -0,0 +1,17 @@
+#ifndef UTSM_CRYPTO_H
+#define UTSM_CRYPTO_H
+
+#include <utsm/types.h>
+#include <utsm/uuid.h>
+
+struct utsm_segment_desc;
+
+typedef struct {
+    u64 words[4];
+} utsm_key_material;
+
+void utsm_kdf_segment_key(uuid128_t process_uuid, uuid128_t segment_uuid, u64 key_epoch, utsm_key_material *out_key);
+u64 utsm_make_tweak(u64 tweak_seed, u64 line_index, u64 key_epoch);
+void utsm_crypt_line(const utsm_key_material *key, u64 tweak, const u8 *in, u8 *out);
+
+#endif

CODE/UTSM/include/utsm/dirty.h

@@ -0,0 +1,20 @@
+#ifndef UTSM_DIRTY_H
+#define UTSM_DIRTY_H
+
+#include <utsm/types.h>
+
+typedef struct {
+    u32 dirty_count;
+    u32 shard_id;
+    u64 page_base;
+    u64 page_count;
+    u64 last_checkpoint_epoch;
+    u64 *bitmap;
+} utsm_dirty_shard;
+
+struct utsm_segment_desc;
+
+void utsm_dirty_init(struct utsm_segment_desc *desc, u64 page_count);
+void utsm_mark_dirty(struct utsm_segment_desc *desc, u64 offset, u64 len);
+
+#endif

CODE/UTSM/include/utsm/dkm.h

@@ -0,0 +1,141 @@
+#ifndef UTSM_DKM_H
+#define UTSM_DKM_H
+
+#include <utsm/types.h>
+#include <utsm/dma.h>
+#include <utsm/block.h>
+#include <utsm/net.h>
+
+#define DKM_DRIVER_MAGIC 0x444B4D31u
+#define DKM_ABI_VERSION  1u
+#define DKM_KERNEL_API_VERSION 1u
+
+#define DKM_CLASS_PLATFORM  1u
+#define DKM_CLASS_BUS       2u
+#define DKM_CLASS_INTERRUPT 3u
+#define DKM_CLASS_TIMER     4u
+#define DKM_CLASS_CONSOLE   5u
+#define DKM_CLASS_STORAGE   6u
+#define DKM_CLASS_FS        7u
+#define DKM_CLASS_NET       8u
+#define DKM_CLASS_INPUT     9u
+#define DKM_CLASS_GPU       10u
+#define DKM_CLASS_MISC      11u
+
+#define DKM_F_REQUIRED        (1u << 0)
+#define DKM_F_BOOT_MODULE     (1u << 1)
+#define DKM_F_NO_UNLOAD       (1u << 2)
+#define DKM_F_STRONG_RECOVERY (1u << 3)
+#define DKM_F_DMA_REQUIRED    (1u << 4)
+#define DKM_F_EARLY_LOG       (1u << 5)
+
+struct dkm_kernel_api;
+struct dkm_driver_handle;
+
+typedef struct dkm_driver_desc {
+    u32 magic;
+    u16 abi_version;
+    u16 desc_size;
+
+    const char *name;
+    const char *version;
+    const char *vendor;
+
+    u32 driver_class;
+    u32 stage;
+    u32 flags;
+    u32 priority;
+
+    const char *const *depends;
+    u32 depends_count;
+
+    const char *const *provides;
+    u32 provides_count;
+
+    u64 min_kernel_abi;
+    u64 feature_bits;
+
+    u64 reserved0;
+    u64 reserved1;
+} dkm_driver_desc;
+
+typedef int (*dkm_driver_init_fn)(const struct dkm_kernel_api *api, struct dkm_driver_handle *handle);
+typedef int (*dkm_driver_exit_fn)(struct dkm_driver_handle *handle);
+
+typedef struct dkm_log_api {
+    void (*info)(const char *msg);
+    void (*warn)(const char *msg);
+    void (*error)(const char *msg);
+    void (*panic)(const char *msg);
+} dkm_log_api;
+
+typedef struct dkm_kernel_api {
+    u32 version;
+    u32 size;
+    u64 feature_bits;
+
+    const dkm_log_api *log;
+    const void *mem;
+    const void *utsm;
+    const void *irq;
+    const void *pci;
+    const dkm_dma_api *dma;
+    const void *vfs;
+    const dkm_net_api *net;
+    const void *timer;
+    const void *drr;
+
+    const void *rsdp_address;   /* ACPI RSDP physical address */
+    const void *fb_address;     /* framebuffer base */
+    u64 fb_width;
+    u64 fb_height;
+    u64 fb_pitch;
+    u16 fb_bpp;
+    const void *boot_modules_response;  /* limine_module_response* */
+    int (*irq_register)(u8 irq, void *handler);  /* kernel irq_register */
+    u64 hhdm_offset;                               /* physical → virtual */
+    const dkm_block_api *block;                    /* block provider registry */
+} dkm_kernel_api;
+
+typedef enum dkm_driver_state {
+    DKM_STATE_DISCOVERED = 0,
+    DKM_STATE_ABI_CHECKED,
+    DKM_STATE_INITING,
+    DKM_STATE_ACTIVE,
+    DKM_STATE_FAILED
+} dkm_driver_state;
+
+typedef struct dkm_driver_handle {
+    const dkm_driver_desc *desc;
+    dkm_driver_state state;
+    i32 init_status;
+    u32 load_stage;
+    u32 flags;
+} dkm_driver_handle;
+
+typedef struct dkm_builtin_driver {
+    const dkm_driver_desc *desc;
+    dkm_driver_init_fn init;
+    dkm_driver_exit_fn exit;
+} dkm_builtin_driver;
+
+void dkm_init(void);
+int dkm_load_builtin(const dkm_builtin_driver *driver);
+void dkm_scan_boot_modules(void);
+void dsm_load_by_manifest(void);
+void dkm_fill_platform_info(void);
+const dkm_kernel_api *dkm_get_kernel_api(void);
+
+/* exposed for manifest parser */
+struct dkm_symbol_scan {
+    const void *driver_desc;
+    const void *driver_init;
+    const void *driver_exit;
+};
+int dkm_check_elf64(const void *address, u64 size);
+int dkm_scan_symbols(const void *address, u64 size, struct dkm_symbol_scan *out);
+int dkm_load_elf_rel(const void *address, u64 size, const struct dkm_symbol_scan *symbols);
+
+extern const dkm_builtin_driver dkm_builtin_console_early;
+
+#endif

CODE/UTSM/include/utsm/dma.h

@@ -0,0 +1,20 @@
+#ifndef UTSM_DMA_H
+#define UTSM_DMA_H
+
+#include <utsm/types.h>
+
+typedef struct dkm_dma_buffer {
+    void *virt;
+    u64 phys;
+    u64 size;
+} dkm_dma_buffer;
+
+typedef struct dkm_dma_api {
+    int (*alloc_pages)(u64 page_count, u64 alignment, u64 max_phys, dkm_dma_buffer *out);
+} dkm_dma_api;
+
+void dma_init(void);
+int dma_alloc_pages(u64 page_count, u64 alignment, u64 max_phys, dkm_dma_buffer *out);
+const dkm_dma_api *dma_get_api(void);
+
+#endif

CODE/UTSM/include/utsm/dmp.h

@@ -0,0 +1,26 @@
+#ifndef UTSM_DMP_H
+#define UTSM_DMP_H
+
+#include <utsm/types.h>
+
+typedef struct {
+    u64 magic;
+    u32 version;
+    u32 segment_slot;
+    u64 fast_base;
+    u64 fast_limit;
+    u64 fast_tweak_seed;
+    u64 fast_key_epoch;
+    u64 dirty_bitmap_base;
+    u64 mac_table_base;
+    u64 last_writer_seq;
+    u32 last_cpu;
+    u32 flags;
+    u64 crc;
+} utsm_dmp;
+
+struct utsm_segment_desc;
+
+void utsm_dmp_init(utsm_dmp *dmp, struct utsm_segment_desc *desc, u32 slot);
+
+#endif

CODE/UTSM/include/utsm/drr.h

@@ -0,0 +1,13 @@
+#ifndef UTSM_DRR_H
+#define UTSM_DRR_H
+
+#include <utsm/types.h>
+
+void drr_stub_init(void);
+const u64 *drr_get_root_key(void);
+u64 drr_recovery_generation(void);
+void drr_report_fault(const char *reason);
+void drr_log_write_intent(u32 segment_slot, u64 offset, u64 len);
+void drr_log_write_commit(u32 segment_slot, u64 offset, u64 len);
+
+#endif

CODE/UTSM/include/utsm/dsk.h

@@ -0,0 +1,51 @@
+#ifndef UTSM_DSK_H
+#define UTSM_DSK_H
+
+#include <utsm/types.h>
+
+#define DSK_BOOT_MAGIC 0x44534B31424F4F54ULL /* "DSK1BOOT" */
+#define DSK_BOOT_ABI_VERSION 1u
+
+#define DSK_BOOT_FLAG_FROM_UTSM       (1ULL << 0)
+#define DSK_BOOT_FLAG_DKM_READY       (1ULL << 1)
+#define DSK_BOOT_FLAG_FAT32_PATH      (1ULL << 2)
+
+typedef struct dsk_boot_context {
+    u64 magic;
+    u32 abi_version;
+    u32 size;
+
+    u64 flags;
+
+    u64 hhdm_offset;
+    u64 rsdp_address;
+
+    u64 framebuffer_address;
+    u64 framebuffer_width;
+    u64 framebuffer_height;
+    u64 framebuffer_pitch;
+    u32 framebuffer_bpp;
+    u32 reserved_fb;
+
+    u64 boot_modules_response;
+
+    u64 dkm_kernel_api;
+    u64 dkm_driver_table;
+    u64 dkm_driver_count;
+
+    u64 utsm_state;
+    u64 drr_state;
+
+    u64 memory_map;
+    u64 memory_map_count;
+    u64 memory_map_entry_size;
+
+    u64 kernel_stack_top;
+    u64 reserved[8];
+} dsk_boot_context;
+
+typedef void (*dsk_entry_fn)(const dsk_boot_context *context);
+
+int dsk_load_and_jump(void);
+
+#endif

CODE/UTSM/include/utsm/idt.h

@@ -0,0 +1,12 @@
+#ifndef UTSM_IDT_H
+#define UTSM_IDT_H
+
+#include <utsm/types.h>
+
+void idt_init(void);
+
+/* IRQ handler: return 1 to suppress default ACK, 0 for normal EOI */
+typedef int (*irq_handler_t)(u8 irq);
+int irq_register(u8 irq, irq_handler_t handler);
+
+#endif

CODE/UTSM/include/utsm/log.h

@@ -0,0 +1,16 @@
+#ifndef UTSM_LOG_H
+#define UTSM_LOG_H
+
+#include <utsm/types.h>
+
+void serial_init(void);
+void serial_putc(char c);
+void serial_write(const char *s);
+
+void log_info(const char *msg);
+void log_warn(const char *msg);
+void log_error(const char *msg);
+void log_hex64(const char *prefix, u64 value);
+void panic(const char *msg);
+
+#endif

CODE/UTSM/include/utsm/net.h

@@ -0,0 +1,42 @@
+#ifndef UTSM_NET_H
+#define UTSM_NET_H
+
+#include <utsm/types.h>
+
+#define DKM_NET_MAX_DEVICES 8u
+
+/* 网卡链路/能力标志。 */
+#define DKM_NET_F_LINK_UP  (1u << 0)
+#define DKM_NET_F_TX_READY (1u << 1)
+#define DKM_NET_F_RX_READY (1u << 2)
+
+typedef int (*dkm_net_tx_fn)(void *ctx, const void *packet, u32 length);
+typedef int (*dkm_net_rx_poll_fn)(void *ctx, void *buffer, u32 capacity, u32 *out_length);
+
+typedef struct dkm_net_device_desc {
+    const char *name;
+    u8 mac[6];
+    u32 flags;
+    void *ctx;
+    dkm_net_tx_fn tx;
+    dkm_net_rx_poll_fn rx_poll;
+} dkm_net_device_desc;
+
+typedef struct dkm_net_device_info {
+    const char *name;
+    u8 mac[6];
+    u32 flags;
+} dkm_net_device_info;
+
+typedef struct dkm_net_api {
+    int (*register_device)(const dkm_net_device_desc *desc);
+    u32 (*device_count)(void);
+    int (*device_info)(u32 index, dkm_net_device_info *out);
+    int (*tx)(u32 index, const void *packet, u32 length);
+    int (*rx_poll)(u32 index, void *buffer, u32 capacity, u32 *out_length);
+} dkm_net_api;
+
+void net_init(void);
+const dkm_net_api *net_get_api(void);
+
+#endif

CODE/UTSM/include/utsm/pckc.h

@@ -0,0 +1,29 @@
+#ifndef UTSM_PCKC_H
+#define UTSM_PCKC_H
+
+#include <utsm/types.h>
+#include <utsm/config.h>
+#include <utsm/uuid.h>
+#include <utsm/crypto.h>
+
+struct utsm_segment_desc;
+
+typedef struct {
+    bool valid;
+    u32 segment_slot;
+    u64 key_epoch;
+    utsm_key_material key;
+} utsm_pckc_entry;
+
+typedef struct {
+    uuid128_t current_process_uuid;
+    utsm_pckc_entry entries[UTSM_MAX_PCKC_KEYS];
+    u64 hit_count;
+    u64 miss_count;
+    u32 next_replace;
+} utsm_pckc;
+
+void utsm_pckc_init(void);
+int utsm_pckc_get_or_derive(u32 segment_slot, struct utsm_segment_desc *desc, utsm_key_material *out_key);
+
+#endif

CODE/UTSM/include/utsm/process.h

@@ -0,0 +1,18 @@
+#ifndef UTSM_PROCESS_H
+#define UTSM_PROCESS_H
+
+#include <utsm/types.h>
+#include <utsm/uuid.h>
+
+typedef struct utsm_process_context {
+    uuid128_t process_uuid;
+    u64 crypto_epoch;
+    u64 recovery_generation;
+    u32 capability_table_slot;
+    u32 capability_count;
+    u32 flags;
+} utsm_process_context;
+
+void utsm_process_create_test(utsm_process_context *process, u64 seed);
+
+#endif

CODE/UTSM/include/utsm/segment.h

@@ -0,0 +1,50 @@
+#ifndef UTSM_SEGMENT_H
+#define UTSM_SEGMENT_H
+
+#include <utsm/types.h>
+#include <utsm/uuid.h>
+#include <utsm/status.h>
+#include <utsm/capability.h>
+#include <utsm/dirty.h>
+
+typedef enum {
+    UTSM_SEG_FREE = 0,
+    UTSM_SEG_ACTIVE,
+    UTSM_SEG_CHECKPOINTING,
+    UTSM_SEG_SEALED,
+    UTSM_SEG_RECOVERING,
+    UTSM_SEG_POISONED,
+    UTSM_SEG_DESTROYED
+} utsm_segment_state;
+
+#define UTSM_SEG_F_READ            (1U << 0)
+#define UTSM_SEG_F_WRITE           (1U << 1)
+#define UTSM_SEG_F_EXEC            (1U << 2)
+#define UTSM_SEG_F_DMA             (1U << 3)
+#define UTSM_SEG_F_STRONG_RECOVERY (1U << 4)
+
+typedef struct utsm_segment_desc {
+    uuid128_t segment_uuid;
+    uuid128_t owner_process_uuid;
+    u8 *cipher_base;
+    u64 cipher_length;
+    void *dmp_base;
+    u64 key_epoch;
+    u64 tweak_seed;
+    utsm_dirty_shard *dirty_shards;
+    u32 dirty_shard_count;
+    void *mac_table;
+    u32 generation;
+    u32 flags;
+    u32 state;
+    u32 last_cpu;
+    volatile u64 writer_seq;
+    u64 checkpoint_generation;
+} utsm_segment_desc;
+
+struct utsm_process_context;
+
+int utsm_create_segment(struct utsm_process_context *process, u64 size, u32 flags, utsm_capability *out_cap);
+utsm_segment_desc *utsm_get_segment(u32 slot);
+
+#endif

CODE/UTSM/include/utsm/status.h

@@ -0,0 +1,18 @@
+#ifndef UTSM_STATUS_H
+#define UTSM_STATUS_H
+
+typedef enum {
+    UTSM_OK = 0,
+    UTSM_ERR_INVALID = -1,
+    UTSM_ERR_NO_MEMORY = -2,
+    UTSM_ERR_ACCESS = -3,
+    UTSM_ERR_BOUNDS = -4,
+    UTSM_ERR_STALE_CAP = -5,
+    UTSM_ERR_EPOCH = -6,
+    UTSM_ERR_KEY_MISS = -7,
+    UTSM_ERR_STATE = -8,
+    UTSM_ERR_POISONED = -9,
+    UTSM_ERR_RETRY = -10
+} utsm_status;
+
+#endif

CODE/UTSM/include/utsm/types.h

@@ -0,0 +1,36 @@
+#ifndef UTSM_TYPES_H
+#define UTSM_TYPES_H
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long long u64;
+
+typedef signed char i8;
+typedef signed short i16;
+typedef signed int i32;
+typedef signed long long i64;
+
+typedef u64 usize;
+typedef i64 isize;
+
+typedef int bool;
+#define true 1
+#define false 0
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define UTSM_UNUSED(x) ((void)(x))
+#define UTSM_ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))
+
+static inline u64 utsm_align_up_u64(u64 value, u64 alignment) {
+    return (value + alignment - 1ULL) & ~(alignment - 1ULL);
+}
+
+static inline void *utsm_align_up_ptr(void *ptr, u64 alignment) {
+    return (void *)utsm_align_up_u64((u64)ptr, alignment);
+}
+
+#endif

CODE/UTSM/include/utsm/utrw.h

@@ -0,0 +1,12 @@
+#ifndef UTSM_UTRW_H
+#define UTSM_UTRW_H
+
+#include <utsm/types.h>
+#include <utsm/status.h>
+#include <utsm/capability.h>
+
+int utsm_read(utsm_capability cap, u64 offset, void *dst, u64 len);
+int utsm_write(utsm_capability cap, u64 offset, const void *src, u64 len);
+int utsm_slow_path(int reason);
+
+#endif

CODE/UTSM/include/utsm/utsm.h

@@ -0,0 +1,16 @@
+#ifndef UTSM_H
+#define UTSM_H
+
+#include <utsm/types.h>
+#include <utsm/status.h>
+#include <utsm/config.h>
+#include <utsm/uuid.h>
+#include <utsm/process.h>
+#include <utsm/segment.h>
+#include <utsm/capability.h>
+#include <utsm/utrw.h>
+
+void utsm_init(void);
+int utsm_selftest_run(void);
+
+#endif

CODE/UTSM/include/utsm/uuid.h

@@ -0,0 +1,22 @@
+#ifndef UTSM_UUID_H
+#define UTSM_UUID_H
+
+#include <utsm/types.h>
+
+typedef struct {
+    u64 hi;
+    u64 lo;
+} uuid128_t;
+
+static inline uuid128_t uuid_make_test(u64 seed) {
+    uuid128_t id;
+    id.hi = 0x5554534d00000000ULL ^ (seed * 0x9e3779b97f4a7c15ULL);
+    id.lo = 0x4453484200000000ULL ^ (seed + 0xd1b54a32d192ed03ULL);
+    return id;
+}
+
+static inline bool uuid_equal(uuid128_t a, uuid128_t b) {
+    return a.hi == b.hi && a.lo == b.lo;
+}
+
+#endif