123 lines
3.5 KiB
Rust
123 lines
3.5 KiB
Rust
use std::fs;
|
|
use std::process::Command;
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
use anyhow::{anyhow, Context, Result};
|
|
|
|
use pcid_interface::config::Config;
|
|
use pcid_interface::PciFunctionHandle;
|
|
|
|
fn wait_for_pci_scheme() -> Result<()> {
|
|
let mut last_err = None;
|
|
for i in 0..200 {
|
|
match fs::read_dir("/scheme/pci") {
|
|
Ok(_) => return Ok(()),
|
|
Err(err) => {
|
|
last_err = Some(err);
|
|
if i == 0 {
|
|
log::debug!("pcid-spawner: waiting for /scheme/pci to become available");
|
|
}
|
|
thread::sleep(Duration::from_millis(50));
|
|
}
|
|
}
|
|
}
|
|
Err(last_err.unwrap().into())
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
let mut args = pico_args::Arguments::from_env();
|
|
let initfs = args.contains("--initfs");
|
|
|
|
common::setup_logging(
|
|
"bus",
|
|
"pci",
|
|
"pci-spawner.log",
|
|
common::output_level(),
|
|
common::file_level(),
|
|
);
|
|
|
|
let mut config_data = String::new();
|
|
for path in if initfs {
|
|
config::config_for_initfs("pcid")?
|
|
} else {
|
|
config::config("pcid")?
|
|
} {
|
|
if let Ok(tmp) = fs::read_to_string(path) {
|
|
config_data.push_str(&tmp);
|
|
}
|
|
}
|
|
|
|
let config: Config = toml::from_str(&config_data)?;
|
|
|
|
wait_for_pci_scheme().context("/scheme/pci is not available")?;
|
|
|
|
for entry in fs::read_dir("/scheme/pci")? {
|
|
let entry = entry.context("failed to get entry")?;
|
|
let device_path = entry.path();
|
|
log::trace!("ENTRY: {}", device_path.to_string_lossy());
|
|
|
|
let mut handle = match PciFunctionHandle::connect_by_path(&device_path) {
|
|
Ok(handle) => handle,
|
|
Err(err) if err.raw_os_error() == Some(syscall::ENOLCK) => {
|
|
log::debug!(
|
|
"pcid-spawner: {} already in use: {err}",
|
|
device_path.display(),
|
|
);
|
|
continue;
|
|
}
|
|
Err(err) => {
|
|
log::error!(
|
|
"pcid-spawner: failed to open channel for {}: {err}",
|
|
device_path.display(),
|
|
);
|
|
continue;
|
|
}
|
|
};
|
|
|
|
let full_device_id = handle.config().func.full_device_id;
|
|
|
|
log::debug!(
|
|
"pcid-spawner enumerated: PCI {} {}",
|
|
handle.config().func.addr,
|
|
full_device_id.display()
|
|
);
|
|
|
|
let Some(driver) = config
|
|
.drivers
|
|
.iter()
|
|
.find(|driver| driver.match_function(&full_device_id))
|
|
else {
|
|
log::debug!("no driver for {}, continuing", handle.config().func.addr);
|
|
continue;
|
|
};
|
|
|
|
let mut args = driver.command.iter();
|
|
|
|
let program = args
|
|
.next()
|
|
.ok_or_else(|| anyhow!("driver configuration entry did not have any command!"))?;
|
|
let program = if program.starts_with('/') {
|
|
program.to_owned()
|
|
} else {
|
|
"/usr/lib/drivers/".to_owned() + program
|
|
};
|
|
|
|
let mut command = Command::new(program);
|
|
command.args(args);
|
|
|
|
log::info!("pcid-spawner: spawn {:?}", command);
|
|
|
|
handle.enable_device();
|
|
|
|
let channel_fd = handle.into_inner_fd();
|
|
command.env("PCID_CLIENT_CHANNEL", channel_fd.to_string());
|
|
|
|
#[allow(deprecated, reason = "we can't yet move this to init")]
|
|
daemon::Daemon::spawn(command);
|
|
libredox::call::close(channel_fd as usize).unwrap();
|
|
}
|
|
|
|
Ok(())
|
|
}
|