2. cap_access
3. 1. Overview
4. 2. Core Architecture
5. 1. 2.1. Capability System
   2. 2.2. Object Protection with WithCap
   3. 2.3. Access Control Methods
6. 3. Usage Guide
7. 4. ArceOS Integration
8. 5. Development Guide
9. 1. 5.1. Build System and CI
   2. 5.2. Multi-Platform Support
11. kspin
12. 6. Overview
13. 1. 6.1. Project Structure and Dependencies
14. 7. Spinlock Types and Public API
15. 1. 7.1. SpinRaw
    2. 7.2. SpinNoPreempt
    3. 7.3. SpinNoIrq
    4. 7.4. Usage Guidelines and Safety
16. 8. Core Implementation Architecture
17. 1. 8.1. BaseSpinLock and BaseSpinLockGuard
    2. 8.2. BaseGuard Trait System
    3. 8.3. SMP vs Single-Core Implementation
    4. 8.4. Memory Ordering and Atomic Operations
18. 9. Development and Building
19. 1. 9.1. Build System and Feature Flags
    2. 9.2. Testing and CI Pipeline
    3. 9.3. Development Environment Setup
21. kernel_guard
22. 10. Overview
23. 11. Core Architecture
24. 1. 11.1. RAII Guards
    2. 11.2. Trait System
25. 12. Multi-Architecture Support
26. 1. 12.1. Architecture Abstraction Layer
    2. 12.2. x86/x86_64 Implementation
    3. 12.3. RISC-V Implementation
    4. 12.4. AArch64 Implementation
    5. 12.5. LoongArch64 Implementation
27. 13. Integration Guide
28. 1. 13.1. Feature Configuration
    2. 13.2. Implementing KernelGuardIf
29. 14. Development
30. 1. 14.1. Build System and CI
    2. 14.2. Development Environment
32. timer_list
33. 15. Overview
34. 16. Core API Reference
35. 1. 16.1. TimerList Data Structure
    2. 16.2. TimerEvent System
36. 17. Usage Guide and Examples
37. 18. Development Workflow
38. 1. 18.1. Building and Testing
    2. 18.2. Project Structure
40. slab_allocator
41. 19. Overview
42. 20. Getting Started
43. 21. Core Architecture
44. 1. 21.1. Heap Allocator Design
    2. 21.2. Slab Implementation
45. 22. API Reference
46. 23. Testing and Validation
47. 24. Development Workflow
49. cpumask
50. 25. Overview
51. 26. API Reference
52. 1. 26.1. Construction and Conversion Methods
    2. 26.2. Query and Inspection Operations
    3. 26.3. Modification and Iteration
    4. 26.4. Bitwise Operations and Traits
53. 27. Architecture and Design
54. 28. Usage Guide and Examples
55. 29. Development and Contribution
57. axcpu
58. 30. Overview
59. 31. x86_64 Architecture
60. 1. 31.1. x86_64 Context Management
    2. 31.2. x86_64 Trap and Exception Handling
    3. 31.3. x86_64 System Calls
    4. 31.4. x86_64 System Initialization
61. 32. AArch64 Architecture
62. 1. 32.1. AArch64 Context Management
    2. 32.2. AArch64 Trap and Exception Handling
    3. 32.3. AArch64 System Initialization
63. 33. RISC-V Architecture
64. 1. 33.1. RISC-V Context Management
    2. 33.2. RISC-V Trap and Exception Handling
    3. 33.3. RISC-V System Initialization
65. 34. LoongArch64 Architecture
66. 1. 34.1. LoongArch64 Context Management
    2. 34.2. LoongArch64 Assembly Operations
    3. 34.3. LoongArch64 System Initialization
67. 35. Cross-Architecture Features
68. 1. 35.1. User Space Support
    2. 35.2. Core Trap Handling Framework
69. 36. Development and Build Configuration
70. 1. 36.1. Dependencies and Package Structure
    2. 36.2. Toolchain Configuration
72. axfs_crates
73. 37. Overview
74. 1. 37.1. Repository Structure
    2. 37.2. Development and Contribution
75. 38. File System Architecture
76. 1. 38.1. Virtual File System Interface (axfs_vfs)
77. 39. Device File System (axfs_devfs)
78. 1. 39.1. Directory Structure
    2. 39.2. Null Device
    3. 39.3. Zero Device
    4. 39.4. Usage Examples
79. 40. RAM File System (axfs_ramfs)
81. scheduler
82. 41. Overview
83. 42. Core Architecture
84. 43. Scheduler Implementations
85. 1. 43.1. FIFO Scheduler
    2. 43.2. Completely Fair Scheduler (CFS)
    3. 43.3. Round Robin Scheduler
    4. 43.4. Scheduler Comparison
86. 44. Testing Framework
87. 45. Development Guide
89. tuple_for_each
90. 46. Overview
91. 1. 46.1. Project Structure
92. 47. Getting Started
93. 1. 47.1. Basic Usage
    2. 47.2. Generated Functionality
94. 48. Implementation Guide
95. 1. 48.1. Derive Macro Processing
    2. 48.2. Code Generation Pipeline
96. 49. Development
97. 1. 49.1. Testing
    2. 49.2. CI/CD Pipeline
98. 50. API Reference
99. 1. 50.1. TupleForEach Derive Macro
    2. 50.2. Generated Macros
    3. 50.3. Generated Methods
101. allocator
102. 51. Overview
103. 52. Architecture and Design
104. 53. Allocator Implementations
105. 1. 53.1. Bitmap Page Allocator
     2. 53.2. Buddy System Allocator
     3. 53.3. Slab Allocator
     4. 53.4. TLSF Allocator
106. 54. Usage and Configuration
107. 55. Testing and Benchmarks
108. 1. 55.1. Integration Tests
     2. 55.2. Performance Benchmarks
109. 56. Development and Contributing
111. axmm_crates
112. 57. Overview
113. 1. 57.1. System Architecture
114. 58. memory_addr Crate
115. 1. 58.1. Address Types and Operations
     2. 58.2. Address Ranges
     3. 58.3. Page Iteration
116. 59. memory_set Crate
117. 1. 59.1. MemorySet Core
     2. 59.2. MemoryArea
     3. 59.3. MappingBackend
     4. 59.4. Usage Examples and Testing
118. 60. Development Guide
120. arm_pl031
121. 61. Overview
122. 1. 61.1. Project Purpose and Scope
     2. 61.2. System Architecture
123. 62. Getting Started
124. 1. 62.1. Installation and Dependencies
     2. 62.2. Basic Usage and Examples
125. 63. Core Driver Implementation
126. 1. 63.1. Driver Architecture and Design
     2. 63.2. Hardware Interface and MMIO
     3. 63.3. Register Operations
     4. 63.4. Interrupt Handling
     5. 63.5. Memory Safety and Concurrency
127. 64. Features and Extensions
128. 1. 64.1. Chrono Integration
     2. 64.2. Feature Configuration
129. 65. Development and Contributing
130. 1. 65.1. Building and Testing
     2. 65.2. API Evolution and Changelog
     3. 65.3. Development Environment
132. crate_interface
133. 66. Overview
134. 67. Getting Started
135. 68. Macro Reference
136. 1. 68.1. def_interface Macro
     2. 68.2. impl_interface Macro
     3. 68.3. call_interface Macro
137. 69. Architecture and Internals
138. 70. Development Guide
139. 1. 70.1. Testing
     2. 70.2. CI/CD Pipeline
     3. 70.3. Project Structure
141. lazyinit
142. 71. Overview
143. 72. LazyInit Implementation
144. 1. 72.1. API Reference
     2. 72.2. Thread Safety & Memory Model
     3. 72.3. Usage Patterns & Examples
145. 73. Project Configuration
146. 74. Development & Contributing
147. 1. 74.1. CI/CD Pipeline
     2. 74.2. Development Environment Setup
149. linked_list_r4l
150. 75. Overview
151. 76. Quick Start Guide
152. 77. Architecture Overview
153. 78. API Reference
154. 1. 78.1. User-Friendly API
     2. 78.2. Advanced API
     3. 78.3. Low-Level API
155. 79. Core Concepts
156. 1. 79.1. Memory Management
     2. 79.2. Thread Safety
157. 80. Development Guide
159. arm_pl011
160. 81. Overview
161. 1. 81.1. Architecture
     2. 81.2. Getting Started
162. 82. Core Implementation
163. 1. 82.1. Register Definitions
     2. 82.2. UART Operations
164. 83. API Reference
165. 1. 83.1. Pl011Uart Methods
     2. 83.2. Thread Safety and Memory Safety
166. 84. Development
167. 1. 84.1. Building and Testing
     2. 84.2. CI/CD Pipeline
168. 85. Hardware Reference
170. handler_table
171. 86. Introduction
172. 1. 86.1. ArceOS Integration
     2. 86.2. Lock-free Design Benefits
173. 87. User Guide
174. 1. 87.1. API Reference
     2. 87.2. Usage Examples
175. 88. Implementation Details
176. 1. 88.1. Atomic Operations
     2. 88.2. Memory Layout and Safety
177. 89. Development Guide
178. 1. 89.1. Building and Testing
     2. 89.2. CI/CD Pipeline
180. memory_set
181. 90. Overview
182. 1. 90.1. Core Concepts
     2. 90.2. System Architecture
183. 91. Implementation Details
184. 1. 91.1. MemoryArea and MappingBackend
     2. 91.2. MemorySet Collection Management
     3. 91.3. Public API and Error Handling
185. 92. Usage and Examples
186. 1. 92.1. Basic Usage Patterns
     2. 92.2. Advanced Examples and Testing
187. 93. Development and Project Setup
188. 1. 93.1. Dependencies and Configuration
     2. 93.2. Development Workflow
190. int_ratio
191. 94. Overview
192. 95. Ratio Type Implementation
193. 1. 95.1. Internal Architecture
     2. 95.2. API Reference
     3. 95.3. Mathematical Foundation
194. 96. Usage Guide
195. 97. Development Guide
197. flatten_objects
198. 98. Overview
199. 1. 98.1. Project Structure and Dependencies
     2. 98.2. Key Concepts and Terminology
200. 99. FlattenObjects API Documentation
201. 1. 99.1. Container Creation and Configuration
     2. 99.2. Object Management Operations
     3. 99.3. Query and Inspection Methods
202. 100. Implementation Details
203. 1. 100.1. Internal Data Structures
     2. 100.2. Memory Management and Safety
     3. 100.3. ID Management System
204. 101. Usage Guide and Examples
205. 1. 101.1. Basic Operations
     2. 101.2. Advanced Patterns and Best Practices
206. 102. Development and Maintenance
207. 1. 102.1. Building and Testing
     2. 102.2. Project Configuration
209. arm_gicv2
210. 103. Overview
211. 104. Interrupt System Architecture
212. 1. 104.1. Interrupt Types and Ranges
     2. 104.2. Trigger Modes and Translation
213. 105. Hardware Interface Implementation
214. 1. 105.1. GIC Distributor
     2. 105.2. GIC CPU Interface
215. 106. Development Guide
216. 1. 106.1. Build System and Dependencies
     2. 106.2. CI/CD Pipeline
     3. 106.3. Development Environment
218. axconfig-gen
219. 107. Overview
220. 1. 107.1. System Architecture
     2. 107.2. Quick Start Guide
221. 108. axconfig-gen Package
222. 1. 108.1. Command Line Interface
     2. 108.2. Library API
     3. 1. 108.2.1. Core Data Structures
        2. 108.2.2. Type System
        3. 108.2.3. Output Generation
223. 109. axconfig-macros Package
224. 1. 109.1. Macro Usage Patterns
     2. 109.2. Macro Implementation
225. 110. Configuration Examples
226. 1. 110.1. TOML Configuration Format
     2. 110.2. Generated Output Examples
227. 111. Development Guide
228. 1. 111.1. Build System and Dependencies
     2. 111.2. Testing
     3. 111.3. Continuous Integration
230. page_table_multiarch
231. 112. Overview
232. 1. 112.1. System Architecture
     2. 112.2. Supported Platforms
233. 113. Workspace Structure
234. 1. 113.1. page_table_multiarch Crate
     2. 113.2. page_table_entry Crate
235. 114. Core Concepts
236. 1. 114.1. PageTable64 Implementation
     2. 114.2. Generic Traits System
     3. 114.3. Memory Mapping Flags
237. 115. Architecture Support
238. 1. 115.1. x86_64 Support
     2. 115.2. AArch64 Support
     3. 115.3. RISC-V Support
     4. 115.4. LoongArch64 Support
239. 116. Development Guide
240. 1. 116.1. Building and Testing
     2. 116.2. Contributing
242. x86_rtc
243. 117. Overview
244. 1. 117.1. Crate Definition and Metadata
     2. 117.2. Quick Start Guide
245. 118. Implementation
246. 1. 118.1. RTC Driver API
     2. 118.2. CMOS Hardware Interface
     3. 118.3. Data Format Handling
247. 119. Dependencies and Platform Support
248. 1. 119.1. Dependency Analysis
     2. 119.2. Platform and Architecture Requirements
249. 120. Development Workflow
250. 1. 120.1. CI/CD Pipeline
     2. 120.2. Development Environment Setup
252. percpu
253. 121. Overview
254. 1. 121.1. System Components
     2. 121.2. Supported Platforms
255. 122. Getting Started
256. 1. 122.1. Installation and Setup
     2. 122.2. Basic Usage Examples
     3. 122.3. Feature Flags Configuration
257. 123. Architecture and Design
258. 1. 123.1. Memory Layout and Initialization
     2. 123.2. Cross-Platform Abstraction
     3. 123.3. Code Generation Pipeline
259. 124. API Reference
260. 1. 124.1. def_percpu Macro
     2. 124.2. Runtime Functions
     3. 124.3. Safety and Preemption
261. 125. Implementation Details
262. 1. 125.1. Architecture-Specific Code Generation
     2. 125.2. Naive Implementation
     3. 125.3. Memory Management Internals
263. 126. Development and Testing
264. 1. 126.1. Testing Guide
     2. 126.2. Build System
     3. 126.3. Contributing
266. axdriver_crates
267. 127. Overview
268. 128. Architecture and Design
269. 129. Foundation Layer (axdriver_base)
270. 130. Network Drivers
271. 1. 130.1. Network Driver Interface
     2. 130.2. Network Buffer Management
     3. 130.3. Hardware Implementations
272. 131. Block Storage Drivers
273. 1. 131.1. Block Driver Interface
     2. 131.2. Block Device Implementations
274. 132. Display Drivers
275. 133. VirtIO Integration
276. 1. 133.1. VirtIO Core Abstraction
     2. 133.2. VirtIO Device Implementations
277. 134. PCI Bus Operations
278. 135. Development and Build Configuration
280. axio
281. 136. Overview
282. 137. Core I/O Traits
283. 138. Crate Configuration and Features
284. 139. Implementations
285. 1. 139.1. Buffered I/O
     2. 139.2. Basic Type Implementations
286. 140. Supporting Systems
287. 1. 140.1. Error Handling
     2. 140.2. Prelude Module
288. 141. Development and Maintenance
289. 1. 141.1. Build System and CI
     2. 141.2. Project Configuration
291. riscv_goldfish
292. 142. Overview
293. 1. 142.1. Architecture Overview
294. 143. RTC Driver Implementation
295. 1. 143.1. API Reference
     2. 143.2. Hardware Interface
     3. 143.3. Time Conversion
296. 144. Project Configuration
297. 1. 144.1. Target Platforms and Cross-Compilation
     2. 144.2. Licensing and Distribution
298. 145. Development Workflow
299. 1. 145.1. CI/CD Pipeline
     2. 145.2. Development Environment Setup