Merge pull request #350 from dave-tucker/monorepo

Bring aya-log into aya, creating a Monorepo

.cargo/config

@@ -1,5 +1,7 @@
 [alias]
 xtask = "run --package xtask --"
+build-bpfel = "build -Zbuild-std=core --target=bpfel-unknown-none"
+build-bpfeb = "build -Zbuild-std=core --target=bpfeb-unknown-none"
 
 [target.armv7-unknown-linux-gnueabi]
 linker = "arm-linux-gnueabi-gcc"

.github/workflows/build-aya-bpf.yml

@@ -31,59 +31,19 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly
+          components: rust-src
           override: true
 
       - uses: Swatinem/rust-cache@v1
 
       - name: Prereqs
-        run: cargo install cross --git https://github.com/cross-rs/cross
+        run: cargo install bpf-linker
 
       - name: Build
         env:
           CARGO_CFG_BPF_TARGET_ARCH: ${{ matrix.arch }}
         run: |
-          pushd bpf
-          cargo build --workspace --exclude aya-bpf-macros --verbose
-          popd
-
-      - name: Run tests
-        env:
-          CARGO_CFG_BPF_TARGET_ARCH: ${{ matrix.arch }}
-        run: |
-          pushd bpf
-          cargo test --workspace --exclude aya-bpf-macros --verbose
-          popd
-
-  build-macros:
-    strategy:
-      matrix:
-        arch:
-          - x86_64-unknown-linux-gnu
-          - aarch64-unknown-linux-gnu
-          - armv7-unknown-linux-gnueabi
-          - riscv64gc-unknown-none-elf
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          override: true
-
-      - uses: Swatinem/rust-cache@v1
-
-      - name: Prereqs
-        run: cargo install cross --git https://github.com/cross-rs/cross
-
-      - name: Build bpf macros
-        run: |
-          pushd bpf
-          cross build -p aya-bpf-macros --verbose
-          popd
-
-      - name: Test bpf macros
-        run: |
-          pushd bpf
-          RUST_BACKTRACE=full cross test -p aya-bpf-macros --verbose
-          popd
+          cargo build-bpfel -p aya-bpf --verbose
+          cargo build-bpfeb -p aya-bpf --verbose
+          cargo build-bpfel -p aya-log-ebpf --verbose
+          cargo build-bpfeb -p aya-log-ebpf --verbose

.github/workflows/build-aya.yml

@@ -21,19 +21,28 @@ jobs:
           - x86_64-unknown-linux-gnu
           - aarch64-unknown-linux-gnu
           - armv7-unknown-linux-gnueabi
-          - riscv64gc-unknown-none-elf
+          - riscv64gc-unknown-linux-gnu
     runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
       - uses: Swatinem/rust-cache@v1
       - name: Prereqs
         run: cargo install cross --git https://github.com/cross-rs/cross
 
       - name: Build
-        run: cross build --verbose
+        run: cross build --verbose --target ${{matrix.arch}}
 
       - name: Run test
-        run: RUST_BACKTRACE=full cross test --verbose
+        env:
+          RUST_BACKTRACE: full
+        run: |
+          cross test --verbose --target ${{matrix.arch}}
 
   test:
     runs-on: ubuntu-20.04
@@ -60,12 +69,10 @@ jobs:
           sudo apt-get -qy install linux-tools-common qemu-system-x86 cloud-image-utils openssh-client libelf-dev gcc-multilib
           cargo install bpf-linker
 
-
       - name: Lint integration tests
         run: |
           cargo xtask build-integration-test-ebpf --libbpf-dir ./libbpf
           cargo clippy -p integration-test -- --deny warnings
-          cargo clippy -p integration-test-macros -- --deny warnings
 
       - name: Run integration tests
         run: |

.github/workflows/lint.yml

@@ -30,22 +30,11 @@ jobs:
       - name: Check formatting
         run: |
           cargo fmt --all -- --check
-          (cd bpf && cargo fmt --all -- --check)
-          (cd test/integration-ebpf && cargo fmt --all -- --check)
 
       - name: Run clippy
         run: |
-          cargo clippy -p aya -- --deny warnings
-          cargo clippy -p aya-gen -- --deny warnings
-          cargo clippy -p xtask -- --deny warnings
-          (cd bpf && cargo clippy -p aya-bpf -- --deny warnings)
-          (cd test/integration-ebpf && cargo clippy -- --deny warnings)
+          cargo clippy --workspace --exclude integration-test -- --deny warnings
 
       - name: Run miri
-        env:
-          MIRIFLAGS: -Zmiri-disable-stacked-borrows
         run: |
-          cargo miri test --all-targets
-          pushd bpf
-          cargo miri test
-          popd
+          cargo miri test --all-targets

.vim/coc-settings.json

@@ -1,4 +1,4 @@
 {
-  "rust-analyzer.linkedProjects": ["Cargo.toml", "bpf/Cargo.toml", "test/integration-ebpf/Cargo.toml"],
-  "rust-analyzer.checkOnSave.allTargets": false
+  "rust-analyzer.checkOnSave.allTargets": false,
+  "rust-analyzer.checkOnSave.command": "clippy"
 }

.vscode/settings.json

@@ -1,4 +1,4 @@
 {
-  "rust-analyzer.linkedProjects": ["Cargo.toml", "bpf/Cargo.toml", "test/integration-ebpf/Cargo.toml"],
-  "rust-analyzer.checkOnSave.allTargets": false
+  "rust-analyzer.checkOnSave.allTargets": false,
+  "rust-analyzer.checkOnSave.command": "clippy"
 }

Cargo.toml

@@ -1,3 +1,22 @@
 [workspace]
-members = ["aya", "aya-gen", "test/integration-test", "test/integration-test-macros", "xtask"]
-default-members = ["aya", "aya-gen"]
+members = [
+    "aya", "aya-gen", "aya-log", "aya-log-common", "test/integration-test", "test/integration-test-macros", "xtask",
+    # macros
+    "aya-bpf-macros", "aya-log-ebpf-macros",
+    # ebpf crates
+    "bpf/aya-bpf", "bpf/aya-bpf-bindings", "bpf/aya-log-ebpf", "test/integration-ebpf"
+]
+default-members = ["aya", "aya-gen", "aya-log", "aya-bpf-macros", "aya-log-ebpf-macros"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+
+[profile.dev.package.integration-ebpf]
+opt-level = 2
+overflow-checks = false
+
+[profile.release.package.integration-ebpf]
+debug = 2

bpf/aya-bpf-macros/Cargo.toml → aya-bpf-macros/Cargo.toml

@@ -13,4 +13,4 @@ quote = "1.0"
 syn = {version = "1.0", features = ["full"]}
 
 [dev-dependencies]
-aya-bpf = { path = "../aya-bpf" }
+aya-bpf = { path = "../bpf/aya-bpf" }

aya-log-common/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "aya-log-common"
+version = "0.1.11-dev.0"
+description = "A logging library for eBPF programs."
+keywords = ["ebpf", "bpf", "log", "logging"]
+license = "MIT OR Apache-2.0"
+authors = ["The Aya Contributors"]
+repository = "https://github.com/aya-rs/aya-log"
+documentation = "https://docs.rs/aya-log"
+edition = "2018"
+
+[features]
+default = []
+userspace = [ "aya" ]
+
+[dependencies]
+aya = { path = "../aya", version = "0.11.0", optional=true }
+
+[lib]
+path = "src/lib.rs"

aya-log-common/release.toml

@@ -0,0 +1 @@
+shared-version = true

aya-log-common/src/lib.rs

@@ -0,0 +1,185 @@
+#![no_std]
+
+use core::{cmp, mem, ptr};
+
+pub const LOG_BUF_CAPACITY: usize = 8192;
+
+pub const LOG_FIELDS: usize = 7;
+
+#[repr(usize)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
+pub enum Level {
+    /// The "error" level.
+    ///
+    /// Designates very serious errors.
+    Error = 1,
+    /// The "warn" level.
+    ///
+    /// Designates hazardous situations.
+    Warn,
+    /// The "info" level.
+    ///
+    /// Designates useful information.
+    Info,
+    /// The "debug" level.
+    ///
+    /// Designates lower priority information.
+    Debug,
+    /// The "trace" level.
+    ///
+    /// Designates very low priority, often extremely verbose, information.
+    Trace,
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug)]
+pub enum RecordField {
+    Target = 1,
+    Level,
+    Module,
+    File,
+    Line,
+    NumArgs,
+    Log,
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug)]
+pub enum ArgType {
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+    Isize,
+
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+    Usize,
+
+    F32,
+    F64,
+
+    Str,
+}
+
+#[cfg(feature = "userspace")]
+mod userspace {
+    use super::*;
+
+    unsafe impl aya::Pod for RecordField {}
+    unsafe impl aya::Pod for ArgType {}
+}
+
+struct TagLenValue<'a, T> {
+    tag: T,
+    value: &'a [u8],
+}
+
+impl<'a, T> TagLenValue<'a, T>
+where
+    T: Copy,
+{
+    #[inline(always)]
+    pub(crate) fn new(tag: T, value: &'a [u8]) -> TagLenValue<'a, T> {
+        TagLenValue { tag, value }
+    }
+
+    pub(crate) fn write(&self, mut buf: &mut [u8]) -> Result<usize, ()> {
+        let size = mem::size_of::<T>() + mem::size_of::<usize>() + self.value.len();
+        let remaining = cmp::min(buf.len(), LOG_BUF_CAPACITY);
+        // Check if the size doesn't exceed the buffer bounds.
+        if size > remaining {
+            return Err(());
+        }
+
+        unsafe { ptr::write_unaligned(buf.as_mut_ptr() as *mut _, self.tag) };
+        buf = &mut buf[mem::size_of::<T>()..];
+
+        unsafe { ptr::write_unaligned(buf.as_mut_ptr() as *mut _, self.value.len()) };
+        buf = &mut buf[mem::size_of::<usize>()..];
+
+        let len = cmp::min(buf.len(), self.value.len());
+        // The verifier isn't happy with `len` being unbounded, so compare it
+        // with `LOG_BUF_CAPACITY`.
+        if len > LOG_BUF_CAPACITY {
+            return Err(());
+        }
+        buf[..len].copy_from_slice(&self.value[..len]);
+        Ok(size)
+    }
+}
+
+pub trait WriteToBuf {
+    #[allow(clippy::result_unit_err)]
+    fn write(&self, buf: &mut [u8]) -> Result<usize, ()>;
+}
+
+macro_rules! impl_write_to_buf {
+    ($type:ident, $arg_type:expr) => {
+        impl WriteToBuf for $type {
+            fn write(&self, buf: &mut [u8]) -> Result<usize, ()> {
+                TagLenValue::<ArgType>::new($arg_type, &self.to_ne_bytes()).write(buf)
+            }
+        }
+    };
+}
+
+impl_write_to_buf!(i8, ArgType::I8);
+impl_write_to_buf!(i16, ArgType::I16);
+impl_write_to_buf!(i32, ArgType::I32);
+impl_write_to_buf!(i64, ArgType::I64);
+impl_write_to_buf!(i128, ArgType::I128);
+impl_write_to_buf!(isize, ArgType::Isize);
+
+impl_write_to_buf!(u8, ArgType::U8);
+impl_write_to_buf!(u16, ArgType::U16);
+impl_write_to_buf!(u32, ArgType::U32);
+impl_write_to_buf!(u64, ArgType::U64);
+impl_write_to_buf!(u128, ArgType::U128);
+impl_write_to_buf!(usize, ArgType::Usize);
+
+impl_write_to_buf!(f32, ArgType::F32);
+impl_write_to_buf!(f64, ArgType::F64);
+
+impl WriteToBuf for str {
+    fn write(&self, buf: &mut [u8]) -> Result<usize, ()> {
+        TagLenValue::<ArgType>::new(ArgType::Str, self.as_bytes()).write(buf)
+    }
+}
+
+#[allow(clippy::result_unit_err)]
+#[doc(hidden)]
+#[inline(always)]
+pub fn write_record_header(
+    buf: &mut [u8],
+    target: &str,
+    level: Level,
+    module: &str,
+    file: &str,
+    line: u32,
+    num_args: usize,
+) -> Result<usize, ()> {
+    let mut size = 0;
+    for attr in [
+        TagLenValue::<RecordField>::new(RecordField::Target, target.as_bytes()),
+        TagLenValue::<RecordField>::new(RecordField::Level, &(level as usize).to_ne_bytes()),
+        TagLenValue::<RecordField>::new(RecordField::Module, module.as_bytes()),
+        TagLenValue::<RecordField>::new(RecordField::File, file.as_bytes()),
+        TagLenValue::<RecordField>::new(RecordField::Line, &line.to_ne_bytes()),
+        TagLenValue::<RecordField>::new(RecordField::NumArgs, &num_args.to_ne_bytes()),
+    ] {
+        size += attr.write(&mut buf[size..])?;
+    }
+
+    Ok(size)
+}
+
+#[allow(clippy::result_unit_err)]
+#[doc(hidden)]
+pub fn write_record_message(buf: &mut [u8], msg: &str) -> Result<usize, ()> {
+    TagLenValue::<RecordField>::new(RecordField::Log, msg.as_bytes()).write(buf)
+}