Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 178e031a authored by Soichiro Fujii's avatar Soichiro Fujii
Browse files

libprefetch: Remove `start` command 

This command evaluates the current state of device
and sets either `record` or `replay` property depending
on the result.

As these checks are now performed by its respective
commands by their own, `start` is now obsolete and can
be removed.

Bug: 380766679
Test: Build
Test: on cuttlefish, observe that record only starts when
the same condition originally checked in start is met.
Test: on cuttlefish, observe that replay only starts when
the same condition originally checked in start is met.

Change-Id: Idb791187b1c8d3c69a1d7f662a4b74413f6819a2
parent a0c570bf

init/libprefetch/prefetch/src/arch/android.rs

+0 −68
Original line number Diff line number Diff line 
use crate::Error;

use crate::RecordArgs;

use crate::StartArgs;

use log::info;

use log::warn;

use std::fs::File;

use std::fs::OpenOptions;
@@ -12,8 +10,6 @@ use std::time::Duration; 
use rustutils::system_properties::error::PropertyWatcherError;

use rustutils::system_properties::PropertyWatcher;



const PREFETCH_RECORD_PROPERTY: &str = "prefetch_boot.record";

const PREFETCH_REPLAY_PROPERTY: &str = "prefetch_boot.replay";

const PREFETCH_RECORD_PROPERTY_STOP: &str = "prefetch_boot.record_stop";



fn wait_for_property_true(
@@ -32,16 +28,6 @@ pub fn wait_for_record_stop() { 
    });

}



fn start_prefetch_service(property_name: &str) -> Result<(), Error> {

    match rustutils::system_properties::write(property_name, "true") {

        Ok(_) => {}

        Err(_) => {

            return Err(Error::Custom { error: "Failed to start prefetch service".to_string() });

        }

    }

    Ok(())

}



/// Checks if we can perform replay phase.

/// Ensure that the pack file exists and is up-to-date, returns false otherwise.

pub fn can_perform_replay(pack_path: &Path, fingerprint_path: &Path) -> Result<bool, Error> {
@@ -79,60 +65,6 @@ pub fn ensure_record_is_ready( 
    Ok(!can_replay)

}



/// Start prefetch service

///

/// 1: Check the presence of the file 'prefetch_ready'. If it doesn't

/// exist then the device is booting for the first time after wipe.

/// Thus, we would just create the file and exit as we do not want

/// to initiate the record after data wipe primiarly because boot

/// after data wipe is long and the I/O pattern during first boot may not actually match

/// with subsequent boot.

///

/// 2: If the file 'prefetch_ready' is present:

///

///   a: Compare the build-finger-print of the device with the one record format

///   is associated with by reading the file 'build_finger_print'. If they match,

///   start the prefetch_replay.

///

///   b: If they don't match, then the device was updated through OTA. Hence, start

///   a fresh record and delete the build-finger-print file. This should also cover

///   the case of device rollback.

///

///   c: If the build-finger-print file doesn't exist, then just restart the record

///   from scratch.

pub fn start_prefetch(args: &StartArgs) -> Result<(), Error> {

    if !args.path.exists() {

        match File::create(args.path.clone()) {

            Ok(_) => {}

            Err(_) => {

                return Err(Error::Custom { error: "File Creation failed".to_string() });

            }

        }

        return Ok(());

    }



    if args.build_fingerprint_path.exists() {

        let device_build_fingerprint = rustutils::system_properties::read("ro.build.fingerprint")

            .map_err(|e| Error::Custom {

            error: format!("Failed to read ro.build.fingerprint: {}", e),

        })?;

        let pack_build_fingerprint = std::fs::read_to_string(&args.build_fingerprint_path)?;

        if pack_build_fingerprint.trim() == device_build_fingerprint.as_deref().unwrap_or_default()

        {

            info!("Start replay");

            start_prefetch_service(PREFETCH_REPLAY_PROPERTY)?;

        } else {

            info!("Start record");

            std::fs::remove_file(&args.build_fingerprint_path)?;

            start_prefetch_service(PREFETCH_RECORD_PROPERTY)?;

        }

    } else {

        info!("Start record");

        start_prefetch_service(PREFETCH_RECORD_PROPERTY)?;

    }

    Ok(())

}



/// Write build finger print to associate prefetch pack file

pub fn write_build_fingerprint(args: &RecordArgs) -> Result<(), Error> {

    let mut build_fingerprint_file = OpenOptions::new()

init/libprefetch/prefetch/src/args.rs

+0 −4
Original line number Diff line number Diff line
@@ -25,8 +25,6 @@ use std::process::exit; 


pub use args_internal::OutputFormat;

pub use args_internal::ReplayArgs;

#[cfg(target_os = "android")]

pub use args_internal::StartArgs;

pub use args_internal::TracerType;

pub use args_internal::{DumpArgs, MainArgs, RecordArgs, SubCommands};

use serde::Deserialize;
@@ -68,8 +66,6 @@ fn verify_and_fix(args: &mut MainArgs) -> Result<(), Error> { 
        SubCommands::Dump(arg) => {

            ensure_path_exists(&arg.path)?;

        }

        #[cfg(target_os = "android")]

        SubCommands::Start(_arg) => return Ok(()),

    }

    Ok(())

}

init/libprefetch/prefetch/src/args/args_argh.rs

+0 −22
Original line number Diff line number Diff line
@@ -40,12 +40,6 @@ pub enum SubCommands { 
    Replay(ReplayArgs),

    /// Dump prefetch data in human readable format

    Dump(DumpArgs),

    /// Start prefetch service if possible

    /// If the pack file is present, then prefetch replay is started

    /// If the pack file is absent or if the build fingerprint

    /// of the current pack file is different, then prefetch record is started.

    #[cfg(target_os = "android")]

    Start(StartArgs),

}



#[cfg(target_os = "android")]
@@ -58,22 +52,6 @@ fn default_build_finger_print_path() -> PathBuf { 
    PathBuf::from("/metadata/prefetch/build_finger_print")

}



#[cfg(target_os = "android")]

#[derive(Eq, PartialEq, Debug, Default, FromArgs)]

/// Start prefetch service based on if pack file is present.

#[argh(subcommand, name = "start")]

pub struct StartArgs {

    /// file path to check if prefetch_ready is present.

    ///

    /// A new file is created at the given path if it's not present.

    #[argh(option, default = "default_ready_path()")]

    pub path: PathBuf,



    /// file path where build fingerprint is stored

    #[argh(option, default = "default_build_finger_print_path()")]

    pub build_fingerprint_path: PathBuf,

}



impl Default for SubCommands {

    fn default() -> Self {

        Self::Dump(DumpArgs::default())

init/libprefetch/prefetch/src/lib.rs

+0 −2
Original line number Diff line number Diff line
@@ -42,8 +42,6 @@ use log::LevelFilter; 
pub use args::args_from_env;

use args::OutputFormat;

pub use args::ReplayArgs;

#[cfg(target_os = "android")]

pub use args::StartArgs;

pub use args::{DumpArgs, MainArgs, RecordArgs, SubCommands};

pub use error::Error;

pub use format::FileId;

init/libprefetch/prefetch/src/main.rs

+0 −4
Original line number Diff line number Diff line
@@ -22,8 +22,6 @@ use prefetch_rs::dump; 
use prefetch_rs::init_logging;

use prefetch_rs::record;

use prefetch_rs::replay;

#[cfg(target_os = "android")]

use prefetch_rs::start_prefetch;

use prefetch_rs::LogLevel;

use prefetch_rs::MainArgs;

use prefetch_rs::SubCommands;
@@ -35,8 +33,6 @@ fn main() { 
        SubCommands::Record(args) => record(args),

        SubCommands::Replay(args) => replay(args),

        SubCommands::Dump(args) => dump(args),

        #[cfg(target_os = "android")]

        SubCommands::Start(args) => start_prefetch(args),

    };



    if let Err(err) = ret {