Nothing to see here, move along meow
1use crate::cap::object::ObjectTag;
2use crate::cap::pool::POOL;
3use crate::cap::table::{CapRef, Rights};
4use crate::error::KernelError;
5use crate::ipc::endpoint;
6use crate::proc::PROCESSES;
7use crate::proc::context::IpcMessage;
8
9crate::kernel_test!(
10 fn send_requires_write_right() {
11 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
12 let mut ptable = PROCESSES.lock();
13
14 let sender_created = ptable.allocate(&mut allocator).expect("alloc sender");
15 ptable.start(sender_created).expect("start sender");
16 let sender_pid = sender_created.pid();
17
18 let (ep_id, ep_gen) =
19 crate::tests::helpers::alloc_endpoint(&mut POOL.lock()).expect("alloc endpoint");
20
21 let cap_readonly = CapRef::new(ObjectTag::Endpoint, ep_id, Rights::READ, ep_gen);
22
23 let needs = Rights::WRITE;
24 assert!(
25 !cap_readonly.rights().contains(needs),
26 "READ-only cap should not contain WRITE"
27 );
28
29 let _ = POOL.lock().dec_ref_phys(ep_id, ep_gen);
30 ptable.destroy(sender_pid, &mut allocator);
31 }
32);
33
34crate::kernel_test!(
35 fn recv_requires_read_right() {
36 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
37 let mut ptable = PROCESSES.lock();
38
39 let recv_created = ptable.allocate(&mut allocator).expect("alloc receiver");
40 ptable.start(recv_created).expect("start receiver");
41 let recv_pid = recv_created.pid();
42
43 let (ep_id, ep_gen) =
44 crate::tests::helpers::alloc_endpoint(&mut POOL.lock()).expect("alloc endpoint");
45
46 let cap_writeonly = CapRef::new(ObjectTag::Endpoint, ep_id, Rights::WRITE, ep_gen);
47
48 let needs = Rights::READ;
49 assert!(
50 !cap_writeonly.rights().contains(needs),
51 "WRITE-only cap should not contain READ"
52 );
53
54 let _ = POOL.lock().dec_ref_phys(ep_id, ep_gen);
55 ptable.destroy(recv_pid, &mut allocator);
56 }
57);
58
59crate::kernel_test!(
60 fn call_requires_read_and_write() {
61 let (ep_id, ep_gen) =
62 crate::tests::helpers::alloc_endpoint(&mut POOL.lock()).expect("alloc endpoint");
63
64 let cap_read = CapRef::new(ObjectTag::Endpoint, ep_id, Rights::READ, ep_gen);
65 let cap_write = CapRef::new(ObjectTag::Endpoint, ep_id, Rights::WRITE, ep_gen);
66 let cap_rw = CapRef::new(
67 ObjectTag::Endpoint,
68 ep_id,
69 Rights::READ | Rights::WRITE,
70 ep_gen,
71 );
72
73 let needs = Rights::READ | Rights::WRITE;
74 assert!(
75 !cap_read.rights().contains(needs),
76 "READ-only should not satisfy READ|WRITE"
77 );
78 assert!(
79 !cap_write.rights().contains(needs),
80 "WRITE-only should not satisfy READ|WRITE"
81 );
82 assert!(
83 cap_rw.rights().contains(needs),
84 "READ|WRITE should satisfy READ|WRITE"
85 );
86
87 let _ = POOL.lock().dec_ref_phys(ep_id, ep_gen);
88 }
89);
90
91crate::kernel_test!(
92 fn send_on_stale_endpoint_fails() {
93 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
94 let mut ptable = PROCESSES.lock();
95
96 let sender_created = ptable.allocate(&mut allocator).expect("alloc sender");
97 ptable.start(sender_created).expect("start sender");
98 let sender_pid = sender_created.pid();
99
100 let (ep_id, ep_gen) =
101 crate::tests::helpers::alloc_endpoint(&mut POOL.lock()).expect("alloc endpoint");
102
103 let cap = CapRef::new(ObjectTag::Endpoint, ep_id, Rights::ALL, ep_gen);
104
105 let _ = POOL.lock().revoke_phys(ep_id, ep_gen);
106
107 ptable.exec_mut(sender_pid).unwrap().ipc_message =
108 IpcMessage::from_regs([0, 0, 0, 0, 0, 0]);
109
110 let result = endpoint::do_send(&cap, sender_pid, &mut ptable);
111 assert!(
112 matches!(result, Err(KernelError::StaleGeneration)),
113 "send on revoked endpoint should return StaleGeneration"
114 );
115
116 ptable.destroy(sender_pid, &mut allocator);
117 }
118);
119
120crate::kernel_test!(
121 fn recv_on_stale_endpoint_fails() {
122 let mut allocator = crate::mem::phys::BitmapFrameAllocator;
123 let mut ptable = PROCESSES.lock();
124
125 let recv_created = ptable.allocate(&mut allocator).expect("alloc receiver");
126 ptable.start(recv_created).expect("start receiver");
127 let recv_pid = recv_created.pid();
128
129 let (ep_id, ep_gen) =
130 crate::tests::helpers::alloc_endpoint(&mut POOL.lock()).expect("alloc endpoint");
131
132 let cap = CapRef::new(ObjectTag::Endpoint, ep_id, Rights::ALL, ep_gen);
133
134 let _ = POOL.lock().revoke_phys(ep_id, ep_gen);
135
136 let result = endpoint::do_recv(&cap, recv_pid, &mut ptable);
137 assert!(
138 matches!(result, Err(KernelError::StaleGeneration)),
139 "recv on revoked endpoint should return StaleGeneration"
140 );
141
142 ptable.destroy(recv_pid, &mut allocator);
143 }
144);