Method from_values

kernel/src/message.rs:145–218

Take data passed via syscall and convert to a kernel Message object. If the user passed rendezvous or memory handles then these are removed from the process using take_rendezvous() and take_memory_chunk() methods, and stored in the Message.

(
        thread: &mut Thread,
        syscall_id: u64,
        data1: u64,
        data2: u64,
        data3: u64)

    /// take_memory_chunk() methods, and stored in the Message.
    ///
    pub fn from_values(
        thread: &mut Thread,
        syscall_id: u64,
        data1: u64,
        data2: u64,
        data3: u64) -> Result<Message, usize> {
        
        if syscall_id & MESSAGE_LONG == 0 {
            Ok(Message::Short(data1,
                              data2,
                              data3))
        } else {
            // Long message
            let message = Message::Long(
                data1,
                match syscall_id & MESSAGE_DATA2_TYPE {
                    MESSAGE_DATA2_RDV => {
                        // Moving or copying a handle
                        // First copy, then drop if message is valid
                        if let Some(rdv) = thread.rendezvous(data2) {
                            MessageData::Rendezvous(rdv)
                        } else {
                            // Invalid handle
                            return Err(syscalls::SYSCALL_ERROR_INVALID_HANDLE);
                        }
                    }
                    MESSAGE_DATA2_MEM => {
                        // Memory handle
                        let (physaddr, _level) = thread.memory_chunk(
                            VirtAddr::new(data2))?;
                        MessageData::Memory(physaddr)
                    }
                    _ => MessageData::Value(data2)
                },
                match syscall_id & MESSAGE_DATA3_TYPE {
                    MESSAGE_DATA3_RDV => {
                        if let Some(rdv) = thread.rendezvous(data3) {
                            MessageData::Rendezvous(rdv)
                        } else {
                            // Invalid handle.
                            // If we moved data2 we would have to put it back here
                            return Err(syscalls::SYSCALL_ERROR_INVALID_HANDLE);
                        }
                    }
                    MESSAGE_DATA3_MEM => {
                        // Memory handle
                        let (physaddr, _level) = thread.memory_chunk(
                            VirtAddr::new(data3))?;
                        MessageData::Memory(physaddr)
                    }
                    _ => MessageData::Value(data3)
                });
            // Message is valid => Remove handles being moved
            match syscall_id & MESSAGE_DATA2_TYPE {
                MESSAGE_DATA2_RDV => {
                    let _ = thread.take_rendezvous(data2);
                }
                MESSAGE_DATA2_MEM => {