rumia/src/op/seq.rs

use std::fs;
use lazy_static::lazy_static;
use crate::log::{logger};
use std::sync::atomic::{AtomicBool, Ordering};
use crate::op::{makesure, once};
use crate::{cfg};
use crate::mount::{convert_flag_from_string_vec, mount_custom};

lazy_static!{
    static ref SEQ_OK_PREPARE: AtomicBool = AtomicBool::new(false);
    static ref SEQ_OK_FSMOUNT: AtomicBool = AtomicBool::new(false);
    static ref SEQ_OK_NEWENV: AtomicBool = AtomicBool::new(false);
    static ref SEQ_OK_MOVEMNT: AtomicBool = AtomicBool::new(false);
}

pub fn prepare() {
    if SEQ_OK_PREPARE.load(Ordering::Relaxed) {
        logger().warn("seq", "The sequence 'prepare' is already executed. Ignored.");
        return;
    }
    makesure::mkdir_p("/boot");
    once::mount_bootfs();
    cfg::load_phase2();
    makesure::export_initrd_env_from_cfg();
    once::mount_runfs_from_cfg();
    SEQ_OK_PREPARE.store(true, Ordering::Relaxed);
}

pub fn fstab_mount() {
    if SEQ_OK_FSMOUNT.load(Ordering::Relaxed) {
        logger().warn("seq", "The sequence 'fstab-mount' is already executed. Ignored.");
        return;
    }
    let cfg_inst = cfg::CFG.get();
    let fstab = cfg_inst.get_cfg().get_fstab();
    'mount_fs:
    for item in fstab {
        let m_must_mount = match item.must_mount {
            None => false,
            Some(v) => v,
        };
        let m_src = match &item.src {
            None => None,
            Some(v) => Some(v.as_str())
        };
        let m_fstype = match &item.fstype {
            None => None,
            Some(v) => Some(v.as_str())
        };
        let m_opt = match &item.option {
            None => None,
            Some(v) => Some(v.as_str())
        };
        let m_target = (&item.target).as_str();
        let m_flg = convert_flag_from_string_vec(&item.flags, m_target);
        let d_src = match &item.src {
            None => "<none>",
            Some(v) => {v.as_str()}
        };
        let d_fstype = match &item.fstype {
            None => "<none>",
            Some(v) => {v.as_str()}
        };
        let d_opt = match &item.option {
            None => "<none>",
            Some(v) => {v.as_str()}
        };
        match &item.pre_mkdir {
            None => {}
            Some(v) => {
                for pmi in v.clone() {
                    let mkr = fs::create_dir_all(pmi.as_str());
                    match mkr {
                        Ok(_) => {}
                        Err(err) => {
                            if m_must_mount{
                                logger().fatal("fstab", format!(
                                    "failed mount '{}': failed in creating pre-mount dir '{}': {:?}",
                                    d_src,
                                    pmi.as_str(),
                                    err
                                ).as_str())
                            }else {
                                logger().warn("fstab", format!(
                                    "failed mount '{}': failed in creating pre-mount dir '{}': {:?}",
                                    d_src,
                                    m_target,
                                    err
                                ).as_str());
                                continue 'mount_fs;
                            }
                        }
                    }
                }
            }
        }
        let r = mount_custom(m_src, m_target, m_fstype, m_opt, m_flg);
        match r {
            Ok(_) => {
                logger().debug("fstab", format!(
                    "mounted '{}' at '{}' with fstype='{}', option='{}', flags={:#x}.",
                    d_src,
                    m_target,
                    d_fstype,
                    d_opt,
                    m_flg,
                ).as_str())
            }
            Err(err) => {
                if m_must_mount {
                    logger().fatal("fstab", format!(
                        "failed mount '{}' at '{}' with fstype='{}', option='{}', flags={:#x}: {:?}",
                        d_src,
                        m_target,
                        d_fstype,
                        d_opt,
                        m_flg,
                        err
                    ).as_str());
                    continue 'mount_fs;
                }else{
                    logger().warn("fstab", format!(
                        "failed mount '{}' at '{}' with fstype='{}', option='{}', flags={:#x}: {:?}",
                        d_src,
                        m_target,
                        d_fstype,
                        d_opt,
                        m_flg,
                        err
                    ).as_str());
                    continue 'mount_fs;
                }
            }
        }
        match &item.post_mkdir {
            None => {}
            Some(v) => {
                for pmi in v.clone() {
                    let mkr = fs::create_dir_all(pmi.as_str());
                    match mkr {
                        Ok(_) => {}
                        Err(err) => {
                            if m_must_mount{
                                logger().fatal("fstab", format!(
                                    "failed mount '{}': failed in creating post-mount dir '{}': {:?}",
                                    d_src,
                                    pmi.as_str(),
                                    err
                                ).as_str())
                            }else {
                                logger().warn("fstab", format!(
                                    "failed mount '{}': failed in creating post-mount dir '{}': {:?}",
                                    d_src,
                                    m_target,
                                    err
                                ).as_str());
                                continue 'mount_fs;
                            }
                        }
                    }
                }
            }
        }
    }
    SEQ_OK_FSMOUNT.store(true, Ordering::Relaxed);
}

pub fn new_env() {
    if SEQ_OK_NEWENV.load(Ordering::Relaxed) {
        logger().warn("seq", "The sequence 'new-env' is already executed. Ignored.");
        return;
    }
    makesure::export_env_from_cfg();
    SEQ_OK_NEWENV.store(true, Ordering::Relaxed)
}

pub fn move_prepare_mount() {
    if SEQ_OK_MOVEMNT.load(Ordering::Relaxed) {
        logger().warn("seq", "The sequence 'move-mnt' is already executed. Ignored.");
        return;
    }
    let new_root = cfg::CFG.get().get_cfg().get_new_root();
    once::move_sysfs(format!("{}/sys", new_root).as_str());
    once::move_proc(format!("{}/proc", new_root).as_str());
    once::move_bootfs(format!("{}/boot", new_root).as_str());
    once::move_run(format!("{}/run", new_root).as_str());
    once::move_temporary_devtmpfs(new_root.as_str());
    SEQ_OK_MOVEMNT.store(true, Ordering::Relaxed)
}