+  DragonOS is a 64-bit operating system with a completely independent kernel, designed for lightweight cloud computing scenarios, offering Linux binary compatibility. It aims to provide lightweight, high-performance solutions for containerized workloads. Developed using Rust for enhanced reliability.
-仔细阅读 [DragonOS社区介绍文档] ,能够帮助你了解社区的运作方式,以及如何参与贡献!
+  The DragonOS open-source community was established in July 2022 and is entirely commercially neutral. We warmly welcome interested developers and enthusiasts to join us!
+  DragonOS features excellent and comprehensive architectural design. Compared to other systems of similar scale, DragonOS supports eBPF and virtualization. Currently, we are actively advancing container support, cloud platform compatibility, RISC-V support, as well as porting compilers and application software. Our goal is to achieve large-scale production environment deployment within five years.
+  DragonOS is rapidly evolving under community-driven development. Currently, DragonOS has implemented approximately 1/4 of Linux interfaces. In the future, we will provide 100% Linux compatibility along with new features.
+Read the [DragonOS Community Introduction Document] carefully to understand how the community operates and how you can contribute!
+  If you'd like to join us, check out the issues and participate in discussions or share your ideas. You can also visit the DragonOS forum to stay updated on development progress and tasks: [https://bbs.dragonos.org.cn](https://bbs.dragonos.org.cn)
-## 如何运行?
+  You can also bring your creativity and ideas to discuss with the community and contribute new features to DragonOS.
+- You can find contact details for members of various committees in the [Community Management Team] section.
+- You can also locate the contact information for leaders of specific community groups via the [SIGs] and [WGs] pages.
+## Contributor List
[Contributors to DragonOS-Community/DragonOS · GitHub](https://github.com/DragonOS-Community/DragonOS/graphs/contributors)
[Contributors to DragonOS-Community/DragonOS · GitHub](https://github.com/DragonOS-Community/DragonOS/graphs/contributors)
+## Sponsorship
+[](https://dragonos.org/?page_id=37)
+  DragonOS is a non-profit open-source project, and its development relies on financial support. All sponsors will be publicly acknowledged. Every contribution you make will help advance DragonOS!
+This project is open-sourced under the GPLv2 license. You are welcome to use the code in compliance with the open-source license!
-本项目采用GPLv2协议进行开源,欢迎您在遵守开源协议的基础之上,使用本项目的代码!
+If you encounter any violations of the open-source license, we encourage you to email pmc@dragonos.org to report them. Let's work together to build a trustworthy open-source community.
+[Contributors to DragonOS-Community/DragonOS · GitHub](https://github.com/DragonOS-Community/DragonOS/graphs/contributors)
+
+## 赞助
+
+[](https://dragonos.org/?page_id=37)
-  DragonOS is a 64-bit operating system designed for lightweight cloud computing scenarios, featuring a fully independent kernel and offering Linux binary compatibility. Developed using the Rust programming language, it aims to provide improved reliability. In the Rust operating system domain, DragonOS consistently ranks among the top three on GitHub nationally.
-
-  The DragonOS open-source community was established in July 2022 and is entirely business-neutral. Our goal is to build a fully independent, open-source, high-performance, and highly reliable server operating system, fostering a digitally autonomous and controllable future!
-
-  DragonOS boasts an excellent and comprehensive architecture design. Compared to other systems of similar scale, DragonOS supports virtualization and has certain advantages in terms of device model and调度子系统 (scheduler subsystem).Currently, significant efforts are being made to promote cloud platform support, RISC-V compatibility, and the porting of compilers and application software. The aim is to achieve large-scale application in production environments within five years.
-
-  Driven by the community, DragonOS is currently evolving rapidly. DragonOS has already implemented about 1/4 of Linux interfaces, and in the future, we will strive to provide 100% compatibility with Linux, along with new features.
-
-
-## Get Involved in Development?
-
-Carefully read the [DragonOS Community Introduction Document] to understand how the community operates and how you can contribute!
-
-- **To stay updated on development news and tasks, visit the DragonOS Community Forum**: [https://bbs.dragonos.org.cn](https://bbs.dragonos.org.cn)
-- You can also learn about the development progress by checking the project's issues.
-
-  If you're interested in joining us, you can check out the issues and post your discussions or ideas under them, or visit the DragonOS forum to learn about development updates and tasks: [https://bbs.dragonos.org.cn](https://bbs.dragonos.org.cn)
-
-  You're also welcome to bring your creative ideas and discuss them with the community members, working together to create new features for DragonOS.
-- Community Introduction Document: [community.dragonos.org](https://community.dragonos.org)
-
-## How to Run?
-
-  Running DragonOS is quite straightforward. You can refer to the following resources and get DragonOS up and running in as little as 15 minutes!
-
-- [Building DragonOS — DragonOS Development Documentation](https://docs.dragonos.org/zh_CN/latest/introduction/build_system.html)
-
-## How to Connect with the Community?
-
-Please read the [Contributor Guide](https://community.dragonos.org/contributors/#%E7%A4%BE%E5%8C%BA)~
-
-- You can establish contact with the members of various committees through the [Community Management Team] information.
-- Additionally, you can find the contact information of the respective community group leaders via the [SIGs] and [WGs] pages.
-
-
-## Reward
-
-  DragonOS is an open source public welfare project, but its development cannot be separated from the support of funds. If you want, you can visit **[Sponsor - DragonOS](https://dragonos.org/?page_id=37)** , so as to promote the development of this project. The list of all sponsors will be published. Every bit of your sponsorship will contribute to the development of DragonOS!
-
-### Where will the sponsorship funds be used?
-
-We guarantee that all sponsorship funds and items will be used for:
-
-- Subsidies or equipment support for active community developers
-- Cloud service expenditure of DragonOS
-- Equipment purchase
-- Any use conducive to the development and construction of DragonOS
-
-### Sponsor List
-
-**Not yet**
-
-- **[China YaCloud](https://yacloud.net)** Ya'an Digital Economy Operations Co., Ltd. provides cloud server support for DragonOS.
-  This project adopts GPLv2 LICENSE for open source. You are welcome to use the code of this project on the basis of abiding by the open source license!
-
-**What we support:** using this project to create greater value and contribute code to this project under the condition of abiding by the agreement.
-
-**What we condemn**: any non-compliance with the open source license. Including but not limited to: plagiarizing the code of the project as your graduation project and other academic misconduct, as well as commercial closed source use without payment.
-
-If you find any violation of the open source license, we welcome you to send email feedback! Let's build an honest open source community together!
-
-[DragonOS Community Introduction Document]: https://community.dragonos.org/
+Thank you to the following individuals and organizations for supporting this project! Whether through code contributions, issue feedback, or financial sponsorship, your support makes this project better.
+
+> *"Open source shines because of you!"* ✨
+---
+
+## 🌟 Sponsors
+
+**Special thanks to these generous financial supporters** (in reverse chronological order):
+
+[](https://dragonos.org/?page_id=37)
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# V0.1.0
+
+:::{note}
+Author of this document: Longjin <longjin@RinGoTek.cn>
+
+November 6, 2022
+:::
+
+## Preface
+
+  DragonOS has been under development since January 15, 2022, and has now gone through nearly 300 days. In these many days and nights, it's hard to count how much time has been spent on DragonOS development. I have basically given all my free time to DragonOS, and the estimated total working hours have already exceeded 1000 hours. It feels very rewarding to be able to release the first version.
+
+  Since July 2022, a number of friends and mentors from six universities or companies have joined the development of DragonOS. I was very happy about this. I think, with everyone's joint efforts, we can create an operating system that is truly practical! We have held 14 discussion meetings. I believe, with everyone's joint efforts, in the future, we will be able to create an independent, open, server-oriented open-source operating system that can be used in production environments.
+
+  Although DragonOS is currently just a toy-level operating system, it's "only slightly more difficult than a undergraduate graduation project." However, please don't underestimate it. Its internal architecture design targets Linux 5.18 and later distributions. Although it has not yet reached the level of Linux, we are working hard to catch up. Thanks to the relevant resources of Linux, DragonOS has learned a lot of design ideas from Linux during its architecture design. The related components have considered scalability and portability as much as possible.
+
+  A journey of a thousand miles begins with a single step. The release of DragonOS V0.1.0 is a new beginning. **I hope, in the next ten years, we can work together with many partners, and by 2032, build DragonOS into a practical, widely used open-source operating system in the server field!**
+
+  **A hundred boats race, the ones who row first win; in the middle stream, the brave win.** I believe, with the continuous efforts of the community developers in the coming time, our goal will become a reality!
+
+## Special Thanks
+
+  At the time of the release of DragonOS V0.1.0, I would like to express my sincere gratitude to my teachers, predecessors, and school!
+
+- **Teacher Yao Zhicheng from Dali Town Central Primary School, Nanhai District, Foshan City**: You are the guide who introduced me to computers and taught me programming. Ten years ago, when we talked, you said, "Our country currently does not have an independent and mature operating system." This sentence planted the seed of my dream. You cultivated my love for computers, so I chose the major of software engineering. Thank you for your guidance back then, I will never forget your kindness!
+
+- **Shimen Experimental School, Nanhai District, Foshan City**: During the three years I studied at Shimen Experimental School, I am very grateful for the school's "Strength-based Education" philosophy. Under the guidance of the teachers, I was able to fully develop my personality and talents, and achieved good results. During the three years at Shimen Experimental School, I learned C++, Java, and simple algorithms, and I developed several Android apps, accumulating nearly 6,000 lines of code.
+
+- **Shimen Middle School, Nanhai District, Foshan City**: "The road is long and the task is heavy, never forget to strive" is the school motto of Shimen Middle School. I think this motto should also become the motto of each new generation of youth. During the three years at Shimen Middle School, the education of national sentiment had a great impact on me. I think, as new generation of youth, we should shoulder the responsibility of the times, strive hard, and work for the development of the country, the strength of the nation, and the future of humanity!
+
+- **South China University of Technology**: "Broad learning, careful thinking, clear discernment, and firm action" – at SCUT, I received further learning and development. I broadened my horizons, learned to communicate with many people. Moreover, in the School of Software, I met a group of conscientious and responsible teachers. I am very grateful for the support of the school, which supported us in establishing the project group. I believe, with the support of the school, DragonOS can achieve better development and go further!
+
+- **Professor Wang Guohua from the School of Software, South China University of Technology**: Professor Wang is my teacher for the course "Operating System". Under her guidance, I gained a deeper understanding of the principles of operating systems, and participated in the "Pan-Delta+ University Students' Computer Works Competition". In the Guangdong provincial selection in June 2022, DragonOS won the first prize and the Best Innovation Award.
+
+- **Professor Tang Feng from the School of Software, South China University of Technology**: Professor Tang is our project group's on-campus mentor. Under her careful guidance, we will continue to move forward, keep our direction, and continuously build an open-source community. I sincerely thank Professor Tang for her guidance!
+
+- **[Yaotian Feng](https://github.com/Codetector1374)**: I met this very capable person on Bilibili. He answered many of my questions. Many times, after I had debugged for several days without any idea, a few words from him would wake me up and help me find the path to solve the problem. He also shared with me the places where I might fall into traps, allowing me to have a psychological expectation when about to fall into a trap, so I wouldn't feel so uncomfortable, ha ha.
+
+## Contributors List
+
+The release of DragonOS V0.1.0 could not have been achieved without the joint efforts of the following friends:
+
+- Longjin <longjin@RinGoTek.cn>
+- zzy666-hw <zzy666@mail.ustc.edu.cn>
+- Guan Jinquan <guanjinquan@DragonOS.org>
+- Zhou Yuzhe <zhouyuzhe@DragonOS.org>
+- kkkkkong <kongweichao@DragonOS.org>
+- houmkh <jiaying.hou@qq.com>
+- wang904 <1234366@qq.com>
+- Liric Mechan <i@liric.cn>
+- Mustang <handsomepd@qq.com>
+- Eugene <caima12138@foxmail.com>
+- kun <1582068144@qq.com>
+- zhujikuan <1335289286@qq.com>
+- Alloc Alice <1548742234@qq.com>
+
+## Sponsors List
+
+Thank you to the following students for their donations. We will keep working hard!
+
+- TerryLeeSCUT
+- Wu
+- slientbard
+
+## Kernel
+
+### Some Standards and Specifications Followed
+
+- Bootloader: Multiboot2
+- System Interface: POSIX 2008
+
+### Hardware Architecture
+
+- Currently supports running on x86-64 architecture processors
+
+### Bootloader
+
+- Uses Grub 2.06 as the bootloader
+
+### Memory Management
+
+- Implemented a bitmap-based page allocator
+- Implemented a slab allocator for allocating small, aligned memory blocks
+- Abstracted VMA (Virtual Memory Area)
+- Implemented VMA reverse mapping mechanism
+- Implemented MMIO address space auto-mapping mechanism
+
+### Multi-core
+
+- Supports multi-core boot. That is, after DragonOS starts, it will start the AP processor. However, to simplify the implementation of other kernel modules, currently, there are no tasks running on the AP processor.
+- Roughly implemented the IPI (Inter-Processor Interrupt) framework
+
+### Process Management
+
+- Supports process creation and recycling
+- Kernel threads
+- Kthread mechanism
+- User-space and kernel-space process/thread fork/vfork (note that user-space fork and kernel-space fork have some differences; kernel-space fork is more complex)
+- exec allows a process to execute a new executable file
+- Process timer sleep (sleep) (supports high-precision sleep with spin/rdtsc, supports sleep via context switching)
+
+### Synchronization Primitives
+
+- spinlock spin lock
+- mutex mutex
+- atomic atomic variable
+- wait_queue wait queue
+- semaphore semaphore
+
+### Scheduling Related
+
+- CFS scheduler
+- Single-core scheduling (multi-core load balancing is temporarily not supported)
+- completion "completion" mechanism, allowing a process to wait for a task to complete
+
+### IPC (Inter-Process Communication)
+
+- Anonymous pipe
+
+### File System
+
+- Basic functionality of the VFS virtual file system
+- FAT32 file system (does not support deleting folders)
+- devfs device file system. Currently, only the keyboard file is registered.
+- rootfs root file system, provides support for other pseudo-file systems before the real disk file system is mounted
+- Mount point abstraction. Currently, file system mounting is implemented, and all mount points are managed in a stack-like manner (optimization is needed in the future)
+
+### Exception and Interrupt Handling
+
+- Handling of processor exceptions
+- Support for APIC
+- Softirq soft interrupt mechanism
+- Ability to trace the kernel stack
+
+### Kernel Data Structures
+
+- Ordinary binary tree
+- kfifo first-in-first-out buffer
+- Circular linked list
+- IDR mapping data structure
+- IDA ID allocation data component
+
+### Screen Display
+
+- VESA VBE display chip driver
+- Implemented a screen manager, supporting multiple display frameworks to be registered with the screen manager
+- Implemented a TextUI text interface framework, capable of rendering text to the screen. Also reserves support for scrollable pages and multiple display windows
+- printk
+
+### Kernel Utility Library
+
+- String operation library
+- ELF executable file support component
+- Basic math library
+- CRC function library
+
+### Software Portability
+
+- Ported the LZ4 compression library (V1.9.3), laying the foundation for future page compression mechanisms
+
+### Kernel Testing
+
+- ktest unit test framework
+- Supports outputting screen content to a file via serial port (COM1)
+
+### Driver Support
+
+- IDE hard disk
+- AHCI hard disk (SATA Native)
+- ACPI Advanced Power Configuration module
+- PCI bus driver
+- XHCI host controller driver (USB 3.0)
+- PS/2 keyboard
+- PS/2 mouse
+- HPET high-precision timer
+- RTC clock
+- Local APIC timer
+- UART serial port (supports RS-232)
+- VBE display
+- Virtual tty device
+
+### System Calls
+
+DragonOS currently has a total of 22 valid system calls.
+
+- SYS_PUT_STRING Print characters to the screen
+- SYS_OPEN Open a file
+- SYS_CLOSE Close a file
+- SYS_READ Read from a file
+- SYS_WRITE Write to a file
+- SYS_LSEEK Adjust the file pointer
+- SYS_FORK Fork system call
+- SYS_VFORK Vfork system call
+- SYS_BRK Adjust the heap size to a specified value
+- SYS_SBRK Adjust the heap size by a relative value
+- SYS_REBOOT Reboot (this system call will be removed after sysfs is improved; please do not rely on this system call excessively)
+- SYS_CHDIR Change the working directory of the process
+- SYS_GET_DENTS Get metadata of directory entries
+- SYS_EXECVE Let the current process execute a new program file
+- SYS_WAIT4 Wait for a process to exit
+- SYS_EXIT Exit the current process
+- SYS_MKDIR Create a directory
+- SYS_NANOSLEEP Nanosecond-level sleep (up to 1 second), capable of high-precision sleep when less than 500ns
+- SYS_CLOCK Get the current CPU time
+- SYS_PIPE Create a pipe
+- SYS_MSTAT Get the current memory status information of the system
+- SYS_UNLINK_AT Delete a directory or delete a file link
+
+### Rust Support
+
+- Implemented a simple "hello world" in Rust. Plan to gradually shift to using Rust for development in the next version.
+
+## User Environment
+
+### LibC
+
+  LibC is the bridge between applications and the operating system. DragonOS's LibC implements some simple functions.
+
+- malloc heap memory allocator
+- Basic math library
+- A few simple functions related to files
+- pipe
+- fork/vfork
+- clock
+- sleep
+- printf
+
+### Shell Command Line Programs
+
+- Based on simple string matching parsing (not done through the compilation course's method, so it's simple and crude)
+  You can obtain the source code in the following ways:
+
+### Get via Git
+
+- You can visit [https://github.com/fslongjin/DragonOS/releases](https://github.com/fslongjin/DragonOS/releases) to download the release code and the compiled, runnable disk image.
+- We also have a mirror repository on gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To solve the problem of slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the DragonOS code archive and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source protocol. Everyone who can obtain the DragonOS source code and related software products (including but not limited to binary copies and documents) will enjoy the rights granted by us through the GPLv2 protocol, and you must also comply with the obligations stipulated in the protocol.
+
+This is a rather strict protocol that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most people with good intentions, you will not violate our open source protocol.
+
+We encourage the free spread and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others, nor do they violate the GPLv2 protocol.
+
+Please pay special attention to the fact that those who violate the open source protocol, especially **commercial closed-source use and any plagiarism or academic misconduct**, will be held seriously accountable. (This is the easiest scenario to violate our open source protocol.)
+
+Also, please note that according to the requirements of the GPLv2 protocol, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 protocol and must indicate that it is based on DragonOS. It must also ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must make sure that the DragonOS developers can obtain the source code of your modified version through the same way from public channels, otherwise you will violate the GPLv2 protocol.
+
+For detailed information about the protocol, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 protocol, **only the English original version has legal effect**. Any translated version is for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, some open source projects' designs were referenced, or parts of their code were introduced, or they were inspired by them. Below are the list of these open source projects. We sincerely thank the contributors of these open source projects!
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# V0.1.1
+
+:::{note}
+Author: Longjin <longjin@RinGoTek.cn>
+
+November 27, 2022
+:::
+
+## Contributors List
+
+The DragonOS V0.1.1 version was contributed by the following team members:
+
+- Longjin <longjin@RinGoTek.cn>
+- Zhou Yuzhe <zhouyuzhe@DragonOS.org>
+
+## Sponsors List
+
+Thank you to the following individuals for their support. We will continue to strive for excellence!
+
+- David Wen
+- TerryLeeSCUT
+- Wu
+- slientbard
+
+Among them, we are especially grateful to **David Wen** for his sponsorship of RMB 1000 to the DragonOS project! We will carefully record each donation and ensure that it is used appropriately.
+
+## Update Content - Kernel
+
+- Added Rust FFI (#_translated_label__77_en)
+- Ported kmalloc and printk to Rust
+- Rust macros for kdebug, kinfo, kwarn, kBUG, kerror
+- Bugfix: Fixed the issue where the process PCB was not removed from the list when it was reclaimed
+- Directory structure optimization: Moved asm.h and cmpxchg.h
+- Signal sending
+- procfs: View process status
+- Resolved the issue of disk image permission errors during the first compilation
+- Moved fork-related code to fork.c
+
+## Update Content - User Environment
+
+- Shell: Added the kill command, which can send signals to a target process. However, since the signal mechanism is still not fully implemented, the target process cannot currently respond to this signal.
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can download the release code and the compiled, runnable disk image from [https://github.com/fslongjin/DragonOS/releases](https://github.com/fslongjin/DragonOS/releases).
+- We also have a mirror repository on Gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To address the slow and unstable access to GitHub in China, and to make it easier for developers to download the code for each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the compressed package of DragonOS code and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documentation) will enjoy the rights granted by us through the GPLv2 license, and you must also comply with the obligations stipulated in the agreement.
+
+This is a rather strict license that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others or violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source use and any plagiarism or academic misconduct**, will be subject to serious accountability. (This is the most common scenario where the open source license is violated.)
+
+Also, please note that according to the requirements of the GPLv2 license, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must clearly indicate that it is based on DragonOS. It is also necessary to ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must make it possible for the developers of DragonOS to obtain the source code of your modified version through public channels, otherwise you will violate the GPLv2 license.
+
+For detailed information about the agreement, please read the **LICENSE** file in the project root directory. Please note that according to the requirements of the GPLv2 license, **only the English original version is legally binding**. Any translated version is for reference only.
+:::
+
+### Open Source Software Usage
+
+  During the development of DragonOS, we have referenced the design of some open source projects, or introduced parts of their code, or been inspired by them. Below is a list of these open source projects. We sincerely thank the contributors of these open source projects!
+- fix(riscv): Changed kernel compilation target to riscv64gc, obtained time csr frequency, and fixed assembly issues with floating point save and restore (#_translated_label__699_en)
+- chore: Adapt to dadk 0.1.11 (#_translated_label__777_en)
+- fix(libs/lib_ui): Fixed display errors when system initializes (#_translated_label__779_en)
+- fix(riscv/process): Synchronized riscv's scheduling clock tick rate with HZ, and fixed the bug of forgetting to disable interrupts in kernel mode when switching to user mode (#_translated_label__780_en)
+- fix: (riscv/timer): Fixed bug where riscv did not update wall clock and did not handle soft interrupts (#_translated_label__783_en)
+- ci: update the match regex of issue checker (#_translated_label__784_en)
+- ci: Added one-click installation script for Gentoo system (#_translated_label__809_en)
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Through Git
+
+- You can access the DragonOS repository to get the source code: [https://github.com/DragonOS-Community/DragonOS](https://github.com/DragonOS-Community/DragonOS)
+- You can download the release code from [https://github.com/DragonOS-Community/DragonOS/releases](https://github.com/DragonOS-Community/DragonOS/releases).
+
+### Through DragonOS Software Mirror Site
+
+  To address the slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the DragonOS source code archive and the compiled and runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documentation) can enjoy the rights granted by us through the GPLv2 license, while you also need to comply with the obligations stipulated in the agreement.
+
+This is a rather strict agreement that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe upon the legitimate rights and interests of others or violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source usage and any plagiarism or academic misconduct**, will be subject to serious accountability. (This is the most common scenario where the open source license is violated.)
+
+Also, please note that according to the requirements of the GPLv2 license, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must clearly indicate that it is based on DragonOS. It is also necessary to ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must make sure that DragonOS developers can obtain the source code of your modified version through public channels in the same way, otherwise you will violate the GPLv2 license.
+
+For detailed information about the agreement, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 license, **only the English original version has legal effect**. Any translated version is for reference only.
+:::
+
+### Open Source Software Usage
+
+  During the development of DragonOS, we have referenced some designs from the Linux community, or introduced parts of their ideas, or been inspired by them. We would like to express our sincere gratitude to the Linux community and its contributors here!
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# V0.1.2
+
+:::{note}
+Author: Long Jin <longjin@RinGoTek.cn>
+
+December 17, 2022
+:::
+
+## Contributors
+
+The DragonOS V0.1.2 version has been contributed by the following developers:
+
+- Long Jin <longjin@ringotek.cn>
+- Wu Yujian <wuyujian@DragonOS.org>
+- Gou Ngai <sujintao@DragonOS.org>
+- Huang Ting <huangting@DragonOS.org>
+- Wang Wencong <1297389017@qq.com>
+
+## Sponsors
+
+Thank you to the following individuals for their support. We will continue to strive hard!
+
+- David Wen
+- [Seele.Clover](https://github.com/seeleclover)
+- TerryLeeSCUT
+- Wu
+- slientbard
+
+Among them, we are especially grateful to **Seele.Clover** for contributing RMB 500 to the DragonOS project! We will carefully record every sponsorship and ensure that it is used appropriately.
+ - Currently only supports the old version of sighandler, i.e., signal handler functions with only one parameter of type `void handler(int signum)`. The other type of signal handler function `void handler(int signum, siginfo_t *info, void* data)` does not currently support passing the third parameter.
+- Add a custom stdint.h file in the kernel code (#_translated_label__109_en)
+- Adjust the script for compiling grub (#_translated_label__108_en)
+- Add 32-bit and 64-bit UEFI boot support (#_translated_label__105_en)(#_translated_label__101_en)
+- Use compiled installed grub-2.06 to solve the problem of compilation failure due to incorrect grub version on the client.
+- Add a timekeeping module (#_translated_label__106_en)
+- Bugfix: Fix the issue where the rtc clock forgot to process the day field when converting to BCD code (#_translated_label__104_en)
+- New: Development process documentation (completed half)
+- bootstrap.sh solves the problem of slow rust download
+- Update the "Build System" documentation
+- procfs->status adds display of preempt and virtual runtime (#_translated_label__100_en)
+- ffz function: get the first bit that is 0 in a u64 (#_translated_label__100_en)
+- Solve the problem of local_irq_restore not being able to get the correct rflags value due to compiler optimization
+- Refactor the serial port driver using Rust (#_translated_label__99_en)
+
+## Update Content - User Environment
+
+- about app: Display the current git commit sha1 and build time (#_translated_label__114_en)
+- shell: Fix the error in the shell's exec command when concatenating absolute paths (#_translated_label__114_en)
+- shell: Add "&" background execution option for the exec command (#_translated_label__100_en)
+- New: Test app for signal
+- Adjust the libc directory and add cargo as the Rust package manager
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can download the release code and the compiled, runnable disk image from [https://github.com/fslongjin/DragonOS/releases](https://github.com/fslongjin/DragonOS/releases).
+- We also have a mirror repository on gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To solve the problem of slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the DragonOS source code package and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documents) can enjoy the rights granted by us through the GPLv2 protocol, while you also need to comply with the obligations stipulated in the protocol.
+
+This is a rather strict protocol that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source protocol.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others or violate the GPLv2 protocol.
+
+Please pay special attention to the fact that violations of the open source protocol, especially **commercial closed-source use and any plagiarism or academic misconduct**, will be subject to serious accountability. (This is the easiest scenario to violate our open source protocol.)
+
+Also, please note that according to the requirements of the GPLv2 protocol, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 protocol and clearly indicate that it is based on DragonOS. It must also ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must make sure that the developers of DragonOS can obtain the source code of your modified version through public channels in the same way, otherwise you will violate the GPLv2 protocol.
+
+For detailed information about the protocol, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 protocol, **only the English original version is legally binding**. Any translated version is for reference only.
+:::
+
+### Open Source Software Usage
+
+  During the development of DragonOS, we have referenced some open source projects' designs, or introduced parts of their code, or been inspired by them. We list them below. We sincerely thank the contributors of these open source projects!
+- arch: update: Change the path of the arch module in lib.rs, so that other modules can use the code in arch without specifying arch::x86_64 (#_translated_label__128_en)
+- mm: bugfix: Fix the bug where ZONE_NORMAL_INDEX was always 0 during initialization of the page allocator (#_translated_label__129_en)
+- scheduler: new: Refactor CFS scheduler using Rust (#_translated_label__131_en)
+- smp: Remove the HPET interrupt forwarding function that has been deprecated in smp (#_translated_label__131_en)
+- process: bugfix: Fix the issue where the init process forgot to set the fs and gs registers. (#_translated_label__132_en)
+- vfs: update: Rename the VFS folder to vfs (#_translated_label__133_en)
+- lockref: new: Add Rust version of lockref (#_translated_label__135_en)
+- cpu: new: Rust wrapper for cpu_relax(), using the pause instruction to let the CPU rest for a while, reducing idle power consumption. (#_translated_label__135_en)
+- Refactor softirq mechanism using Rust (#_translated_label__138_en)
+
+## Update Content - User Environment
+
+- libc: bugfix: Always register sigkill when registering signal handlers (#_translated_label__120_en)
+- libc: new: Simply add `fopen()` for handling the mode parameter. Please note that it does not fully comply with POSIX, and is inconsistent with Linux. It will be improved when using Rust in the future. (#_translated_label__141_en)
+- Porting: new: Add porting and build scripts for gmp, mpfr, and mpc (#_translated_label__136_en)
+- Porting: new: Add cross-compilation build scripts for gcc and binutils, as well as patches for gcc-11.3.0 and binutils-2.38 (in the DragonOS-community repository) (#_translated_label__136_en)
+- compile: update: Update the include path for the compiler, so that includes do not need the `<libc/src/include/>` prefix (#_translated_label__124_en)
+
+## Update Content - Others
+
+- bugfix: Fix the bug where Docker installation would exit abnormally (#_translated_label__116_en)
+- new: Add a new GCC bare-metal compiler targeting x86_64-elf, and use it to compile DragonOS (#_translated_label__111_en)
+- update: Update the Docker build image to version `dragonos/dragonos-dev:v1.2`, and support building this build image from a Dockerfile (#_translated_label__111_en)
+- bugfix: Fix the bug where the MBR disk image did not set the boot flag (#_translated_label__111_en)
+- update: Update the GitHub workflow, add cache, and speed up build checks
+- bugfix: Fix the error message when downloading grub2.06 (#_translated_label__125_en)
+- new: mpc 1.2.1, (can be ported without applying patches), repository: [https://github.com/DragonOS-Community/mpc](https://github.com/DragonOS-Community/mpc)
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can download the release code and the compiled, runnable disk image from [https://github.com/fslongjin/DragonOS/releases](https://github.com/fslongjin/DragonOS/releases).
+- We also have a mirror repository on Gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To address the slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the DragonOS source code archive and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documentation) can enjoy the rights granted by us through the GPLv2 protocol, while you also need to comply with the obligations stipulated in the protocol.
+
+This is a rather strict protocol that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others or violate the GPLv2 protocol.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source usage and any acts of plagiarism or academic misconduct**, will be subject to serious accountability. (This is the easiest scenario to violate our open source license.)
+
+Also, please note that according to the requirements of the GPLv2 protocol, software modified or developed based on DragonOS must also be open-sourced under the GPLv2 protocol and must indicate that it is based on DragonOS. It must also ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must allow the DragonOS developers to obtain the source code of your modified version through the same method from public channels; otherwise, you will violate the GPLv2 protocol.
+
+For detailed information about the protocol, please read the **LICENSE** file in the root directory of the project. Please note that, according to the requirements of the GPLv2 protocol, **only the English original version has legal effect**. Any translated version is for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, we have referenced the design of some open source projects, or introduced parts of their code, or been inspired by them. Below is a list of these open source projects. We sincerely thank the contributors of these open source projects!
+- WaitQueue: new: Rust version of WaitQueue (#_translated_label__162_en)
+- WaitQueue: update: For the C version of wait_queue, changed to immediate wake-up (#_translated_label__158_en)
+- block io: new: Block IO scheduler. When there are multiple cores, the IO scheduler runs on core 1. (#_translated_label__158_en)
+- smp: bugfix: Start apic_timer for AP cores, making them able to run scheduling (#_translated_label__158_en)
+- smp: new: Added kick_cpu function, supporting making a specific core run the scheduler immediately (#_translated_label__158_en)
+- smp: new: Added process migration functionality between cores (#_translated_label__158_en)
+- scheduler: new: Added real-time process scheduler (supporting FIFO and RR strategies) (#_translated_label__139_en)
+- scheduler: update: CFS scheduler sets a separate IDLE process pcb (pid is 0) for each core (#_translated_label__158_en)
+- scheduler: bugfix: When process_wakeup, reset the virtual runtime for CFS processes. Solves the problem of other processes starving due to small virtual runtime of sleeping processes. (#_translated_label__158_en)
+- process: new: Added migrate_to field in pcb (#_translated_label__158_en)
+
+## Update Content - User Environment
+
+None
+
+## Update Content - Others
+
+None
+
+## Update Content - Software Porting
+
+None
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can visit [https://github.com/fslongjin/DragonOS/releases](https://github.com/fslongjin/DragonOS/releases) to download the release code, as well as the compiled and runnable disk image.
+- We also have a mirror repository on gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To solve the problem of slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can get the DragonOS code package and the compiled and runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documents) will enjoy the rights granted by us through the GPLv2 license, and you must also comply with the obligations stipulated in the agreement.
+
+This is a rather strict license that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others and do not violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source use and any acts of plagiarism or academic misconduct**, will be subject to serious accountability. (This is the easiest scenario to violate our open source license.)
+
+Also, please note that according to the requirements of the GPLv2 license, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must clearly indicate that it is based on DragonOS. It must also ensure that users of these modified versions can conveniently obtain the original version of DragonOS.
+
+You must make it possible for the DragonOS developers to obtain the source code of your modified version through public channels in the same way, otherwise you will violate the GPLv2 license.
+
+For detailed information about the license, please read the **LICENSE** file in the root directory of the project. Please note that according to the GPLv2 license, **only the English original version is legally binding**. Any translated version is for reference only.
+:::
+
+### Open Source Software Usage
+
+  During the development of DragonOS, we have referenced the design of some open source projects, or introduced parts of their code, or been inspired by them. Below is a list of these open source projects. We sincerely thank the contributors of these open source projects!
+- driver: refactor: Rust version of the AHCI driver (#_translated_label__198_en)
+- block io: delete: Removed the Block IO scheduler. (#_translated_label__196_en)
+- filesystem: refactor: New version of VFS (#_translated_label__198_en)
+- filesystem: refactor: New version of ProcFS (#_translated_label__198_en)
+- filesystem: refactor: New version of DevS (#_translated_label__198_en)
+- filesystem: new: RamFS memory file system (#_translated_label__198_en)
+- filesystem: new: FAT12/FAT16/FAT32 file system (#_translated_label__198_en)
+- filesystem: new: New device and block device abstraction (#_translated_label__198_en)
+
+## Update Content - User Environment
+
+- libc: Adjusted, all apps are now directly linked to libc.a, instead of going through the "search.o" process (#_translated_label__171_en)
+
+## Update Content - Others
+
+- bootstrap: Fixed the issue with Ubuntu2210 not being able to compile GRUB correctly, and properly install QEMU (#_translated_label__176_en)
+- toolchain: Added a Rust bare bone toolchain (#_translated_label__197_en)
+
+## Update Content - Software Porting
+
+None
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can download the release code and the compiled, runnable disk image by visiting [https://github.com/DragonOS-Community/DragonOS/releases](https://github.com/DragonOS-Community/DragonOS/releases).
+- We also have a mirror repository on Gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To address the slow and unstable access to GitHub in China, and to make it easier for developers to download the code for each version of DragonOS, we have specifically set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the DragonOS source code archive and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and related software products (including but not limited to binary copies and documentation) is entitled to the rights granted by us through the GPLv2 license, and you must also comply with the obligations stipulated in the agreement.
+
+This is a rather strict license that protects the healthy development of open-source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open-source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others or violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open-source license, especially **commercial closed-source usage and any acts of plagiarism or academic misconduct**, will be subject to serious accountability. (This is the most common scenario where the open-source license is violated.)
+
+Also, please note that according to the requirements of the GPLv2 license, any software that is modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must clearly indicate that it is based on DragonOS. It is also necessary to ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must make it possible for the DragonOS developers to obtain the source code of your modified version through public channels, otherwise you will violate the GPLv2 license.
+
+For detailed information about the license, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 license, **only the English original version has legal effect**. Any translated versions are for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, some open-source projects were referenced, or parts of their code were introduced, or they inspired us. Below is a list of these open-source projects. We sincerely thank the contributors of these open-source projects!
+- timer: Refactored system timer (#_translated_label__223_en)
+- stdio: Added tty device for standard input and output (#_translated_label__202_en) (#_translated_label__217_en)
+- lib: First set of keyboard scan code state machine (#_translated_label__216_en) (#_translated_label__219_en)
+- syscall: Added dup and dup2 system calls (#_translated_label__224_en)
+- syscall: Added SystemError enum type to make error handling clearer (#_translated_label__205_en)
+- driver: Added support for x87 floating-point processor (#_translated_label__212_en)
+- driver: VirtIO network card can now send and receive data normally (#_translated_label__204_en)
+- filesystem: Fixed FAT32 judgment logic, resolving the issue where the system could not boot normally when the file system was FAT12/16. (#_translated_label__211_en)
+- filesystem: Added VFS document and modified document configuration (#_translated_label__209_en)
+- textui: Fixed the issue where the process scheduler did not run when "processes output characters continuously" due to textui locking and changes in preempt_count. (#_translated_label__203_en)
+- scheduler: Solved the issue of double locking in cpu_queue caused by not disabling interrupts during sched_enqueue outside of interrupt context. (#_translated_label__201_en)
+
+## Update Content - User Environment
+
+### New Repositories
+
+- Added a sub-project: [dsc](https://github.com/DragonOS-Community/dsc.git)
+- build: Added an option for using VNC as the image output for QEMU (#_translated_label__222_en)
+
+## Update Content - Software Porting
+
+None
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can download the release code and the compiled, runnable disk image from [https://github.com/DragonOS-Community/DragonOS/releases](https://github.com/DragonOS-Community/DragonOS/releases).
+- We also have a mirror repository on gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To address the slow and unstable access to GitHub in China, and to make it convenient for developers to download the code for each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the DragonOS source code archive and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documentation) can enjoy the rights granted by us through the GPLv2 protocol, while you also need to comply with the obligations stipulated in the protocol.
+
+This is a rather strict protocol that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others or violate the GPLv2 protocol.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source usage and any acts of plagiarism or academic misconduct**, will be subject to serious accountability. (This is the most common scenario of violating our open source license.)
+
+Also, please note that according to the requirements of the GPLv2 protocol, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 protocol and must indicate that it is based on DragonOS. It is also necessary to ensure that users of these modified versions can easily access the original version of DragonOS.
+
+You must make sure that the DragonOS developers can obtain the source code of your modified version through public channels in the same way, otherwise you will violate the GPLv2 protocol.
+
+For detailed information about the protocol, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 protocol, **only the English original version has legal effect**. Any translated version is for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, some open source projects were referenced, or parts of their code were introduced, or they inspired us. The following list shows them. We sincerely thank the contributors of these open source projects!
+- Add sys_dup and sys_dup2 support (#_translated_label__2_en)
+- Add the original libc memory allocator, fix alignment issues. (#_translated_label__6_en) (#_translated_label__7_en)
+- Configure network-related system calls (#_translated_label__8_en)
+- Fix the issue of errno not working properly due to DragonOS not supporting TLS (thread local storage). (#_translated_label__8_en)
+
+## Update Content - Others
+
+- build: Fix Issue#220; restore VNC port number to 5900 (#_translated_label__243_en)
+- bootstrap: Solve the problem of not being able to directly use the one-click initialization script for installation when using zsh to build DragonOS (#_translated_label__252_en)
+
+## Update Content - Software Porting
+
+None
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following ways:
+
+### Get via Git
+
+- You can visit [https://github.com/DragonOS-Community/DragonOS/releases](https://github.com/DragonOS-Community/DragonOS/releases) to download the release code and the compiled, runnable disk image.
+- We also have a mirror repository on gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To solve the problem of slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can get the compressed package of DragonOS code and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the source code of DragonOS and the corresponding software products (including but not limited to binary copies and documents) can enjoy the rights granted by us through the GPLv2 license, and you must also comply with the obligations stipulated in the agreement.
+
+This is a rather strict license that protects the healthy development of open source software and prevents it from being encroached upon.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others or violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source use and any acts of plagiarism or academic misconduct**, will be subject to serious accountability. (This is the most common scenario where the open source license is violated.)
+
+Also, please note that according to the requirements of the GPLv2 license, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must indicate that it is based on DragonOS. It is also necessary to ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must make it possible for the developers of DragonOS to obtain the source code of your modified version through the same way from public channels, otherwise you will violate the GPLv2 license.
+
+For detailed information about the license, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 license, **only the English original version has legal effect**. Any translated version is for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, some open source projects' designs were referenced, or parts of their code were introduced, or they were inspired by them. The following list shows them. We sincerely thank the contributors of these open source projects!
+- feature: Add fcntl system call (#_translated_label__323_en)
+- feature: Add support for per CPU variables (#_translated_label__327_en)
+- feature: Spinlock guard adds leak, spinlock adds force unlock function (#_translated_label__329_en)
+
+### Bug Fixes
+
+- bugfix: Fix the issue of not being able to read stdin normally (#_translated_label__264_en)
+- bugfix: Fix the memory overflow problem when the buffer address passed to the AHCI driver is a user buffer (temporarily solved by allocating a kernel buffer) (#_translated_label__265_en)
+- bugfix: Solve the bug caused by the improper assembly of local_irq_save and local_irq_restore functions affecting stack behavior (#_translated_label__303_en)
+- bugfix: Solve the error of local_irq_save not disabling interrupts (#_translated_label__303_en)
+- bugfix: Solve the error in arch_try_cmpxchg for pointer handling (#_translated_label__307_en)
+- bugfix: Fix the exception error in wait4 (#_translated_label__312_en)
+- bugfix: Fix the issue of null device and zero device not being able to open and not behaving as expected (#_translated_label__314_en)
+- bugfix: Fix the bug in FAT file system not correctly extending file size (#_translated_label__323_en)
+- bugfix: Fix the use after free issue caused by not using ManuallyDrop in some places of rwlock (#_translated_label__329_en)
+
+## Update Content - User Environment
+
+### New Features
+
+- feature: Add new HTTP server (#_translated_label__265_en)
+
+### Bug Fixes
+
+- bugfix: Solve the issue of the init segment linking error caused by crt*.o not being sorted in ascending order during linking (#_translated_label__265_en)
+
+## Update Content - Others
+
+- bugfix: Fix the toolchain and resolve errors caused by the new Rust compiler (#_translated_label__258_en)
+- feature: Makefile: Add make help command in the root directory (#_translated_label__271_en)
+- bugfix: Fix the issue where the relibc header file could not recognize the __dragonos__ definition (#_translated_label__315_en)
+- feature: Set the remote for the kernel and relibc to the DragonOS Git mirror site to prevent compilation failure due to domestic network issues (#_translated_label__318_en)
+- feature: Automatic installation and update of dadk (#_translated_label__319_en)
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can visit [https://github.com/DragonOS-Community/DragonOS/releases](https://github.com/DragonOS-Community/DragonOS/releases) to download the source code of the release version, as well as the compiled and runnable disk image.
+- We also have a mirror repository on Gitee for download: [https://gitee.com/DragonOS/DragonOS](https://gitee.com/DragonOS/DragonOS)
+
+### Get via DragonOS Software Mirror Site
+
+  To address the slow and unstable access to GitHub in China, and to make it convenient for developers to download the source code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can obtain the source code package and the compiled and runnable disk image of DragonOS through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the source code of DragonOS and the corresponding software products (including but not limited to binary copies and documentation) will enjoy the rights granted by us through the GPLv2 license, and you must also comply with the obligations stipulated in the license.
+
+This is a very strict license that protects the healthy development of open source software and prevents it from being infringed.
+
+For most people with good intentions, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe on the legitimate rights and interests of others and do not violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source use and any plagiarism or academic misconduct**, will be subject to serious accountability. (This is the easiest scenario to violate our open source license.)
+
+Also, please note that according to the requirements of the GPLv2 license, any software modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must indicate that it is based on DragonOS. It must also ensure that users of these modified versions can easily obtain the original version of DragonOS.
+
+You must ensure that the developers of DragonOS can obtain the source code of your modified version through the same way from public channels. Otherwise, you will violate the GPLv2 license.
+
+For detailed information about the license, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 license, **only the English original version has legal effect**. Any translated version is for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, some open source projects were referenced, or parts of their code were introduced, or they were inspired by them. The following list shows them. We sincerely thank the contributors of these open source projects!
+- feature: Implement several POSIX standard system calls
+
+### Bug Fixes
+
+- bugfix: Fix the issue caused by the init proc union and the bug caused by the default sleep behavior of kernel threads leading to the inability to run the init process ([#_translated_label__381_en](https://github.com/DragonOS-Community/DragonOS/pull/381))
+- bugfix: Fix the bug where TLB was not automatically flushed during Flusher Drop ([#_translated_label__384_en](https://github.com/DragonOS-Community/DragonOS/pull/384))
+- bugfix: Fix the bug where multiboot2 startup information was not saved in time, leading to the inability to query it later ([#_translated_label__405_en](https://github.com/DragonOS-Community/DragonOS/pull/405))
+- bugfix: Fix the error in the handling of the unloading logic by bus/device manager ([#_translated_label__385_en](https://github.com/DragonOS-Community/DragonOS/pull/385))
+- bugfix: Solve the bug where the waitqueue sleep caused the sched failure due to preempt count not being zero, leading to the PCB being added multiple times to the scheduling queue on the next wake-up ([#_translated_label__419_en](https://github.com/DragonOS-Community/DragonOS/pull/419))
+- bugfix: Fix the bug where the vm holes were not correctly copied during fork ([#_translated_label__433_en](https://github.com/DragonOS-Community/DragonOS/pull/433))
+- bugfix: Fix the issue where multiple memory areas on the physical machine could not be used correctly, and the memory holes in the kernel code caused the system to fail to run normally ([#_translated_label__448_en](https://github.com/DragonOS-Community/DragonOS/pull/448))
+- bugfix: Fix the bug where the ACPI could not be initialized properly due to the rsdp v1 v2 version issue ([#_translated_label__454_en](https://github.com/DragonOS-Community/DragonOS/pull/454))
+- bugfix: Fix the bug where the bus driver and device strong-weak reference relationship was incorrect, leading to the object being released ([#_translated_label__483_en](https://github.com/DragonOS-Community/DragonOS/pull/483))
+- bugfix: Fix the bug where epoll still held the weak reference of the file descriptor after the file was closed ([#_translated_label__455_en](https://github.com/DragonOS-Community/DragonOS/pull/455))
+- bugfix: Fix the issue of being unable to sleep and the problem where the process in block(true) state could not be awakened by signals and the signals were not handled after waking up ([#_translated_label__470_en](https://github.com/DragonOS-Community/DragonOS/pull/470))
+
+## Update Content - User Environment
+
+### New Features
+
+- feature: Add the init program dragonreach ([#_translated_label__391_en](https://github.com/DragonOS-Community/DragonOS/pull/391))
+- featurn: Add the shell program NovaShell ([#_translated_label__456_en](https://github.com/DragonOS-Community/DragonOS/pull/456))
+- featurn: Add the text editor Held ([#_translated_label__583_en](https://github.com/DragonOS-Community/DragonOS/pull/583))
+- featurn: Support the execution of programs such as gcc, tar, redis, etc.
+
+## Source Code and Release Image Download
+
+  You can obtain the source code through the following methods:
+
+### Get via Git
+
+- You can visit [https://github.com/DragonOS-Community/DragonOS/releases](https://github.com/DragonOS-Community/DragonOS/releases) to download the release code and the compiled, runnable disk image.
+
+### Get via DragonOS Software Mirror Site
+
+  To solve the problem of slow and unstable access to GitHub in China, and to make it convenient for developers to download the code of each version of DragonOS, we have specially set up a mirror site. You can access the mirror site through the following address:
+
+  You can get the DragonOS code package and the compiled, runnable disk image through the mirror site.
+To promote the healthy development of the DragonOS project, DragonOS is released under the GPLv2 open source license. Anyone who can obtain the DragonOS source code and corresponding software products (including but not limited to binary copies and documents) can enjoy the rights granted by us through the GPLv2 license, and you must also comply with the obligations stipulated in the license.
+
+This is a rather strict license that protects the healthy development of open source software and prevents it from being infringed.
+
+For most well-intentioned people, you will not violate our open source license.
+
+We encourage the free dissemination and promotion of DragonOS, but please ensure that all actions do not infringe upon the legitimate rights and interests of others or violate the GPLv2 license.
+
+Please pay special attention to the fact that violations of the open source license, especially **commercial closed-source use and any acts of plagiarism or academic misconduct**, will be subject to serious accountability. (This is the easiest scenario to violate our open source license.)
+
+Also, please note that according to the requirements of the GPLv2 license, software modified or developed based on DragonOS must also be open-sourced under the GPLv2 license and must clearly indicate that it is based on DragonOS. It is also necessary to ensure that users of these modified versions can conveniently obtain the original version of DragonOS.
+
+You must make sure that the DragonOS developers can obtain the source code of your modified version through public channels in the same way, otherwise you will violate the GPLv2 license.
+
+For detailed information about the license, please read the **LICENSE** file in the root directory of the project. Please note that according to the requirements of the GPLv2 license, **only the English original version is legally binding**. Any translated version is for reference only.
+:::
+
+### Usage of Open Source Software
+
+  During the development of DragonOS, we have referenced some designs from the Linux community, or introduced some of their ideas, or been inspired by them. We would like to express our sincere gratitude to the Linux community and its contributors here!
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# C Language Code Style
+
+  This document will briefly introduce the C language code style used in DragonOS. It is completely normal for each person to have their own code style. However, for the maintainability of an open-source project, we hope to establish some code standards so that every developer, including you, can feel more comfortable when reading the code. A project filled with various code styles is difficult to maintain.
+
+  We propose some recommendations here, and we hope you will follow them as much as possible. These recommendations are similar to those of Linux, but with some differences. DragonOS uses Linux's style for variable naming; for indentation, DragonOS uses Microsoft's style.
+
+## 0. Code Formatter
+
+  Before we present the following recommendations, we recommend that you use the `C/C++ Extension Pack` plugin in Visual Studio Code as a code formatter during development. These plugins provide good auto-formatting functionality, ensuring that your code's basic format meets DragonOS's requirements.
+
+  Pressing `Ctrl+shift+I` or your set code formatting shortcut frequently while coding can help you maintain good code formatting consistently.
+
+## 1. Indentation
+
+  The width of a tab is equal to 4 spaces. Code indentation is based on the tab width (usually 4 characters in most editors).
+
+  This makes your code more readable and helps better identify the control structures in the code. This can avoid many unnecessary troubles!
+
+For example: In a switch statement, place the switch and case on the same indentation level. And indent each case's code by one tab to the right. This improves code readability.
+
+```c
+switch (cmd)
+{
+case AHCI_CMD_READ_DMA_EXT:
+ pack->blk_pak.end_handler = NULL;
+ pack->blk_pak.cmd = AHCI_CMD_READ_DMA_EXT;
+ break;
+case AHCI_CMD_WRITE_DMA_EXT:
+ pack->blk_pak.end_handler = NULL;
+ pack->blk_pak.cmd = AHCI_CMD_WRITE_DMA_EXT;
+ break;
+default:
+ pack->blk_pak.end_handler = NULL;
+ pack->blk_pak.cmd = cmd;
+ break;
+}
+```
+
+## 2. Line Breaks
+
+  We recommend that each line should not exceed 120 characters. If it does, unless there is a necessary reason, it should be split into two lines.
+
+  When breaking lines, we need to indent the second line by one level from the first line's starting part to indicate that it is a sub-line. Using the code formatting shortcut can quickly accomplish this.
+
+  For log strings, we do not recommend breaking them into multiple lines for easier retrieval.
+
+  For code line breaks, do not try to place several statements on the same line, as this provides no benefit to code readability:
+
+```c
+// 错误示范(1)
+if(a) return 1;
+
+// 错误示范(2)
+if(b)
+ do_a(),do_b();
+```
+
+## 3. Braces and Spaces
+
+### 3.1 Braces
+
+  The placement of braces is a matter of personal preference, mainly due to habit rather than technical reasons. We recommend placing the opening and closing braces on new lines, as shown below:
+
+```c
+while(i<10)
+{
+ ++i;
+}
+```
+
+  This rule applies to all code blocks.
+
+  The reason for this choice is that, in some editors, placing the braces in this way will result in **a semi-transparent vertical line appearing in the editor, with the line ends being the braces**. This helps developers better understand the hierarchical relationships of the code blocks.
+
+Let's demonstrate this with some examples:
+
+  In the following code block, we need to note that the `else if` statement should be on a new line, not after the previous `}`. This is because we require `{` to be at the start of each line and maintain the indentation level.
+
+```c
+if (*fmt == '*')
+{
+ ++fmt;
+}
+else if (is_digit(*fmt))
+{
+ field_width = skip_and_atoi(&fmt);
+}
+```
+
+  When there are multiple simple statements in a loop, braces should be used.
+
+```c
+while (condition)
+{
+ if (test)
+ do_something();
+}
+```
+
+  When there is only one simple statement, we do not need to use braces.
+
+```c
+if(a)
+ return 1;
+```
+
+### 3.2 Spaces
+
+  For most keywords, we need to add a space after them to improve code readability.
+
+  Please add a space after all of these keywords:
+
+```c
+if, switch, case, for, do, while
+```
+
+  Keywords such as sizeof, typeof, alignof, and __attribute__ do not require a space after them, as they are used like functions.
+
+  For pointer-type variables, the asterisk should be close to the variable name rather than the type name. As shown below:
+
+```c
+char *a;
+void *func(char* s, int **p);
+```
+
+  Use a space on both sides of most binary and ternary operators, as shown below:
+
+```c
+= + - < > * / % | & ^ <= >= == != ? :
+```
+
+  There is no space after these unary operators:
+  Special cases: no space is needed before or after the following operators:
+
+```c
+++ -- . ->
+```
+
+## 4. Naming
+
+  DragonOS does not use the camelCase naming convention for function names, but instead uses concise and clear names like `tmp`.
+
+  Note that this refers to our entire project not using the camelCase naming convention. It does not mean that programmers can use obscure abbreviations for variable names.
+
+  For global variables or globally visible functions and structures, we need to follow the following naming conventions:
+
+- The name should be easy to understand and not ambiguous. For example, for a function that calculates folder size, we recommend using `count_folder_size()` instead of `cntfs()`, which can confuse others.
+- For global, non-static names, unless there is a special need, the naming should follow the format: `模块名缩写前缀_函数/变量名`. This naming convention helps others distinguish which module the name belongs to and reduces the risk of naming conflicts.
+- Global names that do not need to be visible to other code files must be prefixed with the `static` modifier.
+
+  For local variables within functions, the naming convention should be concise. Long names for local variables have little significance.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Code Commit Guidelines
+
+  This document will briefly introduce the code commit guidelines for the DragonOS GitHub repository, mainly providing the naming conventions based on Conventional Commit, as well as a brief introduction to the DragonOS Bot.
+
+## Conventional Commit (Conventional Commit)
+
+  For detailed specifications on Conventional Commit, please refer to the website [Conventional Commit/Conventional Commit](https://www.conventionalcommits.org/zh-hans/v1.0.0/). At the end of this section, we will provide examples (taken from the [Conventional Commit/Conventional Commit](https://www.conventionalcommits.org/zh-hans/v1.0.0/) website), which are optional to read. We make the following special notes:
+1. Since the DragonOS kernel ensures external usability primarily through system call interfaces, and up to now (April 22, 2024), considering the software ecosystem, DragonOS has chosen to implement system calls consistent with Linux. Therefore, there is no special explanation for `破坏性变更(BREAKING CHANGES)`, or in the current development environment, there will not be any destructive changes that significantly affect users. Therefore, unless there is a special need, the DragonOS kernel should not use `feat!` to indicate destructive changes. (Outside the kernel, such as dadk, the guidelines still apply.)
+2. The DragonOS community strictly follows a squash-based workflow, so we do not require each individual commit in a PR to conform to [Conventional Commit/Conventional Commit](https://www.conventionalcommits.org/zh-hans/v1.0.0/). However, we still strongly recommend using it.
+3. Regarding scope: If not specified otherwise, the scope should be the name of the submodule/system/directory. For example, if the code change is adding a feature in `kernel/src/driver/net`, it should be named as `feat(driver/net):`; if it is in `kernel/src/mm/allocator`, it should be named as `feat(mm)`. In short, the scope should be as short as possible to indicate the module it belongs to. Most of the time, it should not use more than two levels of scope identifiers. For example, `fix(x86_64/driver/apic)` is incorrect and should be named as `fix(x86_64/apic)`.
+4. In the DragonOS kernel code repository, `issue checker` will perform a simple review of the title format. If it does not conform to the format, it will be marked as `ambiguous`. Contributors are advised to modify it as needed.
+5. Use lowercase.
+
+### Examples
+
+#### Commit message with a description and a footnote indicating a breaking change
+```
+feat: allow provided config object to extend other configs
+
+BREAKING CHANGE: `extends` key in config file is now used for extending other config files
+```
+#### Commit message with the ! character to alert about a breaking change
+```
+feat!: send an email to the customer when a product is shipped
+```
+#### Commit message with scope and a breaking change !
+```
+feat(api)!: send an email to the customer when a product is shipped
+```
+#### Commit message with ! and BREAKING CHANGE footnote
+```
+chore!: drop support for Node 6
+
+BREAKING CHANGE: use JavaScript features not available in Node 6.
+```
+#### Commit message without a body
+```
+docs: correct spelling of CHANGELOG
+```
+#### Commit message with scope
+```
+feat(lang): add polish language
+```
+
+## DragonOS Bot
+
+  DragonOS uses triagebot to implement automatic labeling and reviewer assignment. Contributors can also interact with triagebot through some commands. For more details, see [triagebot](https://forge.rust-lang.org/triagebot/index.html)
+ Please report issues via `Community Channel <https://github.com/DragonOS-Community/DragonOS/issues>`_
+
+====================================
+Contributing to Development
+====================================
+
+ DragonOS community warmly welcomes your participation! While learning technology is important, the following documents will help you understand what DragonOS community needs.
+
+ Reading these documents will help you get involved in development and make your code merge into the mainline more quickly.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Rust Language Code Style
+
+  This document will introduce the Rust language code style used in DragonOS. As development progresses, these styles may change, but we will strive to maintain consistency in the style.
+
+## 1. Naming
+
+  This section is based on the naming conventions from the Rust language bible, [Naming Guide](https://course.rs/practice/naming.html). For parts not mentioned in this document, please refer to the [Naming Guide](https://course.rs/practice/naming.html) in the Rust language bible.
+
+## 2. Formatting
+
+### 2.1 Indentation
+
+  Please use the `cargo fmt` command to format the code before submitting it.
+
+### 2.2 Function Return Values
+
+  Although Rust allows returning the value of the last line of a function, this approach can reduce code readability. Therefore, we recommend using the `return` statement as the last line of the function, rather than directly returning the value.
+
+```rust
+// 不推荐
+fn foo() -> i32 {
+ 1 + 2
+}
+
+// 推荐
+fn foo() -> i32 {
+ return 1 + 2;
+}
+```
+### 2.3 Error Handling
+
+  DragonOS uses returning POSIX error codes as the **inter-module error handling** method. To ensure consistency in error handling code across modules, we recommend returning the `SystemError` type when an error occurs. This approach is especially beneficial when calling functions across modules, as it allows direct return of a generic error code, thereby reducing the coupling of error handling code.
+
+```rust
+// 函数跨越模块边界时(由其他模块调用当前函数),不推荐
+fn foo() -> Result<(), CustomErr> {
+ if 1 + 2 == 3 {
+ return Ok(());
+ } else {
+ return Err(CustomErr::error);
+ }
+}
+
+// 函数跨越模块边界时(由其他模块调用当前函数),推荐
+fn foo() -> Result<(), SystemError> {
+ if 1 + 2 == 3 {
+ return Ok(());
+ } else {
+ return Err(SystemError::EINVAL);
+ }
+}
+```
+
+  Within **modules**, you can either use a custom error enum or return the `SystemError` type. However, we recommend using a custom error enum for error handling within modules, as it makes the error handling code clearer.
+
+  **TODO**: Convert existing code that uses i32 as an error code to use `SystemError`.
+
+## 3. Comments
+
+  The commenting style in DragonOS is consistent with the official Rust style. We also recommend adding as many meaningful comments as possible in your code to help others understand your code. Additionally, variable and function declarations should follow the naming conventions mentioned in Section 1, making them "self-documenting."
+
+### 3.1 Function Comments
+
+  Function comments should include the following:
+
+- The function's purpose
+- The function's parameters
+- The function's return value
+- The function's error handling
+- Any side effects or other information that needs to be explained
+
+  The format for function comments is as follows:
+DragonOS is an open-source project, and we welcome any form of sponsorship and donations. Your donations will be used for the development and maintenance of DragonOS, as well as the operation of the community.
+
+You can sponsor or donate through the following methods:
+
+- Visit the DragonOS official website at https://DragonOS.org, click the "Sponsor" button in the top right corner, and make a donation.
+- Contact the community leader to discuss specific sponsorship methods. Contact information: longjin@dragonos.org
+The donation information of the DragonOS community will be made public annually. Sponsorship details and sponsor information will be made public within 15 days after receiving the donation.
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: introduction/build_system.md
+
+- Translation time: 2025-05-19 01:44:01
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Building DragonOS
+
+## 1. Introduction
+
+  Regardless of which method you use to compile DragonOS in the following sections, you must first follow the steps in this section to initialize your development environment.
+
+  Before you start, you need a computer running Linux or macOS with an X86-64 processor architecture.
+
+  For Linux distributions, it is recommended to use newer distributions such as Ubuntu 22, Debian, or Arch Linux, which can save you a lot of trouble.
+For convenience in subsequent development, we recommend using `ssh` to clone (please configure your GitHub SSH Key first) to avoid cloning failures due to network issues:
+
+Use `ssh` to clone (please configure your GitHub SSH Key first):
+## 2. Installation Using One-Click Initialization Script (Recommended)
+
+  We provide a one-click initialization script that can install everything with a single command. Just run the following command in the terminal:
+The one-click configuration script currently supports the following systems:
+
+- Ubuntu/Debian/Deepin/UOS and other derivatives based on Debian
+- Gentoo, due to the characteristics of the Gentoo system, when Gentoo encounters USE or circular dependency issues, please handle them according to the emerge prompt information. Official dependency handling examples [GentooWiki](https://wiki.gentoo.org/wiki/Handbook:AMD64/Full/Working/zh-cn#.E5.BD.93_Portage_.E6.8A.A5.E9.94.99.E7.9A.84.E6.97.B6.E5.80.99)
+
+We welcome you to improve the build script for other systems!
+:::
+
+**If the one-click initialization script runs normally and outputs the final "Congratulations" interface (as shown below), please close the current terminal and then reopen it.**
+
+```shell
+|-----------Congratulations!---------------|
+| |
+| 你成功安装了DragonOS所需的依赖项! |
+| |
+| 请关闭当前终端, 并重新打开一个终端 |
+| 然后通过以下命令运行: |
+| |
+| make run |
+| |
+|------------------------------------------|
+```
+
+**Then, please directly jump to {ref}`编译命令讲解 <_build_system_command>` for reading!**
+
+## 3. Manual Installation
+
+### 3.1 Dependency List
+
+  If the automatic installation script does not support your operating system, you need to manually install the required packages. The following is the list of dependencies:
+
+  Among the following dependencies, except for `docker-ce` and `Rust及其工具链`, the rest can be installed using the system's built-in package manager. For the installation of Docker and Rust, please refer to the following sections.
+
+- docker-ce
+- llvm-dev
+- libclang-dev
+- clang
+- gcc-multilib
+- qemu qemu-system qemu-kvm
+- build-essential
+- fdisk
+- lsb-release
+- git
+- dosfstools
+- unzip
+- Rust and its toolchain
+
+**Please note that if your Linux system is running in a virtual machine, please make sure to enable the Intel VT-x or AMD-V option in the processor settings of your VMware/Virtual Box virtual machine, otherwise DragonOS will not be able to run.**
+
+:::{note}
+
+*In some Linux distributions, the Qemu built from the software repository may be incompatible with DragonOS due to an outdated version. If you encounter this issue, uninstall Qemu and reinstall it by compiling from source.*
+
+Download the Qemu source code from this address: https://download.qemu.org/
+
+After decompression, enter the source code directory and execute the following command:
+Please note that the compiled QEMU will be linked via VNC mode, so you also need to install a VNC viewer on your computer to connect to the QEMU virtual machine.
+:::
+
+### 3.2 Installing Docker
+
+  You can download and install docker-ce from the Docker official website.
+
+> For detailed information, please visit: [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/)
+
+### 3.3 Installing Rust
+
+:::{warning}
+**[Common Misconception]**: If you plan to compile using Docker, although the Docker image already includes a Rust compilation environment, to enable code hints in VSCode using Rust-Analyzer and for the `make clean` command to run normally, you still need to install the Rust environment on your client machine.
+:::
+
+  You can install Rust by entering the following command in the terminal.
+**At this point, the public dependencies have been installed. You can proceed to read the subsequent sections according to your needs.**
+
+**For the usage of the compilation command, please refer to: {ref}`编译命令讲解 <_build_system_command>`**
+
+## 4. Building from Docker (Not Recommended)
+
+  DragonOS provides a Docker compilation environment for developers to run DragonOS. However, since the coding process still needs to be performed on the client machine, you need to install the Rust compilation environment on your client machine.
+
+  This section assumes that all operations are performed under Linux.
+
+### 4.1 Installing QEMU Virtual Machine
+
+  In this section, we recommend installing QEMU via the command line:
+
+```shell
+sudo apt install -y qemu qemu-system qemu-kvm
+```
+
+### 4.2 Creating a Disk Image
+
+  First, you need to use the `create_hdd_image.sh` script in the `tools` folder to create a virtual disk image. You need to run this command in the `tools` folder.
+
+```shell
+bash create_hdd_image.sh
+```
+
+### 4.3 Running DragonOS
+
+  If everything goes well, this will be the final step to run DragonOS. You just need to execute the following command in the DragonOS root directory to run DragonOS.
+
+```shell
+make run-docker
+```
+
+  Wait a moment, DragonOS will be started.
+
+  After the QEMU virtual machine is started, you need to input the letter `c` in the console and press Enter. This will start the virtual machine.
+
+:::{note}
+1. During the first compilation, since it requires downloading Rust-related indexes (hundreds of MB in size), it will take some time. Please be patient!
+2. Entering commands may require adding `sudo`
+:::
+
+**For the usage of the compilation command, please refer to: {ref}`编译命令讲解 <_build_system_command>`**
+
+## 5. Other Notes
+
+### 5.1 Creating a Disk Image
+
+  First, you need to run `tools/create_hdd_image.sh` with **normal user** permissions to create a disk image file for DragonOS. This script will automatically complete the creation of the disk image and move it to the `bin/` directory.
+
+  Please note that due to permission issues, you must run this script with **normal user** permissions. (After running, the system may prompt you to enter a password when you need to elevate permissions.)
+
+### 5.2 Compiling and Running DragonOS
+
+1. Install the compilation and runtime environment
+2. Enter the DragonOS folder
+3. Input `make run` to compile and write to the disk image, and run
+
+  After the QEMU virtual machine is started, you need to input the letter `c` in the console and press Enter. This will start the virtual machine.
+
+:::{note}
+During the first compilation, since it requires downloading Rust-related indexes (hundreds of MB in size), it will take some time. Please be patient!
+:::
+
+**For the usage of the compilation command, please refer to: {ref}`编译命令讲解 <_build_system_command>`**
+
+(_translated_label___build_system_command_en)=
+## 6. Explanation of Compilation Commands
+
+- Local compilation, no execution: `make all -j 您的CPU核心数`
+- Local compilation, write to disk image, no execution: `make build`
+- Local compilation, write to disk image, and run in QEMU: `make run`
+- Local compilation, write to disk image, and run in headless mode:
+`make run-nographic`
+- Docker compilation, write to disk image: `make docker`
+- Docker compilation, write to disk image, and run in QEMU: `make run-docker`
+- Start directly from an existing disk image without compilation: `make qemu`
+- Start directly from an existing disk image without compilation (headless mode): `make qemu-nographic`
+- Clean up compiled files: `make clean`
+- Compile documentation: `make docs` (requires manual installation of sphinx and dependencies in `requirements.txt`)
+- Clean up documentation: `make clean-docs`
+- Format code: `make fmt`
+
+:::{note}
+If you need to run DragonOS in VNC, add the `-vnc` suffix to the above command. For example: `make run-vnc`
+
+The QEMU virtual machine will listen on port 5900 for VNC connections. You can connect to the QEMU virtual machine using a VNC viewer or Remmina.
+:::
+
+## 7. Compiling for riscv64
+
+Since DragonOS has not been fully ported to riscv64 yet, the compilation needs to be done as follows:
+
+1. Modify `env.mk` and `.vscode/settings.json`
+
+Change the value of `ARCH` in `env.mk` to `riscv64`, and in `setting.json`, comment out `"rust-analyzer.cargo.target": "x86_64-unknown-none",` and change it to the line enabling riscv64.
+
+2. Restart rust-analyzer
+
+3. Clean up the compilation cache
+
+Due to the differences between x86_64 and riscv64 architectures, there may be compilation issues caused by cache. Ensure that you clean up the cache before running.
+
+```shell
+make clean
+```
+
+4. Compile and run for riscv64
+
+```shell
+# 下载DragonStub
+git submodule update --init --recursive --force
+
+make run
+```
+
+Please note that since you are running QEMU in the console, when you want to exit, input `Ctrl+A` and press `X` to do so.
+ This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+ - Source document: introduction/index.rst
+
+ - Translation time: 2025-05-19 01:41:59
+
+ - Translation model: `Qwen/Qwen3-8B`
+
+
+ Please report issues via `Community Channel <https://github.com/DragonOS-Community/DragonOS/issues>`_
+
+Introduction to DragonOS
+====================================
+
+ DragonOS, the Dragon Operating System, is a 64-bit operating system designed for lightweight cloud computing scenarios. It features a fully self-developed kernel and provides Linux binary compatibility. Developed using the Rust programming language, it offers enhanced reliability. Currently, DragonOS ranks among the top three in the Rust operating system field on GitHub.
+
+ The DragonOS open-source community was established in July 2022. It is completely neutral in commercial matters. Our goal is to build a fully independent, open-source, high-performance, and highly reliable server operating system, **to create a fully self-controlled digital future!**
+
+ DragonOS has an excellent and well-designed architecture. Compared to other systems of similar size, DragonOS supports virtualization and has certain advantages in areas such as device model and scheduling subsystems. Currently, we are actively promoting cloud platform support, RISC-V support, as well as the porting of compilers and application software. We aim to achieve large-scale application in production environments within five years.
+
+ DragonOS is currently developing rapidly under the drive of the community. At present, DragonOS has already implemented about 1/4 of the Linux interface. In the future, we will provide 100% compatibility with Linux and introduce new features.
+
+ The goal of DragonOS is to build a fully independent, open-source, high-performance, and highly reliable server operating system, providing a completely self-controlled core power for the country's digital infrastructure construction.
+
+ As a community-driven open-source operating system, in order to promote the development of the open-source community and avoid potential infringement by commercial companies that do not comply with open-source agreements, we have decided to open the source code under the GPLv2 license, using a strict open-source agreement to protect DragonOS.
+
+ You may be interested in the features that have already been implemented in DragonOS. You can visit here: :ref:`功能特性 <_genreal_features>`
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/boot/bootloader.md
+
+- Translation time: 2025-05-19 01:41:31
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Bootloader
+
+## X86_64
+
+- [x] multiboot2
+- [x] HVM/PVH
+
+### HVM/PVH Boot on x86_64
+
+In the DragonOS note segment, there is a PVH header that allows QEMU to boot the DragonOS kernel using the ``-kernel`` parameter.
+
+## RISC-V 64
+
+DragonOS's boot process on RISC-V 64 is as follows:
+
+opensbi --> uboot --> DragonStub --> kernel
+
+This boot process decouples the DragonOS kernel from specific hardware boards, enabling the same binary file to boot and run on different hardware boards.
+
+## Kernel Boot Callbacks
+
+DragonOS abstracts the kernel bootloader, which is represented by the trait ``BootCallbacks``.
+Different bootloaders implement the corresponding callback to initialize the kernel's bootParams or other data structures.
+
+When the kernel boots, it automatically registers callbacks based on the type of bootloader. And at the appropriate time, it calls these callback functions.
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/boot/cmdline.md
+
+- Translation time: 2025-05-19 01:41:48
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Kernel Boot Command Line Parameters
+
+:::{note}
+Author:
+- Longjin <longjin@DragonOS.org>
+:::
+
+## Overview
+
+  The DragonOS kernel boot command line parameter parsing module aims to provide support for parsing kernel boot command line parameters similar to Linux, enabling more flexible behavior for the kernel. This module allows the kernel to receive and parse command line parameters at boot time, and execute corresponding callback functions or set environment variables based on the type of parameters.
+
+:::{note}
+Callback functions are not supported temporarily.
+:::
+
+## Design
+
+### Parameter Types
+
+Kernel boot command line parameters are divided into three types:
+
+- Arg type
+- KV type
+- EarlyKV type
+
+#### Arg Type
+
+Arg type parameters have only a name and no value. They are divided into the following two types:
+
+- ArgNormal: The default value is `false`. If the parameter is present in the command line, it will be set to `true`.
+- ArgInv: The default value is `true`. If the parameter is present in the command line, it will be set to `false`.
+
+#### KV Type
+
+KV type parameters are represented in the command line as `name=value`, `value` separated by commas. Kernel modules can provide default values for these parameters.
+
+#### EarlyKV Type
+
+EarlyKV type parameters are similar to KV type parameters, but they are parsed before memory management initialization.
+
+### Module Flags
+
+Module flags are similar to `usbprobe.xxxx`.
+
+### Parameter Declaration
+
+Provides macros to declare kernel command line parameters.
+### procfs Support
+
+:::{note}
+TODO: Display the current kernel's boot command line parameters under `/proc/cmdline`.
+:::
+
+## Macros for Declaring Kernel Boot Command Line Parameters
+Please note that changing the architecture requires a recompilation, so please run `make clean` to clean up the compilation results. Then run `make run` to proceed.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Kernel Compilation Configuration Guide
+
+## Principle
+
+  Within the kernel directory, the kernel configuration is set using `kernel.config`. This file is parsed in a manner similar to a TOML file, and then the configuration of each module's `d.config` is parsed to determine the status of features.
+
+## Example
+
+**kernel.config**
+
+```toml
+[[module.include]]
+name = "init"
+path = "src/init/"
+enable = "y"
+description = ""
+
+[[module.include]]
+name = "mm"
+path = "src/mm/"
+enable = "y"
+description = ""
+```
+
+- **[[module.include]]:** Adds the module to the include list
+- **name:** Module name
+- **path:** Module path, where the `d.config` file is located
+- **enable:**
+ - **y:** Enabled, parse the `d.config` file of the module
+ - **n:** Disabled, do not parse
+- **description:** Description of the module
+
+**src/mm/d.config**
+
+```toml
+[module]
+name = "mm"
+description = ""
+
+[[module.include]]
+name = "allocator"
+path = "src/mm/allocator/"
+enable = "y"
+description = ""
+
+[[module.features]]
+name = "mm_debug"
+enable = "y"
+description = ""
+```
+
+- **[module]:** Current module
+ - **name:** Name of the current module
+ - **description:** Description of the module
+- **[[module.include]]:** Modules included in the current module, same as in `kernel.config`
+- **[[module.features]]:** Features in the current module
+ - **name:** Feature name
+ - **enable:** Whether the feature is enabled
+ - **y:** Enabled
+ - **n:** Disabled
+ - **description:** Description of the feature
+
+*The following are the `d.config` files of other modules:*
+
+**src/mm/allocator/d.config**
+
+```toml
+[module]
+name = "allocator"
+description = ""
+
+[[module.features]]
+name = "allocator_debug"
+enable = "y"
+description = ""
+```
+
+**src/init/d.config**
+
+```toml
+[module]
+name = "init"
+description = ""
+
+[[module.features]]
+name = "init_debug"
+enable = "y"
+description = ""
+```
+
+All features enabled in the `d.config` files of the activated modules will be ultimately generated into the `D.config` file in the kernel directory. That is, `D.config` is the final kernel compilation configuration, as follows:
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Mount Namespace
+
+## Underlying Architecture
+
+pcb -> nsproxy -> mnt_namespace
+
+Each mounted file system has its own independent mount point, which is represented in the data structure as a red-black tree of mounts. Each namespace has its own independent mounts, so mounting and unmounting file systems will not affect others.
+
+## System Call Interface
+
+- clone
+ - CLONE_NEWNS is used to create a new MNT namespace. It provides an independent file system mount point.
+- unshare
+ - After calling unshare() with the CLONE_NEWPID flag, all subsequent child processes will run in the new namespace.
+- setns
+ - Adds the process to the specified namespace.
+- chroot
+ - Changes the current process's root directory to the specified path, providing file system isolation.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Process Namespace
+:::{note} Author: Cao Fengyi 1553389239@qq.com
+
+October 30, 2024
+:::
+
+`pid_namespace` is a type of namespace in the kernel that is used to achieve process isolation. It allows processes running in different namespaces to have independent views of process IDs (PIDs).
+
+## Underlying Architecture
+
+pcb -> nsproxy -> pid_namespace
+- `pid_namespace` contains an independent set of process allocators and an orphan process reaper, which independently manages PIDs within the namespace.
+- Detailed information about processes is stored in the proc file system. The information corresponding to a specific PID is located within the `pid_namespace`, recording information related to the `pid_namespace`.
+- The limitations imposed by `pid_namespace` are controlled and managed by `ucount`.
+
+## System Call Interface
+
+- `clone`
+ - `CLONE_NEWPID` is used to create a new PID namespace. When this flag is used, the child process will run in the new PID namespace, with the process ID starting from 1.
+- `unshare`
+ - After calling `unshare()` with the `CLONE_NEWPID` flag, all subsequent child processes will run within the new namespace.
+- `getpid`
+ - Calling `getpid()` within a namespace returns the process ID of the process within the current PID namespace.
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/core_api/atomic.md
+
+- Translation time: 2025-05-19 01:41:25
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Atomic Variables
+
+## Introduction
+
+  DragonOS implements atomic variables of type `atomic_t`. Atomic variables are implemented using architecture-specific atomic operation instructions. The specific implementation is located in `kernel/common/atomic.h`.
+
+## API
+
+   Note that all the following APIs are atomic operations.
+
+### `inline void atomic_add(atomic_t *ato, long val)`
+
+#### Description
+
+   Atomically adds a specified value to the atomic variable.
+
+#### Parameters
+
+**ato**
+
+   The atomic variable object.
+
+**val**
+
+   The value to be added to the variable.
+
+### `inline void atomic_sub(atomic_t *ato, long val)`
+
+#### Description
+
+   Atomically subtracts a specified value from the atomic variable.
+
+#### Parameters
+
+**ato**
+
+   The atomic variable object.
+
+**val**
+
+   The value to be subtracted from the variable.
+
+### `void atomic_inc(atomic_t *ato)`
+
+#### Description
+
+   Atomically increments the atomic variable by 1.
+
+#### Parameters
+
+**ato**
+
+   The atomic variable object.
+
+### `void atomic_dec(atomic_t *ato)`
+
+#### Description
+
+   Atomically decrements the atomic variable by 1.
+
+#### Parameters
+
+**ato**
+
+   The atomic variable object.
+
+### `inline void atomic_set_mask(atomic_t *ato, long mask)`
+
+#### Description
+
+   Performs a bitwise OR operation between the atomic variable and the mask variable.
+
+#### Parameters
+
+**ato**
+
+   The atomic variable object.
+
+**mask**
+
+   The variable used for the OR operation with the atomic variable.
+
+### `inline void atomic_clear_mask(atomic_t *ato, long mask)`
+
+#### Description
+
+   Performs a bitwise AND operation between the atomic variable and the mask variable.
+
+#### Parameters
+
+**ato**
+
+   The atomic variable object.
+
+**mask**
+
+   The variable used for the AND operation with the atomic variable.
+ return <Self as FromPrimitive>::from_i32(-errno);
+ }
+
+ /// @brief 把系统错误枚举类型转换为负数posix错误码。
+ pub fn to_posix_errno(&self) -> i32 {
+ return -<Self as ToPrimitive>::to_i32(self).unwrap();
+ }
+}
+```
+
+  These two functions well illustrate how to use these two traits.
+
+## 2. Arc Type Conversion
+
+### 2.1 Conversion from Arc<dyn U> to Arc<T>
+
+  When we need to convert an `Arc<dyn U>` to a specific type pointer of `Arc<T>`, we need to implement the `DowncastArc` trait for `U`. This trait is defined in `kernel/src/libs/casting.rs`. It requires `trait U` to implement the `Any + Sync + Send` trait.
+
+  To implement the `DowncastArc` trait for `trait U: Any + Send + Sync`, you need to do the following:
+### `list_for_each_entry_safe_continue(pos, n, head, member)`
+
+#### Description
+
+  Continue iterating through the list from the next element of the specified position (supports deletion of the current list node).
+
+#### Parameters
+
+**pos**
+
+  Pointer to a structure of the specific type. This pointer is used as the iteration pointer.
+
+**n**
+
+  Pointer to store the temporary value (same type as pos).
+
+**head**
+
+  Pointer to the struct List structure to start iteration from.
+
+**member**
+
+  The name of the List member in the structure pointed to by pos.
+
+### `list_for_each_entry_safe_continue_reverse(pos, n, head, member)`
+
+#### Description
+
+  Iterate through the list in reverse order, starting from the previous element of the specified position (supports deletion of the current list node).
+
+#### Parameters
+
+  Same as {ref}`list_for_each_entry_safe_continue() <_list_for_each_entry_safe_continue>`
+
+### `list_for_each_entry_safe_from(pos, n, head, member)`
+
+#### Description
+
+  Continue iterating through the list from the specified position (supports deletion of the current list node).
+
+#### Parameters
+
+  Same as {ref}`list_for_each_entry_safe_continue() <_list_for_each_entry_safe_continue>`
+
+---
+
+## Basic C Function Library
+
+  Kernel programming differs from application layer programming; you will not be able to use functions from LibC. To address this, the kernel implements some commonly used C language functions, trying to make their behavior as close as possible to standard C library functions. It is important to note that the behavior of these functions may differ from standard C library functions, so it is recommended to carefully read the following documentation, which will be helpful to you.
+
+### String Operations
+
+#### `int strlen(const char *s)`
+
+##### Description
+
+  Measure and return the length of the string.
+
+##### Parameters
+
+**src**
+
+  Source string.
+
+#### `long strnlen(const char *src, unsigned long maxlen)`
+
+##### Description
+
+  Measure and return the length of the string. If the string length is greater than maxlen, return maxlen.
+
+##### Parameters
+
+**src**
+
+  Source string.
+
+**maxlen**
+
+  Maximum length.
+
+#### `long strnlen_user(const char *src, unsigned long maxlen)`
+
+##### Description
+
+  Measure and return the length of the string. If the string length is greater than maxlen, return maxlen.
+
+  This function performs address space validation, requiring the src string to be from user space. If the source string is from kernel space, it will return 0.
+
+##### Parameters
+
+**src**
+
+  Source string, located in user space.
+
+**maxlen**
+
+  Maximum length.
+
+#### `char *strncpy(char *dst, const char *src, long count)`
+
+##### Description
+
+  Copy a string of count bytes and return the dst string.
+
+##### Parameters
+
+**src**
+
+  Source string.
+
+**dst**
+
+  Destination string.
+
+**count**
+
+  Length of the source string to copy.
+
+#### `char *strcpy(char *dst, const char *src)`
+
+##### Description
+
+  Copy the source string and return the dst string.
+
+##### Parameters
+
+**src**
+
+  Source string.
+
+**dst**
+
+  Destination string.
+
+#### `long strncpy_from_user(char *dst, const char *src, unsigned long size)`
+
+##### Description
+
+  Copy a string of count bytes from user space to kernel space, and return the size of the copied string.
+
+  This function performs address space validation to prevent address space overflow issues.
+  Similar to `memcpy()`, but this function prevents data from being incorrectly overwritten when the source and destination memory regions overlap.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Notifier Chain Notification Chain
+
+## 1. Overview of Principles
+
+  The notification chain is an event notification mechanism between subsystems within the kernel or between modules within a subsystem. Essentially, a notification chain is a list of event handling functions. Each notification chain is associated with a specific type of event (e.g., reboot event). When a specific event occurs, the corresponding callback functions in the event's notification chain are called, allowing the subsystem/module to respond to the event and perform the appropriate processing.
+
+  The notification chain is somewhat similar to the subscription mechanism. It can be understood as: there is a "notifier" that maintains a list, and the "subscriber" registers its callback function into this list ("subscriber" can also unregister its callback function). When an event occurs that needs to be notified, the "notifier" traverses all the callback functions in the list and calls them, allowing all registered "subscribers" to respond and handle the event accordingly.
+
+## 2. Core Features
+
+### 2.1 Registering Callback Functions
+
+  The callback function is encapsulated into a specific structure and registered into the designated notification chain. The related method is `register`, which is used by the "subscriber".
+
+### 2.2 Unregistering Callback Functions
+
+  The callback function is removed from the designated notification chain, i.e., it is deleted from the notification chain. The related method is `unregister`, which is used by the "subscriber".
+
+### 2.3 Event Notification
+
+  When an event occurs, the notification chain related to that event performs the event notification through this method. `call_chain` This method traverses all elements in the notification chain and calls the registered callback functions in sequence. This method is used by the "notifier".
+
+## 3. Types of Notification Chains
+
+  Each type of notification chain has corresponding `register`, `unregister`, and `call_chain` interfaces, with functions as described in the core features above.
+
+- `AtomicNotifierChain`: Atomic notification chain, cannot sleep, recommended for use in interrupt context.
+- `BlockingNotifierChain`: Blocking notification chain, can sleep, recommended for use in process context.
+- `RawNotifierChain`: Raw notification chain, the caller is responsible for thread safety.
+
+## 4. Other Issues
+
+  `BlockingNotifierChain` does not currently support the sleeping functionality.
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/core_api/softirq.md
+
+- Translation time: 2025-05-19 01:41:38
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Soft Interrupt
+
+  Software interrupt, also known as the bottom half of an interrupt, is used to delay the processing of work that was not completed by the hard interrupt (the top half of the interrupt). Dividing the interrupt into two stages can effectively solve the problems of long interrupt handling time and interrupt loss.
+
+## 1. Design Philosophy
+
+  Each CPU has its own pending status. Soft interrupts are "initiated by which CPU, executed by which CPU", and the pending status of each CPU is not shared. The same soft interrupt vector can run concurrently on multiple cores.
+
+  When we need to register a new soft interrupt, we need to implement the `SoftirqVec` feature for the soft interrupt handler, and then call the `register_softirq` function to register the soft interrupt handler within the soft interrupt mechanism.
+
+  Please note that due to the reentrancy and concurrency of soft interrupts, the soft interrupt handler must ensure thread safety itself.
+
+## 2. Soft Interrupt Vector Number
+
+```rust
+pub enum SoftirqNumber {
+ /// 时钟软中断信号
+ TIMER = 0,
+ /// 帧缓冲区刷新软中断
+ VideoRefresh = 1,
+}
+```
+
+## 3. Soft Interrupt API
+
+### 3.1. SoftirqVec Feature
+
+```rust
+pub trait SoftirqVec: Send + Sync + Debug {
+ fn run(&self);
+}
+```
+
+  The feature that the soft interrupt handler needs to implement. It needs to implement the `run` function to handle the soft interrupt. When the soft interrupt is executed, the `run` function will be called.
+
+### 3.2. Softirq API
+
+#### 3.2.1. Register Soft Interrupt Vector
+
+```rust
+pub fn register_softirq(&self,
+ softirq_num: SoftirqNumber,
+ handler: Arc<dyn SoftirqVec>,
+ ) -> Result<i32, SystemError>
+```
+
+- Parameters:
+
+ - softirq_num: Interrupt vector number
+
+ - handler: The structure corresponding to the interrupt function, which needs to point to a structure variable that implements the `SoftirqVec` feature
+- Purpose: Clear the pending flag of the specified soft interrupt on the current CPU. Please note that this function is unsafe because it directly modifies the pending flag without locking.
+
+- Parameters:
+
+ - softirq_num: Interrupt vector number
+
+#### 3.2.5. Mark Soft Interrupt as to be Executed
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# USB Legacy Support
+
+## Introduction
+
+  USB Legacy Support refers to the support provided by the BIOS for USB mice and USB keyboards. On computers that support and enable USB Legacy Support, the USB mouse and keyboard are simulated by the BIOS, making them appear to the operating system as if they were PS/2 mice and keyboards.
+
+## Related
+
+- When initializing the USB controller, its USB Legacy Support should be disabled.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# How to Use GDB to Debug the Kernel
+
+## Introduction
+  GDB is a powerful open-source debugging tool that can help you better diagnose and fix errors in programs.
+
+  It provides a rich set of features that allow you to check the execution status of a program, track the execution flow of code, view and modify the values of variables, analyze memory states, and more. It can be used in conjunction with a compiler to allow you to access debugging information during the debugging process.
+
+  This tutorial will guide you on how to use `rust-gdb` to debug the kernel in DragonOS, including how to start debugging and the corresponding debugging commands.
+
+:::{note}
+If you are already familiar with the various commands of `rust-gdb`, you only need to read the first part of this tutorial.
+:::
+
+---
+## 1. Getting Started
+
+### 1.1 Preparation
+
+  Before you start debugging the kernel, you need to enable debug mode in /Kernel/Cargo.toml by changing `debug = false` to `debug = true` in the Cargo.toml file.
+
+```shell
+debug = false
+```
+  **Change to**
+```shell
+debug = true
+```
+
+### 1.2 Running DragonOS
+
+  After the preparation is complete, you can compile and run DragonOS to proceed with the subsequent debugging work.
+
+  Open a terminal in the root directory of DragonOS and use `make run` to start compiling and running DragonOS. For more help with compilation commands, see
+  Once we have set breakpoints, how can we view all the breakpoint information?
+
+  You can use `info b`, `info break`, or `info breakpoints` to view all breakpoint information:
+
+```shell
+(gdb) b 309
+Breakpoint 12 at 0xffff8000001f8f16: file /home/heyicong/.cargo/registry/src/mirrors.tuna.tsinghua.edu.cn-df7c3c540f42cdbd/thingbuf-0.1.4/src/lib.rs, line 315.
+(gdb) watch slots
+Watchpoint 13: slots
+(gdb) info b
+Num Type Disp Enb Address What
+12 breakpoint keep y 0xffff8000001f8f16 in thingbuf::Core::pop_ref<u8>
+ at /home/heyicong/.cargo/registry/src/mirrors.tuna.tsinghua.edu.cn-df7c3c540f42cdbd/thingbuf-0.1.4/src/lib.rs:315
+13 watchpoint keep y slots
+(gdb)
+```
+
+  In the above information, the breakpoint with number 12 is the one we set in line 309 of the active source file. If its `Address` is `<MULTIPLE>`, it indicates that there are identical breakpoints at multiple addresses. This is very common in loops. The breakpoint with number 13 is the watchpoint we set for the `slots` variable.
+
+  We can perform operations on breakpoints or watchpoints using the following commands:
+
+```shell
+delete <breakpoint#> # 或 d <breakpoint#> 删除对应编号的断点,在您不再需要使用这个断点的时候可以通过此命令删除断点
+delete <watchpoint#> # 或 d <watchpoint##> 删除对应编号的监视点,在您不再需要使用这个监视点的时候可以通过此命令删除监视点
+  You can use `print` or `p` to print variable values.
+
+  The `print` command is used to print the value of a variable or expression. It allows you to view the data in the program during debugging.
+
+```shell
+print <variable> # 打印对应变量名的值,例如:print my_variable 或者 p my_variable
+
+print <expression> # 打印合法表达式的值,例如:print a+b 或者 p a+b
+
+# 示例输出
+(gdb) print order
+$3 = core::sync::atomic::Ordering::SeqCst
+```
+
+```{note}
+如果您不仅想打印值,还想显示更多详细信息(例如类型信息),可以使用ptype命令。
+```
+
+  You can use the `display` command to continuously track variables or expressions. The `display` command is used to set expressions that need to be tracked and displayed every time the program stops. It is similar to the print command, but unlike print, the display command automatically prints the value of the specified expression every time the program stops, without requiring manual input of a command.
+  **To cancel an already set display command and stop automatically displaying the value of an expression, you can use the undisplay command:**
+  You can set the output format to get more information you need, for example: `print /a var`
+> Refer to [GDB Cheat Sheet](https://darkdust.net/files/GDB%20Cheat%20Sheet.pdf)
+
+```shell
+Format
+a Pointer.
+c Read as integer, print as character.
+d Integer, signed decimal.
+f Floating point number.
+o Integer, print as octal.
+s Try to treat as C string.
+t Integer, print as binary (t = „two“).
+u Integer, unsigned decimal.
+x Integer, print as hexadecimal.
+```
+
+### 2.4 Viewing the Call Stack
+
+- **Viewing the Call Stack**
+
+  When the program is paused at a breakpoint, how should you trace the program's behavior?
+
+  You can use the `backtarce` command to view the call stack. The `backtrace` command is used to print the backtrace information of the current call stack. It displays all the active function call chains during program execution, including the function names, parameters, and line numbers in the source files.
+
+```shell
+# 示例输出
+(gdb) backtrace
+#0 function1 (arg1=10, arg2=20) at file1.c:15
+#1 function2 () at file2.c:25
+#2 xx () at xx.c:8
+```
+
+  Each line of backtrace information starts with #<frame_number>, indicating the frame number. Then comes the function name and parameter list, followed by the source file name and line number.
+By viewing the backtrace information, you can understand in which functions the program is executing and the position of each function in the call stack. This is very useful for debugging the program and locating problems.
+
+- **Switching the Stack**
+
+  You can use the `frame` or `f` command to switch to the corresponding stack frame to get more information and perform operations.
+
+```shell
+frame <frame_number>
+f <frame_number>
+```
+
+  In addition to simply executing the backtrace command, you can also use some options to customize the output of the backtrace information. For example:
+```shell
+backtrace full #显示完整的符号信息,包括函数参数和局部变量。
+backtrace <frame_count> #限制回溯信息的帧数,只显示指定数量的帧。
+backtrace <frame_start>-<frame_end> #指定要显示的帧范围。
+backtrace thread <thread_id> #显示指定线程的回溯信息。
+```
+
+### 2.5 Multi-core
+
+  When debugging the kernel, you may need to view the running status of each core.
+
+  You can use the `info threads` command to view the running status of each core.
+
+```shell
+(gdb) info threads
+ Id Target Id Frame
+ 1 Thread 1.1 (CPU#0 [halted ]) 0xffff800000140a3e in Start_Kernel () at main.c:227
+ at /home/heyicong/.cargo/registry/src/mirrors.tuna.tsinghua.edu.cn-df7c3c540f42cdbd/thingbuf-0.1.4/src/lib.rs:315
+(gdb)
+```
+
+  You can use the `thread <thread_id>` command to switch to the context of a specific core to view and debug the status of that core. For example:
+
+```shell
+(gdb) thread 1
+[Switching to thread 1 (Thread 1.1)]
+#0 0xffff800000140a3e in Start_Kernel () at main.c:227
+227 hlt();
+```
+
+### 2.6 More
+
+  Next, I will introduce more commands that you may find useful during debugging:
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Performance Analysis of the Kernel Using DADK
+
+## 1. Overview
+
+This document will teach you how to use DADK to perform performance analysis on the DragonOS kernel, in order to identify and resolve potential performance bottlenecks.
+
+### 1.1 Preparation
+
+::: {note}
+Before you start, please ensure that you have installed DADK and have set up the compilation environment for the DragonOS kernel.
+:::
+
+### 1.2 What is a Flame Graph?
+
+If you haven't heard of flame graphs before, you can read this article: [How to Read Flame Graphs? - Ruanyifeng](https://www.ruanyifeng.com/blog/2017/09/flame-graph.html)
+
+In simple terms, a flame graph is an SVG image generated from performance sampling results, used to display the call stack of the CPU.
+The x-axis represents the number of samples. If a function occupies a wider width on the x-axis, it means it was sampled more frequently, indicating longer execution time. Note that the x-axis does not represent time, but rather all call stacks are merged and sorted alphabetically.
+
+A flame graph is used to identify which function at the top level occupies the largest width. If there is a "plateau" (flat area), it indicates that the function may have performance issues.
+
+Colors have no special meaning, as flame graphs represent the CPU's busy level, so warm tones are generally chosen.
+
+## 2. Configuring the DragonOS Kernel
+
+Since performance analysis requires detailed symbol table data, we need to configure the kernel compilation as follows:
+
+In `kernel/Cargo.toml`'s `[profile.release]` section, set the following two options:
+
+```toml
+[profile.release]
+debug = true
+opt-level = 1
+```
+
+This will ensure that the compiled kernel includes symbol table data, making it easier for us to perform performance analysis.
+
+## 3. Using DADK for Performance Analysis
+
+### 3.1 Booting the Kernel
+
+First, we need to boot the DragonOS kernel.
+
+```shell
+# 使用你喜欢的方式启动内核,例如:
+make run
+# 或者
+make build && make qemu-nographic
+```
+
+### 3.2 Running Your Workload
+
+After booting the kernel, we need to run some workloads in order to perform performance analysis.
+
+This can be an application or something else. Even you can choose to do nothing and simply observe the call stack of the DragonOS kernel when it is idle.
+
+### 3.3 Starting DADK for Performance Analysis
+
+In the DragonOS project directory, run the following command:
+The above command will perform performance analysis on the DragonOS kernel and generate a flame graph.
+
+Detailed explanation:
+
+- `--format flamegraph`: Specifies the output format as a flame graph.
+- `--output flame.svg`: Specifies the output filename as `flame.svg`.
+- `--interval 200ms`: Specifies the sampling interval as 200ms.
+- `--duration 20s`: Specifies the sampling duration as 20 seconds.
+- `--cpu-mask 0x1`: Specifies the CPU to be sampled as CPU 0. (This is a bitmask, meaning if you want to sample CPU 0 and 1, the cpu-mask would be 0x3)
+
+*For more parameters, please refer to `dadk profile sample --help`.*
+
+::: {note}
+Since sampling will pause vCPU, the sampling time should not be too short, otherwise it may affect the normal operation of the system.
+:::
+
+After waiting for a while, you will get a `flame.svg` file.
+
+### 3.4 Analyzing the Flame Graph
+
+Open the `flame.svg` file in a browser, and you will see a flame graph.
+
+You can click on a function in the flame graph to view its call stack.
+
+**You can right-click the image below and open it in a new tab to experience the interactive effects.**
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/debug/traceback.md
+
+- Translation time: 2025-05-19 01:41:10
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Kernel Stack Traceback
+
+## Introduction
+
+  The functionality of the kernel stack traceback is located in the `kernel/debug/traceback/` folder. It provides traceback capabilities for the kernel mode, printing the call stack to the screen.
+
+---
+
+## API
+
+### `void traceback(struct pt_regs * regs)`
+
+#### Purpose
+
+  This interface is defined in `kernel/debug/traceback/traceback.h`, which will perform a traceback on the given kernel stack and print the trace results to the screen.
+
+#### Parameters
+
+##### regs
+
+  The first stack frame of the kernel stack to start the tracing (i.e., the bottom of the stack)
+
+---
+
+## Implementation Principle
+
+  After the kernel is linked for the first time, the Makefile will run the `kernel/debug/kallsyms` program to extract the symbol table of the kernel file, and then generate `kernel/debug/kallsyms.S`. The rodata segment of this file stores the symbol table of the functions in the text segment. Then, this file will be compiled into `kallsyms.o`. Finally, the Makefile will again call the `ld` command to link the kallsyms.o into the kernel file.
+
+  When the `traceback` function is called, it will traverse the symbol table to find the corresponding symbols and output them.
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/filesystem/kernfs.md
+
+- Translation time: 2025-05-19 01:41:15
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# KernFS
+
+:::{note}
+
+Maintainer:
+- Long Jin <longjin@dragonos.org>
+:::
+
+## 1. Introduction
+  KernFS is a pseudo file system that acts as a container for other kernel file systems, providing a file interface to users. Its core functionality is that when files in KernFS are read/written or trigger callback points, the predefined callback functions will be invoked, triggering operations on other kernel file systems.
+
+  This design decouples the basic operations of SysFS and file systems. KernFS serves as the carrier of SysFS, allowing SysFS to focus more on the management of KObjects, resulting in more elegant code.
+
+  In the future, the kernel subsystem of DragonOS or other kernel file systems can use KernFS as a carrier for file system operations, decoupling the system management logic from specific file system operations.
+
+## 2. Usage
+
+  Taking SysFS as an example, a new KernFS instance is created as the file system interface for SysFS, and then it is mounted under the directory `/sys`. Then, sysfs implements the upper-layer logic to manage KObjects. Each upper-layer KObject must include a KernFSInode. By setting the PrivateData of KernFSInode, KernFS can retrieve the corresponding KObject or sysfs attribute based on the Inode. Furthermore, when creating a KernFSInode, different callbacks are passed to the specific Inode, enabling "different Inodes to trigger different callback behaviors when read or written."
+
+  When a callback occurs, KernFS passes the callback information and private information to the callback function, allowing the callback function to retrieve the corresponding KObject or sysfs attribute based on the input information, thus achieving the high-level functionality provided by sysfs.
+
+  From the above description, we can see that KernFS achieves the purpose of "decoupling specific file operations from high-level management logic" by storing the callback functions and callback information of the upper-layer file systems.
+  For the specific meaning of the interfaces, you can refer to the relevant documentation of Linux.
+
+## Virtual File System (VFS)
+
+  VFS is the core of the DragonOS file system, providing a unified set of file system interfaces, allowing DragonOS to support various different file systems. The main functions of VFS include:
+
+- Provide a unified file system interface
+- Provide file system mounting and unmounting mechanism (MountFS)
+- Provide file abstraction (File)
+- Provide file system abstraction (FileSystem)
+- Provide IndexNode abstraction
+- Provide file system caching and synchronization mechanism (not implemented yet)
+
+  For detailed introduction of VFS, please see [DragonOS Virtual File System](vfs/index.rst).
+
+## Specific File Systems
+
+  The file systems currently supported by DragonOS include:
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/filesystem/sysfs.md
+
+- Translation time: 2025-05-19 01:41:50
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# SysFS
+
+:::{note}
+Author: Huang Ting
+
+Email: <huangting@DragonOS.org>
+:::
+
+## 1. SysFS and Device Driver Model
+
+### 1.1. The relationship between devices, drivers, buses, etc., is complex
+
+  If you want the kernel to run smoothly, you must code these functionalities for each module. This will make the kernel very bloated and redundant. The idea of the device model is to abstract these codes into a shared framework for all modules. This not only makes the code concise, but also allows device driver developers to avoid the headache of this essential but burdensome task, and focus their limited energy on implementing the differences of the devices.
+
+  The device model provides a template, an optimal approach and process that has been proven. This reduces unnecessary errors during the development process and clears the way for future maintenance.
+
+### 1.2. sysfs is a memory-based file system, its role is to provide kernel information in the form of files for user programs to use.
+
+  sysfs can be seen as a file system similar to proc, devfs, and devpty. This file system is virtual and can make it easier to manage system devices. It can generate a hierarchical view of all system hardware, similar to the proc file system that provides process and status information. sysfs organizes the devices and buses connected to the system into a hierarchical file structure, which can be accessed from user space, exporting kernel data structures and their attributes to user space.
+
+## 2. Device Driver Model in DragonOS
+
+### 2.1. The basic elements are composed of devices and drivers
+
+#### 2.1.1. Device
+
+```rust
+/// @brief: 所有设备都应该实现该trait
+pub trait Device: Any + Send + Sync + Debug {}
+```
+
+  DragonOS uses a global device manager to manage all devices in the system.
+ sys_info: Option<Arc<dyn IndexNode>>, // sys information
+}
+```
+
+### 2.2. Bus
+
+  Bus is a type of device, and it also needs a driver to initialize. Due to the special nature of buses, a global bus manager is used for management.
+  As can be seen, each manager contains a sys_info. The device model establishes a connection with sysfs through this member, and sys_info points to the unique inode in sysfs. For a device, it corresponds to the devices folder under sysfs, and the same applies to other components.
+
+## 3. How to Develop Drivers
+
+  Taking the platform bus as an example, the platform bus is a virtual bus that can match devices and drivers mounted on it and drive the devices. This bus is a type of device and also a type of bus. When programming, you need to create an instance of this device and implement the Device trait and Bus trait for the device instance to indicate that this structure is a bus device. At the same time, the matching rules on the bus should be implemented. Different buses have different matching rules. This bus uses a matching table for matching, and both devices and drivers should have a matching table, indicating the devices supported by the driver and the drivers supported by the device.
+ match sys_bus_register(&bus.get_id_table().to_name()) {
+ Ok(inode) => {
+ let _ = sys_bus_init(&inode);
+ return device_register(bus);
+ }
+ Err(_) => Err(DeviceError::RegisterError),
+ }
+}
+```
+
+  From the source code of bus_register, we can see that this function not only generates a bus folder under sysfs/bus, but also internally calls device_register. This function adds the bus to the device manager and generates a device folder under sys/devices.
+ Please report issues via `Community Channel <https://github.com/DragonOS-Community/DragonOS/issues>`_
+
+====================================
+Union Filesystem
+====================================
+Union Filesystem:
+OverlayFS merges multiple filesystems (referred to as "layers") into a single logical filesystem, allowing users to see a unified directory structure.
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# overlayfs
+
+OverlayFS is currently the most widely used union file system, with a simple principle and convenient usage, mainly used in containers.
+
+In Docker, OverlayFS is one of the default storage drivers. Docker creates an independent upper directory for each container, while all containers share the same lower image file. This design makes resource sharing between containers more efficient and reduces storage requirements.
+
+## Architecture Design
+
+OverlayFS has two layers and a virtual merged layer.
+
+- **Lower Layer (Lower Layer)**: Usually a read-only file system. It can contain multiple layers.
+- **Upper Layer (Upper Layer)**: A writable layer. All write operations are performed on this layer.
+- **Merged Layer (Merged Layer)**: The logical view of the upper and lower layers is merged, and the final file system presented to the user is shown.
+
+## Working Principle
+
+- **Read Operation**:
+ - OverlayFS will first read the file from the Upper Layer. If the file does not exist in the upper layer, it will read the content from the Lower Layer.
+- **Write Operation**:
+ - If a file is located in the Lower Layer and an attempt is made to write to it, the system will copy it up to the Upper Layer and then write to it in the upper layer. If the file already exists in the Upper Layer, it will be directly written to that layer.
+- **Delete Operation**:
+ - When deleting a file, OverlayFS creates a whiteout entry in the upper layer, which hides the file in the lower layer.
+
+## Copy-up
+
+- **Copy-on-Write (Write-time Copy)**
+When a file in the lower layer is modified, it is copied to the upper layer (called copy-up). All subsequent modifications will be performed on the copied file in the upper layer.
+
+## Implementation Logic
+
+The implementation is achieved by building `ovlInode` to implement the `indexnode` trait to represent the inode of the upper or lower layer. Specific operations related to files and directories are handled accordingly.
+  The File structure is the most basic abstraction in VFS, representing an opened file. Whenever a process opens a file, a File structure is created to maintain the state information of that file.
+
+## 2. Traits
+
+  For each specific file system, the following traits must be implemented:
+
+- FileSystem: Indicates that a struct is a file system
+- IndexNode: Indicates that a struct is an index node
+
+  Generally, there is a one-to-one relationship between FileSystem and IndexNode, meaning that one file system corresponds to one type of IndexNode. However, for some special file systems, such as DevFS, different IndexNodes may exist based on different device types. Therefore, there is a one-to-many relationship between FileSystem and IndexNode.
+
+## 3. MountFS
+
+  Although MountFS implements the FileSystem and IndexNode traits, it is not itself a "file system," but rather a mechanism used to mount different file systems onto the same file system tree.
+All file systems that need to be mounted onto the file system tree must go through MountFS to complete the mounting process. In other words, each file system structure in the mount tree is wrapped with a MountFS structure.
+
+  For most operations, MountFS simply forwards the operation to the specific file system without any processing. At the same time, to support cross-file system operations, such as searching in a directory tree, each lookup or find operation will go through the corresponding method of MountFSInode to determine whether the current inode is a mount point and handle it specially. If the operation is found to cross the boundary of a specific file system, MountFS will forward the operation to the next file system and perform an inode replacement. This functionality is implemented by wrapping a regular Inode structure with a MountFSInode structure.
+ Please report issues via `Community Channel <https://github.com/DragonOS-Community/DragonOS/issues>`_
+
+VFS Virtual File System
+====================================
+
+In DragonOS, VFS acts as an adapter, hiding the differences between specific file systems and providing a unified file operation interface abstraction to the outside.
+
+VFS is the core of the file system in DragonOS. It provides a set of unified file system interfaces, enabling DragonOS to support various different file systems. The main functions of VFS include:
+
+- Providing a unified file system interface
+- Providing mount and unmount mechanisms for file systems (MountFS)
+- Providing file abstraction (File)
+- Providing file system abstraction (FileSystem)
+- Providing IndexNode abstraction
+- Providing caching and synchronization mechanisms for file systems (not yet implemented)
+This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+- Source document: kernel/ipc/signal.md
+
+- Translation time: 2025-05-19 01:41:43
+
+- Translation model: `Qwen/Qwen3-8B`
+
+Please report issues via [Community Channel](https://github.com/DragonOS-Community/DragonOS/issues)
+
+:::
+
+# Signal Signal
+
+:::{note}
+This document Maintainer: Longjin
+
+Email: <longjin@RinGoTek.cn>
+:::
+
+  Signals are a mechanism for inter-process communication. When a signal is sent to a specific process, it can trigger a specific behavior (such as exiting the program or running a signal handler). Signals are asynchronous notifications sent to a process or a specific thread within the same process, used to notify it that an event has occurred. Common uses of signals include interrupting, suspending, terminating, or ending a process. When sending a signal, the operating system interrupts the normal execution flow of the target process to deliver the signal. Execution can be interrupted at any non-atomic instruction. If the process has previously registered a signal handler, the handler routine is executed. Otherwise, the default signal handler is executed.
+
+  Signals are similar to interrupts, with the difference being that interrupts are mediated by the CPU and handled by the kernel, while signals are generated within the kernel (and can also be generated through system calls) and are handled by the default handlers of individual processes or the kernel.
+
+## 1. Overview of Signal Handling
+
+### 1.1 Signal Sending
+
+  When process A wants to send a signal to process B, it uses the `kill(pid, signal)` interface to send the signal. Then, it enters the `sys_kill()` function in the kernel for processing. The kernel will then add the signal to the `sigpending` in the target process's PCB.
+
+Illustration:
+
+```text
+ ┌────────────┐
+ │ Process A: │
+ │ │
+ │ sys_kill │
+ └──────┬─────┘
+ │
+ │
+ ┌──────▼──────┐ ┌────────────────────┐
+ │ Send Signal ├────►Add to sigpending of│
+ └─────────────┘ │ process B. │
+ └────────────────────┘
+
+```
+
+### 1.2 Signal Handling
+
+  When a process exits the kernel mode, it jumps into the `do_signal()` function to check if there are any signals that need to be handled. If there are, the signal handling process is initiated.
+ │ userland ├─►sa_restorer ├──────────────►│Restore the stack│
+ │ sig handler │ └────────────┘ │ frame. │
+ └──────────────┘ └─────────────────┘
+
+```
+
+- If the kernel checks and finds that the process has not specified a signal handler and the signal handling action is not "ignore", the process will be terminated.
+- If the kernel finds that the signal is not ignored, it will:
+ - Save the current kernel stack
+ - Set up the user-mode stack frame for signal handling
+ - Return to user mode and execute the signal handler
+ - After the signal handler finishes, it will enter the __sa_restorer__ provided by libc, initiating the `sys_sigreturn()` system call to return to kernel mode
+ - The kernel restores the kernel stack before handling the signal.
+ - The signal handling process ends, and the kernel continues with the process of returning to user mode.
+- If the kernel finds that the current signal is being ignored, it checks the next signal.
+- If no signals need to be handled, it returns to user mode.
+ This document was automatically translated by `Qwen/Qwen3-8B` model, for reference only.
+
+ - Source document: kernel/ktest/index.rst
+
+ - Translation time: 2025-05-19 01:41:16
+
+ - Translation model: `Qwen/Qwen3-8B`
+
+
+ Please report issues via `Community Channel <https://github.com/DragonOS-Community/DragonOS/issues>`_
+
+====================================
+Kernel Testing
+====================================
+
+ This chapter will introduce how to test the kernel, including manual testing and automated testing.
+
+ We need to perform thorough testing on the kernel as much as possible, so that we can better ensure the stability of the kernel and reduce the difficulty of debugging other modules.
+
+ Setting up comprehensive test cases can help us detect problems as much as possible, preventing us from being "stabbed" by hidden bugs in existing modules when writing new modules.
+
+ Since it is difficult to debug using tools like GDB, manual testing in the kernel is more challenging compared to testing applications.
+
+ For some modules, we can write code for unit testing and output error messages. Unfortunately, not all modules can be unit tested. For example, common modules such as memory management and process management cannot be unit tested.
Some files were not shown because too many files changed in this diff