build.rs

use std::{collections::HashMap, fs::File, path::Path};

extern crate rand;
extern crate syn;
extern crate walkdir;

use cfg_aliases::cfg_aliases;
use quote::format_ident;
use std::io::Write;
use syn::{Attribute, LitInt};
use walkdir::WalkDir;

extern crate cbindgen;

fn main() {
    println!("cargo::rerun-if-changed=src");
    println!("cargo::rerun-if-changed=build.rs");
    let out_dir = std::env::var("OUT_DIR").unwrap();

    if gen_syscall_match(Path::new("src/syscalls"), Path::new(&out_dir)).is_err() {
        panic!("Failed to generate syscall match statement.");
    }

    cfg_aliases! {
        freestanding: { all(not(test), not(doctest), not(doc), not(kani), any(target_os = "none", target_os = "unknown")) },
    }
}

// Syscalls ---------------------------------------------------------------------------------------

fn gen_syscall_match(root: &Path, out: &Path) -> Result<(), std::io::Error> {
    let syscalls = find_syscalls(root);
    let mut file = File::create(out.join("syscall_match.in"))?;

    let arms = syscalls.iter().map(|(name, number)| {
        let entry = format_ident!("entry_{}", name);
        quote::quote! {
            #number => #entry(args),
        }
    });

    let syscall_match = quote::quote! {
        // This match statement is @generated by build.rs. Do not edit.
        match number {
            #(#arms)*
            _ => panic!("Unknown syscall number: {}", number),
        }
    };

    writeln!(file, "{syscall_match}")?;
    Ok(())
}

fn is_syscall(attrs: &[Attribute], name: &str) -> Option<u16> {
    let mut num = 0;

    for attr in attrs {
        if attr.path().is_ident("syscall_handler") {
            let result = attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("num") {
                    let raw = meta.value()?;
                    let value: LitInt = raw.parse()?;
                    num = value.base10_parse::<u16>()?;

                    if !(0..=255).contains(&num) {
                        return Err(meta.error(format!("invalid syscall number: {num}")));
                    }

                    return Ok(());
                }

                Err(meta.error(format!(
                    "unknown attribute '{}'",
                    meta.path.get_ident().unwrap()
                )))
            });

            if let Err(e) = result {
                println!("cargo::warning=Failed to parse syscall arguments for `{name}`, {e}");
                return None;
            }

            return Some(num);
        }
    }

    None
}

fn find_syscalls(root: &Path) -> HashMap<String, u16> {
    let mut syscalls = HashMap::new();
    let mut numbers = HashMap::new();

    for entry in WalkDir::new(&root) {
        let entry = match entry {
            Ok(entry) => entry,
            Err(_) => continue,
        };

        if entry.file_type().is_file() {
            let path = entry.path();

            println!("Processing file: {}", path.display());

            let contents = match std::fs::read_to_string(path) {
                Ok(contents) => contents,
                Err(_) => continue,
            };

            let file = match syn::parse_file(&contents) {
                Ok(file) => file,
                Err(_) => continue,
            };

            for item in file.items {
                let item = match item {
                    syn::Item::Fn(item) => item,
                    _ => continue,
                };

                let name = item.sig.ident.to_string();

                if let Some(num) = is_syscall(&item.attrs, &name) {
                    if syscalls.contains_key(&name) {
                        println!("cargo::warning=Duplicate syscall handler: {name}");
                        continue;
                    }

                    if numbers.contains_key(&num) {
                        println!("cargo::warning=Duplicate syscall number: {num} for {name}");
                        continue;
                    }

                    syscalls.insert(name.clone(), num);
                    numbers.insert(num, name);
                }
            }
        }
    }

    syscalls
}