mod.rs 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627
  1. use core::{
  2. arch::asm,
  3. intrinsics::unlikely,
  4. mem::ManuallyDrop,
  5. sync::atomic::{compiler_fence, Ordering},
  6. };
  7. use alloc::{
  8. string::String,
  9. sync::{Arc, Weak},
  10. vec::Vec,
  11. };
  12. use kdepends::memoffset::offset_of;
  13. use system_error::SystemError;
  14. use x86::{controlregs::Cr4, segmentation::SegmentSelector};
  15. use crate::{
  16. arch::process::table::TSSManager,
  17. exception::InterruptArch,
  18. kerror, kwarn,
  19. libs::spinlock::SpinLockGuard,
  20. mm::VirtAddr,
  21. process::{
  22. fork::{CloneFlags, KernelCloneArgs},
  23. KernelStack, ProcessControlBlock, ProcessFlags, ProcessManager, PROCESS_SWITCH_RESULT,
  24. },
  25. syscall::Syscall,
  26. };
  27. use self::{
  28. kthread::kernel_thread_bootstrap_stage1,
  29. syscall::ARCH_SET_FS,
  30. table::{switch_fs_and_gs, KERNEL_DS, USER_DS},
  31. };
  32. use super::{fpu::FpState, interrupt::TrapFrame, syscall::X86_64GSData, CurrentIrqArch};
  33. pub mod idle;
  34. pub mod kthread;
  35. pub mod syscall;
  36. pub mod table;
  37. extern "C" {
  38. /// 从中断返回
  39. fn ret_from_intr();
  40. }
  41. #[allow(dead_code)]
  42. #[repr(align(32768))]
  43. union InitProcUnion {
  44. /// 用于存放idle进程的内核栈
  45. idle_stack: [u8; 32768],
  46. }
  47. #[link_section = ".data.init_proc_union"]
  48. #[no_mangle]
  49. static BSP_IDLE_STACK_SPACE: InitProcUnion = InitProcUnion {
  50. idle_stack: [0; 32768],
  51. };
  52. /// PCB中与架构相关的信息
  53. #[derive(Debug)]
  54. #[allow(dead_code)]
  55. pub struct ArchPCBInfo {
  56. rflags: usize,
  57. rbx: usize,
  58. r12: usize,
  59. r13: usize,
  60. r14: usize,
  61. r15: usize,
  62. rbp: usize,
  63. rsp: usize,
  64. rip: usize,
  65. cr2: usize,
  66. fsbase: usize,
  67. gsbase: usize,
  68. fs: SegmentSelector,
  69. gs: SegmentSelector,
  70. /// 存储PCB系统调用栈以及在syscall过程中暂存用户态rsp的结构体
  71. gsdata: X86_64GSData,
  72. /// 浮点寄存器的状态
  73. fp_state: Option<FpState>,
  74. }
  75. #[allow(dead_code)]
  76. impl ArchPCBInfo {
  77. /// 创建一个新的ArchPCBInfo
  78. ///
  79. /// ## 参数
  80. ///
  81. /// - `kstack`:内核栈的引用,如果为None,则不会设置rsp和rbp。如果为Some,则会设置rsp和rbp为内核栈的最高地址。
  82. ///
  83. /// ## 返回值
  84. ///
  85. /// 返回一个新的ArchPCBInfo
  86. #[inline(never)]
  87. pub fn new(kstack: &KernelStack) -> Self {
  88. let mut r = Self {
  89. rflags: 0,
  90. rbx: 0,
  91. r12: 0,
  92. r13: 0,
  93. r14: 0,
  94. r15: 0,
  95. rbp: 0,
  96. rsp: 0,
  97. rip: 0,
  98. cr2: 0,
  99. fsbase: 0,
  100. gsbase: 0,
  101. gsdata: X86_64GSData {
  102. kaddr: VirtAddr::new(0),
  103. uaddr: VirtAddr::new(0),
  104. },
  105. fs: KERNEL_DS,
  106. gs: KERNEL_DS,
  107. fp_state: None,
  108. };
  109. r.rsp = kstack.stack_max_address().data() - 8;
  110. r.rbp = kstack.stack_max_address().data();
  111. return r;
  112. }
  113. pub fn set_stack(&mut self, stack: VirtAddr) {
  114. self.rsp = stack.data();
  115. }
  116. pub fn set_stack_base(&mut self, stack_base: VirtAddr) {
  117. self.rbp = stack_base.data();
  118. }
  119. pub fn rbp(&self) -> usize {
  120. self.rbp
  121. }
  122. pub unsafe fn push_to_stack(&mut self, value: usize) {
  123. self.rsp -= core::mem::size_of::<usize>();
  124. *(self.rsp as *mut usize) = value;
  125. }
  126. pub unsafe fn pop_from_stack(&mut self) -> usize {
  127. let value = *(self.rsp as *const usize);
  128. self.rsp += core::mem::size_of::<usize>();
  129. value
  130. }
  131. pub fn save_fp_state(&mut self) {
  132. if self.fp_state.is_none() {
  133. self.fp_state = Some(FpState::new());
  134. }
  135. self.fp_state.as_mut().unwrap().save();
  136. }
  137. pub fn restore_fp_state(&mut self) {
  138. if unlikely(self.fp_state.is_none()) {
  139. return;
  140. }
  141. self.fp_state.as_mut().unwrap().restore();
  142. }
  143. /// 返回浮点寄存器结构体的副本
  144. pub fn fp_state(&self) -> &Option<FpState> {
  145. &self.fp_state
  146. }
  147. // 清空浮点寄存器
  148. pub fn clear_fp_state(&mut self) {
  149. if unlikely(self.fp_state.is_none()) {
  150. kwarn!("fp_state is none");
  151. return;
  152. }
  153. self.fp_state.as_mut().unwrap().clear();
  154. }
  155. pub unsafe fn save_fsbase(&mut self) {
  156. if x86::controlregs::cr4().contains(Cr4::CR4_ENABLE_FSGSBASE) {
  157. self.fsbase = x86::current::segmentation::rdfsbase() as usize;
  158. } else {
  159. self.fsbase = x86::msr::rdmsr(x86::msr::IA32_FS_BASE) as usize;
  160. }
  161. }
  162. pub unsafe fn save_gsbase(&mut self) {
  163. if x86::controlregs::cr4().contains(Cr4::CR4_ENABLE_FSGSBASE) {
  164. self.gsbase = x86::current::segmentation::rdgsbase() as usize;
  165. } else {
  166. self.gsbase = x86::msr::rdmsr(x86::msr::IA32_GS_BASE) as usize;
  167. }
  168. }
  169. pub unsafe fn restore_fsbase(&mut self) {
  170. if x86::controlregs::cr4().contains(Cr4::CR4_ENABLE_FSGSBASE) {
  171. x86::current::segmentation::wrfsbase(self.fsbase as u64);
  172. } else {
  173. x86::msr::wrmsr(x86::msr::IA32_FS_BASE, self.fsbase as u64);
  174. }
  175. }
  176. pub unsafe fn restore_gsbase(&mut self) {
  177. if x86::controlregs::cr4().contains(Cr4::CR4_ENABLE_FSGSBASE) {
  178. x86::current::segmentation::wrgsbase(self.gsbase as u64);
  179. } else {
  180. x86::msr::wrmsr(x86::msr::IA32_GS_BASE, self.gsbase as u64);
  181. }
  182. }
  183. /// 将gsdata写入KernelGsbase寄存器
  184. pub unsafe fn store_kernel_gsbase(&self) {
  185. x86::msr::wrmsr(
  186. x86::msr::IA32_KERNEL_GSBASE,
  187. &self.gsdata as *const X86_64GSData as u64,
  188. );
  189. }
  190. /// ### 初始化系统调用栈,不得与PCB内核栈冲突(即传入的应该是一个新的栈,避免栈损坏)
  191. pub fn init_syscall_stack(&mut self, stack: &KernelStack) {
  192. self.gsdata.set_kstack(stack.stack_max_address() - 8);
  193. }
  194. pub fn fsbase(&self) -> usize {
  195. self.fsbase
  196. }
  197. pub fn gsbase(&self) -> usize {
  198. self.gsbase
  199. }
  200. pub fn cr2_mut(&mut self) -> &mut usize {
  201. &mut self.cr2
  202. }
  203. pub fn fp_state_mut(&mut self) -> &mut Option<FpState> {
  204. &mut self.fp_state
  205. }
  206. /// ### 克隆ArchPCBInfo,需要注意gsdata也是对应clone的
  207. pub fn clone_all(&self) -> Self {
  208. Self {
  209. rflags: self.rflags,
  210. rbx: self.rbx,
  211. r12: self.r12,
  212. r13: self.r13,
  213. r14: self.r14,
  214. r15: self.r15,
  215. rbp: self.rbp,
  216. rsp: self.rsp,
  217. rip: self.rip,
  218. cr2: self.cr2,
  219. fsbase: self.fsbase,
  220. gsbase: self.gsbase,
  221. fs: self.fs,
  222. gs: self.gs,
  223. gsdata: self.gsdata.clone(),
  224. fp_state: self.fp_state,
  225. }
  226. }
  227. // ### 从另一个ArchPCBInfo处clone,gsdata会被保留
  228. pub fn clone_from(&mut self, from: &Self) {
  229. let gsdata = self.gsdata.clone();
  230. *self = from.clone_all();
  231. self.gsdata = gsdata;
  232. }
  233. }
  234. impl ProcessControlBlock {
  235. /// 获取当前进程的pcb
  236. pub fn arch_current_pcb() -> Arc<Self> {
  237. // 获取栈指针
  238. let ptr = VirtAddr::new(x86::current::registers::rsp() as usize);
  239. let stack_base = VirtAddr::new(ptr.data() & (!(KernelStack::ALIGN - 1)));
  240. // 从内核栈的最低地址处取出pcb的地址
  241. let p = stack_base.data() as *const *const ProcessControlBlock;
  242. if unlikely((unsafe { *p }).is_null()) {
  243. kerror!("p={:p}", p);
  244. panic!("current_pcb is null");
  245. }
  246. unsafe {
  247. // 为了防止内核栈的pcb weak 指针被释放,这里需要将其包装一下
  248. let weak_wrapper: ManuallyDrop<Weak<ProcessControlBlock>> =
  249. ManuallyDrop::new(Weak::from_raw(*p));
  250. let new_arc: Arc<ProcessControlBlock> = weak_wrapper.upgrade().unwrap();
  251. return new_arc;
  252. }
  253. }
  254. }
  255. impl ProcessManager {
  256. pub fn arch_init() {
  257. // do nothing
  258. }
  259. /// fork的过程中复制线程
  260. ///
  261. /// 由于这个过程与具体的架构相关,所以放在这里
  262. pub fn copy_thread(
  263. current_pcb: &Arc<ProcessControlBlock>,
  264. new_pcb: &Arc<ProcessControlBlock>,
  265. clone_args: KernelCloneArgs,
  266. current_trapframe: &TrapFrame,
  267. ) -> Result<(), SystemError> {
  268. let clone_flags = clone_args.flags;
  269. let mut child_trapframe = *current_trapframe;
  270. // 子进程的返回值为0
  271. child_trapframe.set_return_value(0);
  272. // 设置子进程的栈基址(开始执行中断返回流程时的栈基址)
  273. let mut new_arch_guard = unsafe { new_pcb.arch_info() };
  274. let kernel_stack_guard = new_pcb.kernel_stack();
  275. // 设置子进程在内核态开始执行时的rsp、rbp
  276. new_arch_guard.set_stack_base(kernel_stack_guard.stack_max_address());
  277. let trap_frame_vaddr: VirtAddr =
  278. kernel_stack_guard.stack_max_address() - core::mem::size_of::<TrapFrame>();
  279. new_arch_guard.set_stack(trap_frame_vaddr);
  280. // 拷贝栈帧
  281. unsafe {
  282. let usp = clone_args.stack;
  283. if usp != 0 {
  284. child_trapframe.rsp = usp as u64;
  285. }
  286. let trap_frame_ptr = trap_frame_vaddr.data() as *mut TrapFrame;
  287. *trap_frame_ptr = child_trapframe;
  288. }
  289. let current_arch_guard = current_pcb.arch_info_irqsave();
  290. new_arch_guard.fsbase = current_arch_guard.fsbase;
  291. new_arch_guard.gsbase = current_arch_guard.gsbase;
  292. new_arch_guard.fs = current_arch_guard.fs;
  293. new_arch_guard.gs = current_arch_guard.gs;
  294. new_arch_guard.fp_state = current_arch_guard.fp_state;
  295. // 拷贝浮点寄存器的状态
  296. if let Some(fp_state) = current_arch_guard.fp_state.as_ref() {
  297. new_arch_guard.fp_state = Some(*fp_state);
  298. }
  299. drop(current_arch_guard);
  300. // 设置返回地址(子进程开始执行的指令地址)
  301. if new_pcb.flags().contains(ProcessFlags::KTHREAD) {
  302. let kthread_bootstrap_stage1_func_addr = kernel_thread_bootstrap_stage1 as usize;
  303. new_arch_guard.rip = kthread_bootstrap_stage1_func_addr;
  304. } else {
  305. new_arch_guard.rip = ret_from_intr as usize;
  306. }
  307. // 设置tls
  308. if clone_flags.contains(CloneFlags::CLONE_SETTLS) {
  309. drop(new_arch_guard);
  310. Syscall::do_arch_prctl_64(new_pcb, ARCH_SET_FS, clone_args.tls, true)?;
  311. }
  312. return Ok(());
  313. }
  314. /// 切换进程
  315. ///
  316. /// ## 参数
  317. ///
  318. /// - `prev`:上一个进程的pcb
  319. /// - `next`:下一个进程的pcb
  320. pub unsafe fn switch_process(prev: Arc<ProcessControlBlock>, next: Arc<ProcessControlBlock>) {
  321. assert!(!CurrentIrqArch::is_irq_enabled());
  322. // 保存浮点寄存器
  323. prev.arch_info_irqsave().save_fp_state();
  324. // 切换浮点寄存器
  325. next.arch_info_irqsave().restore_fp_state();
  326. // 切换fsbase
  327. prev.arch_info_irqsave().save_fsbase();
  328. next.arch_info_irqsave().restore_fsbase();
  329. // 切换gsbase
  330. Self::switch_gsbase(&prev, &next);
  331. // 切换地址空间
  332. let next_addr_space = next.basic().user_vm().as_ref().unwrap().clone();
  333. compiler_fence(Ordering::SeqCst);
  334. next_addr_space.read().user_mapper.utable.make_current();
  335. drop(next_addr_space);
  336. compiler_fence(Ordering::SeqCst);
  337. // 切换内核栈
  338. // 获取arch info的锁,并强制泄露其守卫(切换上下文后,在switch_finish_hook中会释放锁)
  339. let next_arch = SpinLockGuard::leak(next.arch_info_irqsave()) as *mut ArchPCBInfo;
  340. let prev_arch = SpinLockGuard::leak(prev.arch_info_irqsave()) as *mut ArchPCBInfo;
  341. (*prev_arch).rip = switch_back as usize;
  342. // 恢复当前的 preempt count*2
  343. ProcessManager::current_pcb().preempt_enable();
  344. ProcessManager::current_pcb().preempt_enable();
  345. // 切换tss
  346. TSSManager::current_tss().set_rsp(
  347. x86::Ring::Ring0,
  348. next.kernel_stack().stack_max_address().data() as u64,
  349. );
  350. PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().prev_pcb = Some(prev);
  351. PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().next_pcb = Some(next);
  352. // kdebug!("switch tss ok");
  353. compiler_fence(Ordering::SeqCst);
  354. // 正式切换上下文
  355. switch_to_inner(prev_arch, next_arch);
  356. }
  357. unsafe fn switch_gsbase(prev: &Arc<ProcessControlBlock>, next: &Arc<ProcessControlBlock>) {
  358. asm!("swapgs", options(nostack, preserves_flags));
  359. prev.arch_info_irqsave().save_gsbase();
  360. next.arch_info_irqsave().restore_gsbase();
  361. // 将下一个进程的kstack写入kernel_gsbase
  362. next.arch_info_irqsave().store_kernel_gsbase();
  363. asm!("swapgs", options(nostack, preserves_flags));
  364. }
  365. }
  366. /// 保存上下文,然后切换进程,接着jmp到`switch_finish_hook`钩子函数
  367. #[naked]
  368. unsafe extern "sysv64" fn switch_to_inner(prev: *mut ArchPCBInfo, next: *mut ArchPCBInfo) {
  369. asm!(
  370. // As a quick reminder for those who are unfamiliar with the System V ABI (extern "C"):
  371. //
  372. // - the current parameters are passed in the registers `rdi`, `rsi`,
  373. // - we can modify scratch registers, e.g. rax
  374. // - we cannot change callee-preserved registers arbitrarily, e.g. rbx, which is why we
  375. // store them here in the first place.
  376. concat!("
  377. // Save old registers, and load new ones
  378. mov [rdi + {off_rbx}], rbx
  379. mov rbx, [rsi + {off_rbx}]
  380. mov [rdi + {off_r12}], r12
  381. mov r12, [rsi + {off_r12}]
  382. mov [rdi + {off_r13}], r13
  383. mov r13, [rsi + {off_r13}]
  384. mov [rdi + {off_r14}], r14
  385. mov r14, [rsi + {off_r14}]
  386. mov [rdi + {off_r15}], r15
  387. mov r15, [rsi + {off_r15}]
  388. // switch segment registers (这些寄存器只能通过接下来的switch_hook的return来切换)
  389. mov [rdi + {off_fs}], fs
  390. mov [rdi + {off_gs}], gs
  391. // mov fs, [rsi + {off_fs}]
  392. // mov gs, [rsi + {off_gs}]
  393. mov [rdi + {off_rbp}], rbp
  394. mov rbp, [rsi + {off_rbp}]
  395. mov [rdi + {off_rsp}], rsp
  396. mov rsp, [rsi + {off_rsp}]
  397. // // push RFLAGS (can only be modified via stack)
  398. pushfq
  399. // // pop RFLAGS into `self.rflags`
  400. pop QWORD PTR [rdi + {off_rflags}]
  401. // // push `next.rflags`
  402. push QWORD PTR [rsi + {off_rflags}]
  403. // // pop into RFLAGS
  404. popfq
  405. // push next rip to stack
  406. push QWORD PTR [rsi + {off_rip}]
  407. // When we return, we cannot even guarantee that the return address on the stack, points to
  408. // the calling function. Thus, we have to execute this Rust hook by
  409. // ourselves, which will unlock the contexts before the later switch.
  410. // Note that switch_finish_hook will be responsible for executing `ret`.
  411. jmp {switch_hook}
  412. "),
  413. off_rflags = const(offset_of!(ArchPCBInfo, rflags)),
  414. off_rbx = const(offset_of!(ArchPCBInfo, rbx)),
  415. off_r12 = const(offset_of!(ArchPCBInfo, r12)),
  416. off_r13 = const(offset_of!(ArchPCBInfo, r13)),
  417. off_r14 = const(offset_of!(ArchPCBInfo, r14)),
  418. off_rbp = const(offset_of!(ArchPCBInfo, rbp)),
  419. off_rsp = const(offset_of!(ArchPCBInfo, rsp)),
  420. off_r15 = const(offset_of!(ArchPCBInfo, r15)),
  421. off_rip = const(offset_of!(ArchPCBInfo, rip)),
  422. off_fs = const(offset_of!(ArchPCBInfo, fs)),
  423. off_gs = const(offset_of!(ArchPCBInfo, gs)),
  424. switch_hook = sym crate::process::switch_finish_hook,
  425. options(noreturn),
  426. );
  427. }
  428. #[naked]
  429. unsafe extern "sysv64" fn switch_back() -> ! {
  430. asm!("ret", options(noreturn));
  431. }
  432. pub unsafe fn arch_switch_to_user(path: String, argv: Vec<String>, envp: Vec<String>) -> ! {
  433. // 以下代码不能发生中断
  434. CurrentIrqArch::interrupt_disable();
  435. let current_pcb = ProcessManager::current_pcb();
  436. let trap_frame_vaddr = VirtAddr::new(
  437. current_pcb.kernel_stack().stack_max_address().data() - core::mem::size_of::<TrapFrame>(),
  438. );
  439. // kdebug!("trap_frame_vaddr: {:?}", trap_frame_vaddr);
  440. let new_rip = VirtAddr::new(ret_from_intr as usize);
  441. assert!(
  442. (x86::current::registers::rsp() as usize) < trap_frame_vaddr.data(),
  443. "arch_switch_to_user(): current_rsp >= fake trap
  444. frame vaddr, this may cause some illegal access to memory!
  445. rsp: {:#x}, trap_frame_vaddr: {:#x}",
  446. x86::current::registers::rsp() as usize,
  447. trap_frame_vaddr.data()
  448. );
  449. let mut arch_guard = current_pcb.arch_info_irqsave();
  450. arch_guard.rsp = trap_frame_vaddr.data();
  451. arch_guard.fs = USER_DS;
  452. arch_guard.gs = USER_DS;
  453. // 将内核gs数据压进cpu
  454. arch_guard.store_kernel_gsbase();
  455. switch_fs_and_gs(
  456. SegmentSelector::from_bits_truncate(arch_guard.fs.bits()),
  457. SegmentSelector::from_bits_truncate(arch_guard.gs.bits()),
  458. );
  459. arch_guard.rip = new_rip.data();
  460. drop(arch_guard);
  461. // 删除kthread的标志
  462. current_pcb.flags().remove(ProcessFlags::KTHREAD);
  463. current_pcb.worker_private().take();
  464. *current_pcb.sched_info().sched_policy.write_irqsave() = crate::sched::SchedPolicy::CFS;
  465. let mut trap_frame = TrapFrame::new();
  466. compiler_fence(Ordering::SeqCst);
  467. Syscall::do_execve(path, argv, envp, &mut trap_frame).unwrap_or_else(|e| {
  468. panic!(
  469. "arch_switch_to_user(): pid: {pid:?}, Failed to execve: , error: {e:?}",
  470. pid = current_pcb.pid(),
  471. e = e
  472. );
  473. });
  474. compiler_fence(Ordering::SeqCst);
  475. // 重要!在这里之后,一定要保证上面的引用计数变量、动态申请的变量、锁的守卫都被drop了,否则可能导致内存安全问题!
  476. drop(current_pcb);
  477. compiler_fence(Ordering::SeqCst);
  478. ready_to_switch_to_user(trap_frame, trap_frame_vaddr.data(), new_rip.data());
  479. }
  480. /// 由于需要依赖ret来切换到用户态,所以不能inline
  481. #[inline(never)]
  482. unsafe extern "sysv64" fn ready_to_switch_to_user(
  483. trap_frame: TrapFrame,
  484. trapframe_vaddr: usize,
  485. new_rip: usize,
  486. ) -> ! {
  487. *(trapframe_vaddr as *mut TrapFrame) = trap_frame;
  488. compiler_fence(Ordering::SeqCst);
  489. asm!(
  490. "swapgs",
  491. "mov rsp, {trapframe_vaddr}",
  492. "push {new_rip}",
  493. "ret",
  494. trapframe_vaddr = in(reg) trapframe_vaddr,
  495. new_rip = in(reg) new_rip
  496. );
  497. unreachable!()
  498. }
  499. // bitflags! {
  500. // pub struct ProcessThreadFlags: u32 {
  501. // /*
  502. // * thread information flags
  503. // * - these are process state flags that various assembly files
  504. // * may need to access
  505. // */
  506. // const TIF_NOTIFY_RESUME = 1 << 1; /* callback before returning to user */
  507. // const TIF_SIGPENDING = 1 << 2; /* signal pending */
  508. // const TIF_NEED_RESCHED = 1 << 3; /* rescheduling necessary */
  509. // const TIF_SINGLESTEP = 1 << 4; /* reenable singlestep on user return*/
  510. // const TIF_SSBD = 1 << 5; /* Speculative store bypass disable */
  511. // const TIF_SPEC_IB = 1 << 9; /* Indirect branch speculation mitigation */
  512. // const TIF_SPEC_L1D_FLUSH = 1 << 10; /* Flush L1D on mm switches (processes) */
  513. // const TIF_USER_RETURN_NOTIFY = 1 << 11; /* notify kernel of userspace return */
  514. // const TIF_UPROBE = 1 << 12; /* breakpointed or singlestepping */
  515. // const TIF_PATCH_PENDING = 1 << 13; /* pending live patching update */
  516. // const TIF_NEED_FPU_LOAD = 1 << 14; /* load FPU on return to userspace */
  517. // const TIF_NOCPUID = 1 << 15; /* CPUID is not accessible in userland */
  518. // const TIF_NOTSC = 1 << 16; /* TSC is not accessible in userland */
  519. // const TIF_NOTIFY_SIGNAL = 1 << 17; /* signal notifications exist */
  520. // const TIF_MEMDIE = 1 << 20; /* is terminating due to OOM killer */
  521. // const TIF_POLLING_NRFLAG = 1 << 21; /* idle is polling for TIF_NEED_RESCHED */
  522. // const TIF_IO_BITMAP = 1 << 22; /* uses I/O bitmap */
  523. // const TIF_SPEC_FORCE_UPDATE = 1 << 23; /* Force speculation MSR update in context switch */
  524. // const TIF_FORCED_TF = 1 << 24; /* true if TF in eflags artificially */
  525. // const TIF_BLOCKSTEP = 1 << 25; /* set when we want DEBUGCTLMSR_BTF */
  526. // const TIF_LAZY_MMU_UPDATES = 1 << 27; /* task is updating the mmu lazily */
  527. // const TIF_ADDR32 = 1 << 29; /* 32-bit address space on 64 bits */
  528. // }
  529. // }