Winda

MIT 6.S081: Operating System Engineering

Contents · 36

  1. 01-IntroductionIntroduces operating system goals, including hardware abstraction, multiplexing, isolation, sharing, security, performance, and support for diverse applications.
  2. 02-C and gdbC pointer syntax and arithmetic, memory lifetimes, arrays, bitwise operations, casting, and header declarations.
  3. 03-OS organization and system callsIntroduces operating-system organization, focusing on isolation, kernel and user modes, system calls, and their implementation in xv6.
  4. 03-OS organization and system calls
  5. 04-Page tablesIntroduces virtual memory, address spaces, and RISC-V paging hardware, focusing on how page tables support process isolation.
  6. 04-Page tables
  7. 05-Calling conventions and stack frames RISC-VDiscussion of syscall lab experiences, followed by an introduction to how C code is compiled to RISC-V assembly and why assembly and calling conventions matter for traps.
  8. 05-Calling conventions and stack frames RISC-V
  9. 06-Isolation and system call entry/exitExplains the RISC-V transition from user mode to the xv6 kernel during system calls, faults, and interrupts, including register preservation, page-table and stack switching, and security constraints.
  10. 07-Q&A labsReviews staff solutions for the page-table lab, explains virtual-memory debugging challenges and kernel memory layout, and addresses student questions.
  11. 07-Q&A labsMaps page-table entries to physical addresses and lists their flags for the displayed memory regions.
  12. 08-Page faultsExplains how page faults enable dynamic virtual-memory features, including lazy allocation, copy-on-write fork, demand paging, and memory-mapped files.
  13. 08-Page faults
  14. 09-InterruptsInterrupts and trap handling, with a look at real-world memory use, buffer caching, virtual memory, and resident memory on an Athena machine.
  15. 09-Interrupts
  16. 10-Multiprocessors and lockingExplains why operating systems need locks to protect shared data across CPU cores, prevent race conditions, and balance correctness with performance.
  17. 10-Multiprocessors and locking
  18. 11-Thread switchingExplains thread state, why systems use threads, and how xv6 interleaves threads across CPUs.
  19. 12-Q&A labsExplains copy-on-write fork goals, implementation challenges, and an incremental approach to debugging xv6 lab tests.
  20. 13-Sleep and wakeupExplains xv6 thread switching, process-lock rules across context switches, and how these constraints shape sleep/wakeup coordination and prevent lost wake-ups.
  21. 14-File systemsIntroduces file systems’ user-facing features, including hierarchical names and persistence, and previews disk layout, crash safety, and performance.
  22. 14-File systems
  23. 15-Crash recoveryIntroduces crash safety in file systems, focusing on how power failures can leave on-disk data structures inconsistent.
  24. 15-Crash recovery
  25. 16-File system performance and fast crash recoveryExplains ext3 journaling through comparison with xv6, including log structure, transaction commits, crash recovery, and performance tradeoffs.
  26. 17-Virtual memory for applicationsUser-level virtual memory primitives, including page-fault handling and page protection, and their uses in garbage collection, compression, and shared memory.
  27. 17-Virtual memory for applications
  28. 18-OS OrganizationMonolithic kernel design, including its abstractions, portability, resource management, complexity, and tightly integrated subsystems.
  29. 19-Virtual MachinesVirtual machines, host and guest operating systems, and uses such as server consolidation, cloud computing, kernel development, checkpointing, and migration.
  30. 20-Kernels and HLLEvaluates the safety, programmability, and performance trade-offs of writing a production-style UNIX kernel in Go, using the Biscuit kernel as a case study. Covers its design, memory management, implementation, and comparison with C.
  31. 20-Kernels and HLLDiscusses the tradeoffs of writing operating-system kernels in C versus memory-safe languages, and introduces Biscuit as a basis for measuring those costs and benefits.
  32. 21-NetworkingIntroduces LANs, routers, and Internet routing, then explains Ethernet frames, addresses, and packet types.
  33. 22-MeltdownMeltdown exploits speculative CPU behavior to bypass page-table protections and expose kernel memory, undermining user-kernel isolation.
  34. 23-RCULinux RCU for scaling read-heavy shared kernel data, using a linked list to illustrate reader-writer synchronization and the performance costs of locks.
  35. 23-RCUExplains kernel scalability challenges, read-copy-update for read-heavy data, per-CPU reference counters, and scalable commutativity.
  36. 24-Q&ADiscusses follow-on systems courses, ways to explore current systems research, and Linux kernel updates.