2026-01-08
An analysis of the mainline Linux watchdog subsystem and the Samsung SoC s3c2410_wdt driver, from register level up to PMU integration.
2024-11-30
A capstone project on a fuzzer that uses an IoT router's power consumption as coverage feedback — LSTM caught the requests, but turning power into a coverage signal was where it fell short.
2024-10-15
Concepts I pinned down while building a STIX-based CTI visualizer for Incognito 2024: what CTI is, why a standard like STIX is needed, and how SDOs, SROs, and SCOs turn threats into a graph.
2024-10-06
Building the chat server, then implementing block_on and spawn_blocking by hand to get at wakers and Pin — and when async is actually worth it.
2024-10-05
Why go async at all, what futures and async/await really are, block_on and spawning tasks, where the Send bound comes from, and building a chat client.
2024-09-22
Pattern matching and repetition in macro_rules!, fragment types, hygiene, and building a json! macro from scratch.
2024-09-21
Three approaches — fork-join, channels, shared mutable state — what Send and Sync actually do, and an assignment parallelizing the Mandelbrot set four ways.
2024-09-10
A retrospective on the FRRmalloc research I assisted as an undergraduate researcher: combining one-time allocation with remapping to stop Use-After-Free while keeping memory overhead low.
2024-08-18
Closures that borrow versus closures that steal, what separates Fn/FnMut/FnOnce, closure performance, and two ways to store callbacks.
2024-07-21
Splitting code into crates and modules, the file layout rules, the levels of pub, and an assignment that breaks a GUI library into modules.
2024-07-20
Two tracks: panic and Result. What the ? operator actually expands to, how to combine several error types, and how to define a custom error type.
2024-07-14
An expression language where nearly everything produces a value: blocks and semicolons, if/match as values, and why Rust has a separate loop keyword.
2024-07-13
Borrowing values, how Rust references differ from C++ ones, how lifetimes check reference safety, and why sharing and mutation are exclusive.
2024-07-07
The ownership tree, everywhere a move happens, moves under control flow and out of indexed content, and shared ownership with Rc/Arc.
2024-07-07
Fixed-size numeric types and four ways to handle overflow, how arrays, vectors and slices differ, and the relationship between String and &str.
2024-07-06
Ownership, borrowing and lifetimes, traits, Option/Result, Copy vs Clone — one lap around how Rust gets memory safety without a garbage collector.
2024-07-06
The start of my notes on the Rust + Linux Kernel lecture series at HSPACE in summer 2024 — books, format, and setting up the toolchain.
2024-01-20
A commissioned research project I joined as an undergraduate researcher — applying angr's symbolic execution to C, C#, Delphi, and Go binaries, and the problems I ran into.
2023-11-27
Parsing a SQLite file by hand in a hex editor to find an orphaned page detached from the B-tree, then following the overflow page chain to recover both a deleted record and its JPEG.
2023-11-26
A forensics challenge where the flag is assembled from a leftover PDB path, the PE debug directory's TimeDateStamp, and the entropy of the .text section — all pulled out of an executable hidden inside a PPTX.
2023-06-16
Project 3. Adding double and triple indirect blocks to the inode to grow the maximum file size, implementing symbolic links, and moving from per-transaction commits to committing when the buffer fills.
2023-05-29
Project 2. Adding a tgid to struct proc to get threads, a freelist that recycles their stacks, and redefining fork, exec, sbrk, kill, and exit for a threaded world.
2023-05-18
Three memory-management topics from the labs: best/first/worst fit, FIFO versus LRU versus LFU, and copy-on-write.
2023-05-14
Project 1. Reading the existing Round Robin scheduler first, then a three-level L0/L1/L2 MLFQ with priority boosting and a schedulerLock callable through an interrupt.
2023-05-02
Following the path from user mode into kernel mode in xv6 — int n, the IDT and tvinit, CPL and DPL, alltraps — and finishing with the boot sequence.
2023-04-25
From race conditions to the three critical-section conditions, Peterson's algorithm, TAS and Swap, semaphores and block/wakeup, and the three places it bites inside the kernel.
2023-04-23
From FCFS and the convoy effect through SJF and SRTF, exponential averaging, the upper bound Round Robin buys you, and on to MLQ and MLFQ.
2023-04-20
A process's address space and five states, PCBs and queues and schedulers, context switching, and then fork/exec and threads.
2023-04-18
Multiprogramming versus multitasking, dual mode and system calls, and what the OS actually does for processes, memory, storage, and I/O.
2023-04-16
Starting from registers and the fetch-execute cycle: why interrupts exist, and what caches and DMA take off the CPU's hands.
2023-04-14
The start of my notes on the operating systems course I took in my third year — lectures, labs, and three xv6 projects, and how I'm splitting them up.