Major restructure to move gfx control out to crate

supergfx/src/config.rs

@@ -0,0 +1,89 @@
+use log::{error, warn};
+use serde_derive::{Deserialize, Serialize};
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+use crate::gfx_vendors::GfxVendors;
+
+pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
+pub static AURA_CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
+
+#[derive(Deserialize, Serialize)]
+pub struct GfxConfig {
+    #[serde(skip)]
+    config_path: String,
+    /// The current mode set, also applies on boot
+    pub gfx_mode: GfxVendors,
+    /// Only for informational purposes
+    #[serde(skip)]
+    pub gfx_tmp_mode: Option<GfxVendors>,
+    /// Set if graphics management is enabled
+    pub gfx_managed: bool,
+    /// Set if vfio option is enabled. This requires the vfio drivers to be built as modules
+    pub gfx_vfio_enable: bool,
+}
+
+impl GfxConfig {
+    fn new(config_path: String) -> Self {
+        Self {
+            config_path,
+            gfx_mode: GfxVendors::Hybrid,
+            gfx_tmp_mode: None,
+            gfx_managed: true,
+            gfx_vfio_enable: false,
+        }
+    }
+
+    /// `load` will attempt to read the config, and panic if the dir is missing
+    pub fn load(config_path: String) -> Self {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(&config_path)
+            .unwrap_or_else(|_| panic!("The directory {} is missing", config_path)); // okay to cause panic here
+        let mut buf = String::new();
+        let mut config;
+        if let Ok(read_len) = file.read_to_string(&mut buf) {
+            if read_len == 0 {
+                config = Self::new(config_path);
+            } else if let Ok(data) = serde_json::from_str(&buf) {
+                config = data;
+                config.config_path = config_path;
+            } else {
+                warn!("Could not deserialise {}", config_path);
+                panic!("Please remove {} then restart service", config_path);
+            }
+        } else {
+            config = Self::new(config_path)
+        }
+        config.write();
+        config
+    }
+
+    pub fn read(&mut self) {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&self.config_path)
+            .unwrap_or_else(|err| panic!("Error reading {}: {}", self.config_path, err));
+        let mut buf = String::new();
+        if let Ok(l) = file.read_to_string(&mut buf) {
+            if l == 0 {
+                warn!("File is empty {}", self.config_path);
+            } else {
+                let mut x: Self = serde_json::from_str(&buf)
+                    .unwrap_or_else(|_| panic!("Could not deserialise {}", self.config_path));
+                // copy over serde skipped values
+                x.gfx_tmp_mode = self.gfx_tmp_mode;
+                *self = x;
+            }
+        }
+    }
+
+    pub fn write(&self) {
+        let mut file = File::create(&self.config_path).expect("Couldn't overwrite config");
+        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
+        file.write_all(json.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+}

supergfx/src/controller.rs

@@ -0,0 +1,703 @@
+use log::{error, info, warn};
+use logind_zbus::{
+    types::{SessionClass, SessionInfo, SessionState, SessionType},
+    ManagerProxy, SessionProxy,
+};
+use ::zbus::Connection;
+use std::{io::Write, ops::Add, path::Path, time::Instant};
+use std::{process::Command, thread::sleep, time::Duration};
+use std::{str::FromStr, sync::mpsc};
+use std::{sync::Arc, sync::Mutex};
+use sysfs_class::RuntimePM;
+use sysfs_class::{PciDevice, SysClass};
+
+use crate::{*, error::GfxError, system::{GraphicsDevice, PciBus}};
+
+use super::config::GfxConfig;
+use super::gfx_vendors::{GfxPower, GfxRequiredUserAction, GfxVendors};
+
+const THREAD_TIMEOUT_MSG: &str = "GFX: thread time exceeded 3 minutes, exiting";
+const NVIDIA_RUNTIME_STATUS_PATH: &str = "/sys/bus/pci/devices/0000:01:00.0/power/runtime_status";
+
+pub struct CtrlGraphics {
+    bus: PciBus,
+    _amd: Vec<GraphicsDevice>,
+    _intel: Vec<GraphicsDevice>,
+    nvidia: Vec<GraphicsDevice>,
+    #[allow(dead_code)]
+    other: Vec<GraphicsDevice>,
+    config: Arc<Mutex<GfxConfig>>,
+    thread_kill: Arc<Mutex<Option<mpsc::Sender<bool>>>>,
+}
+
+impl CtrlGraphics {
+    pub fn new(config: Arc<Mutex<GfxConfig>>) -> std::io::Result<CtrlGraphics> {
+        let bus = PciBus::new()?;
+        info!("GFX: Rescanning PCI bus");
+        bus.rescan()?;
+        let devs = PciDevice::all()?;
+
+        let functions = |parent: &PciDevice| -> Vec<PciDevice> {
+            let mut functions = Vec::new();
+            if let Some(parent_slot) = parent.id().split('.').next() {
+                for func in devs.iter() {
+                    if let Some(func_slot) = func.id().split('.').next() {
+                        if func_slot == parent_slot {
+                            info!("GFX: {}: Function for {}", func.id(), parent.id());
+                            functions.push(func.clone());
+                        }
+                    }
+                }
+            }
+            functions
+        };
+
+        let mut amd = Vec::new();
+        let mut intel = Vec::new();
+        let mut nvidia = Vec::new();
+        let mut other = Vec::new();
+        for dev in devs.iter() {
+            let c = dev.class().map_err(|err| {
+                error!(
+                    "GFX: device error: {}, {}",
+                    dev.path().to_string_lossy(),
+                    err
+                );
+                err
+            })?;
+            if 0x03 == (c >> 16) & 0xFF {
+                match dev.vendor()? {
+                    0x1002 => {
+                        info!("GFX: {}: AMD graphics", dev.id());
+                        amd.push(GraphicsDevice::new(dev.id().to_owned(), functions(dev)));
+                    }
+                    0x10DE => {
+                        info!("GFX: {}: NVIDIA graphics", dev.id());
+                        dev.set_runtime_pm(sysfs_class::RuntimePowerManagement::On)?;
+                        nvidia.push(GraphicsDevice::new(dev.id().to_owned(), functions(dev)));
+                    }
+                    0x8086 => {
+                        info!("GFX: {}: Intel graphics", dev.id());
+                        intel.push(GraphicsDevice::new(dev.id().to_owned(), functions(dev)));
+                    }
+                    vendor => {
+                        info!("GFX: {}: Other({:X}) graphics", dev.id(), vendor);
+                        other.push(GraphicsDevice::new(dev.id().to_owned(), functions(dev)));
+                    }
+                }
+            }
+        }
+
+        Ok(CtrlGraphics {
+            bus,
+            _amd: amd,
+            _intel: intel,
+            nvidia,
+            other,
+            config,
+            thread_kill: Arc::new(Mutex::new(None)),
+        })
+    }
+
+    /// Force reinit of all state, including reset of device state
+    pub fn reload(&mut self) -> Result<(), GfxError> {
+        self.auto_power()?;
+        info!("GFX: Reloaded gfx mode: {:?}", self.get_gfx_mode()?);
+        Ok(())
+    }
+
+    pub fn bus(&self) -> PciBus {
+        self.bus.clone()
+    }
+
+    pub fn devices(&self) -> Vec<GraphicsDevice> {
+        self.nvidia.clone()
+    }
+
+    /// Save the selected `Vendor` mode to config
+    fn save_gfx_mode(vendor: GfxVendors, config: Arc<Mutex<GfxConfig>>) {
+        if let Ok(mut config) = config.lock() {
+            config.gfx_mode = vendor;
+            config.write();
+        }
+    }
+
+    /// Associated method to get which vendor mode is set
+    pub(super) fn get_gfx_mode(&self) -> Result<GfxVendors, GfxError> {
+        if let Ok(config) = self.config.lock() {
+            if let Some(mode) = config.gfx_tmp_mode {
+                return Ok(mode);
+            }
+            return Ok(config.gfx_mode);
+        }
+        // TODO: Error here
+        Ok(GfxVendors::Hybrid)
+    }
+
+    pub(super) fn get_runtime_status() -> Result<GfxPower, GfxError> {
+        let path = Path::new(NVIDIA_RUNTIME_STATUS_PATH);
+        if path.exists() {
+            let buf = std::fs::read_to_string(path).map_err(|err| {
+                GfxError::Read(
+                    path.to_string_lossy().to_string(),
+                    err,
+                )
+            })?;
+            Ok(GfxPower::from_str(&buf)?)
+        } else {
+            Ok(GfxPower::Off)
+        }
+    }
+
+    /// Some systems have a fallback service to load nouveau if nvidia fails
+    fn toggle_fallback_service(vendor: GfxVendors) -> Result<(), GfxError> {
+        let action = if vendor == GfxVendors::Nvidia {
+            info!("GFX: Enabling nvidia-fallback.service");
+            "enable"
+        } else {
+            info!("GFX: Disabling nvidia-fallback.service");
+            "disable"
+        };
+
+        let status = Command::new("systemctl")
+            .arg(action)
+            .arg("nvidia-fallback.service")
+            .status()
+            .map_err(|err| GfxError::Command("systemctl".into(), err))?;
+
+        if !status.success() {
+            // Error is ignored in case this service is removed
+            warn!(
+                "systemctl: {} (ignore warning if service does not exist!)",
+                status
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Write the appropriate xorg config for the chosen mode
+    fn write_xorg_conf(vendor: GfxVendors) -> Result<(), GfxError> {
+        let text = if vendor == GfxVendors::Nvidia {
+            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_NVIDIA, PRIMARY_GPU_END].concat()
+        } else {
+            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
+        };
+
+        if !Path::new(XORG_PATH).exists() {
+            std::fs::create_dir(XORG_PATH).map_err(|err| GfxError::Write(XORG_PATH.into(), err))?;
+        }
+
+        let file = XORG_PATH.to_string().add(XORG_FILE);
+        info!("GFX: Writing {}", file);
+        let mut file = std::fs::OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(&file)
+            .map_err(|err| GfxError::Write(file, err))?;
+
+        file.write_all(&text)
+            .and_then(|_| file.sync_all())
+            .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
+        Ok(())
+    }
+
+    /// Creates the full modprobe.conf required for vfio pass-through
+    fn get_vfio_conf(devices: &[GraphicsDevice]) -> Vec<u8> {
+        let mut vifo = MODPROBE_VFIO.to_vec();
+        for (d_count, dev) in devices.iter().enumerate() {
+            for (f_count, func) in dev.functions().iter().enumerate() {
+                let vendor = func.vendor().unwrap();
+                let device = func.device().unwrap();
+                unsafe {
+                    vifo.append(format!("{:x}", vendor).as_mut_vec());
+                }
+                vifo.append(&mut vec![b':']);
+                unsafe {
+                    vifo.append(format!("{:x}", device).as_mut_vec());
+                }
+                if f_count < dev.functions().len() - 1 {
+                    vifo.append(&mut vec![b',']);
+                }
+            }
+            if d_count < dev.functions().len() - 1 {
+                vifo.append(&mut vec![b',']);
+            }
+        }
+        let mut conf = MODPROBE_INTEGRATED.to_vec();
+        conf.append(&mut vifo);
+        conf
+    }
+
+    fn write_modprobe_conf(vendor: GfxVendors, devices: &[GraphicsDevice]) -> Result<(), GfxError> {
+        info!("GFX: Writing {}", MODPROBE_PATH);
+        let content = match vendor {
+            GfxVendors::Nvidia | GfxVendors::Hybrid => {
+                let mut base = MODPROBE_BASE.to_vec();
+                base.append(&mut MODPROBE_DRM_MODESET.to_vec());
+                base
+            }
+            GfxVendors::Vfio => Self::get_vfio_conf(devices),
+            GfxVendors::Integrated => MODPROBE_INTEGRATED.to_vec(),
+            GfxVendors::Compute => MODPROBE_BASE.to_vec(),
+        };
+
+        let mut file = std::fs::OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(MODPROBE_PATH)
+            .map_err(|err| GfxError::Path(MODPROBE_PATH.into(), err))?;
+
+        file.write_all(&content)
+            .and_then(|_| file.sync_all())
+            .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
+
+        Ok(())
+    }
+
+    fn unbind_remove_nvidia(devices: &[GraphicsDevice]) -> Result<(), GfxError> {
+        // Unbind NVIDIA graphics devices and their functions
+        let unbinds = devices.iter().map(|dev| dev.unbind());
+        // Remove NVIDIA graphics devices and their functions
+        let removes = devices.iter().map(|dev| dev.remove());
+        unbinds
+            .chain(removes)
+            .collect::<Result<_, _>>()
+            .map_err(|err| GfxError::Command("device unbind error".into(), err))
+    }
+
+    fn unbind_only(devices: &[GraphicsDevice]) -> Result<(), GfxError> {
+        let unbinds = devices.iter().map(|dev| dev.unbind());
+        unbinds
+            .collect::<Result<_, _>>()
+            .map_err(|err| GfxError::Command("device unbind error".into(), err))
+    }
+
+    /// Add or remove driver modules
+    fn do_driver_action(driver: &str, action: &str) -> Result<(), GfxError> {
+        let mut cmd = Command::new(action);
+        cmd.arg(driver);
+
+        let mut count = 0;
+        const MAX_TRIES: i32 = 6;
+        loop {
+            if count > MAX_TRIES {
+                let msg = format!("{} {} failed for unknown reason", action, driver);
+                error!("GFX: {}", msg);
+                return Ok(()); //Err(GfxError::Modprobe(msg));
+            }
+
+            let output = cmd
+                .output()
+                .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
+            if !output.status.success() {
+                if output
+                    .stderr
+                    .ends_with("is not currently loaded\n".as_bytes())
+                {
+                    return Ok(());
+                }
+                if output.stderr.ends_with("is builtin.\n".as_bytes()) {
+                    return Err(GfxError::VfioBuiltin);
+                }
+                if output.stderr.ends_with("Permission denied\n".as_bytes()) {
+                    warn!(
+                        "{} {} failed: {:?}",
+                        action,
+                        driver,
+                        String::from_utf8_lossy(&output.stderr)
+                    );
+                    warn!("GFX: It may be safe to ignore the above error, run `lsmod |grep {}` to confirm modules loaded", driver);
+                    return Ok(());
+                }
+                if String::from_utf8_lossy(&output.stderr)
+                    .contains(&format!("Module {} not found", driver))
+                {
+                    return Err(GfxError::MissingModule(driver.into()));
+                }
+                if count >= MAX_TRIES {
+                    let msg = format!(
+                        "{} {} failed: {:?}",
+                        action,
+                        driver,
+                        String::from_utf8_lossy(&output.stderr)
+                    );
+                    return Err(GfxError::Modprobe(msg));
+                }
+            } else if output.status.success() {
+                return Ok(());
+            }
+
+            count += 1;
+            std::thread::sleep(std::time::Duration::from_millis(50));
+        }
+    }
+
+    fn do_display_manager_action(action: &str) -> Result<(), GfxError> {
+        let mut cmd = Command::new("systemctl");
+        cmd.arg(action);
+        cmd.arg(DISPLAY_MANAGER);
+
+        let status = cmd
+            .status()
+            .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
+        if !status.success() {
+            let msg = format!(
+                "systemctl {} {} failed: {:?}",
+                action, DISPLAY_MANAGER, status
+            );
+            return Err(GfxError::DisplayManagerAction(msg, status));
+        }
+        Ok(())
+    }
+
+    fn wait_display_manager_state(state: &str) -> Result<(), GfxError> {
+        let mut cmd = Command::new("systemctl");
+        cmd.arg("is-active");
+        cmd.arg(DISPLAY_MANAGER);
+
+        let mut count = 0;
+
+        while count <= (4 * 3) {
+            // 3 seconds max
+            let output = cmd
+                .output()
+                .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
+            if output.stdout.starts_with(state.as_bytes()) {
+                return Ok(());
+            }
+            std::thread::sleep(std::time::Duration::from_millis(250));
+            count += 1;
+        }
+        Err(GfxError::DisplayManagerTimeout(state.into()))
+    }
+
+    /// Determine if we need to logout/thread. Integrated<->Vfio mode does not
+    /// require logout.
+    fn is_logout_required(&self, vendor: GfxVendors) -> GfxRequiredUserAction {
+        if let Ok(config) = self.config.lock() {
+            let current = config.gfx_mode;
+            // Modes that can switch without logout
+            if matches!(
+                current,
+                GfxVendors::Integrated | GfxVendors::Vfio | GfxVendors::Compute
+            ) && matches!(
+                vendor,
+                GfxVendors::Integrated | GfxVendors::Vfio | GfxVendors::Compute
+            ) {
+                return GfxRequiredUserAction::None;
+            }
+            // Modes that require a switch to integrated first
+            if matches!(current, GfxVendors::Nvidia | GfxVendors::Hybrid)
+                && matches!(vendor, GfxVendors::Compute | GfxVendors::Vfio)
+            {
+                return GfxRequiredUserAction::Integrated;
+            }
+        }
+        GfxRequiredUserAction::Logout
+    }
+
+    /// Do a full setup flow for the chosen mode:
+    ///
+    /// Tasks:
+    /// - rescan for devices
+    /// - write xorg config
+    /// - write modprobe config
+    ///   + add drivers
+    ///   + or remove drivers and devices
+    ///
+    /// The daemon needs direct access to this function when it detects that the
+    /// bios has G-Sync switch is enabled
+    pub fn do_mode_setup_tasks(
+        vendor: GfxVendors,
+        vfio_enable: bool,
+        devices: &[GraphicsDevice],
+        bus: &PciBus,
+    ) -> Result<(), GfxError> {
+        // Rescan before doing remove or add drivers
+        bus.rescan()?;
+        // Make sure the power management is set to auto for nvidia devices
+        let devs = PciDevice::all()?;
+        for dev in devs.iter() {
+            let c = dev.class().map_err(|err| {
+                error!(
+                    "GFX: device error: {}, {}",
+                    dev.path().to_string_lossy(),
+                    err
+                );
+                err
+            })?;
+            if 0x03 == (c >> 16) & 0xFF && dev.vendor()? == 0x10DE {
+                info!("GFX: {}: NVIDIA graphics, setting PM to auto", dev.id());
+                dev.set_runtime_pm(sysfs_class::RuntimePowerManagement::On)?;
+            }
+        }
+        // Only these modes should have xorg config
+        if matches!(
+            vendor,
+            GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Integrated
+        ) {
+            Self::write_xorg_conf(vendor)?;
+        }
+
+        // Write different modprobe to enable boot control to work
+        Self::write_modprobe_conf(vendor, devices)?;
+
+        match vendor {
+            GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Compute => {
+                if vfio_enable {
+                    for driver in VFIO_DRIVERS.iter() {
+                        Self::do_driver_action(driver, "rmmod")?;
+                    }
+                }
+                for driver in NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "modprobe")?;
+                }
+            }
+            GfxVendors::Vfio => {
+                if vfio_enable {
+                    Self::do_driver_action("nouveau", "rmmod")?;
+                    for driver in NVIDIA_DRIVERS.iter() {
+                        Self::do_driver_action(driver, "rmmod")?;
+                    }
+                    Self::unbind_only(devices)?;
+                    Self::do_driver_action("vfio-pci", "modprobe")?;
+                } else {
+                    return Err(GfxError::VfioDisabled);
+                }
+            }
+            GfxVendors::Integrated => {
+                Self::do_driver_action("nouveau", "rmmod")?;
+                if vfio_enable {
+                    for driver in VFIO_DRIVERS.iter() {
+                        Self::do_driver_action(driver, "rmmod")?;
+                    }
+                }
+                for driver in NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "rmmod")?;
+                }
+                Self::unbind_remove_nvidia(devices)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Check if the user has any graphical uiser sessions that are active or online
+    fn graphical_user_sessions_exist(
+        connection: &Connection,
+        sessions: &[SessionInfo],
+    ) -> Result<bool, GfxError> {
+        for session in sessions {
+            let session_proxy = SessionProxy::new(connection, session)?;
+            if session_proxy.get_class()? == SessionClass::User {
+                match session_proxy.get_type()? {
+                    SessionType::X11 | SessionType::Wayland | SessionType::MIR => {
+                        match session_proxy.get_state()? {
+                            SessionState::Online | SessionState::Active => return Ok(true),
+                            SessionState::Closing | SessionState::Invalid => {}
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Spools until all user sessions are ended then switches to requested mode
+    fn create_mode_change_thread(
+        vendor: GfxVendors,
+        devices: Vec<GraphicsDevice>,
+        bus: PciBus,
+        thread_stop: mpsc::Receiver<bool>,
+        config: Arc<Mutex<GfxConfig>>,
+    ) -> Result<String, GfxError> {
+        info!("GFX: display-manager thread started");
+
+        const SLEEP_PERIOD: Duration = Duration::from_millis(100);
+        let start_time = Instant::now();
+
+        let connection = Connection::new_system()?;
+        let manager = ManagerProxy::new(&connection)?;
+        let mut sessions = manager.list_sessions()?;
+
+        loop {
+            let tmp = manager.list_sessions()?;
+            if !tmp.iter().eq(&sessions) {
+                info!("GFX thread: Sessions list changed");
+                sessions = tmp;
+            }
+
+            if !Self::graphical_user_sessions_exist(&connection, &sessions)? {
+                break;
+            }
+
+            if let Ok(stop) = thread_stop.try_recv() {
+                if stop {
+                    return Ok("Graphics mode change was cancelled".into());
+                }
+            }
+            // exit if 3 minutes pass
+            if Instant::now().duration_since(start_time).as_secs() > 180 {
+                warn!("{}", THREAD_TIMEOUT_MSG);
+                return Ok(THREAD_TIMEOUT_MSG.into());
+            }
+
+            // Don't spin at max speed
+            sleep(SLEEP_PERIOD);
+        }
+
+        info!("GFX thread: all graphical user sessions ended, continuing");
+        Self::do_display_manager_action("stop")?;
+        Self::wait_display_manager_state("inactive")?;
+
+        let mut mode_to_save = vendor;
+        // Need to change to integrated before we can change to vfio or compute
+        if let Ok(mut config) = config.try_lock() {
+            // Since we have a lock, reset tmp to none. This thread should only ever run
+            // for Integrated, Hybrid, or Nvidia. Tmp is also only for informational
+            config.gfx_tmp_mode = None;
+            //
+            let vfio_enable = config.gfx_vfio_enable;
+
+            // Failsafe. In the event this loop is run with a switch from nvidia in use
+            // to vfio or compute do a forced switch to integrated instead to prevent issues
+            if matches!(vendor, GfxVendors::Compute | GfxVendors::Vfio)
+                && matches!(config.gfx_mode, GfxVendors::Nvidia | GfxVendors::Hybrid)
+            {
+                Self::do_mode_setup_tasks(GfxVendors::Integrated, vfio_enable, &devices, &bus)?;
+                Self::do_display_manager_action("restart")?;
+                mode_to_save = GfxVendors::Integrated;
+            } else {
+                Self::do_mode_setup_tasks(vendor, vfio_enable, &devices, &bus)?;
+                Self::do_display_manager_action("restart")?;
+            }
+        }
+
+        // Save selected mode in case of reboot
+        Self::save_gfx_mode(mode_to_save, config);
+        info!("GFX thread: display-manager started");
+
+        let v: &str = vendor.into();
+        info!("GFX thread: Graphics mode changed to {} successfully", v);
+        Ok(format!("Graphics mode changed to {} successfully", v))
+    }
+
+    /// Before starting a new thread the old one *must* be cancelled
+    fn cancel_mode_change_thread(&self) {
+        if let Ok(lock) = self.thread_kill.lock() {
+            if let Some(tx) = lock.as_ref() {
+                // Cancel the running thread
+                info!("GFX: Cancelling previous thread");
+                tx.send(true)
+                    .map_err(|err| {
+                        warn!("GFX thread: {}", err);
+                    })
+                    .ok();
+            }
+        }
+    }
+
+    /// The thread is used only in cases where a logout is required
+    fn setup_mode_change_thread(&mut self, vendor: GfxVendors) {
+        let config = self.config.clone();
+        let devices = self.nvidia.clone();
+        let bus = self.bus.clone();
+        let (tx, rx) = mpsc::channel();
+        if let Ok(mut lock) = self.thread_kill.lock() {
+            *lock = Some(tx);
+        }
+        let thread_kill = self.thread_kill.clone();
+
+        std::thread::spawn(move || {
+            Self::create_mode_change_thread(vendor, devices, bus, rx, config)
+                .map_err(|err| {
+                    error!("GFX: {}", err);
+                })
+                .ok();
+            // clear the tx/rx when done
+            if let Ok(mut lock) = thread_kill.try_lock() {
+                *lock = None;
+            }
+        });
+    }
+
+    /// Initiates a mode change by starting a thread that will wait until all
+    /// graphical sessions are exited before performing the tasks required
+    /// to switch modes.
+    ///
+    /// For manually calling (not on boot/startup) via dbus
+    pub fn set_gfx_mode(&mut self, vendor: GfxVendors) -> Result<GfxRequiredUserAction, GfxError> {
+        // if let Ok(gsync) = CtrlRogBios::get_gfx_mode() {
+        //     if gsync == 1 {
+        //         return Err(GfxError::GsyncModeActive.into());
+        //     }
+        // }
+
+        let vfio_enable = if let Ok(config) = self.config.try_lock() {
+            config.gfx_vfio_enable
+        } else {
+            false
+        };
+
+        if !vfio_enable && matches!(vendor, GfxVendors::Vfio) {
+            return Err(GfxError::VfioDisabled);
+        }
+
+        // Must always cancel any thread running
+        self.cancel_mode_change_thread();
+        // determine which method we need here
+        let action_required = self.is_logout_required(vendor);
+
+        match action_required {
+            GfxRequiredUserAction::Logout => {
+                info!("GFX: mode change requires a logout to complete");
+                self.setup_mode_change_thread(vendor);
+            }
+            GfxRequiredUserAction::Reboot => {
+                info!("GFX: mode change requires reboot");
+                let devices = self.nvidia.clone();
+                let bus = self.bus.clone();
+                Self::do_mode_setup_tasks(vendor, vfio_enable, &devices, &bus)?;
+                info!("GFX: Graphics mode changed to {}", <&str>::from(vendor));
+            }
+            GfxRequiredUserAction::Integrated => {
+                info!("GFX: mode change requires user to be in Integrated mode first");
+            }
+            GfxRequiredUserAction::None => {
+                info!("GFX: mode change does not require logout");
+                let devices = self.nvidia.clone();
+                let bus = self.bus.clone();
+                Self::do_mode_setup_tasks(vendor, vfio_enable, &devices, &bus)?;
+                info!("GFX: Graphics mode changed to {}", <&str>::from(vendor));
+                if let Ok(mut config) = self.config.try_lock() {
+                    config.gfx_tmp_mode = None;
+                    if matches!(vendor, GfxVendors::Vfio | GfxVendors::Compute) {
+                        config.gfx_tmp_mode = Some(vendor);
+                    }
+                }
+            }
+        }
+
+        Ok(action_required)
+    }
+
+    /// Used only on boot to set correct mode
+    fn auto_power(&mut self) -> Result<(), GfxError> {
+        let vendor = self.get_gfx_mode()?;
+        let devices = self.nvidia.clone();
+        let bus = self.bus.clone();
+
+        let vfio_enable = if let Ok(config) = self.config.try_lock() {
+            config.gfx_vfio_enable
+        } else {
+            false
+        };
+
+        Self::do_mode_setup_tasks(vendor, vfio_enable, &devices, &bus)?;
+        Self::toggle_fallback_service(vendor)?;
+        Ok(())
+    }
+}

supergfx/src/error.rs

@@ -0,0 +1,72 @@
+use std::fmt;
+use std::{error, process::ExitStatus};
+
+#[derive(Debug)]
+pub enum GfxError {
+    ParseVendor,
+    ParsePower,
+    Bus(String, std::io::Error),
+    DisplayManagerAction(String, ExitStatus),
+    DisplayManagerTimeout(String),
+    GsyncModeActive,
+    VfioBuiltin,
+    VfioDisabled,
+    MissingModule(String),
+    Modprobe(String),
+    Command(String, std::io::Error),
+    Path(String, std::io::Error),
+    Read(String, std::io::Error),
+    Write(String, std::io::Error),
+    Io(std::io::Error),
+    Zbus(zbus::Error),
+}
+
+impl fmt::Display for GfxError {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            GfxError::ParseVendor => write!(f, "Could not parse vendor name"),
+            GfxError::ParsePower => write!(f, "Could not parse dGPU power status"),
+            GfxError::Bus(func, error) => write!(f, "Bus error: {}: {}", func, error),
+            GfxError::DisplayManagerAction(action, status) => {
+                write!(f, "Display-manager action {} failed: {}", action, status)
+            }
+            GfxError::DisplayManagerTimeout(state) => {
+                write!(f, "Timed out waiting for display-manager {} state", state)
+            }
+            GfxError::GsyncModeActive => write!(
+                f,
+                "Can not switch gfx modes when dedicated/G-Sync mode is active"
+            ),
+            GfxError::VfioBuiltin => write!(
+                f,
+                "Can not switch to vfio mode if the modules are built in to kernel"
+            ),
+            GfxError::VfioDisabled => {
+                write!(f, "Can not switch to vfio mode if disabled in config file")
+            }
+            GfxError::MissingModule(m) => write!(f, "The module {} is missing", m),
+            GfxError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
+            GfxError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
+            GfxError::Path(path, error) => write!(f, "Path {}: {}", path, error),
+            GfxError::Read(path, error) => write!(f, "Read {}: {}", path, error),
+            GfxError::Write(path, error) => write!(f, "Write {}: {}", path, error),
+            GfxError::Io(detail) => write!(f, "std::io error: {}", detail),
+            GfxError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
+        }
+    }
+}
+
+impl error::Error for GfxError {}
+
+impl From<zbus::Error> for GfxError {
+    fn from(err: zbus::Error) -> Self {
+        GfxError::Zbus(err)
+    }
+}
+
+impl From<std::io::Error> for GfxError {
+    fn from(err: std::io::Error) -> Self {
+        GfxError::Io(err)
+    }
+}

supergfx/src/gfx_vendors.rs

@@ -0,0 +1,103 @@
+use serde_derive::{Deserialize, Serialize};
+use std::str::FromStr;
+use zvariant_derive::Type;
+
+use crate::error::GfxError;
+
+#[derive(Debug, Type, PartialEq, Copy, Clone, Deserialize, Serialize)]
+pub enum GfxPower {
+    Active,
+    Suspended,
+    Off,
+    Unknown,
+}
+
+impl FromStr for GfxPower {
+    type Err = GfxError;
+
+    fn from_str(s: &str) -> Result<Self, GfxError> {
+        match s.to_lowercase().trim() {
+            "active" => Ok(GfxPower::Active),
+            "suspended" => Ok(GfxPower::Suspended),
+            "off" => Ok(GfxPower::Off),
+            _ => Ok(GfxPower::Unknown),
+        }
+    }
+}
+
+impl From<&GfxPower> for &str {
+    fn from(gfx: &GfxPower) -> &'static str {
+        match gfx {
+            GfxPower::Active => "active",
+            GfxPower::Suspended => "suspended",
+            GfxPower::Off => "off",
+            GfxPower::Unknown => "unknown",
+        }
+    }
+}
+
+#[derive(Debug, Type, PartialEq, Copy, Clone, Deserialize, Serialize)]
+pub enum GfxVendors {
+    Nvidia,
+    Integrated,
+    Compute,
+    Vfio,
+    Hybrid,
+}
+
+impl FromStr for GfxVendors {
+    type Err = GfxError;
+
+    fn from_str(s: &str) -> Result<Self, GfxError> {
+        match s.to_lowercase().as_str() {
+            "nvidia" => Ok(GfxVendors::Nvidia),
+            "hybrid" => Ok(GfxVendors::Hybrid),
+            "compute" => Ok(GfxVendors::Compute),
+            "vfio" => Ok(GfxVendors::Vfio),
+            "integrated" => Ok(GfxVendors::Integrated),
+            "nvidia\n" => Ok(GfxVendors::Nvidia),
+            "hybrid\n" => Ok(GfxVendors::Hybrid),
+            "compute\n" => Ok(GfxVendors::Compute),
+            "vfio\n" => Ok(GfxVendors::Vfio),
+            "integrated\n" => Ok(GfxVendors::Integrated),
+            _ => Err(GfxError::ParseVendor),
+        }
+    }
+}
+
+impl From<&GfxVendors> for &str {
+    fn from(gfx: &GfxVendors) -> &'static str {
+        match gfx {
+            GfxVendors::Nvidia => "nvidia",
+            GfxVendors::Hybrid => "hybrid",
+            GfxVendors::Compute => "compute",
+            GfxVendors::Vfio => "vfio",
+            GfxVendors::Integrated => "integrated",
+        }
+    }
+}
+
+impl From<GfxVendors> for &str {
+    fn from(gfx: GfxVendors) -> &'static str {
+        (&gfx).into()
+    }
+}
+
+#[derive(Debug, Type, PartialEq, Copy, Clone, Deserialize, Serialize)]
+pub enum GfxRequiredUserAction {
+    Logout,
+    Reboot,
+    Integrated,
+    None,
+}
+
+impl From<&GfxRequiredUserAction> for &str {
+    fn from(gfx: &GfxRequiredUserAction) -> &'static str {
+        match gfx {
+            GfxRequiredUserAction::Logout => "logout",
+            GfxRequiredUserAction::Reboot => "reboot",
+            GfxRequiredUserAction::Integrated => "switch to integrated first",
+            GfxRequiredUserAction::None => "no action",
+        }
+    }
+}

supergfx/src/lib.rs

@@ -0,0 +1,61 @@
+pub mod error;
+pub mod config;
+pub mod gfx_vendors;
+pub mod controller;
+pub mod system;
+pub mod zbus;
+
+const NVIDIA_DRIVERS: [&str; 4] = ["nvidia_drm", "nvidia_modeset", "nvidia_uvm", "nvidia"];
+
+const VFIO_DRIVERS: [&str; 5] = [
+    "vfio-pci",
+    "vfio_iommu_type1",
+    "vfio_virqfd",
+    "vfio_mdev",
+    "vfio",
+];
+
+const DISPLAY_MANAGER: &str = "display-manager.service";
+
+const MODPROBE_PATH: &str = "/etc/modprobe.d/asusd.conf";
+
+static MODPROBE_BASE: &[u8] = br#"# Automatically generated by asusd
+# If you have issues with i2c_nvidia_gpu, copy the 2 lines below to a
+# new blacklist file and uncomment
+#blacklist i2c_nvidia_gpu
+#alias i2c_nvidia_gpu off
+blacklist nouveau
+alias nouveau off
+options nvidia NVreg_DynamicPowerManagement=0x02
+"#;
+
+static MODPROBE_DRM_MODESET: &[u8] = br#"
+options nvidia-drm modeset=1
+"#;
+
+static MODPROBE_INTEGRATED: &[u8] = br#"# Automatically generated by asusd
+blacklist i2c_nvidia_gpu
+blacklist nvidia
+blacklist nvidia-drm
+blacklist nvidia-modeset
+blacklist nouveau
+alias nouveau off
+"#;
+
+static MODPROBE_VFIO: &[u8] = br#"options vfio-pci ids="#;
+
+const XORG_FILE: &str = "90-nvidia-primary.conf";
+const XORG_PATH: &str = "/etc/X11/xorg.conf.d/";
+
+static PRIMARY_GPU_BEGIN: &[u8] = br#"# Automatically generated by asusd
+Section "OutputClass"
+    Identifier "nvidia"
+    MatchDriver "nvidia-drm"
+    Driver "nvidia"
+    Option "AllowEmptyInitialConfiguration" "true""#;
+
+static PRIMARY_GPU_NVIDIA: &[u8] = br#"
+    Option "PrimaryGPU" "true""#;
+
+static PRIMARY_GPU_END: &[u8] = br#"
+EndSection"#;

supergfx/src/system.rs

@@ -0,0 +1,160 @@
+use log::{error, info, warn};
+use std::fs::read_to_string;
+use std::{fs::write, io, path::PathBuf};
+use sysfs_class::{PciDevice, SysClass};
+
+pub struct Module {
+    pub name: String,
+}
+
+impl Module {
+    fn parse(line: &str) -> io::Result<Module> {
+        let mut parts = line.split(' ');
+
+        let name = parts
+            .next()
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "module name not found"))?;
+
+        Ok(Module {
+            name: name.to_string(),
+        })
+    }
+
+    pub fn all() -> io::Result<Vec<Module>> {
+        let mut modules = Vec::new();
+
+        let data = read_to_string("/proc/modules")?;
+        for line in data.lines() {
+            let module = Module::parse(line)?;
+            modules.push(module);
+        }
+
+        Ok(modules)
+    }
+}
+
+#[derive(Clone)]
+pub struct PciBus {
+    path: PathBuf,
+}
+
+impl PciBus {
+    pub fn new() -> io::Result<PciBus> {
+        let path = PathBuf::from("/sys/bus/pci");
+        if path.is_dir() {
+            Ok(PciBus { path })
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "pci directory not found",
+            ))
+        }
+    }
+
+    /// Will rescan the device tree, which adds all removed devices back
+    pub fn rescan(&self) -> io::Result<()> {
+        write(self.path.join("rescan"), "1")
+    }
+}
+
+#[derive(Clone)]
+pub struct GraphicsDevice {
+    _id: String,
+    functions: Vec<PciDevice>,
+}
+
+impl GraphicsDevice {
+    pub fn new(id: String, functions: Vec<PciDevice>) -> GraphicsDevice {
+        GraphicsDevice { _id: id, functions }
+    }
+
+    pub fn exists(&self) -> bool {
+        self.functions.iter().any(|func| func.path().exists())
+    }
+
+    pub fn functions(&self) -> &[PciDevice] {
+        &self.functions
+    }
+
+    pub fn unbind(&self) -> Result<(), std::io::Error> {
+        for func in self.functions.iter() {
+            if func.path().exists() {
+                match func.driver() {
+                    Ok(driver) => {
+                        info!("{}: Unbinding {}", driver.id(), func.id());
+                        unsafe {
+                            driver.unbind(func).map_err(|err| {
+                                error!("gfx unbind: {}", err);
+                                err
+                            })?;
+                        }
+                    }
+                    Err(err) => match err.kind() {
+                        io::ErrorKind::NotFound => (),
+                        _ => {
+                            error!("gfx driver: {:?}, {}", func.path(), err);
+                            return Err(err);
+                        }
+                    },
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn rebind(&self) -> Result<(), std::io::Error> {
+        for func in self.functions.iter() {
+            if func.path().exists() {
+                match func.driver() {
+                    Ok(driver) => {
+                        info!("{}: Binding {}", driver.id(), func.id());
+                        unsafe {
+                            driver.bind(func).map_err(|err| {
+                                error!("gfx bind: {}", err);
+                                err
+                            })?;
+                        }
+                    }
+                    Err(err) => match err.kind() {
+                        io::ErrorKind::NotFound => (),
+                        _ => {
+                            error!("gfx driver: {:?}, {}", func.path(), err);
+                            return Err(err);
+                        }
+                    },
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn remove(&self) -> Result<(), std::io::Error> {
+        for func in self.functions.iter() {
+            if func.path().exists() {
+                match func.driver() {
+                    Ok(driver) => {
+                        error!("{}: in use by {}", func.id(), driver.id());
+                    }
+                    Err(why) => match why.kind() {
+                        std::io::ErrorKind::NotFound => {
+                            info!("{}: Removing", func.id());
+                            unsafe {
+                                // ignore errors and carry on
+                                if let Err(err) = func.remove() {
+                                    error!("gfx remove: {}", err);
+                                }
+                            }
+                        }
+                        _ => {
+                            error!("Remove device failed");
+                        }
+                    },
+                }
+            } else {
+                warn!("{}: Already removed", func.id());
+            }
+        }
+        info!("Removed all gfx devices");
+        Ok(())
+    }
+}

supergfx/src/zbus.rs

@@ -0,0 +1,55 @@
+use log::{error, info, warn};
+use zvariant::ObjectPath;
+use ::zbus::dbus_interface;
+
+use crate::{gfx_vendors::{GfxPower, GfxRequiredUserAction, GfxVendors}};
+
+use super::controller::CtrlGraphics;
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlGraphics {
+    fn vendor(&self) -> zbus::fdo::Result<GfxVendors> {
+        self.get_gfx_mode().map_err(|err| {
+            error!("GFX: {}", err);
+            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
+        })
+    }
+
+    fn power(&self) -> zbus::fdo::Result<GfxPower> {
+        Self::get_runtime_status().map_err(|err| {
+            error!("GFX: {}", err);
+            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
+        })
+    }
+
+    fn set_vendor(&mut self, vendor: GfxVendors) -> zbus::fdo::Result<GfxRequiredUserAction> {
+        info!("GFX: Switching gfx mode to {}", <&str>::from(vendor));
+        let msg = self.set_gfx_mode(vendor).map_err(|err| {
+            error!("GFX: {}", err);
+            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
+        })?;
+        self.notify_gfx(&vendor)
+            .unwrap_or_else(|err| warn!("GFX: {}", err));
+        self.notify_action(&msg)
+            .unwrap_or_else(|err| warn!("GFX: {}", err));
+        Ok(msg)
+    }
+
+    #[dbus_interface(signal)]
+    fn notify_gfx(&self, vendor: &GfxVendors) -> zbus::Result<()> {}
+
+    #[dbus_interface(signal)]
+    fn notify_action(&self, action: &GfxRequiredUserAction) -> zbus::Result<()> {}
+}
+
+impl CtrlGraphics {
+    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at(&ObjectPath::from_str_unchecked("/org/asuslinux/Gfx"), self)
+            .map_err(|err| {
+                warn!("GFX: CtrlGraphics: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}