s_gpt.rs

/*
 * Copyright (c) 2021, Luca Fulchir <luker@fenrirproject.org>
 *
 * This file is part of dfim.
 *
 * dfim is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * dfim is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with dfim.  If not, see <https://www.gnu.org/licenses/>.
 */

use super::{CheckResult, CheckStatus, NextTarget};
use crate::config::trgt;

// we could use lifetimes here instead of copying stuff, but
// - we should have realatively low usage anyway
// - lifetimes can get messy
// - we don't have enough trgts to fully know how lifetimes will impact the
//   code.
// so for now, clone
pub struct GPT(trgt::gpt::GPT);

impl GPT {
    pub fn new(cfg: &trgt::gpt::GPT) -> Self {
        GPT(cfg.clone())
    }
}

impl GPT {
    /// generate a standard config that can be checked easily
    /// so that we can compare the config GPT with the device GPT
    fn generate_standard(&self, dev: &::udev::Device) -> trgt::gpt::GPT {
        let mut ret = trgt::gpt::GPT {
            id: self.0.id.clone(),
            guid: self.0.guid.clone(),
            max_partitions: self.0.max_partitions,
            partitions: Vec::with_capacity(self.0.partitions.len()),
        };
        // we now have to recalculate the partition actual size,
        // and move them all to LBA
        // create (but never write) a new GPT table
        // and work with that to translate to LBA
        let gpt = ::gpt::GptConfig::new().writable(false);
        let node = match dev.devnode() {
            Some(node) => node,
            None => return ret,
        };

        let mut disk = match gpt.open(node) {
            Ok(disk) => disk,
            Err(_) => {
                return ret;
            }
        };
        let mut new_partitions = ::std::collections::BTreeMap::<
            u32,
            ::gpt::partition::Partition,
        >::new();

        disk.update_partitions(new_partitions.clone()).unwrap();
        let disk_alignment = match disk.logical_block_size() {
            ::gpt::disk::LogicalBlockSize::Lb512 => 512,
            ::gpt::disk::LogicalBlockSize::Lb4096 => 4096,
        };
        let free_lba = disk.find_free_sectors();
        let min_lba = free_lba.get(0).unwrap().0;
        let max_lba = free_lba.get(0).unwrap().1;

        use trgt::gpt::{
            Alignment, Index, PartFrom, PartId, PartTo, PartType, PartUUID,
            Partition,
        };
        // convert all to LBA for ease of usage
        let mut lba_partitions = Vec::with_capacity(self.0.partitions.len());
        for p in &self.0.partitions {
            let mut new_p = p.clone();
            new_p.from.lba_align(disk_alignment, min_lba, max_lba);
            new_p.to.lba_align(disk_alignment, min_lba, max_lba);
            lba_partitions.push(new_p);
        }
        // create a fake partition and a pointer to it
        // we will use the pointer to the last partition used
        // so that we can guess where to try to put the next partition
        let prented_part = Partition {
            label: String::new(),
            number: 0,
            part_type: PartId::UUID(PartType::Unused.uuid()),
            part_uuid: PartUUID::UUID(PartType::Unused.uuid()),
            flags: Vec::new(),
            from: PartFrom::Index(
                Index::LBA(0),
                Alignment::Alignment(Index::LBA(0)),
            ),
            to: PartTo::Index(
                Index::LBA(0),
                Alignment::Alignment(Index::LBA(0)),
            ),
            target: trgt::TargetId::Id(String::new()),
        };
        let mut last_p = &prented_part;
        ret
    }
    /*
    /// get the current drevice GPT. make it standard enough that we can
    /// easily check with what comes from generate_standard(dev)
    fn get_current(&self, dev: &::udev::Device) -> Result<trgt::gpt::GPT, ::std::io::Error> {

    }
    */
}

impl super::TargetApply for GPT {
    fn check(
        &mut self,
        logger: &::slog::Logger,
        cfg: &crate::state::cfg::Cfg,
        dev: &::udev::Device,
    ) -> Result<CheckResult, ::std::io::Error> {
        let node = match dev.devnode() {
            Some(node) => ::std::path::Path::new(node),
            None => {
                ::slog::error!(
                    logger,
                    "GPT: device \"{:?}\" does not have a corresponding node",
                    dev.syspath()
                );
                return Err(::std::io::Error::new(
                    ::std::io::ErrorKind::NotFound,
                    "GPT: device does not have a node",
                ));
            }
        };

        let cfg = ::gpt::GptConfig::new().writable(false);

        if let Ok(true) = crate::state::is_empty(dev) {
            return Ok(CheckResult {
                status: CheckStatus::CanBeApplied,
                // FIXME
                next: Vec::new(),
            });
        }

        let disk = match cfg.open(node) {
            Ok(disk) => disk,
            Err(e) => {
                ::slog::error!(
                    logger,
                    "GPT: device \"{:?}\" node \"{:?}\": can't open",
                    dev.syspath(),
                    node
                );
                return Err(e);
            }
        };
        let disk_guid = disk.guid();
        if let trgt::gpt::GptUuid::UUID(uuid) = self.0.guid {
            if *disk_guid != uuid {
                ::slog::debug!(
                    logger,
                    "GPT: device \"{:?}\" wrong guid. Got: {:?} Expected: {:?}",
                    dev.syspath(),
                    disk_guid,
                    uuid
                );
                return Ok(CheckResult {
                    status: CheckStatus::DoNotApply,
                    next: Vec::new(),
                });
            }
        }
        let disk_part = disk.partitions();
        if disk_part.len() != self.0.partitions.len() {
            ::slog::debug!(
                logger,
                "GPT: device \"{:?}\" partitions don't match",
                dev.syspath()
            );
            return Ok(CheckResult {
                status: CheckStatus::DoNotApply,
                next: Vec::new(),
            });
        }
        for (idx, p) in disk_part {
            match self.0.partitions.iter().find(|x| x.number == *idx) {
                None => {
                    ::slog::debug!(
                        logger,
                        "GPT: device \"{:?}\" partition {} does not match",
                        dev.syspath(),
                        idx,
                    );
                    return Ok(CheckResult {
                        status: CheckStatus::DoNotApply,
                        next: Vec::new(),
                    });
                }
                Some(self_p) => {
                    // TODO
                }
            }
        }
        Err(::std::io::Error::new(
            ::std::io::ErrorKind::Other,
            "Exec: nonZero exit status",
        ))
    }
    fn apply(
        &mut self,
        logger: &::slog::Logger,
        cfg: &crate::state::cfg::Cfg,
        cfg_dev: &crate::config::device::Device,
        dev: &::udev::Device,
    ) -> Result<Vec<NextTarget>, ::std::io::Error> {
        Err(::std::io::Error::new(
            ::std::io::ErrorKind::Other,
            "Exec: nonZero exit status",
        ))
    }
}