Function sys_send

kernel/src/syscalls.rs:370–440

This handles both syscall_send and syscall_sendreceive

(
    context_ptr: *mut Context,
    syscall_id: u64,
    data1: u64,
    data2: u64,
    data3: u64)

/// This handles both syscall_send and syscall_sendreceive
fn sys_send(
    context_ptr: *mut Context,
    syscall_id: u64,
    data1: u64,
    data2: u64,
    data3: u64) {
    let handle = syscall_id >> 32; // High 32 bits are the handle
    // Extract the current thread
    if let Some(mut thread) = process::take_current_thread() {
        let current_tid = thread.tid();
        thread.set_context(context_ptr);

        // Get the Rendezvous, create Message and call
        if let Some(rdv) = thread.rendezvous(handle) {
            // Check how many references this Rendezvous has.
            if Arc::strong_count(&rdv) == 2 {
                // Only this handle (rdv) and the one stored in the Thread/Process
                // All other handles have been dropped -> Return error
                thread.return_error(SYSCALL_ERROR_CLOSED);
                process::set_current_thread(thread);
                return;
            }

            match Message::from_values(&mut thread, syscall_id, data1, data2, data3) {
                Ok(message) => {
                    let (thread1, thread2) = match syscall_id & SYSCALL_MASK {
                        SYSCALL_SEND => rdv.write().send(
                            Some(thread),
                            message),
                        SYSCALL_SENDRECEIVE => rdv.write().send_receive(
                            thread,
                            message),
                        _ => panic!("Internal error")
                    };
                    // thread1 should be started asap
                    // thread2 should be scheduled

                    let mut returning = false;
                    for maybe_thread in [thread2, thread1] {
                        if let Some(t) = maybe_thread {
                            if t.tid() == current_tid {
                                // Same thread -> return
                                returning = true;
                                process::set_current_thread(t);
                            } else {
                                process::schedule_thread(t);
                            }
                        }
                    }

                    if !returning {
                        // Original thread is waiting.
                        // Switch to a different thread
                        drop(rdv); // Not returning from launch_thread
                        let new_context_addr = process::schedule_next(context_ptr as usize);
                        interrupts::launch_thread(new_context_addr);
                    }
                }