+44 -33

build/xtask/src/build.rs

··· 12 12 use tracing_core::LevelFilter; 13 13 14 14 use crate::Options; 15 15 - use crate::profile::{LogLevel, Profile, RustTarget}; 15 15 + use crate::configuration::{Configuration, LogLevel, RustTarget}; 16 16 use crate::tracing::{ColorMode, OutputOptions}; 17 17 use crate::util::KillOnDrop; 18 18 ··· 21 21 pub fn build_kernel( 22 22 opts: &Options, 23 23 output: &OutputOptions, 24 24 - profile: &Profile, 24 24 + configuration: &Configuration, 25 25 ) -> crate::Result<PathBuf> { 26 26 - let (mut cargo, output) = Cargo::build(CrateToBuild::Kernel, profile, opts, output)?; 26 26 + let (mut cargo, output) = Cargo::build(CrateToBuild::Kernel, configuration, opts, output)?; 27 27 cargo.build_std(true); 28 28 let mut cmd = cargo.into_cmd(); 29 29 30 30 - let stacksize_pages = profile 30 30 + let stacksize_pages = configuration 31 31 .kernel 32 32 .stacksize_pages 33 33 .unwrap_or(DEFAULT_KERNEL_STACK_SIZE_PAGES); 34 34 35 35 - let max_log_level = match profile 35 35 + let max_log_level = match configuration 36 36 .kernel 37 37 .max_log_level 38 38 - .unwrap_or(profile.max_log_level) 38 38 + .unwrap_or(configuration.max_log_level) 39 39 { 40 40 LogLevel::Trace => "::tracing::Level::TRACE", 41 41 LogLevel::Debug => "::tracing::Level::DEBUG", ··· 65 65 pub fn build_loader( 66 66 opts: &Options, 67 67 output: &OutputOptions, 68 68 - profile: &Profile, 68 68 + configuration: &Configuration, 69 69 kernel: &Path, 70 70 ) -> crate::Result<PathBuf> { 71 71 - let (mut cargo, output) = Cargo::build(CrateToBuild::Loader, profile, opts, output)?; 71 71 + let (mut cargo, output) = Cargo::build(CrateToBuild::Loader, configuration, opts, output)?; 72 72 cargo.build_std(true); 73 73 let mut cmd = cargo.into_cmd(); 74 74 75 75 - let max_log_level = match profile 75 75 + let max_log_level = match configuration 76 76 .kernel 77 77 .max_log_level 78 78 - .unwrap_or(profile.max_log_level) 78 78 + .unwrap_or(configuration.max_log_level) 79 79 { 80 80 LogLevel::Trace => "::log::Level::Trace", 81 81 LogLevel::Debug => "::log::Level::Debug", ··· 124 124 release: bool, 125 125 build_std: bool, 126 126 color_mode: ColorMode, 127 127 - profile: &'a Profile, 127 127 + configuration: &'a Configuration, 128 128 no_default_features: bool, 129 129 features: Vec<String>, 130 130 rust_target: RustTarget, ··· 137 137 krate: CrateToBuild, 138 138 opts: &'a Options, 139 139 output: &OutputOptions, 140 140 - profile: &'a Profile, 140 140 + configuration: &'a Configuration, 141 141 ) -> Self { 142 142 let verbosity = output.log.default_level().map_or(0, |lvl| match lvl { 143 143 LevelFilter::TRACE => 2, ··· 145 145 _ => 0, 146 146 }); 147 147 148 148 - let kernel_target = profile.kernel.target.resolve(&profile); 149 149 - let loader_target = profile.loader.target.resolve(&profile); 148 148 + let kernel_target = configuration.kernel.target.resolve(&configuration); 149 149 + let loader_target = configuration.loader.target.resolve(&configuration); 150 150 151 151 let (no_default_features, features, rust_target) = match krate { 152 152 CrateToBuild::Kernel => ( 153 153 - profile.kernel.no_default_features, 154 154 - profile.kernel.features.clone(), 153 153 + configuration.kernel.no_default_features, 154 154 + configuration.kernel.features.clone(), 155 155 kernel_target.clone(), 156 156 ), 157 157 CrateToBuild::Loader => ( 158 158 - profile.loader.no_default_features, 159 159 - profile.loader.features.clone(), 158 158 + configuration.loader.no_default_features, 159 159 + configuration.loader.features.clone(), 160 160 loader_target.clone(), 161 161 ), 162 162 }; ··· 176 176 release: opts.release, 177 177 build_std: false, 178 178 color_mode: output.color, 179 179 - profile, 179 179 + configuration, 180 180 no_default_features, 181 181 features, 182 182 rust_target, ··· 186 186 187 187 // pub fn check( 188 188 // krate: CrateToBuild, 189 189 - // profile: &'a Profile, 189 189 + // configuration: &'a Configuration, 190 190 // opts: &'a Options, 191 191 // output: &OutputOptions, 192 192 // ) -> crate::Result<Self> { 193 193 - // let this = Self::new("check", krate, opts, output, profile); 193 193 + // let this = Self::new("check", krate, opts, output, configuration); 194 194 // 195 195 // this.maybe_clean()?; 196 196 // ··· 199 199 // 200 200 // pub fn clippy( 201 201 // krate: CrateToBuild, 202 202 - // profile: &'a Profile, 202 202 + // configuration: &'a Configuration, 203 203 // opts: &'a Options, 204 204 // output: &OutputOptions, 205 205 // ) -> crate::Result<Self> { 206 206 - // let this = Self::new("clippy", krate, opts, output, profile); 206 206 + // let this = Self::new("clippy", krate, opts, output, configuration); 207 207 // 208 208 // this.maybe_clean()?; 209 209 // ··· 212 212 213 213 pub fn build( 214 214 krate: CrateToBuild, 215 215 - profile: &'a Profile, 215 215 + configuration: &'a Configuration, 216 216 opts: &'a Options, 217 217 output: &OutputOptions, 218 218 ) -> crate::Result<(Self, PathBuf)> { 219 219 - let this = Self::new("build", krate, opts, output, profile); 219 219 + let this = Self::new("build", krate, opts, output, configuration); 220 220 221 221 this.maybe_clean()?; 222 222 ··· 231 231 232 232 pub fn test( 233 233 krate: CrateToBuild, 234 234 - profile: &'a Profile, 234 234 + configuration: &'a Configuration, 235 235 opts: &'a Options, 236 236 output: &OutputOptions, 237 237 ) -> crate::Result<Self> { 238 238 - let this = Self::new("test", krate, opts, output, profile); 238 238 + let this = Self::new("test", krate, opts, output, configuration); 239 239 240 240 this.maybe_clean()?; 241 241 ··· 260 260 cmd.env("CARGO_TARGET_DIR", self.target_dir); 261 261 cmd.env("CARGO_TERM_COLOR", self.color_mode.as_str()); 262 262 263 263 - cmd.env("K23_CONFIG_PATH", &self.profile.file_path); 263 263 + cmd.env("K23_CONFIG_PATH", &self.configuration.file_path); 264 264 265 265 if self.release { 266 266 cmd.arg("--release"); ··· 299 299 Ok(contents) => { 300 300 if let Ok(contents) = std::str::from_utf8(&contents) { 301 301 if let Ok(cmp) = u64::from_str_radix(contents, 16) { 302 302 - self.profile.buildhash != cmp 302 302 + self.configuration.buildhash != cmp 303 303 } else { 304 304 tracing::warn!("buildstamp file contents unknown; re-building."); 305 305 true ··· 316 316 }; 317 317 // if we need to rebuild, we should clean everything before we start building 318 318 if rebuild { 319 319 - tracing::debug!("profile.toml has changed; rebuilding..."); 319 319 + tracing::debug!("configuration.toml has changed; rebuilding..."); 320 320 321 321 - let kernel_target = self.profile.kernel.target.resolve(&self.profile); 321 321 + let kernel_target = self 322 322 + .configuration 323 323 + .kernel 324 324 + .target 325 325 + .resolve(&self.configuration); 322 326 cargo_clean(&["kernel"], &kernel_target.to_string())?; 323 327 324 324 - let loader_target = self.profile.loader.target.resolve(&self.profile); 328 328 + let loader_target = self 329 329 + .configuration 330 330 + .loader 331 331 + .target 332 332 + .resolve(&self.configuration); 325 333 cargo_clean(&["loader"], &loader_target.to_string())?; 326 334 } 327 335 328 336 // now that we're clean, update our buildstamp file; any failure to build 329 337 // from here on need not trigger a clean 330 330 - std::fs::write(&buildstamp_file, format!("{:x}", self.profile.buildhash))?; 338 338 + std::fs::write( 339 339 + &buildstamp_file, 340 340 + format!("{:x}", self.configuration.buildhash), 341 341 + )?; 331 342 332 343 Ok(()) 333 344 }

+5 -5

build/xtask/src/cmds/build.rs

··· 10 10 use clap::{Parser, ValueHint}; 11 11 12 12 use crate::Options; 13 13 - use crate::profile::Profile; 13 13 + use crate::configuration::Configuration; 14 14 use crate::tracing::OutputOptions; 15 15 16 16 #[derive(Debug, Parser)] 17 17 pub struct Cmd { 18 18 /// The path to the build configuration file 19 19 #[clap(value_hint = ValueHint::FilePath)] 20 20 - profile: PathBuf, 20 20 + configuration: PathBuf, 21 21 } 22 22 23 23 impl Cmd { 24 24 pub fn run(&self, opts: &Options, output: &OutputOptions) -> crate::Result<()> { 25 25 - let profile = Profile::from_file(&self.profile)?; 25 25 + let configuration = Configuration::from_file(&self.configuration)?; 26 26 27 27 - let kernel = crate::build::build_kernel(&opts, output, &profile)?; 28 28 - let _image = crate::build::build_loader(&opts, output, &profile, &kernel)?; 27 27 + let kernel = crate::build::build_kernel(&opts, output, &configuration)?; 28 28 + let _image = crate::build::build_loader(&opts, output, &configuration, &kernel)?; 29 29 30 30 Ok(()) 31 31 }

+5 -5

build/xtask/src/cmds/dist.rs

··· 10 10 use clap::{Parser, ValueHint}; 11 11 12 12 use crate::Options; 13 13 - use crate::profile::Profile; 13 13 + use crate::configuration::Configuration; 14 14 use crate::tracing::OutputOptions; 15 15 16 16 #[derive(Debug, Parser)] 17 17 pub struct Cmd { 18 18 /// The path to the build configuration file 19 19 #[clap(value_hint = ValueHint::FilePath)] 20 20 - profile: PathBuf, 20 20 + configuration: PathBuf, 21 21 22 22 /// Overrides the directory in which to build the output image. 23 23 #[clap(short, long, env = "OUT_DIR", value_hint = ValueHint::DirPath, global = true)] ··· 26 26 27 27 impl Cmd { 28 28 pub fn run(&self, opts: &Options, output: &OutputOptions) -> crate::Result<()> { 29 29 - let profile = Profile::from_file(&self.profile)?; 29 29 + let configuration = Configuration::from_file(&self.configuration)?; 30 30 31 31 - let kernel = crate::build::build_kernel(&opts, output, &profile)?; 32 32 - let _image = crate::build::build_loader(&opts, output, &profile, &kernel)?; 31 31 + let kernel = crate::build::build_kernel(&opts, output, &configuration)?; 32 32 + let _image = crate::build::build_loader(&opts, output, &configuration, &kernel)?; 33 33 34 34 Ok(()) 35 35 }

+8 -8

build/xtask/src/cmds/lldb.rs

··· 11 11 12 12 use clap::{Parser, ValueHint}; 13 13 14 14 - use crate::profile::Profile; 14 14 + use crate::configuration::Configuration; 15 15 use crate::tracing::OutputOptions; 16 16 use crate::{Options, build, qemu}; 17 17 ··· 19 19 pub struct Cmd { 20 20 /// The path to the build configuration file 21 21 #[clap(value_hint = ValueHint::FilePath)] 22 22 - profile: PathBuf, 22 22 + configuration: PathBuf, 23 23 /// The TCP port to listen for debug connections on. 24 24 #[clap(long, default_value = "1234")] 25 25 gdb_port: u16, ··· 33 33 34 34 impl Cmd { 35 35 pub fn run(&self, opts: &Options, output: &OutputOptions) -> crate::Result<()> { 36 36 - let profile = Profile::from_file(&self.profile)?; 36 36 + let configuration = Configuration::from_file(&self.configuration)?; 37 37 38 38 let target_dir = opts 39 39 .target_dir ··· 48 48 qemu_args: self.qemu_args.clone(), 49 49 }; 50 50 51 51 - let kernel = build::build_kernel(opts, output, &profile)?; 52 52 - let loader = build::build_loader(opts, output, &profile, &kernel)?; 51 51 + let kernel = build::build_kernel(opts, output, &configuration)?; 52 52 + let loader = build::build_loader(opts, output, &configuration, &kernel)?; 53 53 54 54 - let mut qemu = qemu::spawn(&qemu_opts, profile, &loader, false, &[])?; 54 54 + let mut qemu = qemu::spawn(&qemu_opts, configuration, &loader, false, &[])?; 55 55 thread::spawn(move || qemu.0.wait().unwrap().exit_ok().unwrap()); 56 56 57 57 (kernel, loader) 58 58 } else { 59 59 let kernel = target_dir 60 60 - .join(profile.kernel.target.resolve(&profile).name()) 60 60 + .join(configuration.kernel.target.resolve(&configuration).name()) 61 61 .join("debug") 62 62 .join("kernel"); 63 63 64 64 let loader = target_dir 65 65 - .join(profile.loader.target.resolve(&profile).name()) 65 65 + .join(configuration.loader.target.resolve(&configuration).name()) 66 66 .join("debug") 67 67 .join("loader"); 68 68

+5 -5

build/xtask/src/cmds/qemu.rs

··· 9 9 10 10 use clap::{Parser, ValueHint}; 11 11 12 12 - use crate::profile::Profile; 12 12 + use crate::configuration::Configuration; 13 13 use crate::tracing::OutputOptions; 14 14 use crate::{Options, qemu}; 15 15 16 16 #[derive(Debug, Parser)] 17 17 pub struct Cmd { 18 18 #[clap(value_hint = ValueHint::FilePath)] 19 19 - profile: PathBuf, 19 19 + configuration: PathBuf, 20 20 #[clap(value_hint = ValueHint::FilePath)] 21 21 kernel: PathBuf, 22 22 #[clap(flatten)] ··· 25 25 26 26 impl Cmd { 27 27 pub fn run(&self, opts: &Options, output: &OutputOptions) -> crate::Result<()> { 28 28 - let profile = Profile::from_file(&self.profile)?; 28 28 + let configuration = Configuration::from_file(&self.configuration)?; 29 29 30 30 - let image = crate::build::build_loader(&opts, output, &profile, &self.kernel)?; 30 30 + let image = crate::build::build_loader(&opts, output, &configuration, &self.kernel)?; 31 31 32 32 - let mut child = qemu::spawn(&self.qemu_opts, profile, &image, true, &[])?; 32 32 + let mut child = qemu::spawn(&self.qemu_opts, configuration, &image, true, &[])?; 33 33 34 34 child.0.wait()?; 35 35

+6 -6

build/xtask/src/cmds/run.rs

··· 9 9 10 10 use clap::{Parser, ValueHint}; 11 11 12 12 - use crate::profile::Profile; 12 12 + use crate::configuration::Configuration; 13 13 use crate::tracing::OutputOptions; 14 14 use crate::{Options, qemu}; 15 15 ··· 17 17 pub struct Cmd { 18 18 /// The path to the build configuration file 19 19 #[clap(value_hint = ValueHint::FilePath)] 20 20 - profile: PathBuf, 20 20 + configuration: PathBuf, 21 21 #[clap(flatten)] 22 22 qemu_opts: qemu::QemuOptions, 23 23 } 24 24 25 25 impl Cmd { 26 26 pub fn run(&self, opts: &Options, output: &OutputOptions) -> crate::Result<()> { 27 27 - let profile = Profile::from_file(&self.profile)?; 27 27 + let configuration = Configuration::from_file(&self.configuration)?; 28 28 29 29 - let kernel = crate::build::build_kernel(&opts, output, &profile)?; 30 30 - let image = crate::build::build_loader(&opts, output, &profile, &kernel)?; 29 29 + let kernel = crate::build::build_kernel(&opts, output, &configuration)?; 30 30 + let image = crate::build::build_loader(&opts, output, &configuration, &kernel)?; 31 31 32 32 - let mut child = qemu::spawn(&self.qemu_opts, profile, &image, true, &[])?; 32 32 + let mut child = qemu::spawn(&self.qemu_opts, configuration, &image, true, &[])?; 33 33 34 34 child.0.wait()?; 35 35

+10 -8

build/xtask/src/cmds/test.rs

··· 15 15 use wait_timeout::ChildExt; 16 16 17 17 use crate::build::{Cargo, CrateToBuild}; 18 18 - use crate::profile::{Architecture, Profile}; 18 18 + use crate::configuration::{Architecture, Configuration}; 19 19 use crate::tracing::OutputOptions; 20 20 use crate::util::KillOnDrop; 21 21 use crate::{Options, qemu}; ··· 24 24 pub struct Cmd { 25 25 /// The path to the build configuration file 26 26 #[clap(value_hint = ValueHint::FilePath)] 27 27 - profile: PathBuf, 27 27 + configuration: PathBuf, 28 28 29 29 /// Timeout for failing test run, in seconds. 30 30 /// ··· 39 39 40 40 impl Cmd { 41 41 pub fn run(&self, opts: &Options, output: &OutputOptions) -> crate::Result<()> { 42 42 - let profile = Profile::from_file(&self.profile)?; 42 42 + let configuration = Configuration::from_file(&self.configuration)?; 43 43 44 44 - let mut cargo = Cargo::test(CrateToBuild::Kernel, &profile, opts, output)?; 44 44 + let mut cargo = Cargo::test(CrateToBuild::Kernel, &configuration, opts, output)?; 45 45 cargo.build_std(true); 46 46 let mut cmd = cargo.into_cmd(); 47 47 48 48 - let (var, val) = cargo_qemu_runner_env(&profile)?; 48 48 + let (var, val) = cargo_qemu_runner_env(&configuration)?; 49 49 cmd.env(var, val); 50 50 51 51 cmd.args(["--", "--"]); ··· 95 95 .context("not a valid number of seconds") 96 96 } 97 97 98 98 - pub fn cargo_qemu_runner_env(profile: &Profile) -> crate::Result<(&'static str, String)> { 98 98 + pub fn cargo_qemu_runner_env( 99 99 + configuration: &Configuration, 100 100 + ) -> crate::Result<(&'static str, String)> { 99 101 // The produced target artifact cannot be run on the host, so we proactively set the 100 102 // runner to the 101 101 - let runner_env_var = match profile.arch { 103 103 + let runner_env_var = match configuration.arch { 102 104 Architecture::Riscv64 => "CARGO_TARGET_RISCV64GC_K23_NONE_KERNEL_RUNNER", 103 105 }; 104 106 ··· 106 108 runner_env_var, 107 109 format!( 108 110 "cargo xtask __qemu {}", 109 109 - profile.file_path.canonicalize()?.display() 111 111 + configuration.file_path.canonicalize()?.display() 110 112 ), 111 113 )) 112 114 }

+1 -1

build/xtask/src/main.rs

··· 21 21 22 22 mod build; 23 23 mod cmds; 24 24 - mod profile; 24 24 + mod configuration; 25 25 mod qemu; 26 26 mod tracing; 27 27 mod util;

+18 -18

build/xtask/src/profile.rs build/xtask/src/configuration.rs

··· 17 17 18 18 #[derive(Clone, Debug, Deserialize)] 19 19 #[serde(rename_all = "kebab-case", deny_unknown_fields)] 20 20 - struct RawProfile { 20 20 + struct RawConfiguration { 21 21 arch: Architecture, 22 22 name: String, 23 23 #[serde(default)] ··· 78 78 } 79 79 80 80 impl RawRustTarget { 81 81 - pub fn resolve(&self, profile: &Profile) -> RustTarget { 81 81 + pub fn resolve(&self, configuration: &Configuration) -> RustTarget { 82 82 if self.0.ends_with(".json") { 83 83 - RustTarget::Json(profile.resolve_path(&self.0).unwrap()) 83 83 + RustTarget::Json(configuration.resolve_path(&self.0).unwrap()) 84 84 } else { 85 85 RustTarget::Builtin(self.0.clone()) 86 86 } ··· 106 106 } 107 107 108 108 #[derive(Clone, Debug)] 109 109 - pub struct Profile { 109 109 + pub struct Configuration { 110 110 pub arch: Architecture, 111 111 pub name: String, 112 112 pub version: u32, ··· 117 117 pub file_path: PathBuf, 118 118 } 119 119 120 120 - impl Profile { 120 120 + impl Configuration { 121 121 pub fn from_file(file_path: &Path) -> crate::Result<Self> { 122 122 let mut hasher = DefaultHasher::new(); 123 123 124 124 let doc = read_and_flatten_toml(file_path, &mut hasher, &mut BTreeSet::new())?; 125 125 - let profile_contents = doc.to_string(); 125 125 + let configuration_contents = doc.to_string(); 126 126 127 127 - let toml: RawProfile = toml::from_str(&profile_contents)?; 127 127 + let toml: RawConfiguration = toml::from_str(&configuration_contents)?; 128 128 129 129 // if we had any other checks, perform them here 130 130 ··· 151 151 } 152 152 153 153 fn read_and_flatten_toml( 154 154 - profile: &Path, 154 154 + configuration: &Path, 155 155 hasher: &mut DefaultHasher, 156 156 seen: &mut BTreeSet<PathBuf>, 157 157 ) -> crate::Result<toml_edit::DocumentMut> { 158 158 use toml_patch::merge_toml_documents; 159 159 160 160 // Prevent diamond inheritance 161 161 - if !seen.insert(profile.to_owned()) { 161 161 + if !seen.insert(configuration.to_owned()) { 162 162 bail!( 163 163 - "{profile:?} is inherited more than once; \ 163 163 + "{configuration:?} is inherited more than once; \ 164 164 diamond dependencies are not allowed" 165 165 ); 166 166 } 167 167 - let profile_contents = 168 168 - std::fs::read(profile).with_context(|| format!("could not read {}", profile.display()))?; 167 167 + let configuration_contents = std::fs::read(configuration) 168 168 + .with_context(|| format!("could not read {}", configuration.display()))?; 169 169 170 170 // Accumulate the contents into the buildhash here, so that we hash both 171 171 // the inheritance file and the target (recursively, if necessary) 172 172 - hasher.write(&profile_contents); 172 172 + hasher.write(&configuration_contents); 173 173 174 174 - let profile_contents = 175 175 - std::str::from_utf8(&profile_contents).context("failed to read manifest as UTF-8")?; 174 174 + let configuration_contents = 175 175 + std::str::from_utf8(&configuration_contents).context("failed to read manifest as UTF-8")?; 176 176 177 177 // Additive TOML file inheritance 178 178 - let mut doc = profile_contents 178 178 + let mut doc = configuration_contents 179 179 .parse::<toml_edit::DocumentMut>() 180 180 .context("failed to parse TOML file")?; 181 181 let Some(inherited_from) = doc.remove("inherit") else { ··· 187 187 let mut original = match inherited_from { 188 188 // Single inheritance 189 189 Item::Value(Value::String(s)) => { 190 190 - let file = profile.parent().unwrap().join(s.value()); 190 190 + let file = configuration.parent().unwrap().join(s.value()); 191 191 read_and_flatten_toml(&file, hasher, seen) 192 192 .with_context(|| format!("Could not load {file:?}"))? 193 193 } ··· 196 196 let mut doc: Option<toml_edit::DocumentMut> = None; 197 197 for a in a.iter() { 198 198 if let Value::String(s) = a { 199 199 - let file = profile.parent().unwrap().join(s.value()); 199 199 + let file = configuration.parent().unwrap().join(s.value()); 200 200 let next: toml_edit::DocumentMut = 201 201 read_and_flatten_toml(&file, hasher, seen) 202 202 .with_context(|| format!("Could not load {file:?}"))?;

+3 -3

build/xtask/src/qemu.rs

··· 10 10 11 11 use clap::Parser; 12 12 13 13 - use crate::profile::{Architecture, Profile}; 13 13 + use crate::configuration::{Architecture, Configuration}; 14 14 use crate::util::KillOnDrop; 15 15 16 16 #[derive(Debug, Parser)] ··· 28 28 29 29 pub fn spawn( 30 30 qemu: &QemuOptions, 31 31 - profile: Profile, 31 31 + configuration: Configuration, 32 32 image: &Path, 33 33 inherit_stdio: bool, 34 34 additional_args: &[String], 35 35 ) -> crate::Result<KillOnDrop> { 36 36 - let mut cmd = match profile.arch { 36 36 + let mut cmd = match configuration.arch { 37 37 Architecture::Riscv64 => { 38 38 let mut cmd = Command::new("qemu-system-riscv64"); 39 39 cmd.args([

+8 -8

justfile

··· 29 29 @just --list 30 30 31 31 # Alias for `cargo xtask qemu` 32 32 - run profile args="" *qemu_args="": 33 33 - {{ _cargo }} xtask run {{ profile }} {{ args }} {{ qemu_args }} 32 32 + run configuration args="" *qemu_args="": 33 33 + {{ _cargo }} xtask run {{ configuration }} {{ args }} {{ qemu_args }} 34 34 35 35 # Alias for `cargo xtask build` 36 36 - build profile args="" *qemu_args="": 37 37 - {{ _cargo }} xtask build {{ profile }} {{ args }} {{ qemu_args }} 36 36 + build configuration args="" *qemu_args="": 37 37 + {{ _cargo }} xtask build {{ configuration }} {{ args }} {{ qemu_args }} 38 38 39 39 # quick check for development 40 40 check crate="" *cargo_args="": 41 41 RUSTFLAGS=-Dwarnings {{ _cargo }} check \ 42 42 {{ if crate == "" { "--workspace --exclude loader --exclude xtask --exclude toml-patch" } else { "-p" } }} {{ crate }} \ 43 43 - --target profile/riscv64/riscv64gc-k23-none-kernel.json \ 43 43 + --target configurations/riscv64/riscv64gc-k23-none-kernel.json \ 44 44 --locked \ 45 45 {{ _buildstd }} \ 46 46 {{ _fmt }} \ ··· 63 63 clippy crate="" *cargo_args="": 64 64 RUSTFLAGS=-Dwarnings {{ _cargo }} clippy \ 65 65 {{ if crate == "" { "--workspace --exclude loader --exclude xtask --exclude toml-patch" } else { "-p" } }} {{ crate }} \ 66 66 - --target profile/riscv64/riscv64gc-k23-none-kernel.json \ 66 66 + --target configurations/riscv64/riscv64gc-k23-none-kernel.json \ 67 67 --locked \ 68 68 {{ _buildstd }} \ 69 69 {{ _fmt_clippy }} \ ··· 160 160 161 161 # run on-target tests for RISCV 64-bit 162 162 test-riscv64 *args='': 163 163 - cargo xtask test profile/riscv64/qemu.toml --release {{ args }} 163 163 + cargo xtask test configurations/riscv64/qemu.toml --release {{ args }} 164 164 165 165 # ============================================================================== 166 166 # Documentation ··· 174 174 #build-docs crate="" *cargo_args="": 175 175 # {{ _rustdoc }} \ 176 176 # {{ if crate == "" { _hosted_crates } else { "-p" + crate } }} \ 177 177 - # --target profile/riscv64/riscv64gc-k23-none-kernel.json \ 177 177 + # --target configurations/riscv64/riscv64gc-k23-none-kernel.json \ 178 178 # {{ _buildstd }} \ 179 179 # {{ _fmt }} \ 180 180 # {{ cargo_args }}

profile/base.toml configurations/base.toml

profile/riscv64/qemu.toml configurations/riscv64/qemu.toml

profile/riscv64/riscv64gc-k23-none-kernel.json configurations/riscv64/riscv64gc-k23-none-kernel.json