1 use core::{
2     ffi::c_void,
3     ptr::{null_mut, read_volatile, write_volatile},
4 };
5 
6 use alloc::boxed::Box;
7 
8 use crate::{
9     arch::asm::current::current_pcb,
10     filesystem::vfs::file::{File, FileDescriptorVec},
11     include::bindings::bindings::{
12         process_control_block, CLONE_FS, EBADF, EFAULT, ENFILE, EPERM, PROC_RUNNING, PROC_STOPPED,
13     },
14     sched::core::{cpu_executing, sched_enqueue},
15     smp::core::{smp_get_processor_id, smp_send_reschedule},
16 };
17 
18 use super::preempt::{preempt_disable, preempt_enable};
19 
20 /// 判断进程是否已经停止
21 #[no_mangle]
process_is_stopped(pcb: *const process_control_block) -> bool22 pub extern "C" fn process_is_stopped(pcb: *const process_control_block) -> bool {
23     let state: u64 = unsafe { read_volatile(&(*pcb).state) } as u64;
24     if (state & (PROC_STOPPED as u64)) != 0 {
25         return true;
26     } else {
27         return false;
28     }
29 }
30 
31 /// @brief 尝试唤醒指定的进程。
32 /// 本函数的行为：If (@_state & @pcb->state) @pcb->state = TASK_RUNNING.
33 ///
34 /// @param _pcb 要被唤醒的进程的pcb
35 /// @param _state 如果pcb的state与_state匹配，则唤醒这个进程
36 /// @param _wake_flags 保留，暂未使用，请置为0
37 /// @return true: 成功唤醒
38 ///         false: 不符合唤醒条件，无法唤醒
39 #[no_mangle]
process_try_to_wake_up( _pcb: *mut process_control_block, _state: u64, _wake_flags: i32, ) -> bool40 pub extern "C" fn process_try_to_wake_up(
41     _pcb: *mut process_control_block,
42     _state: u64,
43     _wake_flags: i32,
44 ) -> bool {
45     preempt_disable();
46 
47     let mut retval = false;
48     // 获取对pcb的可变引用
49     let pcb = unsafe { _pcb.as_mut() }.unwrap();
50 
51     // 如果要唤醒的就是当前的进程
52     if current_pcb() as *mut process_control_block as usize == _pcb as usize {
53         unsafe {
54             write_volatile(&mut pcb.state, PROC_RUNNING as u64);
55         }
56         preempt_enable();
57         retval = true;
58         return retval;
59     }
60     // todo: 将来调度器引入ttwu队列之后，需要修改这里的判断条件
61 
62     // todo: 为pcb引入pi_lock,然后在这里加锁
63     if unsafe { read_volatile(&pcb.state) } & _state != 0 {
64         // 可以wakeup
65         unsafe {
66             write_volatile(&mut pcb.state, PROC_RUNNING as u64);
67         }
68         sched_enqueue(pcb, true);
69 
70         retval = true;
71     }
72     // todo: 对pcb的pi_lock放锁
73     preempt_enable();
74     return retval;
75 }
76 
77 /// @brief 当进程，满足 (@state & @pcb->state)时，唤醒进程，并设置： @pcb->state = TASK_RUNNING.
78 ///
79 /// @return true 唤醒成功
80 /// @return false 唤醒失败
81 #[no_mangle]
process_wake_up_state(pcb: *mut process_control_block, state: u64) -> bool82 pub extern "C" fn process_wake_up_state(pcb: *mut process_control_block, state: u64) -> bool {
83     return process_try_to_wake_up(pcb, state, 0);
84 }
85 
86 /// @brief 让一个正在cpu上运行的进程陷入内核
process_kick(pcb: *mut process_control_block)87 pub fn process_kick(pcb: *mut process_control_block) {
88     preempt_disable();
89     let cpu = process_cpu(pcb);
90     // 如果给定的进程正在别的核心上执行，则立即发送请求，让它陷入内核态，以及时响应信号。
91     if cpu != smp_get_processor_id() && process_is_executing(pcb) {
92         smp_send_reschedule(cpu);
93     }
94     preempt_enable();
95 }
96 
97 /// @brief 获取给定的进程在哪个cpu核心上运行(使用volatile避免编译器优化)
98 #[inline]
process_cpu(pcb: *const process_control_block) -> u3299 pub fn process_cpu(pcb: *const process_control_block) -> u32 {
100     unsafe { read_volatile(&(*pcb).cpu_id) }
101 }
102 
103 /// @brief 判断给定的进程是否正在处理器上执行
104 ///
105 /// @param pcb 进程的pcb
106 #[inline]
process_is_executing(pcb: *const process_control_block) -> bool107 pub fn process_is_executing(pcb: *const process_control_block) -> bool {
108     return cpu_executing(process_cpu(pcb)) as *const process_control_block == pcb;
109 }
110 
111 impl process_control_block {
112     /// @brief 初始化进程PCB的文件描述符数组。
113     /// 请注意，如果当前进程已经有文件描述符数组，那么本操作将被禁止
init_files(&mut self) -> Result<(), i32>114     pub fn init_files(&mut self) -> Result<(), i32> {
115         if self.fds != null_mut() {
116             // 这个操作不被允许，否则会产生内存泄露。
117             // 原因是，C的pcb里面，文件描述符数组的生命周期是static的，如果继续执行，会产生内存泄露的问题。
118             return Err(-(EPERM as i32));
119         }
120         let fd_vec: &mut FileDescriptorVec = Box::leak(FileDescriptorVec::new());
121         self.fds = fd_vec as *mut FileDescriptorVec as usize as *mut c_void;
122         return Ok(());
123     }
124 
125     /// @brief 拷贝进程的文件描述符
126     ///
127     /// @param clone_flags 进程fork的克隆标志位
128     /// @param from 源pcb。从它里面拷贝文件描述符
129     ///
130     /// @return Ok(()) 拷贝成功
131     /// @return Err(i32) 拷贝失败，错误码
copy_files( &mut self, clone_flags: u64, from: &'static process_control_block, ) -> Result<(), i32>132     pub fn copy_files(
133         &mut self,
134         clone_flags: u64,
135         from: &'static process_control_block,
136     ) -> Result<(), i32> {
137         // 不拷贝父进程的文件描述符
138         if clone_flags & CLONE_FS as u64 != 0 {
139             // 由于拷贝pcb的时候，直接copy的指针，因此这里置为空
140             self.fds = null_mut();
141             self.init_files()?;
142             return Ok(());
143         }
144         // 获取源pcb的文件描述符数组的引用
145         let old_fds: &mut FileDescriptorVec = if let Some(o_fds) = FileDescriptorVec::from_pcb(from)
146         {
147             o_fds
148         } else {
149             return self.init_files();
150         };
151 
152         // 拷贝文件描述符数组
153         let new_fd_vec: &mut FileDescriptorVec = Box::leak(Box::new(old_fds.clone()));
154 
155         self.fds = new_fd_vec as *mut FileDescriptorVec as usize as *mut c_void;
156 
157         return Ok(());
158     }
159 
160     /// @brief 释放文件描述符数组。本函数会drop掉整个文件描述符数组，并把pcb的fds字段设置为空指针。
exit_files(&mut self) -> Result<(), i32>161     pub fn exit_files(&mut self) -> Result<(), i32> {
162         if self.fds.is_null() {
163             return Ok(());
164         }
165 
166         let old_fds: Box<FileDescriptorVec> =
167             unsafe { Box::from_raw(self.fds as *mut FileDescriptorVec) };
168         drop(old_fds);
169         self.fds = null_mut();
170         return Ok(());
171     }
172 
173     /// @brief 申请文件描述符，并把文件对象存入其中。
174     ///
175     /// @return Ok(i32) 申请到的文件描述符编号
176     /// @return Err(i32) 申请失败，返回错误码，并且，file对象将被drop掉
alloc_fd(&mut self, file: File) -> Result<i32, i32>177     pub fn alloc_fd(&mut self, file: File) -> Result<i32, i32> {
178         // 获取pcb的文件描述符数组的引用
179         let fds: &mut FileDescriptorVec =
180             if let Some(f) = FileDescriptorVec::from_pcb(current_pcb()) {
181                 f
182             } else {
183                 // 如果进程还没有初始化文件描述符数组，那就初始化它
184                 self.init_files().ok();
185                 let r: Option<&mut FileDescriptorVec> = FileDescriptorVec::from_pcb(current_pcb());
186                 if r.is_none() {
187                     drop(file);
188                     // 初始化失败
189                     return Err(-(EFAULT as i32));
190                 }
191                 r.unwrap()
192             };
193 
194         // 寻找空闲的文件描述符
195         let mut cnt = 0;
196         for x in fds.fds.iter_mut() {
197             if x.is_none() {
198                 *x = Some(Box::new(file));
199                 return Ok(cnt);
200             }
201             cnt += 1;
202         }
203         return Err(-(ENFILE as i32));
204     }
205 
206     /// @brief 根据文件描述符序号，获取文件结构体的可变引用
207     ///
208     /// @param fd 文件描述符序号
209     ///
210     /// @return Option(&mut File) 文件对象的可变引用
get_file_mut_by_fd(&self, fd: i32) -> Option<&mut File>211     pub fn get_file_mut_by_fd(&self, fd: i32) -> Option<&mut File> {
212         if !FileDescriptorVec::validate_fd(fd) {
213             return None;
214         }
215         let r: &mut FileDescriptorVec = FileDescriptorVec::from_pcb(current_pcb()).unwrap();
216         return r.fds[fd as usize].as_deref_mut();
217     }
218 
219     /// @brief 根据文件描述符序号，获取文件结构体的不可变引用
220     ///
221     /// @param fd 文件描述符序号
222     ///
223     /// @return Option(&File) 文件对象的不可变引用
224     #[allow(dead_code)]
get_file_ref_by_fd(&self, fd: i32) -> Option<&File>225     pub fn get_file_ref_by_fd(&self, fd: i32) -> Option<&File> {
226         if !FileDescriptorVec::validate_fd(fd) {
227             return None;
228         }
229         let r: &mut FileDescriptorVec = FileDescriptorVec::from_pcb(current_pcb()).unwrap();
230         return r.fds[fd as usize].as_deref();
231     }
232 
233     /// @brief 释放文件描述符，同时关闭文件。
234     ///
235     /// @param fd 文件描述符序号
drop_fd(&self, fd: i32) -> Result<(), i32>236     pub fn drop_fd(&self, fd: i32) -> Result<(), i32> {
237         // 判断文件描述符的数字是否超过限制
238         if !FileDescriptorVec::validate_fd(fd) {
239             return Err(-(EBADF as i32));
240         }
241         let r: &mut FileDescriptorVec = FileDescriptorVec::from_pcb(current_pcb()).unwrap();
242 
243         let f: Option<&File> = r.fds[fd as usize].as_deref();
244         if f.is_none() {
245             // 如果文件描述符不存在，报错
246             return Err(-(EBADF as i32));
247         }
248         // 释放文件
249         drop(f);
250 
251         // 把文件描述符数组对应位置设置为空
252         r.fds[fd as usize] = None;
253 
254         return Ok(());
255     }
256 }
257 
258 // =========== 导出到C的函数，在将来，进程管理模块被完全重构之后，需要删掉他们  BEGIN ============
259 
260 /// @brief 初始化当前进程的文件描述符数组
261 /// 请注意，如果当前进程已经有文件描述符数组，那么本操作将被禁止
262 #[no_mangle]
process_init_files() -> i32263 pub extern "C" fn process_init_files() -> i32 {
264     let r = current_pcb().init_files();
265     if r.is_ok() {
266         return 0;
267     } else {
268         return r.unwrap_err();
269     }
270 }
271 
272 /// @brief 拷贝当前进程的文件描述符信息
273 ///
274 /// @param clone_flags 克隆标志位
275 /// @param pcb 新的进程的pcb
276 #[no_mangle]
process_copy_files( clone_flags: u64, from: &'static process_control_block, ) -> i32277 pub extern "C" fn process_copy_files(
278     clone_flags: u64,
279     from: &'static process_control_block,
280 ) -> i32 {
281     let r = current_pcb().copy_files(clone_flags, from);
282     if r.is_ok() {
283         return 0;
284     } else {
285         return r.unwrap_err();
286     }
287 }
288 
289 /// @brief 回收进程的文件描述符数组
290 ///
291 /// @param pcb 要被回收的进程的pcb
292 ///
293 /// @return i32
294 #[no_mangle]
process_exit_files(pcb: &'static mut process_control_block) -> i32295 pub extern "C" fn process_exit_files(pcb: &'static mut process_control_block) -> i32 {
296     let r: Result<(), i32> = pcb.exit_files();
297     if r.is_ok() {
298         return 0;
299     } else {
300         return r.unwrap_err();
301     }
302 }
303 
304 // =========== 以上为导出到C的函数，在将来，进程管理模块被完全重构之后，需要删掉他们 END ============
305