rCore Tutorial in single workspace
1.0.0
Just maintain one branch!
Supports direct debugging for Windows!
- Rust environment and Windows Qemu need to be installed
- Of course, Linux also supports it, it is actually cross-platform
The goal of this project is to achieve a complete operating system tutorial that exists in a separate repository and a separate branch.
"One Operating System Tutorial" is defined as a series of chapters used to learn the text and code materials of the operating system. Users can read these chapters in a natural order to gradually understand the development history of the operating system and the technical details of the principle. Therefore, in the subsequent section of this article, users are referred to as students and the use process is referred to as learning.
I assume that students have a good understanding of the Rust language before studying this tutorial, because I hope to try to use the convenience brought by Rust when writing without being constrained by the audience.
I hope that students can focus on Rust and the operating system itself when studying this tutorial. Therefore, tutorials do not require users to be proficient in operating git. git clone is just one of the means to obtain tutorials. There is no essential difference between downloading zip or copying from others (of course, version management is always beneficial); and it will try to cross-platforms. For this reason, some platform-related operations may be needed to add to the build system.
This tutorial does not expect innovation in chapter settings or teaching content , nor is it for experimenting with any new kernel technology, rCore-Tutorial-v3 is excellent enough. This project only focuses on the tutorial construction process and students' learning experience (in other words, if you want to make these two points, it is also acceptable to modify the chapter settings and teaching content). On this basis, I hope to use the Rust mechanism to reduce the amount of code in "construct an operating system" and make library construction standardized and migible.
The textbook department of rCore-Tutorial-v3 has given each chapter a kind of paleobi name, linking the history of the development of the operating system with the history of animal evolution, and bringing novel and interesting to the often boring textbooks. With each chapter, students can learn how a modern kernel has developed step by step from the age of ignorance.
Reading textbooks will bring happiness - the joy of gaining knowledge and progress; reading history will also bring happiness - the joy of those geniuses and stories. However, once the textbook is compared to a real history book, we will find that we seem to be missing something. From ancient times to the present, from simple to traditional - this is a chronicle. Chronicles are straightforward and clear, which is conducive to building concepts, but it is not conducive to understanding a complex character. For operating systems, it is not conducive to understanding the details of a truly modern kernel subsystem. The functions of subsystems are often limited to other related subsystems that do not exist yet and cannot be fully introduced; and when adding a subsystem, the previous subsystem needs to be modified to adapt to the functions of new components. Complex systems either have to be modified multiple times or can only be placed in the following chapters, which leads to tutorials that can be an excellent introduction, but cannot be read frequently and are constantly new.
Fortunately, history has told us about another choice. Chronicles are an important tool for historical research, but what can be called the "masterpiece of historians" is still the style of the Scriptures. Every time you focus your perspective on an important person and use his experience as a clue, it often makes history fuller. Perhaps we need another biography work that introduces the various submodules of the kernel in an disorderly manner, bringing a more effective reference book for kernel researchers who have left the toddler. Such a reference book must naturally require modularity - the module is the chapter itself.
This project still focuses on a better Tutorial. But its modular experience helps other works. If there is such a project, it can be called rCore-Manual, which is a manual for operating system researchers to read at any time. Just as rCore-Tutorial does not need to introduce the original rCore, they are the spiritual sequel to rCore.
This project is not and does not intend to become a model of related work . if you:
Therefore, this project uses WTFPL open source. If you don't like it, you can change the name or delete it directly in your fork, which is supported by itself.
In addition, this project is experimental. This means it is subject to design changes, disruptive refactoring, moving, abandonment or deletion at any time.
cargo qemu --ch <n>
Run the operating system in Chapter n in qemu.
Optional parameters:
--lab is only valid for ch1, execute ch1-lab--features <features> is valid only for ch3, pass features=coop 
