Method receive

kernel/src/rendezvous.rs:105–140

Blocking receive a message 1. Empty -> Receiving, return (None, None) 2. Sending -> Empty, return (receiving thread, sending thread) 3. Receiving -> return (receiving thread, None) Error returned to thread 4. SendReceiving -> Receiving, return (receiving thread, None) Returns ------- Zero, one or two threads (thread1, thread2) thread1 should be started asap thread2 should be scheduled

(&mut self, thread: Box<Thread>)

    /// thread1  should be started asap
    /// thread2  should be scheduled
    pub fn receive(&mut self, thread: Box<Thread>)
                   -> (Option<Box<Thread>>, Option<Box<Thread>>) {
        match &*self {
            Rendezvous::Empty => {
                // Can receive from any thread
                *self = Rendezvous::Receiving(thread, None);
                (None, None)
            }
            Rendezvous::Sending(_, _) => {
                // Complete the message transfer
                if let Rendezvous::Sending(snd_thread, message) = mem::replace(self, Rendezvous::Empty) {
                    thread.return_message(message);
                    if let Some(ref t) = snd_thread {
                        t.return_error(0); // Success
                    }
                    return (Some(thread), snd_thread);
                }
                (None, None) // This should never be reached
            }
            Rendezvous::Receiving(_, _) => {
                // Already receiving
                thread.return_error(syscalls::SYSCALL_ERROR_RECV_BLOCKING);
                (Some(thread), None)
            }
            Rendezvous::SendReceiving(_, _) => {
                // Sending, expecting a reply from the same thread
                if let Rendezvous::SendReceiving(snd_thread, message) = mem::replace(self, Rendezvous::Empty) {
                    thread.return_message(message);
                    // Wait for a reply from the receiving thread
                    *self = Rendezvous::Receiving(snd_thread, Some(thread.tid()));
                    return (Some(thread), None);
                }
                (None, None)
            }
        }
    }

    /// Send a message and block on receive from the same thread
    ///