1 use crate::driver::base::device::device_number::DeviceNumber;
2 use crate::filesystem;
3 use crate::filesystem::devfs::DevFS;
4 use crate::filesystem::vfs::{
5 core::generate_inode_id,
6 file::{File, FileMode},
7 FilePrivateData, FileSystem, FileType, IndexNode, Metadata,
8 };
9 use crate::libs::spinlock::SpinLockGuard;
10 use crate::mm::VirtAddr;
11 use crate::process::ProcessManager;
12 use crate::syscall::user_access::copy_from_user;
13 use crate::virt::kvm::host_mem::KvmUserspaceMemoryRegion;
14 use crate::virt::kvm::update_vm;
15 use crate::virt::kvm::vcpu_dev::LockedVcpuInode;
16 use crate::virt::kvm::vm;
17 use crate::{arch::KVMArch, libs::spinlock::SpinLock, time::PosixTimeSpec};
18 use alloc::{
19 string::String,
20 sync::{Arc, Weak},
21 vec::Vec,
22 };
23 use log::debug;
24 use system_error::SystemError;
25
26 // pub const KVM_API_VERSION:u32 = 12;
27 // pub const GUEST_STACK_SIZE:usize = 1024;
28 // pub const HOST_STACK_SIZE:usize = 0x1000 * 6;
29
30 /*
31 * ioctls for /dev/vm fds:
32 */
33 pub const KVM_CREATE_VCPU: u32 = 0x00;
34 pub const KVM_SET_USER_MEMORY_REGION: u32 = 0x01;
35 pub const KVM_GET_DIRTY_LOG: u32 = 0x02;
36 pub const KVM_IRQFD: u32 = 0x03;
37 pub const KVM_IOEVENTFD: u32 = 0x04;
38 pub const KVM_IRQ_LINE_STATUS: u32 = 0x05;
39
40 // #[derive(Debug)]
41 // pub struct InodeInfo {
42 // kvm: Arc<Hypervisor>,
43 // }
44
45 #[derive(Debug)]
46 pub struct VmInode {
47 /// uuid 暂时不知道有什么用（x
48 // uuid: Uuid,
49 /// 指向自身的弱引用
50 self_ref: Weak<LockedVmInode>,
51 /// 指向inode所在的文件系统对象的指针
52 fs: Weak<DevFS>,
53 /// INode 元数据
54 metadata: Metadata,
55 // fdata: InodeInfo,
56 }
57
58 #[derive(Debug)]
59 pub struct LockedVmInode(SpinLock<VmInode>);
60
61 impl LockedVmInode {
new() -> Arc<Self>62 pub fn new() -> Arc<Self> {
63 let inode = VmInode {
64 self_ref: Weak::default(),
65 fs: Weak::default(),
66 metadata: Metadata {
67 dev_id: 1,
68 inode_id: generate_inode_id(),
69 size: 0,
70 blk_size: 0,
71 blocks: 0,
72 atime: PosixTimeSpec::default(),
73 mtime: PosixTimeSpec::default(),
74 ctime: PosixTimeSpec::default(),
75 file_type: FileType::KvmDevice, // 文件夹，block设备，char设备
76 mode: filesystem::vfs::syscall::ModeType::S_IALLUGO,
77 nlinks: 1,
78 uid: 0,
79 gid: 0,
80 raw_dev: DeviceNumber::default(), // 这里用来作为device number
81 },
82 // fdata: InodeInfo {
83 // kvm: kvm,
84 // },
85 };
86
87 let result = Arc::new(LockedVmInode(SpinLock::new(inode)));
88 result.0.lock().self_ref = Arc::downgrade(&result);
89
90 return result;
91 }
92 }
93
94 impl IndexNode for LockedVmInode {
as_any_ref(&self) -> &dyn core::any::Any95 fn as_any_ref(&self) -> &dyn core::any::Any {
96 self
97 }
98
open( &self, _data: SpinLockGuard<FilePrivateData>, _mode: &FileMode, ) -> Result<(), SystemError>99 fn open(
100 &self,
101 _data: SpinLockGuard<FilePrivateData>,
102 _mode: &FileMode,
103 ) -> Result<(), SystemError> {
104 debug!("file private data:{:?}", _data);
105 return Ok(());
106 }
107
close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError>108 fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> {
109 return Ok(());
110 }
111
metadata(&self) -> Result<Metadata, SystemError>112 fn metadata(&self) -> Result<Metadata, SystemError> {
113 return Ok(self.0.lock().metadata.clone());
114 }
115
fs(&self) -> Arc<dyn FileSystem>116 fn fs(&self) -> Arc<dyn FileSystem> {
117 return self.0.lock().fs.upgrade().unwrap();
118 }
119
list(&self) -> Result<Vec<String>, SystemError>120 fn list(&self) -> Result<Vec<String>, SystemError> {
121 Err(SystemError::ENOSYS)
122 }
123
set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError>124 fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
125 let mut inode = self.0.lock();
126 inode.metadata.atime = metadata.atime;
127 inode.metadata.mtime = metadata.mtime;
128 inode.metadata.ctime = metadata.ctime;
129 inode.metadata.mode = metadata.mode;
130 inode.metadata.uid = metadata.uid;
131 inode.metadata.gid = metadata.gid;
132
133 return Ok(());
134 }
135
136 /// @brief io control接口
137 ///
138 /// @param cmd 命令
139 /// @param data 数据
140 ///
141 /// @return 成功：Ok()
142 /// 失败：Err(错误码)
ioctl( &self, cmd: u32, data: usize, _private_data: &FilePrivateData, ) -> Result<usize, SystemError>143 fn ioctl(
144 &self,
145 cmd: u32,
146 data: usize,
147 _private_data: &FilePrivateData,
148 ) -> Result<usize, SystemError> {
149 match cmd {
150 0xdeadbeef => {
151 debug!("kvm_vm ioctl");
152 Ok(0)
153 }
154 KVM_CREATE_VCPU => {
155 debug!("kvm_vcpu ioctl KVM_CREATE_VCPU");
156 kvm_vm_ioctl_create_vcpu(data as u32)
157 }
158 KVM_SET_USER_MEMORY_REGION => {
159 debug!("kvm_vcpu ioctl KVM_SET_USER_MEMORY_REGION data={:x}", data);
160 let mut kvm_userspace_mem = KvmUserspaceMemoryRegion::default(); // = unsafe { (data as *const KvmUserspaceMemoryRegion).as_ref().unwrap() };
161 unsafe {
162 copy_from_user(
163 core::slice::from_raw_parts_mut(
164 (&mut kvm_userspace_mem as *mut _) as *mut u8,
165 core::mem::size_of::<KvmUserspaceMemoryRegion>(),
166 ),
167 VirtAddr::new(data),
168 )?;
169 }
170 debug!(
171 "slot={}, flag={}, memory_size={:x}, guest_phys_addr={}, userspace_addr={}",
172 kvm_userspace_mem.slot,
173 kvm_userspace_mem.flags,
174 kvm_userspace_mem.memory_size,
175 kvm_userspace_mem.guest_phys_addr, // starting at physical address guest_phys_addr (from the guest’s perspective)
176 kvm_userspace_mem.userspace_addr // using memory at linear address userspace_addr (from the host’s perspective)
177 );
178
179 let mut current_vm = vm(0).unwrap();
180 current_vm.set_user_memory_region(&kvm_userspace_mem)?;
181 update_vm(0, current_vm);
182 Ok(0)
183 }
184 KVM_GET_DIRTY_LOG | KVM_IRQFD | KVM_IOEVENTFD | KVM_IRQ_LINE_STATUS => {
185 Err(SystemError::ENOSYS)
186 }
187 _ => {
188 debug!("kvm_vm ioctl");
189 Ok(usize::MAX)
190 }
191 }
192 }
193 /// 读设备 - 应该调用设备的函数读写，而不是通过文件系统读写
read_at( &self, _offset: usize, _len: usize, _buf: &mut [u8], _data: SpinLockGuard<FilePrivateData>, ) -> Result<usize, SystemError>194 fn read_at(
195 &self,
196 _offset: usize,
197 _len: usize,
198 _buf: &mut [u8],
199 _data: SpinLockGuard<FilePrivateData>,
200 ) -> Result<usize, SystemError> {
201 Err(SystemError::ENOSYS)
202 }
203
204 /// 写设备 - 应该调用设备的函数读写，而不是通过文件系统读写
write_at( &self, _offset: usize, _len: usize, _buf: &[u8], _data: SpinLockGuard<FilePrivateData>, ) -> Result<usize, SystemError>205 fn write_at(
206 &self,
207 _offset: usize,
208 _len: usize,
209 _buf: &[u8],
210 _data: SpinLockGuard<FilePrivateData>,
211 ) -> Result<usize, SystemError> {
212 Err(SystemError::ENOSYS)
213 }
214 }
215
kvm_vm_ioctl_create_vcpu(id: u32) -> Result<usize, SystemError>216 fn kvm_vm_ioctl_create_vcpu(id: u32) -> Result<usize, SystemError> {
217 let vcpu = KVMArch::kvm_arch_vcpu_create(id).unwrap();
218 KVMArch::kvm_arch_vcpu_setup(vcpu.as_ref())?;
219
220 let mut current_vm = vm(0).unwrap();
221 current_vm.vcpu.push(vcpu);
222 current_vm.nr_vcpus += 1;
223 update_vm(0, current_vm);
224
225 let vcpu_inode = LockedVcpuInode::new();
226 let file: File = File::new(vcpu_inode, FileMode::O_RDWR)?;
227 let r = ProcessManager::current_pcb()
228 .fd_table()
229 .write()
230 .alloc_fd(file, None)
231 .map(|fd| fd as usize);
232 return r;
233 }
234