Nothing to see here, move along meow
1use crate::cap::cnode;
2use crate::cap::object::ObjectTag;
3use crate::cap::ops;
4use crate::cap::pool::POOL;
5use crate::cap::table::Rights;
6use crate::error::KernelError;
7use crate::proc::PROCESSES;
8use crate::types::Pid;
9
10fn bootstrap_test_cnode(pid: Pid, ptable: &mut crate::proc::ProcessManager) {
11 crate::tests::helpers::bootstrap_test_cnode(pid, ptable);
12}
13
14crate::kernel_test!(
15 fn derive_from_empty_slot_fails() {
16 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
17 let mut ptable = PROCESSES.lock();
18
19 let created = ptable.allocate(&mut allocator).expect("alloc");
20 ptable.start(created).expect("start");
21 let pid = created.pid();
22 bootstrap_test_cnode(pid, &mut ptable);
23
24 let src_addr = 80u64;
25 let dest_addr = 81u64;
26 let (cnode_id, cnode_gen, depth, gv, gb) =
27 cnode::cnode_coords(pid, &ptable).expect("coords");
28 let result = {
29 let mut pool = POOL.lock_after(&ptable);
30 ops::derive_via_cnode(
31 &mut pool,
32 cnode_id,
33 cnode_gen,
34 src_addr,
35 dest_addr,
36 depth,
37 gv,
38 gb,
39 Rights::ALL,
40 )
41 };
42 assert!(
43 matches!(result, Err(KernelError::SlotEmpty)),
44 "derive from empty slot should return SlotEmpty"
45 );
46
47 ptable.destroy(pid, &mut allocator);
48 }
49);
50
51crate::kernel_test!(
52 fn derive_cannot_escalate_rights() {
53 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
54 let mut ptable = PROCESSES.lock();
55
56 let created = ptable.allocate(&mut allocator).expect("alloc");
57 ptable.start(created).expect("start");
58 let pid = created.pid();
59 bootstrap_test_cnode(pid, &mut ptable);
60
61 let src_addr = 82u64;
62 let dest_addr = 83u64;
63 let (cnode_id, cnode_gen, depth, gv, gb) =
64 cnode::cnode_coords(pid, &ptable).expect("coords");
65
66 {
67 let mut pool = POOL.lock_after(&ptable);
68 ops::create_via_cnode(
69 &mut pool,
70 cnode_id,
71 cnode_gen,
72 src_addr,
73 depth,
74 gv,
75 gb,
76 ObjectTag::Endpoint,
77 )
78 .expect("create");
79 }
80
81 {
82 let pool = POOL.lock_after(&ptable);
83 let old_cap =
84 cnode::resolve_and_clear(&pool, cnode_id, cnode_gen, src_addr, depth, gv, gb)
85 .expect("clear slot");
86 let new_cap = old_cap.with_rights(Rights::READ | Rights::GRANT);
87 cnode::resolve_and_insert(&pool, cnode_id, cnode_gen, src_addr, depth, gv, gb, new_cap)
88 .expect("reinsert cap");
89 }
90
91 {
92 let mut pool = POOL.lock_after(&ptable);
93 ops::derive_via_cnode(
94 &mut pool,
95 cnode_id,
96 cnode_gen,
97 src_addr,
98 dest_addr,
99 depth,
100 gv,
101 gb,
102 Rights::ALL,
103 )
104 .expect("derive");
105 }
106
107 {
108 let pool = POOL.lock_after(&ptable);
109 let cap = cnode::resolve_and_read(&pool, cnode_id, cnode_gen, dest_addr, depth, gv, gb)
110 .expect("read derived slot");
111 assert!(
112 cap.rights().contains(Rights::READ),
113 "derived should have READ"
114 );
115 assert!(
116 cap.rights().contains(Rights::GRANT),
117 "derived should have GRANT"
118 );
119 assert!(
120 !cap.rights().contains(Rights::WRITE),
121 "derived should NOT have WRITE (not in source)"
122 );
123 assert!(
124 !cap.rights().contains(Rights::REVOKE),
125 "derived should NOT have REVOKE (not in source)"
126 );
127 }
128
129 ptable.destroy(pid, &mut allocator);
130 }
131);
132
133crate::kernel_test!(
134 fn revoke_eagerly_invalidates_derived() {
135 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
136 let mut ptable = PROCESSES.lock();
137
138 let created = ptable.allocate(&mut allocator).expect("alloc");
139 ptable.start(created).expect("start");
140 let pid = created.pid();
141 bootstrap_test_cnode(pid, &mut ptable);
142
143 let src_addr = 84u64;
144 let dest_addr = 85u64;
145 let (cnode_id, cnode_gen, depth, gv, gb) =
146 cnode::cnode_coords(pid, &ptable).expect("coords");
147
148 {
149 let mut pool = POOL.lock_after(&ptable);
150 ops::create_via_cnode(
151 &mut pool,
152 cnode_id,
153 cnode_gen,
154 src_addr,
155 depth,
156 gv,
157 gb,
158 ObjectTag::Endpoint,
159 )
160 .expect("create");
161 }
162
163 {
164 let mut pool = POOL.lock_after(&ptable);
165 ops::derive_via_cnode(
166 &mut pool,
167 cnode_id,
168 cnode_gen,
169 src_addr,
170 dest_addr,
171 depth,
172 gv,
173 gb,
174 Rights::ALL,
175 )
176 .expect("derive");
177 }
178
179 ops::revoke_via_cnode(pid, src_addr, &mut ptable).expect("revoke");
180
181 {
182 let pool = POOL.lock_after(&ptable);
183 let src_result =
184 cnode::resolve_and_read(&pool, cnode_id, cnode_gen, src_addr, depth, gv, gb);
185 assert!(
186 matches!(src_result, Err(KernelError::SlotEmpty)),
187 "source slot should be empty after revoke"
188 );
189
190 let dest_result =
191 cnode::resolve_and_read(&pool, cnode_id, cnode_gen, dest_addr, depth, gv, gb);
192 assert!(
193 matches!(dest_result, Err(KernelError::SlotEmpty)),
194 "derived slot should be eagerly cleared by revoke's invalidate_stale_caps"
195 );
196 }
197
198 {
199 let pool = POOL.lock_after(&ptable);
200 let result =
201 ops::identify_via_cnode(&pool, cnode_id, cnode_gen, dest_addr, depth, gv, gb);
202 assert!(
203 matches!(result, Err(KernelError::SlotEmpty)),
204 "identify on eagerly-invalidated slot should return SlotEmpty"
205 );
206 }
207
208 ptable.destroy(pid, &mut allocator);
209 }
210);