VMライフサイクルをシグナルとCLIで管理する——ブロック中のKVM_RUNをSIGUSR1で起こす

pub struct Config {
    pub kernel_path: String,
    pub initramfs_path: String,
    pub disk_path: String,
    pub tap_name: String,
    pub num_vcpus: u64,
    pub memory_mb: usize,
}

pub fn parse_args() -> Config {
    let mut config = Config::default();
    let mut args = std::env::args().skip(1);

    while let Some(arg) = args.next() {
        match arg.as_str() {
            "--kernel" => config.kernel_path = next_value(&mut args, "--kernel"),
            "--vcpus" => {
                config.num_vcpus = next_value(&mut args, "--vcpus")
                    .parse()
                    .expect("--vcpus must be a positive integer");
            }
            // ...
        }
    }
    config
}

const VCPU_KICK_SIGNAL: libc::c_int = libc::SIGUSR1;

extern "C" fn vcpu_kick_handler(_: libc::c_int) {}

pub fn install_vcpu_kick_handler() {
    unsafe {
        libc::signal(VCPU_KICK_SIGNAL, vcpu_kick_handler as *const () as libc::sighandler_t);
    }
}

pub struct Lifecycle {
    shutdown: AtomicBool,
    vcpu_threads: Mutex<Vec<libc::pthread_t>>,
}

impl Lifecycle {
    pub fn register_current_thread(&self) {
        let tid = unsafe { libc::pthread_self() };
        self.vcpu_threads.lock().unwrap().push(tid);
    }

    pub fn request_shutdown(&self) {
        self.shutdown.store(true, Ordering::SeqCst);
        let threads = self.vcpu_threads.lock().unwrap();
        for &tid in threads.iter() {
            unsafe {
                libc::pthread_kill(tid, VCPU_KICK_SIGNAL);
            }
        }
    }
}

loop {
    if lifecycle.is_shutdown_requested() {
        println!("\n[vcpu {vcpu_id}] shutdown requested, stopping this vCPU");
        break;
    }

    let exit = match vcpu.run() {
        Ok(exit) => exit,
        Err(e) if e.errno() == libc::EAGAIN => continue,
        Err(e) if e.errno() == libc::EINTR => continue,
        Err(e) => panic!("[vcpu {vcpu_id}] KVM_RUN failed: {e}"),
    };
    // ...
}

// 他のスレッドを生成するより前に呼ぶ必要がある。
// スレッドは生成元のシグナルマスクを引き継ぐため。
pub fn block_shutdown_signals() {
    unsafe {
        let mut set: libc::sigset_t = std::mem::zeroed();
        libc::sigemptyset(&mut set);
        libc::sigaddset(&mut set, libc::SIGINT);
        libc::sigaddset(&mut set, libc::SIGTERM);
        libc::pthread_sigmask(libc::SIG_BLOCK, &set, std::ptr::null_mut());
    }
}

pub fn spawn_signal_watcher(lifecycle: Arc<Lifecycle>) {
    std::thread::spawn(move || {
        let mut set: libc::sigset_t = unsafe { std::mem::zeroed() };
        unsafe {
            libc::sigemptyset(&mut set);
            libc::sigaddset(&mut set, libc::SIGINT);
            libc::sigaddset(&mut set, libc::SIGTERM);
        }
        let mut received: libc::c_int = 0;
        unsafe {
            libc::sigwait(&set, &mut received);
        }
        println!("\nreceived signal {received}, shutting down...");
        lifecycle.request_shutdown();
    });
}

[   15.868976] reboot: Restarting system
[   15.872280] reboot: machine restart

[vcpu 0] guest requested reset (i8042), stopping VM

[vcpu 1] shutdown requested, stopping this vCPU
VM stopped.

^C
received signal 2, shutting down...

[vcpu 1] shutdown requested, stopping this vCPU

[vcpu 2] shutdown requested, stopping this vCPU

[vcpu 0] shutdown requested, stopping this vCPU

[vcpu 3] shutdown requested, stopping this vCPU
VM stopped.