Method to_values

kernel/src/message.rs:85–136

Convert a Message into values which will be returned to user code by the receive or send_receive syscalls. Includes moving Rendezvous and memory chunks into the receiving process' handles and page tables, calling give_rendezvous() and give_memory_chunk() methods. Note: No error return type because errors are indicated to the receiver in the values.

(
        &self,
        thread: &Thread
    )

    /// Note: No error return type because errors are indicated to the
    ///       receiver in the values.
    pub fn to_values(
        &self,
        thread: &Thread
    ) -> (u64, u64, u64, u64) {
        match self {
            Message::Short(data1, data2, data3) => (0, *data1, *data2, *data3),
            Message::Long(data1, data2, data3) => {
                let mut ctrl: u64 = 0; // No error

                let value2 = match data2 {
                    MessageData::Value(value) => *value,
                    MessageData::Rendezvous(rdv) => {
                        ctrl |= MESSAGE_DATA2_RDV | MESSAGE_LONG;
                        thread.give_rendezvous(rdv.clone()) as u64
                    }
                    MessageData::Memory(physaddr) => {
                        match thread.give_memory_chunk(*physaddr) {
                            Ok(virtaddr) => {
                                ctrl |= MESSAGE_DATA2_MEM | MESSAGE_LONG;
                                virtaddr.as_u64()
                            }
                            Err(error_code) => {
                                ctrl |= MESSAGE_DATA2_ERR | MESSAGE_LONG;
                                error_code as u64
                            }
                        }
                    }
                };

                let value3 = match data3 {
                    MessageData::Value(value) => *value,
                    MessageData::Rendezvous(rdv) => {
                        ctrl |= MESSAGE_DATA3_RDV | MESSAGE_LONG;
                        thread.give_rendezvous(rdv.clone()) as u64
                    }
                    MessageData::Memory(physaddr) => {
                        match thread.give_memory_chunk(*physaddr) {
                            Ok(virtaddr) => {
                                ctrl |= MESSAGE_DATA3_MEM | MESSAGE_LONG;
                                virtaddr.as_u64()
                            }
                            Err(error_code) => {
                                ctrl |= MESSAGE_DATA3_ERR | MESSAGE_LONG;
                                error_code as u64
                            }
                        }
                    }
                };
                (ctrl, *data1, value2, value3)
            }
        }
    }

    /// Take data passed via syscall and convert to
    /// a kernel Message object.