diff --git a/docs/community/README.md b/docs/community/README.md new file mode 100644 index 000000000..04e552ef2 --- /dev/null +++ b/docs/community/README.md @@ -0,0 +1,24 @@ +# Community + +Join [#lind](https://secure-systems-lab.slack.com/archives/CBKAGSC9Z) on the +[NYU Secure Systems Lab Slack](https://secure-systems-lab.slack.com/) to receive +updates about the project and upcoming events, or dial in on a community +meeting! Details are listed below and on +[Google Calendar](https://calendar.google.com/calendar/u/1?cid=Y18zMDViOTU2M2U2NjEwOTllYjUwMWIzNjA0MmYyMjBjNGNjMjIyNmRiZTBiMmE4NzMxYjdmMWM0Nzk4ODMxMWRkQGdyb3VwLmNhbGVuZGFyLmdvb2dsZS5jb20). + +## Meetings + +### Governance Committee +- **Weekly** on Friday 15:00 - 16:00 ET +- [Zoom](https://nyu.zoom.us/j/93302778069) +- [Meeting notes](https://docs.google.com/document/d/1hUkdsszfXFyx3Ue9oFUt1mx7R8WcHX4PEWAXXa0Wqyw/edit?usp=sharing) + +### Tech Talks +- **Every 2 weeks** on Friday 13:00 - 14:00 ET +- [Zoom](https://nyu.zoom.us/j/93845545729) +- [Meeting notes](https://docs.google.com/document/d/1W7pg76im7WLGa2M4fpy20ba27BoOk1WumcnSwwpHbDc/edit?usp=sharing) + +### Maintainers, Evaluation, & Benchmarking WG +- **Every 2 weeks** on Thursday 13:00 - 14:00 ET +- [Zoom](https://nyu.zoom.us/j/97941224575) +- [Meeting notes](https://docs.google.com/document/d/1Imxzcn6O3w86SyAetiqzMhz_Gc47XVWhsnPAJO6Sec0/edit?usp=sharing) diff --git a/docs/contribute/README.md b/docs/contribute/README.md new file mode 100644 index 000000000..d1dcdc236 --- /dev/null +++ b/docs/contribute/README.md @@ -0,0 +1,12 @@ +# Contributing + +The Lind sandbox is developed in the [lind-wasm](https://github.com/Lind-Project/lind-wasm) +monorepo on GitHub. You can find the documentation assets, including this site, +in the [`lind-wasm/docs`](https://github.com/Lind-Project/lind-wasm/tree/main/docs) +subdirectory. Please contribute to the Lind project by submitting issues or pull +requests to these repositories. + +To report a security issue, please refer to the [Security Policy](security.md)! + +Continue reading the pages in this section for detailed guidelines about +writing code, tests, documentation, and more. diff --git a/geteuid.c b/geteuid.c new file mode 100644 index 000000000..e3ecec39d --- /dev/null +++ b/geteuid.c @@ -0,0 +1,8 @@ +#include +#include + +int main(int argc, char *argv[]) { + int ret = geteuid(); + printf("[Cage | geteuid] geteuid ret = %d\n", ret); + return 0; +} diff --git a/geteuid_grate.c b/geteuid_grate.c new file mode 100644 index 000000000..e739354ac --- /dev/null +++ b/geteuid_grate.c @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include + +int geteuid_grate(uint64_t cageid, uint64_t arg1, uint64_t arg1cage, uint64_t arg2, uint64_t arg2cage, uint64_t arg3, uint64_t arg3cage, uint64_t arg4, uint64_t arg4cage, uint64_t arg5, uint64_t arg5cage, uint64_t arg6, uint64_t arg6cage) { + return 10; +} +// Main function will always be same in all grates +int main(int argc, char *argv[]) { + // Should be at least two inputs (at least one grate file and one cage file) + if (argc < 2) { + fprintf(stderr, "Usage: %s [...]\n", argv[0]); + exit(EXIT_FAILURE); + } + + int grateid = getpid(); + + // Because we assume that all cages are unaware of the existence of grate, cages will not handle the logic of `exec`ing + // grate, so we need to handle these two situations separately in grate. + // grate needs to fork in two situations: + // - the first is to fork and use its own cage; + // - the second is when there is still at least one grate in the subsequent command line input. + // In the second case, we fork & exec the new grate and let the new grate handle the subsequent process. + for (int i = 1; i < (argc < 3 ? argc : 3); i++) { + pid_t pid = fork(); + if (pid < 0) { + perror("fork failed"); + exit(EXIT_FAILURE); + } else if (pid == 0) { + // According to input format, the odd-numbered positions will always be grate, and even-numbered positions + // will always be cage. + if (i % 2 != 0) { + // Next one is cage, only set the register_handler when next one is cage + int cageid = getpid(); + // Set the geteuid (syscallnum=51) of this cage to call this grate function geteuid_grate (func index=0) + // Syntax of register_handler: + int ret = register_handler(cageid, 51, 0, grateid); + } + + if ( execv(argv[i], &argv[i]) == -1) { + perror("execv failed"); + exit(EXIT_FAILURE); + } + } + } + + int status; + while (wait(&status) > 0) { + printf("[Grate | geteuid] terminated, status: %d\n", status); + } + + return 0; +} diff --git a/hello.c b/hello.c new file mode 100644 index 000000000..63f880575 --- /dev/null +++ b/hello.c @@ -0,0 +1,6 @@ +#include + +int main(void) { + printf("Hello, World!\n"); + return 0; +} diff --git a/mkdocs.yml b/mkdocs.yml index 081d891f4..759d88e8f 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -7,6 +7,46 @@ theme: features: - content.action.edit +nav: + - Home: index.md + - Getting Started: getting-started.md + - Internal Documentation: + - libc: internal/libc.md + - Wasmtime: internal/wasmtime.md + - RawPOSIX: internal/rawposix.md + - Multi-Processing: internal/multiprocess-support.md + - Signals: internal/signals.md + - Contributing: + - contribute/README.md + - Development setup: contribute/dev-container.md + - Rust style guide: contribute/styleguide.md + - Lind toolchain: contribute/toolchain.md + - Unit tests: contribute/unit-tests.md + - Debug programs: contribute/debug-programs.md + - Adding to the docs: contribute/add-docs.md + - Security policy: contribute/security.md + - Docker Hub release workflow: contribute/docker-release-workflow.md + - Community: + - community/README.md + - Team: community/team.md + - Code of conduct: community/conduct.md + +extra_css: + - stylesheets/img.css + +markdown_extensions: + - admonition + - sane_lists + - pymdownx.superfences +site_name: Lind-Wasm Docs +site_url: https://lind-project.github.io/lind-wasm/ +repo_url: https://github.com/Lind-Project/lind-wasm/ +edit_uri: edit/main/docs/ +theme: + name: material + features: + - content.action.edit + plugins: - search - section-index diff --git a/scripts/Dockerfile.dev b/scripts/Dockerfile.dev new file mode 100644 index 000000000..ba59208a9 --- /dev/null +++ b/scripts/Dockerfile.dev @@ -0,0 +1,94 @@ +# syntax=docker/dockerfile:1.7-labs +# NOTE: Enable Docker Labs syntax for future convenience + +# Base image for development and debugging with perf and gdb support +# +# - Installs standard build tools and debugging utilities +# - Assumes container is run with --privileged for perf to function +# +# Usage: +# docker build -f Dockerfile.dev -t devtest . +# docker run --privileged -it devtest /bin/bash + +FROM ubuntu:22.04 + +# --- Build arguments --- +ARG USERNAME=lind +ARG BRANCH_NAME=main +ARG LLVM_VERSION="llvmorg-16.0.4" +ARG CLANG_PACKAGE="clang+llvm-16.0.4-x86_64-linux-gnu-ubuntu-22.04" + +# --- System setup --- +ENV DEBIAN_FRONTEND=noninteractive + +# Install base tools +RUN apt-get update && apt-get install -y --no-install-recommends -qq \ + binutils \ + bison \ + build-essential \ + ca-certificates \ + curl \ + gawk \ + git \ + gnupg \ + libc6-dev-i386-cross \ + libxml2 \ + make \ + python3 \ + sed \ + sudo \ + unzip \ + zip \ + vim \ + wget \ + openssl \ + libssl-dev \ + golang \ + gdb \ + linux-tools-common \ + linux-tools-generic \ + && rm -rf /var/lib/apt/lists/* + +# --- Create user --- +RUN groupadd --gid 1000 ${USERNAME} && \ + useradd --uid 1000 --gid ${USERNAME} --create-home --shell /bin/bash ${USERNAME} && \ + echo "${USERNAME} ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers + +# --- Switch to user ASAP --- +USER ${USERNAME} +WORKDIR /home/${USERNAME} + +# --- Install Rust as user --- +RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \ + sh -s -- -y --default-toolchain nightly-2025-06-01 + +# --- Clone the repo as user --- +RUN git clone --branch "${BRANCH_NAME}" --single-branch https://github.com/Lind-Project/lind-wasm.git + +# --- Enable discovery of all branches, then fetch them --- +WORKDIR /home/${USERNAME}/lind-wasm +RUN git remote set-branches origin '*' && git fetch origin + +# --- Switch back to root for installing Clang binaries and symlinking --- +USER root + +RUN curl -sL https://github.com/llvm/llvm-project/releases/download/${LLVM_VERSION}/${CLANG_PACKAGE}.tar.xz | \ + tar -xJ -C /home/${USERNAME}/lind-wasm && \ + ln -sf /home/${USERNAME}/lind-wasm/${CLANG_PACKAGE}/bin/* /usr/local/bin/ + +# --- Patch glibc wasi includes into clang dir and fix permissions --- +RUN cp -r /home/${USERNAME}/lind-wasm/src/glibc/wasi \ + /home/${USERNAME}/lind-wasm/${CLANG_PACKAGE}/lib/clang/16/lib && \ + chown -R ${USERNAME}:${USERNAME} /home/${USERNAME}/ + +# --- Back to user for everything else --- +USER ${USERNAME} + +# --- Fix PATH --- +ENV PATH="/usr/local/bin:/home/${USERNAME}/.cargo/bin:/home/${USERNAME}/go/bin:$PATH" +ENV CLANG="/home/${USERNAME}/lind-wasm/${CLANG_PACKAGE}" + +# --- Prebuild --- +RUN make sysroot && make wasmtime + +CMD ["/bin/bash"] diff --git a/scripts/Dockerfile.e2e b/scripts/Dockerfile.e2e new file mode 100644 index 000000000..4a6bd945f --- /dev/null +++ b/scripts/Dockerfile.e2e @@ -0,0 +1,97 @@ +# syntax=docker/dockerfile:1.7-labs +# NOTE: use non-stable syntax for convenient --parents option in COPY command + +# Multi-stage Dockerfile for lind-wasm end-to-end testing and image creation +# +# - Installs build dependencies +# - Builds wasmtime, glibc and sysroot for clang cross-compilation +# - A. Runs end-to-end tests (default) +# - B. Creates Docker image with lind-wasm toolchain +# +# NOTE: The 'test' stage (A) runs end-to-end tests on `docker build`, and is +# optimized for Docker build time and caching. It is not meant for `docker +# run`. Use the 'release' stage (B) to create an image that includes the full +# lind-wasm toolchain, e.g. to run demos, tests, experiments, etc. For +# development you may want to build just the base image (C) and mount the full +# source tree. +# +# Usage A (test): +# docker build --platform=linux/amd64 -f scripts/Dockerfile.e2e . +# +# Usage B (create and run image): +# docker build --platform=linux/amd64 -f scripts/Dockerfile.e2e -t release --target release . +# docker run --platform=linux/amd64 -it release /bin/bash +# +# Usage C (create base image and mount source): +# docker build --platform=linux/amd64 -f scripts/Dockerfile.e2e -t dev --target base . +# docker run --platform=linux/amd64 -v $(PWD):/lind -w /lind -it dev /bin/bash + +# Install build dependencies +# NOTE: We install dependencies for multiple stages at once, to save RUN time +# and cache layers. Details: +# - glibc dependencies as per src/glibc/INSTALL +# - gcc skipped in favor of clang +# - libc6-dev-i386-cross required for wasi cross-compilation with clang +# - build-essential, ca-certificates, curl, libxml2 needed by rust and clang +FROM ubuntu:22.04 AS base +RUN apt-get update && \ + apt-get install -y --no-install-recommends -qq \ + binutils \ + bison \ + build-essential \ + ca-certificates \ + curl \ + gawk \ + libc6-dev-i386-cross \ + libxml2 \ + make \ + python3 \ + sed \ + && rm -rf /var/lib/apt/lists/* + +# Install clang +ARG LLVM="llvmorg-16.0.4" +ARG CLANG="clang+llvm-16.0.4-x86_64-linux-gnu-ubuntu-22.04" +# NOTE: We `curl | tar` in spite of Docker best practices to save cache layers +RUN curl -sL https://github.com/llvm/llvm-project/releases/download/${LLVM}/${CLANG}.tar.xz | \ + tar -xvJ +COPY src/glibc/wasi /${CLANG}/lib/clang/16/lib/wasi +ENV PATH="/${CLANG}/bin:${PATH}" + +# Install rust +# NOTE: pinning known-to-work nightly-2025-06-01 (see #242) +RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \ + sh -s -- -y --default-toolchain nightly-2025-06-01 +ENV PATH="/root/.cargo/bin:${PATH}" + + +# Build wasmtime +FROM base as build-wasmtime +# NOTE: Using 'make' risks cache invalidation on unrelated Makefile changes +COPY --parents src/wasmtime src/RawPOSIX src/fdtables src/sysdefs Makefile . +RUN make wasmtime + + +# Build glibc and generate sysroot +FROM base AS build-glibc +# NOTE: Using 'make' risks cache invalidation on unrelated Makefile changes +COPY --parents scripts/make_glibc_and_sysroot.sh src/glibc Makefile . +RUN make sysroot + + +# Build Docker image that includes the full lind-wasm toolchain +# NOTE: Lind-wasm source code is not included +FROM base AS release +COPY --from=build-wasmtime --parents src/wasmtime/target . +COPY --from=build-glibc --parents src/glibc/sysroot . +COPY --parents scripts tests tools skip_test_cases.txt . + + +# Run all tests, print results, and exit with 1, if any test fails; 0 otherwise +FROM base AS test +COPY --parents scripts tests tools skip_test_cases.txt Makefile . +# NOTE: Build artifacts from prior stages are only mounted, to save COPY time +# and cache layers. This means they are not preserved in the resulting image. +RUN --mount=from=build-wasmtime,source=src/wasmtime/target,destination=src/wasmtime/target \ + --mount=from=build-glibc,source=src/glibc/sysroot,destination=src/glibc/sysroot \ + make test diff --git a/scripts/wasmtestreport.py b/scripts/wasmtestreport.py index 0a7e0ad31..6092a5bf4 100755 --- a/scripts/wasmtestreport.py +++ b/scripts/wasmtestreport.py @@ -173,14 +173,12 @@ def compile_c_to_wasm(source_file): source_file = Path(source_file).resolve() testcase = str(source_file.with_suffix('')) compile_cmd = [os.path.join(LIND_TOOL_PATH, "lind_compile"), source_file] - logger.debug(f"Running command: {' '.join(map(str, compile_cmd))}") if os.path.isfile(os.path.join(LIND_TOOL_PATH, "lind_compile")): logger.debug("File exists and is a regular file!") else: logger.debug("File not found or it's a directory!") - try: result = run_subprocess(compile_cmd, label="wasm compile", shell = False) if result.returncode != 0: @@ -216,14 +214,13 @@ def compile_c_to_wasm(source_file): # ---------------------------------------------------------------------- def run_compiled_wasm(wasm_file, timeout_sec=DEFAULT_TIMEOUT): run_cmd = [os.path.join(LIND_TOOL_PATH, "lind_run"), wasm_file] - + logger.debug(f"Running command: {' '.join(map(str, run_cmd))}") if os.path.isfile(os.path.join(LIND_TOOL_PATH, "lind_run")): logger.debug("File exists and is a regular file!") else: logger.debug("File not found or it's a directory!") - try: proc = run_subprocess(run_cmd,label="wasm run",timeout=timeout_sec, cwd=None, shell = False) full_output = proc.stdout + proc.stderr diff --git a/src/cage/Cargo.lock b/src/cage/Cargo.lock new file mode 100644 index 000000000..8ccbc3a52 --- /dev/null +++ b/src/cage/Cargo.lock @@ -0,0 +1,412 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "bitflags" +version = "2.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" + +[[package]] +name = "btree_monstrousity" +version = "0.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ec92912346b936c974181a172d9abc81f50d41e40118fc101dac8aa8134bee3" +dependencies = [ + "cfg-if", + "rustversion", +] + +[[package]] +name = "cage" +version = "0.1.0" +dependencies = [ + "dashmap", + "fdtables", + "libc", + "nodit", + "once_cell", + "parking_lot", + "quick_cache", + "sysdefs", +] + +[[package]] +name = "cfg-if" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" + +[[package]] +name = "dashmap" +version = "5.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856" +dependencies = [ + "cfg-if", + "hashbrown 0.14.5", + "lock_api", + "once_cell", + "parking_lot_core", + "serde", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "fdtables" +version = "0.1.0" +dependencies = [ + "dashmap", + "lazy_static", + "libc", +] + +[[package]] +name = "getrandom" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasi", +] + +[[package]] +name = "hashbrown" +version = "0.14.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" + +[[package]] +name = "hashbrown" +version = "0.15.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +dependencies = [ + "spin", +] + +[[package]] +name = "libc" +version = "0.2.174" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" + +[[package]] +name = "lock_api" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "nodit" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74369f80df24efd2266602fdcd8fcd56a17c2e2c94ab48d2f7a15eaa137bf49" +dependencies = [ + "btree_monstrousity", + "itertools", + "smallvec", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "parking_lot" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + +[[package]] +name = "proc-macro2" +version = "1.0.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick_cache" +version = "0.6.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b450dad8382b1b95061d5ca1eb792081fb082adf48c678791fe917509596d5f" +dependencies = [ + "ahash", + "equivalent", + "hashbrown 0.15.4", + "parking_lot", +] + +[[package]] +name = "quote" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "redox_syscall" +version = "0.5.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d04b7d0ee6b4a0207a0a7adb104d23ecb0b47d6beae7152d0fa34b692b29fd6" +dependencies = [ + "bitflags", +] + +[[package]] +name = "rustversion" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d" + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "spin" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" + +[[package]] +name = "syn" +version = "2.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sysdefs" +version = "0.1.0" +dependencies = [ + "libc", +] + +[[package]] +name = "unicode-ident" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.14.2+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3" +dependencies = [ + "wit-bindgen-rt", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "wit-bindgen-rt" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" +dependencies = [ + "bitflags", +] + +[[package]] +name = "zerocopy" +version = "0.8.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/src/cage/src/memory/mem_helper.rs b/src/cage/src/memory/mem_helper.rs new file mode 100644 index 000000000..bfac275e1 --- /dev/null +++ b/src/cage/src/memory/mem_helper.rs @@ -0,0 +1,205 @@ +//! VMMAP helper functions +//! +//! This file provides helper functions related to vmmap, including address alignment, +//! initializing vmmap, helper functions for handling vmmap during a fork syscall, and +//! address translation and validation related to vmmap +use crate::cage::{get_cage, Cage}; +use crate::memory::{MemoryBackingType, Vmmap, VmmapOps}; +use libc::c_void; +use sysdefs::constants::err_const::{syscall_error, Errno}; +use sysdefs::constants::fs_const::{ + F_GETFL, MAP_ANONYMOUS, MAP_FIXED, MAP_PRIVATE, MAP_SHARED, MREMAP_FIXED, MREMAP_MAYMOVE, + PAGESHIFT, PAGESIZE, PROT_EXEC, PROT_NONE, PROT_READ, PROT_WRITE, +}; + +// heap is placed at the very top of the memory +pub const HEAP_ENTRY_INDEX: u32 = 0; + +/// Round up the address length to be multiple of pages +/// +/// # Arguments +/// * `length` - length of the address +/// +/// # Returns +/// * `u64` - rounded up length +pub fn round_up_page(length: u64) -> u64 { + if length % PAGESIZE as u64 == 0 { + length + } else { + ((length / PAGESIZE as u64) + 1) * PAGESIZE as u64 + } +} + +/// Copies the memory regions from parent to child based on the provided `vmmap` memory layout. +/// +/// This function is designed to replicate the parent's memory space into the child immediately after +/// a `fork_syscall` in Wasmtime. It assumes that the parent and child share the same `vmmap` structure, +/// a valid assumption in this context. +/// +/// The copying behavior varies based on the type of memory region: +/// 1. **PROT_NONE regions**: +/// - No action is taken, as memory regions are already configured with `PROT_NONE` by default. +/// 2. **Shared memory regions**: +/// - The function uses the `mremap` syscall to replicate shared memory efficiently. Refer to `man 2 mremap` for details. +/// 3. **Private memory regions**: +/// - The function uses `std::ptr::copy_nonoverlapping` to copy the memory contents directly. +/// - **TODO**: Investigate whether using `writev` could improve performance for this case. +/// +/// # Arguments +/// * `parent_vmmap` - vmmap struct of parent +/// * `child_vmmap` - vmmap struct of child +pub fn fork_vmmap(parent_vmmap: &Vmmap, child_vmmap: &Vmmap) { + let parent_base = parent_vmmap.base_address.unwrap(); + let child_base = child_vmmap.base_address.unwrap(); + + // iterate through each vmmap entry + for (_interval, entry) in parent_vmmap.entries.iter() { + // translate page number to user address + let addr_st = (entry.page_num << PAGESHIFT) as u32; + let addr_len = (entry.npages << PAGESHIFT) as usize; + + // translate user address to system address + let parent_st = parent_vmmap.user_to_sys(addr_st); + let child_st = child_vmmap.user_to_sys(addr_st); + if entry.flags & (MAP_SHARED as i32) > 0 { + // for shared memory, we are using mremap to fork shared memory + // See "man 2 mremap" for description of what MREMAP_MAYMOVE does with old_size=0 + // when old_address points to a shared mapping + let result = unsafe { + libc::mremap( + parent_st as *mut libc::c_void, + 0, + addr_len, + (MREMAP_MAYMOVE | MREMAP_FIXED) as i32, + child_st as *mut libc::c_void, + ) + }; + } else { + unsafe { + // temporarily enable write on child's memory region to write parent data + libc::mprotect( + child_st as *mut libc::c_void, + addr_len, + PROT_READ | PROT_WRITE, + ); + + // write parent data + // TODO: replace copy_nonoverlapping with writev for potential performance boost + std::ptr::copy_nonoverlapping( + parent_st as *const u8, + child_st as *mut u8, + addr_len, + ); + + // revert child's memory region prot + libc::mprotect(child_st as *mut libc::c_void, addr_len, entry.prot) + }; + } + } +} + +// set the wasm linear memory base address to vmmap +pub fn init_vmmap_helper(cageid: u64, base_address: usize, program_break: Option) { + let cage = get_cage(cageid).unwrap(); + let mut vmmap = cage.vmmap.write(); + vmmap.set_base_address(base_address); + if program_break.is_some() { + vmmap.set_program_break(program_break.unwrap()); + } +} + +// clone the cage memory. Invoked by wasmtime after cage is forked +pub fn fork_vmmap_helper(parent_cageid: u64, child_cageid: u64) { + let parent_cage = get_cage(parent_cageid).unwrap(); + let child_cage = get_cage(child_cageid).unwrap(); + let parent_vmmap = parent_cage.vmmap.read(); + let child_vmmap = child_cage.vmmap.read(); + + fork_vmmap(&parent_vmmap, &child_vmmap); + + // update program break for child + drop(child_vmmap); + let mut child_vmmap = child_cage.vmmap.write(); + child_vmmap.set_program_break(parent_vmmap.program_break); +} + +/// Validates and converts a virtual memory address to a physical address with protection checks +/// +/// This function performs several critical memory management operations: +/// 1. Validates that the requested memory region is properly mapped +/// 2. Checks protection flags match the requested access +/// 3. Converts virtual addresses to physical addresses +/// +/// # Arguments +/// * `cage` - Reference to the memory cage containing the virtual memory map +/// * `arg` - Virtual memory address to check and convert +/// * `length` - Length of the memory region being accessed +/// * `prot` - Protection flags to validate (read/write/execute) +/// +/// # Returns +/// * `Ok(u64)` - Physical memory address if validation succeeds +/// * `Err(Errno)` - EFAULT if memory access would be invalid +/// +/// # Memory Safety +/// This is a critical security function that prevents invalid memory accesses by: +/// - Ensuring addresses are properly aligned to pages +/// - Validating all pages in the region are mapped with correct permissions +/// - Preventing access outside of allocated memory regions +pub fn check_and_convert_addr_ext( + cageid: u64, + arg: u64, + length: usize, + prot: i32, +) -> Result { + // search from the table and get the item from + let cage = get_cage(cageid).unwrap(); + + // Get read lock on virtual memory map + let mut vmmap = cage.vmmap.write(); + + // Calculate page numbers for start and end of region + let page_num = (arg >> PAGESHIFT) as u32; // Starting page number + let end_page = ((arg + length as u64 + PAGESIZE as u64 - 1) >> PAGESHIFT) as u32; // Ending page number (rounded up) + let npages = end_page - page_num; // Total number of pages spanned + + // Validate memory mapping and permissions + if vmmap.check_addr_mapping(page_num, npages, prot).is_none() { + return Err(Errno::EFAULT); // Return error if mapping invalid + } + + // Convert to physical address by adding base address + Ok(vmmap.base_address.unwrap() as u64 + arg) +} + +pub fn check_addr(cageid: u64, arg: u64, length: usize, prot: i32) -> Result { + // search from the table and get the item from + let cage = get_cage(cageid).unwrap(); + + // Get read lock on virtual memory map + let mut vmmap = cage.vmmap.write(); + + // Calculate page numbers for start and end of region + let page_num = (arg >> PAGESHIFT) as u32; // Starting page number + let end_page = ((arg + length as u64 + PAGESIZE as u64 - 1) >> PAGESHIFT) as u32; // Ending page number (rounded up) + let npages = end_page - page_num; // Total number of pages spanned + + // Validate memory mapping and permissions + if vmmap.check_addr_mapping(page_num, npages, prot).is_none() { + return Err(Errno::EFAULT); // Return error if mapping invalid + } + Ok(true) +} + +/// This function translates a virtual memory address to a physical address by adding the base address of the vmmap to the argument. +/// +/// # Arguments +/// * `cage` - Reference to the memory cage containing the virtual memory map +/// * `arg` - Virtual memory address to translate +/// +/// # Returns +/// * `Ok(u64)` - Translated physical memory address +pub fn translate_vmmap_addr(cage: &Cage, arg: u64) -> Result { + // Get read lock on virtual memory map + let vmmap = cage.vmmap.read(); + Ok(vmmap.base_address.unwrap() as u64 + arg) +} diff --git a/src/fdtables/src/commonconstants.rs b/src/fdtables/src/commonconstants.rs index 03b45f1e5..86d0e7978 100644 --- a/src/fdtables/src/commonconstants.rs +++ b/src/fdtables/src/commonconstants.rs @@ -20,6 +20,8 @@ pub const FDT_INVALID_FD: u32 = 0xff00_0001; /// Use to indicate this is an EPOLLFD (an internal kind of fd) pub const FDT_KINDEPOLL: u32 = 0xff00_0002; +pub const MAXFD: i32 = 1024; // Maximum number of file descriptors + // These are the values we look up with at the end... #[doc = include_str!("../docs/fdtableentry.md")] #[derive(Clone, Copy, Hash, Debug, PartialEq, Eq)] diff --git a/src/fdtables/src/current_impl b/src/fdtables/src/current_impl index 51f2083b2..ce5d6f2ad 100644 --- a/src/fdtables/src/current_impl +++ b/src/fdtables/src/current_impl @@ -1,2 +1,2 @@ -mod dashmaparrayglobal; +pub mod dashmaparrayglobal; pub use crate::dashmaparrayglobal::*; diff --git a/src/fdtables/src/dashmaparrayglobal.rs b/src/fdtables/src/dashmaparrayglobal.rs index 84e4121d2..9ee0e114f 100644 --- a/src/fdtables/src/dashmaparrayglobal.rs +++ b/src/fdtables/src/dashmaparrayglobal.rs @@ -182,6 +182,47 @@ pub fn get_unused_virtual_fd_from_startfd( Err(threei::Errno::EMFILE as u64) } +/// This is used to request an unused fd from specific starting position. This is +/// similar to `get_unused_virtual_fd` except this function starts from a specific +/// starting position mentioned by `arg` arguments. This will be used for `fcntl`. +#[doc = include_str!("../docs/get_unused_virtual_fd_from_startfd.md")] +pub fn get_unused_virtual_fd_from_startfd( + cageid: u64, + fdkind: u32, + underfd: u64, + should_cloexec: bool, + perfdinfo: u64, + arg: u64, +) -> Result { + + assert!(FDTABLE.contains_key(&cageid),"Unknown cageid in fdtable access"); + // Set up the entry so it has the right info... + // Note, a HashMap stores its data on the heap! No need to box it... + // https://doc.rust-lang.org/book/ch08-03-hash-maps.html#creating-a-new-hash-map + let myentry = FDTableEntry { + fdkind, + underfd, + should_cloexec, + perfdinfo, + }; + + let mut myfdrow = FDTABLE.get_mut(&cageid).unwrap(); + + // Check the fds in order. + for fdcandidate in arg..FD_PER_PROCESS_MAX { + // FIXME: This is likely very slow. Should do something smarter... + if myfdrow[fdcandidate as usize].is_none() { + // I just checked. Should not be there... + myfdrow[fdcandidate as usize] = Some(myentry); + _increment_fdcount(myentry); + return Ok(fdcandidate); + } + } + + // I must have checked all fds and failed to find one open. Fail! + Err(threei::Errno::EMFILE as u64) +} + // This is used for things like dup2, which need a specific fd... // If the requested_virtualfd is used, I close it... #[doc = include_str!("../docs/get_specific_virtual_fd.md")] diff --git a/src/fdtables/src/lib.rs b/src/fdtables/src/lib.rs index c1bc5f8c5..3c1ee1aef 100644 --- a/src/fdtables/src/lib.rs +++ b/src/fdtables/src/lib.rs @@ -118,7 +118,7 @@ include!("current_impl"); // This includes general constants and definitions for things that are // needed everywhere, like FDTableEntry. I use the * import here to flatten // the namespace so folks importing this have the symbols directly imported. -mod commonconstants; +pub mod commonconstants; pub use commonconstants::*; // This is used everywhere... Should I re-export more of these symbols? diff --git a/src/glibc/lind_syscall/cp_data_between_cages.c b/src/glibc/lind_syscall/cp_data_between_cages.c new file mode 100644 index 000000000..d1f3f69ce --- /dev/null +++ b/src/glibc/lind_syscall/cp_data_between_cages.c @@ -0,0 +1,6 @@ +#include // For uint64_t definition +#include // For make_syscall definition + +int cp_data_between_cages(uint64_t thiscage, uint64_t targetcage, uint64_t srcaddr, uint64_t srccage, uint64_t destaddr, uint64_t destcage, uint64_t len, uint64_t copytype) { + return CP_DATA_SYSCALL(thiscage, targetcage, srcaddr, srccage, destaddr, destcage, len, copytype); +} diff --git a/src/glibc/lind_syscall/cp_data_between_cages.h b/src/glibc/lind_syscall/cp_data_between_cages.h new file mode 100644 index 000000000..020a71f86 --- /dev/null +++ b/src/glibc/lind_syscall/cp_data_between_cages.h @@ -0,0 +1,3 @@ +#include // For uint64_t definition + +int cp_data_between_cages(uint64_t thiscage, uint64_t targetcage, uint64_t srcaddr, uint64_t srccage, uint64_t destaddr, uint64_t destcage, uint64_t len, uint64_t copytype); diff --git a/src/glibc/lind_syscall/crt1.o b/src/glibc/lind_syscall/crt1.o index 619c21d26..8e99b8360 100644 Binary files a/src/glibc/lind_syscall/crt1.o and b/src/glibc/lind_syscall/crt1.o differ diff --git a/src/glibc/sysdeps/ieee754/dbl-64/build-libm.sh b/src/glibc/sysdeps/ieee754/dbl-64/build-libm.sh new file mode 100755 index 000000000..9af40f609 --- /dev/null +++ b/src/glibc/sysdeps/ieee754/dbl-64/build-libm.sh @@ -0,0 +1,66 @@ +#!/bin/bash +set -e + +CLANG="/home/lind/lind-wasm/clang+llvm-16.0.4-x86_64-linux-gnu-ubuntu-22.04/bin/clang" +AR="/home/lind/lind-wasm/clang+llvm-16.0.4-x86_64-linux-gnu-ubuntu-22.04/bin/llvm-ar" + +INCLUDES="\ +-I/home/lind/lind-wasm/src/glibc/include \ +-I/home/lind/lind-wasm/src/glibc/build/nptl \ +-I/home/lind/lind-wasm/src/glibc/build \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/lind \ +-I/home/lind/lind-wasm/src/glibc/lind_syscall \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv/linux/i386/i686 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv/linux/i386 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv/linux/x86/include \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv/linux/x86 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/x86/nptl \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/i386/nptl \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv/linux/include \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv/linux \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/nptl \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/pthread \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/gnu \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/inet \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/sysv \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix/i386 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/unix \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/posix \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/i386/fpu \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/x86/fpu \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/i386 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/x86/include \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/x86 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/wordsize-32 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/ieee754/float128 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/ieee754/ldbl-96/include \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/ieee754/ldbl-96 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/ieee754/dbl-64 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/ieee754/flt-32 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/ieee754 \ +-I/home/lind/lind-wasm/src/glibc/sysdeps/generic \ +-I/home/lind/lind-wasm/src/glibc \ +-I/home/lind/lind-wasm/src/glibc/libio \ +-I/home/lind/lind-wasm/src/glibc/math" + +CFLAGS="--target=wasm32-unknown-wasi -v -Wno-int-conversion -std=gnu11 -fgnu89-inline -matomics -mbulk-memory -O2 -g \ +-Wall -Wwrite-strings -Wundef -Wstrict-prototypes -Wold-style-definition \ +-fmerge-all-constants -ftrapping-math -fno-stack-protector -fno-common \ +-Wp,-U_FORTIFY_SOURCE -fmath-errno -fPIE -ftls-model=local-exec \ +-nostdinc -isystem /home/lind/lind-wasm/clang+llvm-16.0.4-x86_64-linux-gnu-ubuntu-22.04/lib/clang/16/include \ +-isystem /usr/i686-linux-gnu/include \ +-D_LIBC_REENTRANT -include /home/lind/lind-wasm/src/glibc/build/libc-modules.h \ +-DMODULE_NAME=libc -include /home/lind/lind-wasm/src/glibc/include/libc-symbols.h \ +-DPIC -DTOP_NAMESPACE=glibc" + +# Compile +$CLANG $CFLAGS $INCLUDES -o e_exp2.o -c e_exp2.c +$CLANG $CFLAGS $INCLUDES -o e_fmod.o -c e_fmod.c +$CLANG $CFLAGS $INCLUDES -o math_err.o -c math_err.c +$CLANG $CFLAGS $INCLUDES -o e_exp_data.o -c e_exp_data.c + +# Archive +$AR rcs libm.a e_fmod.o e_exp2.o e_exp_data.o math_err.o + +# Copy +cp libm.a /home/lind/lind-wasm/src/glibc/sysroot/lib/wasm32-wasi/ diff --git a/src/glibc/sysdeps/unix/syscalls.list b/src/glibc/sysdeps/unix/syscalls.list index dbf8b089b..293a471a1 100644 --- a/src/glibc/sysdeps/unix/syscalls.list +++ b/src/glibc/sysdeps/unix/syscalls.list @@ -88,7 +88,7 @@ truncate - truncate i:si __truncate truncate umask - umask Ei:i __umask umask uname - uname i:p __uname uname unlink - unlink i:s __unlink unlink -unlinkat - unlinkat i:sii __unlinkat unlinkat +unlinkat - unlinkat i:sii unlinkat unlinkat utimes - utimes i:sp __utimes utimes vhangup - vhangup i:i vhangup write - write Ci:ibU __libc_write __write write diff --git a/src/glibc/sysdeps/unix/sysv/linux/execve.c b/src/glibc/sysdeps/unix/sysv/linux/execve.c new file mode 100644 index 000000000..b8d908fbc --- /dev/null +++ b/src/glibc/sysdeps/unix/sysv/linux/execve.c @@ -0,0 +1,13 @@ +#include +#include +#include + +int +__execve (const char *__path, char *const __argv[], char *const __envp[]) +{ + return MAKE_SYSCALL(EXECVE_SYSCALL, "syscall|execve", + __path, __argv, __envp, + NOTUSED, NOTUSED, NOTUSED); +} +libc_hidden_def (__execve) +weak_alias (__execve, execve) diff --git a/src/glibc/sysdeps/unix/sysv/linux/getdents.c b/src/glibc/sysdeps/unix/sysv/linux/getdents.c index e7ad0d14d..82f30d7fa 100644 --- a/src/glibc/sysdeps/unix/sysv/linux/getdents.c +++ b/src/glibc/sysdeps/unix/sysv/linux/getdents.c @@ -41,4 +41,4 @@ __getdents (int fd, void *buf0, size_t nbytes) # undef DIRENT_SET_DP_INO -#endif /* _DIRENT_MATCHES_DIRENT64 */ +#endif /* _DIRENT_MATCHES_DIRENT64 */ \ No newline at end of file diff --git a/src/glibc/wasi/libclang_rt.builtins-wasm32.a b/src/glibc/wasi/libclang_rt.builtins-wasm32.a deleted file mode 100644 index ab336debe..000000000 Binary files a/src/glibc/wasi/libclang_rt.builtins-wasm32.a and /dev/null differ diff --git a/src/rawposix/src/fs_calls.rs b/src/rawposix/src/fs_calls.rs index b0820b1f0..ee296b68b 100644 --- a/src/rawposix/src/fs_calls.rs +++ b/src/rawposix/src/fs_calls.rs @@ -18,7 +18,9 @@ use fdtables; /// This function is registered in `fdtables` when creating the cage pub fn kernel_close(fdentry: fdtables::FDTableEntry, _count: u64) { let kernel_fd = fdentry.underfd as i32; - + + // TODO: + // Need to update once we merge with vmmap-alice if kernel_fd == STDIN_FILENO || kernel_fd == STDOUT_FILENO || kernel_fd == STDERR_FILENO { return; } @@ -37,7 +39,7 @@ pub fn kernel_close(fdentry: fdtables::FDTableEntry, _count: u64) { /// after getting the kernel fd. `fdtables` currently only manage when a fd should be closed after open, so /// then we need to set `O_CLOEXEC` flags according to input. /// -/// ## Arguments: +/// Input: /// This call will only have one cageid indicates current cage, and three regular arguments same with Linux /// - cageid: current cage /// - path_arg: This argument points to a pathname naming the file. User's perspective. @@ -45,9 +47,6 @@ pub fn kernel_close(fdentry: fdtables::FDTableEntry, _count: u64) { /// the open file description. The flags are combined together using a bitwise-inclusive-OR and the /// result is passed as an argument to the function. We need to check if `O_CLOEXEC` has been set. /// - mode_arg: This represents the permission of the newly created file. Directly passing to kernel. -/// -/// ## Returns: -/// same with man page pub fn open_syscall( cageid: u64, path_arg: u64, @@ -77,6 +76,7 @@ pub fn open_syscall( return syscall_error(Errno::EFAULT, "open", "Invalide Cage ID"); } + // Get the kernel fd first let kernel_fd = unsafe { libc::open(path.as_ptr(), oflag, mode) }; @@ -106,7 +106,7 @@ pub fn open_syscall( /// Since we implement a file descriptor management subsystem (called `fdtables`), we first translate the virtual file /// descriptor into the corresponding kernel file descriptor before invoking the kernel's `libc::read()` function. /// -/// ## Arguments: +/// Input: /// This call will have one cageid indicating the current cage, and several regular arguments similar to Linux: /// - cageid: current cage identifier. /// - vfd_arg: the virtual file descriptor from the RawPOSIX environment. @@ -144,8 +144,9 @@ pub fn read_syscall( let count = sc_convert_sysarg_to_usize(count_arg, count_cageid, cageid); if !(sc_unusedarg(arg4, arg4_cageid) - && sc_unusedarg(arg5, arg5_cageid) - && sc_unusedarg(arg6, arg6_cageid)) { + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { return syscall_error(Errno::EFAULT, "read", "Invalid Cage ID"); } @@ -169,7 +170,7 @@ pub fn read_syscall( /// subsystem (called `fdtables`) to handle virtual file descriptors. This syscall removes the virtual file /// descriptor from the subsystem, and if necessary, closes the underlying kernel file descriptor. /// -/// ## Arguments: +/// Input: /// This call will have one cageid indicating the current cage, and several regular arguments similar to Linux: /// - cageid: current cage identifier. /// - vfd_arg: the virtual file descriptor from the RawPOSIX environment to be closed. @@ -200,7 +201,7 @@ pub fn close_syscall( match fdtables::close_virtualfd(cageid, vfd_arg) { Ok(()) => 0, Err(e) => { - if e == Errno::EBADFD as u64 { + if e == Errno::EBADF as u64 { syscall_error(Errno::EBADF, "close", "Bad File Descriptor") } else if e == Errno::EINTR as u64 { syscall_error(Errno::EINTR, "close", "Interrupted system call") @@ -211,6 +212,235 @@ pub fn close_syscall( } } +/// Reference to Linux: https://man7.org/linux/man-pages/man2/pipe.2.html +/// +/// Linux `pipe()` syscall is equivalent to calling `pipe2()` with flags set to zero. +/// Therefore, our implementation simply delegates to pipe2_syscall with flags = 0. +/// +/// Input: +/// - cageid: current cage identifier. +/// - pipefd_arg: a u64 representing the pointer to the PipeArray (user's perspective). +/// - pipefd_cageid: cage identifier for the pointer argument. +pub fn pipe_syscall( + cageid: u64, + pipefd_arg: u64, + pipefd_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Delegate to pipe2_syscall with flags set to 0. + pipe2_syscall( + cageid, + pipefd_arg, + pipefd_cageid, + 0, + 0, + arg3, + arg3_cageid, + arg4, + arg4_cageid, + arg5, + arg5_cageid, + arg6, + arg6_cageid, + ) +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/pipe2.2.html +/// +/// Linux `pipe2()` syscall creates a unidirectional data channel and returns two file descriptors, +/// one for reading and one for writing. In our implementation, we first convert the user-supplied +/// pointer to a mutable reference to a PipeArray. Then, we call libc::pipe2() with the provided flags. +/// Finally, we obtain new virtual file descriptors for both ends of the pipe using our fd management +/// subsystem (`fdtables`). +/// +/// Input: +/// - cageid: current cage identifier. +/// - pipefd_arg: a u64 representing the pointer to the PipeArray (user's perspective). +/// - pipefd_cageid: cage identifier for the pointer argument. +/// - flags_arg: this argument contains flags (e.g., O_CLOEXEC) to be passed to pipe2. +/// - flags_cageid: cage identifier for the flags argument. +pub fn pipe2_syscall( + cageid: u64, + pipefd_arg: u64, + pipefd_cageid: u64, + flags_arg: u64, + flags_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Convert the flags argument. + let flags = sc_convert_sysarg_to_i32(flags_arg, flags_cageid, cageid); + + // Validate flags - only O_NONBLOCK and O_CLOEXEC are allowed + let allowed_flags = fs_const::O_NONBLOCK | fs_const::O_CLOEXEC; + if flags & !allowed_flags != 0 { + return syscall_error(Errno::EINVAL, "pipe2_syscall", "Invalid flags"); + } + + // Ensure unused arguments are truly unused. + if !(sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "pipe2_syscall", "Invalid Cage ID"); + } + // Convert the u64 pointer into a mutable reference to PipeArray. + let pipefd = match get_pipearray(pipefd_arg) { + Ok(p) => p, + Err(e) => return e, + }; + // Create an array to hold the two kernel file descriptors. + let mut kernel_fds: [i32; 2] = [0; 2]; + let ret = unsafe { libc::pipe2(kernel_fds.as_mut_ptr(), flags) }; + if ret < 0 { + return handle_errno(get_errno(), "pipe2_syscall"); + } + + // Check whether O_CLOEXEC is set. + let should_cloexec = (flags & fs_const::O_CLOEXEC) != 0; + + // Get virtual fd for read end + let read_vfd = match fdtables::get_unused_virtual_fd( + cageid, + fs_const::FDKIND_KERNEL, + kernel_fds[0] as u64, + should_cloexec, + 0, + ) { + Ok(fd) => fd as i32, + Err(_) => { + unsafe { + libc::close(kernel_fds[0]); + libc::close(kernel_fds[1]); + } + return syscall_error(Errno::EMFILE, "pipe2_syscall", "Too many files opened"); + } + }; + + // Get virtual fd for write end + let write_vfd = match fdtables::get_unused_virtual_fd( + cageid, + fs_const::FDKIND_KERNEL, + kernel_fds[1] as u64, + should_cloexec, + 0, + ) { + Ok(fd) => fd as i32, + Err(_) => { + unsafe { + libc::close(kernel_fds[0]); + libc::close(kernel_fds[1]); + } + return syscall_error(Errno::EMFILE, "pipe2_syscall", "Too many files opened"); + } + }; + + pipefd.readfd = read_vfd; + pipefd.writefd = write_vfd; + ret +} + +pub fn lseek_syscall( + cageid: u64, + virtual_fd: u64, + vfd_cageid: u64, + offset_arg: u64, + offset_cageid: u64, + whence_arg: u64, + whence_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "lseek", "Invalide Cage ID"); + } + + if virtual_fd < 0 { + return syscall_error(Errno::EBADF, "lseek", "Bad File Descriptor"); + } + + let kernel_fd = convert_fd_to_host(virtual_fd, vfd_cageid, cageid); + if kernel_fd == -1 { + return syscall_error(Errno::EFAULT, "lseek", "Invalid Cage ID"); + } else if kernel_fd == -9 { + return syscall_error(Errno::EBADF, "lseek", "Bad File Descriptor"); + } + + let offset = sc_convert_sysarg_to_i64(offset_arg, offset_cageid, cageid); + let whence = sc_convert_sysarg_to_i32(whence_arg, whence_cageid, cageid); + + let ret = unsafe { libc::lseek(kernel_fd, offset, whence) }; + + if ret < 0 { + let errno = get_errno(); + return handle_errno(errno, "lseek"); + } + + ret as i32 +} + +pub fn unlink_syscall( + cageid: u64, + path_arg: u64, + path_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Type conversion + let path = sc_convert_path_to_host(path_arg, path_cageid, cageid); + + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "unlink", "Invalide Cage ID"); + } + + let ret = unsafe { libc::unlink(path.as_ptr()) }; + + if ret < 0 { + let errno = get_errno(); + return handle_errno(errno, "unlink"); + } + + ret +} + /// Reference to Linux: https://man7.org/linux/man-pages/man2/mkdir.2.html /// /// Linux `mkdir()` syscall creates a new directory named by the path name pointed to by a path as the input parameter @@ -218,12 +448,12 @@ pub fn close_syscall( /// RawPOSIX doesn't have any other operations, so all operations will be handled by host. RawPOSIX does error handling /// for this syscall. /// -/// ## Arguments: +/// Input: /// - cageid: current cageid /// - path_arg: This argument points to a pathname naming the file. User's perspective. /// - mode_arg: This represents the permission of the newly created file. Directly passing to kernel. /// -/// ## Returns: +/// Return: /// - return zero on success. On error, -1 is returned and errno is set to indicate the error. pub fn mkdir_syscall( cageid: u64, @@ -263,6 +493,157 @@ pub fn mkdir_syscall( ret } +/// Reference to Linux: https://man7.org/linux/man-pages/man2/write.2.html +/// +/// Linux `write()` syscall attempts to write `count` bytes from the buffer pointed to by `buf` to the file associated +/// with the open file descriptor, `fd`. RawPOSIX first converts virtual fd to kernel fd due to the `fdtable` subsystem, second +/// translates the `buf_arg` pointer to actual system pointer +/// +/// Input: +/// - cageid: current cageid +/// - virtual_fd: virtual file descriptor, needs to be translated kernel fd for future kernel operation +/// - buf_arg: pointer points to a buffer that stores the data +/// - count_arg: length of the buffer +/// +/// Output: +/// - Upon successful completion of this call, we return the number of bytes written. This number will never be greater +/// than `count`. The value returned may be less than `count` if the write_syscall() was interrupted by a signal, or +/// if the file is a pipe or FIFO or special file and has fewer than `count` bytes immediately available for writing. +pub fn write_syscall( + cageid: u64, + virtual_fd: u64, + vfd_cageid: u64, + buf_arg: u64, + buf_cageid: u64, + count_arg: u64, + count_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + let kernel_fd = convert_fd_to_host(virtual_fd, vfd_cageid, cageid); + + if kernel_fd == -1 { + return syscall_error(Errno::EFAULT, "write", "Invalid Cage ID"); + } else if kernel_fd == -9 { + return syscall_error(Errno::EBADF, "write", "Bad File Descriptor"); + } + + let buf = sc_convert_buf(buf_arg, buf_cageid, cageid); + let count = sc_convert_sysarg_to_usize(count_arg, count_cageid, cageid); + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "write", "Invalide Cage ID"); + } + + // Early return + if count == 0 { + return 0; + } + + let ret = unsafe { libc::write(kernel_fd, buf as *const c_void, count) as i32 }; + + if ret < 0 { + let errno = get_errno(); + return handle_errno(errno, "write"); + } + return ret; +} + +pub fn dup_syscall( + cageid: u64, + virtual_fd: u64, + vfd_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + if !(sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "dup", "Invalide Cage ID"); + } + + if virtual_fd < 0 { + return syscall_error(Errno::EBADF, "dup", "Bad File Descriptor"); + } + let wrappedvfd = fdtables::translate_virtual_fd(cageid, virtual_fd as u64); + if wrappedvfd.is_err() { + return syscall_error(Errno::EBADF, "dup", "Bad File Descriptor"); + } + let vfd = wrappedvfd.unwrap(); + let ret_kernelfd = unsafe { libc::dup(vfd.underfd as i32) }; + let ret_virtualfd = + fdtables::get_unused_virtual_fd(cageid, vfd.fdkind, ret_kernelfd as u64, false, 0).unwrap(); + return ret_virtualfd as i32; +} + +pub fn dup2_syscall( + cageid: u64, + old_virtualfd: u64, + old_vfd_cageid: u64, + new_virtualfd: u64, + new_vfd_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "dup2", "Invalide Cage ID"); + } + + if old_virtualfd < 0 || new_virtualfd < 0 { + return syscall_error(Errno::EBADF, "dup2", "Bad File Descriptor"); + } + + match fdtables::translate_virtual_fd(cageid, old_virtualfd) { + Ok(old_vfd) => { + let new_kernelfd = unsafe { libc::dup(old_vfd.underfd as i32) }; + // Map new kernel fd with provided kernel fd + let _ret_kernelfd = unsafe { libc::dup2(old_vfd.underfd as i32, new_kernelfd) }; + let _ = fdtables::get_specific_virtual_fd( + cageid, + new_virtualfd, + old_vfd.fdkind, + new_kernelfd as u64, + false, + old_vfd.perfdinfo, + ) + .unwrap(); + return new_virtualfd as i32; + } + Err(_e) => { + return syscall_error(Errno::EBADF, "dup2", "Bad File Descriptor"); + } + } +} + /// Handles the `mmap_syscall`, interacting with the `vmmap` structure. /// /// This function processes the `mmap_syscall` by updating the `vmmap` entries and performing diff --git a/src/rawposix/src/lib.rs b/src/rawposix/src/lib.rs new file mode 100644 index 000000000..a96d9a0e9 --- /dev/null +++ b/src/rawposix/src/lib.rs @@ -0,0 +1,5 @@ +//! This module contains actual syscall implementation in RawPOSIX +pub mod fs_calls; +pub mod sys_calls; + +pub use sys_calls::{lindrustfinalize, lindrustinit}; diff --git a/src/rawposix/src/sys_calls.rs b/src/rawposix/src/sys_calls.rs new file mode 100644 index 000000000..735068524 --- /dev/null +++ b/src/rawposix/src/sys_calls.rs @@ -0,0 +1,1159 @@ +//! System syscalls implementation +//! +//! This module contains all system calls that are being emulated/faked in Lind. +use crate::fs_calls::kernel_close; +use cage::memory::mem_helper::*; +use cage::memory::vmmap::{VmmapOps, *}; +use cage::{cagetable_init, add_cage, cagetable_clear, get_cage, remove_cage, Cage, Zombie}; +use fdtables; +use libc::sched_yield; +use parking_lot::RwLock; +use std::ffi::CString; +use std::path::PathBuf; +use std::sync::atomic::Ordering::*; +use std::sync::atomic::{AtomicI32, AtomicU64}; +use std::sync::Arc; +use sysdefs::constants::err_const::{get_errno, handle_errno, syscall_error, Errno}; +use sysdefs::constants::fs_const::{STDERR_FILENO, STDOUT_FILENO, STDIN_FILENO, *}; +use sysdefs::constants::{EXIT_SUCCESS, VERBOSE}; +use typemap::syscall_type_conversion::*; +use typemap::fs_type_conversion::*; +use dashmap::DashMap; +use typemap::{sc_convert_addr_to_host, sc_convert_sysarg_to_i32, sc_convert_sysarg_to_i32_ref, sc_unusedarg, sc_convert_buf_to_host, get_sockaddr, sc_convert_sysarg_to_u32}; + + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/fork.2.html +/// +/// `fork_syscall` creates a new process (cage object). The newly created child process is an exact copy of the +/// parent process (the process that calls fork) apart from it's cage_id and the parent_id +/// In this function we separately handle copying fd tables and clone vmmap talbe and create a new Cage object +/// with this cloned tables. +pub fn fork_syscall( + cageid: u64, + child_arg: u64, // Child's cage id + child_arg_cageid: u64, // Child's cage id arguments cageid + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "fork", "Invalide Arguments"); + } + + // Modify the fdtable manually + fdtables::copy_fdtable_for_cage(child_arg_cageid, child_arg).unwrap(); + + // Get the self cage + let selfcage = get_cage(child_arg_cageid).unwrap(); + + let parent_vmmap = selfcage.vmmap.read(); + let new_vmmap = parent_vmmap.clone(); + + let cageobj = Cage { + cageid: child_arg, + cwd: RwLock::new(selfcage.cwd.read().clone()), + parent: child_arg_cageid, + gid: AtomicI32::new(selfcage.gid.load(Relaxed)), + uid: AtomicI32::new(selfcage.uid.load(Relaxed)), + egid: AtomicI32::new(selfcage.egid.load(Relaxed)), + euid: AtomicI32::new(selfcage.euid.load(Relaxed)), + main_threadid: RwLock::new(0), + epoch_handler: DashMap::new(), + pending_signals: RwLock::new(vec![]), + signalhandler: selfcage.signalhandler.clone(), + sigset: AtomicU64::new(0), + zombies: RwLock::new(vec![]), + child_num: AtomicU64::new(0), + vmmap: RwLock::new(new_vmmap), + }; + + // increment child counter for parent + selfcage.child_num.fetch_add(1, SeqCst); + + add_cage(child_arg, cageobj); + 0 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man3/exit.3.html +/// +/// The exit function causes normal process(Cage) termination +/// The termination entails unmapping all memory references +/// Removing the cage object from the cage table, closing all open files which is removing corresponding fdtable +pub fn exit_syscall( + cageid: u64, + status_arg: u64, + status_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + let status = sc_convert_sysarg_to_i32(status_arg, status_cageid, cageid); + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "exit", "Invalide Arguments"); + } + + let _ = fdtables::remove_cage_from_fdtable(cageid); + + // Get the self cage + //may not be removable in case of lindrustfinalize, we don't unwrap the remove result + if let Some(selfcage) = get_cage(cageid) { + if selfcage.parent != cageid { + let parent_cage = get_cage(selfcage.parent); + if let Some(parent) = parent_cage { + parent.child_num.fetch_sub(1, SeqCst); + let mut zombie_vec = parent.zombies.write(); + zombie_vec.push(Zombie { + cageid: cageid, + exit_code: status, + }); + } else { + // if parent already exited + // BUG: we currently do not handle the situation where a parent has exited already + } + } + + remove_cage(cageid); + } + + status +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man3/waitpid.3p.html +/// +/// waitpid() will return the cageid of waited cage, or 0 when WNOHANG is set and there is no cage already exited +/// waitpid_syscall utilizes the zombie list stored in cage struct. When a cage exited, a zombie entry will be inserted +/// into the end of its parent's zombie list. Then when parent wants to wait for any of child, it could just check its +/// zombie list and retrieve the first entry from it (first in, first out). +pub fn waitpid_syscall( + cageid: u64, + cageid_arg: u64, + cageid_arg_cageid: u64, + status_arg: u64, + status_cageid: u64, + options_arg: u64, + options_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + let status = sc_convert_sysarg_to_i32_ref(status_arg, status_cageid, cageid); + let options = sc_convert_sysarg_to_i32(options_arg, options_cageid, cageid); + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "waitpid", "Invalid Arguments"); + } + + // get the cage instance + let cage = get_cage(cageid).unwrap(); + + let mut zombies = cage.zombies.write(); + let child_num = cage.child_num.load(Relaxed); + + // if there is no pending zombies to wait, and there is no active child, return ECHILD + if zombies.len() == 0 && child_num == 0 { + return syscall_error( + Errno::ECHILD, + "waitpid", + "no existing unwaited-for child processes", + ); + } + + let mut zombie_opt: Option = None; + + // cageid <= 0 means wait for ANY child + // cageid < 0 actually refers to wait for any child process whose process group ID equals -pid + // but we do not have the concept of process group in lind, so let's just treat it as cageid == 0 + if cageid_arg <= 0 { + loop { + if zombies.len() == 0 && (options & libc::WNOHANG > 0) { + // if there is no pending zombies and WNOHANG is set + // return immediately + return 0; + } else if zombies.len() == 0 { + // if there is no pending zombies and WNOHANG is not set + // then we need to wait for children to exit + // drop the zombies list before sleep to avoid deadlock + drop(zombies); + // TODO: replace busy waiting with more efficient mechanism + unsafe { + sched_yield(); + } + // after sleep, get the write access of zombies list back + zombies = cage.zombies.write(); + continue; + } else { + // there are zombies avaliable + // let's retrieve the first zombie + zombie_opt = Some(zombies.remove(0)); + break; + } + } + } + // if cageid is specified, then we need to look up the zombie list for the id + else { + // first let's check if the cageid is in the zombie list + if let Some(index) = zombies + .iter() + .position(|zombie| zombie.cageid == cageid_arg as u64) + { + // find the cage in zombie list, remove it from the list and break + zombie_opt = Some(zombies.remove(index)); + } else { + // if the cageid is not in the zombie list, then we know either + // 1. the child is still running, or + // 2. the cage has exited, but it is not the child of this cage, or + // 3. the cage does not exist + // we need to make sure the child is still running, and it is the child of this cage + let child = get_cage(cageid_arg as u64); + if let Some(child_cage) = child { + // make sure the child's parent is correct + if child_cage.parent != cage.cageid { + return syscall_error( + Errno::ECHILD, + "waitpid", + "waited cage is not the child of the cage", + ); + } + } else { + // cage does not exist + return syscall_error(Errno::ECHILD, "waitpid", "cage does not exist"); + } + + // now we have verified that the cage exists and is the child of the cage + loop { + // the cage is not in the zombie list + // we need to wait for the cage to actually exit + + // drop the zombies list before sleep to avoid deadlock + drop(zombies); + // TODO: replace busy waiting with more efficient mechanism + unsafe { + sched_yield(); + } + // after sleep, get the write access of zombies list back + zombies = cage.zombies.write(); + + // let's check if the zombie list contains the cage + if let Some(index) = zombies + .iter() + .position(|zombie| zombie.cageid == cageid_arg as u64) + { + // find the cage in zombie list, remove it from the list and break + zombie_opt = Some(zombies.remove(index)); + break; + } + + continue; + } + } + } + + // reach here means we already found the desired exited child + let zombie = zombie_opt.unwrap(); + // update the status + *status = zombie.exit_code; + + // return child's cageid + zombie.cageid as i32 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/wait.2.html +/// +/// See comments of waitpid_syscall +pub fn wait_syscall( + cageid: u64, + status_arg: u64, + status_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "waitpid", "Invalid Arguments"); + } + // left type conversion done inside waitpid_syscall + waitpid_syscall( + cageid, + 0, + 0, + status_arg, + status_cageid, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ) +} + +pub fn getpid_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "exec", "Invalide Cage ID"); + } + + let cage = get_cage(cageid).unwrap(); + + return cage.cageid as i32; +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man3/getppid.3p.html +/// +/// ## Returns +/// Get the parent cage ID +pub fn getppid_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "exec", "Invalide Cage ID"); + } + + let cage = get_cage(cageid).unwrap(); + + return cage.parent as i32; +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/getgid.2.html +/// +/// Retrieves the group id (gid) for the current cage. If the cage's group id is uninitialized (i.e. -1), +/// then it updates it to a default group id defined in the constants and returns -1. +pub fn getgid_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Validate that unused arguments are indeed unused. + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) { + return syscall_error(Errno::EFAULT, "getgid", "Invalid arguments"); + } + + // Get the current cage. + let cage = match get_cage(cageid) { + Some(c) => c, + None => return syscall_error(Errno::ECHILD, "getgid", "Cage not found"), + }; + + // Read the group id stored in the cage. + let gid = cage.getgid.load(Relaxed); + + // If the group id is uninitialized (-1), update it to the default and return -1. + if gid == -1 { + cage.getgid.store(DEFAULT_GID as i32, Relaxed); + return -1; + } + + // Otherwise, return the default group id + DEFAULT_GID as i32 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/getegid.2.html +/// +/// Retrieves the effective group id (egid) for the current cage. If uninitialized (-1), +/// updates it to a default value and returns -1. +pub fn getegid_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Validate that all extra arguments are unused. + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "getegid", "Invalid arguments"); + } + + // Retrieve the current cage. + let cage = match get_cage(cageid) { + Some(c) => c, + None => return syscall_error(Errno::ECHILD, "getegid", "Cage not found"), + }; + + // Read the effective group id (egid) from the cage. + let egid = cage.getegid.load(Relaxed); + if egid == -1 { + // If not set, update with the default and return -1. + cage.getegid.store(DEFAULT_GID as i32, Relaxed); + return -1; + } + + // Otherwise, return the default effective group id. + DEFAULT_GID as i32 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/getuid.2.html +/// +/// Retrieves the user id (uid) for the current cage. If the cage’s uid is uninitialized (-1), +/// it updates it to the default user id and returns -1. +pub fn getuid_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Validate unused arguments. + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) { + return syscall_error(Errno::EFAULT, "getuid", "Invalid arguments"); + } + + // Retrieve the cage. + let cage = match get_cage(cageid) { + Some(c) => c, + None => return syscall_error(Errno::ECHILD, "getuid", "Cage not found"), + }; + + // Read the current uid from the cage. + let uid = cage.getuid.load(Relaxed); + if uid == -1 { + // If uid is uninitialized, set it to the default and return -1. + cage.getuid.store(DEFAULT_UID as i32, Relaxed); + return -1; + } + + // Otherwise, return the stored uid (which is default in Lind's design). + DEFAULT_UID as i32 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/geteuid.2.html +/// +/// Retrieves the effective user id (euid) for the current cage. If uninitialized (-1), +/// it updates the euid to the default value and returns -1. +pub fn geteuid_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Validate that each extra argument is unused. + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) { + return syscall_error(Errno::EFAULT, "geteuid", "Invalid arguments"); + } + + // Retrieve the current cage (process) object. + let cage = match get_cage(cageid) { + Some(c) => c, + None => return syscall_error(Errno::ECHILD, "geteuid", "Cage not found"), + }; + + // Load the effective user ID. + let euid = cage.geteuid.load(Relaxed); + if euid == -1 { + // If uninitialized, update to the default and return -1. + cage.geteuid.store(DEFAULT_UID as i32, Relaxed); + return -1; + } + + // Otherwise, return the default effective user ID. + DEFAULT_UID as i32 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/sigaction.2.html +/// +/// Copy the existing signal handler state from the cage into the caller-provided memory +/// (oact). Install the new handler provided by the caller into the cage’s signal handler +/// table (act). Reserved arguments must remain unused, and SIGKILL/SIGSTOP cannot be +/// modified. +/// +/// # Arguments +/// * `cageid` - The ID of the cage invoking the syscall. +/// * `sig_arg` - Signal number (as u64, later cast to i32). +/// * `sig_arg_cageid` - Cage ID that owns the `sig_arg` (for validation). +/// * `act_arg` - Pointer to the new `sigaction` struct, or 0 if none. +/// * `act_arg_cageid` - Cage ID of the memory holding `act_arg`. +/// * `oact_arg` - Pointer to store the old `sigaction` struct, or 0 if not needed. +/// * `oact_arg_cageid` - Cage ID of the memory holding `oact_arg`. +/// +/// # Returns +/// * `0` on success. +/// * Negative errno wrapped via `syscall_error` on failure. +pub fn sigaction_syscall( + cageid: u64, + sig_arg: u64, + sig_arg_cageid: u64, + act_arg: u64, + act_arg_cageid: u64, + oact_arg: u64, + oact_arg_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, arg6_cageid: u64, +) -> i32 { + let sig = sc_convert_sysarg_to_i32(sig_arg, sig_arg_cageid, cageid); + let act = sc_convert_SigactionStruct(act_arg, act_arg_cageid, cageid); + let oact = sc_convert_SigactionStruct_mut(oact_arg, oact_arg_cageid, cageid); + // Validate that the extra unused arguments are indeed unused. + if !(sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "sigaction", "Invalid extra arguments"); + } + + // Retrieve the cage. + let cage = match get_cage(cageid) { + Some(c) => c, + None => return syscall_error(Errno::ECHILD, "sigaction", "Cage not found"), + }; + + // If oact (old action pointer) is provided, fill it with the current action. + if let Some(oact_ref) = oact { + if let Some(current_act) = cage.signalhandler.get(&sig) { + // Copy the current signal action into the provided memory. + oact_ref.clone_from(current_act); + } else { + // If there is no current action, use a default. + oact_ref.clone_from(&SigactionStruct::default()); + } + } + + // If a new action is provided in act, update the signal handler. + if let Some(new_act) = act { + // Disallow modification for SIGKILL and SIGSTOP. + if sig == SIGKILL || sig == SIGSTOP { + return syscall_error(Errno::EINVAL, "sigaction", "Cannot modify SIGKILL or SIGSTOP"); + } + // Insert the new signal action into the cage’s signal handler table. + cage.signalhandler.insert(sig, new_act.clone()); + } + + 0 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/kill.2.html +/// +/// This function allows one cage (the caller) to send a signal to another cage +/// (the target), similar to the `kill(2)` syscall in POSIX. +/// +/// ## Arguments +/// * `cageid` - The ID of the calling cage (not directly used to deliver the signal). +/// * `target_cage_arg` / `target_cage_arg_cageid` - Encoded system arguments +/// specifying the target cage ID to which the signal should be sent. +/// * `sig_arg` / `sig_arg_cageid` - Encoded system arguments specifying the signal number. +/// +/// ## Returns +/// On success, returns `0`. If the target cage does not exist, returns `ESRCH`. +/// +/// ## Errors +/// * `EFAULT` – Reserved arguments were not unused. +/// * `EINVAL` – Invalid target cage ID or signal number. +/// * `ESRCH` – Target cage does not exist. +pub fn kill_syscall( + cageid: u64, + target_cage_arg: u64, + target_cage_arg_cageid: u64, + sig_arg: u64, + sig_arg_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // Convert target cage id and signal value. + let target_cage = sc_convert_sysarg_to_i32(target_cage_arg, target_cage_arg_cageid, cageid); + let sig = sc_convert_sysarg_to_i32(sig_arg, sig_arg_cageid, cageid); + + // Validate the unused arguments. + if !(sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) { + return syscall_error(Errno::EFAULT, "kill", "Invalid extra arguments"); + } + + // Validate the target cage id: it must not be negative and typically within a system-defined maximum. + if target_cage < 0 { + return syscall_error(Errno::EINVAL, "kill", "Invalid target cage id"); + } + + // Validate the signal number: for example, it should typically be in the range 1..32. + if sig <= 0 || sig >= 32 { + return syscall_error(Errno::EINVAL, "kill", "Invalid signal number"); + } + + // Optionally, you could verify that certain signals (e.g., SIGKILL, SIGSTOP) + // are handled with special semantics; however, in this implementation we assume they are valid. + + // Attempt to send the signal using a helper function such as lind_send_signal. + // This helper returns a boolean indicating whether the operation was successful. + // The caller's cage id is not directly used to send the signal; instead, the target cage id is used. + if !lind_send_signal(target_cage as u64, sig) { + return syscall_error(Errno::ESRCH, "kill", "Target cage does not exist"); + } + + 0 +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man2/sigprocmask.2.html +/// +/// This function allows a cage to examine or change its +/// signal mask, i.e., the set of signals currently blocked from delivery. +/// If `oldset` is provided, copies the current signal mask into it. If `set` is +/// provided, updates the mask according to `how`: +/// - `SIG_BLOCK`: add signals from `set` to the mask. +/// - `SIG_UNBLOCK`: remove signals from `set` from the mask; if any pending +/// signals are now unblocked, trigger a signal epoch. +/// - `SIG_SETMASK`: replace the mask with `set`; if any previously blocked +/// pending signals are now unblocked, trigger a signal epoch. +/// +/// ## Arguments +/// * `cageid` – The ID of the calling cage. +/// * `how_arg` / `how_cageid` – Encoded argument specifying how the mask is modified +/// (`SIG_BLOCK`, `SIG_UNBLOCK`, or `SIG_SETMASK`). +/// * `set_arg` / `set_cageid` – Optional pointer to a new signal set. +/// - If provided, defines the signals to block, unblock, or set. +/// - If null, the mask is not modified. +/// * `oldset_arg` / `oldset_cageid` – Optional pointer where the previous mask +/// should be stored. +/// +/// ## Returns: +/// Returns `0` on success, or an error code (`EINVAL`, `EFAULT`) on failure. +/// +/// ## Errors +/// * `EFAULT` – Reserved arguments were not unused. +/// * `EINVAL` – Invalid value passed for `how`. +pub fn sigprocmask_syscall( + cageid: u64, + how_arg: u64, + how_cageid: u64, + set_arg: u64, + set_cageid: u64, + oldset_arg: u64, + oldset_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + let how = sc_convert_sysarg_to_i32(how_arg, how_cageid, cageid); + let set = sc_convert_sigset(set_arg, set_cageid, cageid); + let oldset = sc_convert_sigset(oldset_arg, oldset_cageid, cageid); + if !(sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "sigprocmask_syscall", "Invalide Cage ID"); + } + + let cage = get_cage(cageid).unwrap(); + + let mut res = 0; + + if let Some(some_oldset) = oldset { + *some_oldset = cage.sigset.load(Relaxed); + } + + if let Some(some_set) = set { + let curr_sigset = cage.sigset.load(Relaxed); + res = match how { + SIG_BLOCK => { + // Block signals in set + cage.sigset.store( + curr_sigset | *some_set, + Relaxed, + ); + 0 + } + SIG_UNBLOCK => { + // Unblock signals in set + let newset = curr_sigset & !*some_set; + cage.sigset + .store(newset, Relaxed); + // check if any of the unblocked signals are in the pending signal list + // and trigger the epoch if it has + let pending_signals = cage.pending_signals.read(); + if pending_signals + .iter() + .any(|signo| (*some_set & convert_signal_mask(*signo)) != 0) + { + cage::signal_epoch_trigger(cage.cageid); + } + 0 + } + SIG_SETMASK => { + let pending_signals = cage.pending_signals.read(); + // find all signals switched from blocking to nonblocking + // 1. perform a xor operation to find signals that switched state + // all the signal masks changed from 0 to 1, or 1 to 0 are filtered in this step + // 2. perform an and operation to the old sigset, this further filtered masks and only + // left masks changed from 1 to 0 + let unblocked_signals = (curr_sigset ^ *some_set) & curr_sigset; + // check if any of the unblocked signals are in the pending signal list + // and trigger the epoch if it has + if pending_signals + .iter() + .any(|signo| (unblocked_signals & convert_signal_mask(*signo)) != 0) + { + cage::signal_epoch_trigger(cage.cageid); + } + // Set sigset to set + cage.sigset + .store(*some_set, Relaxed); + 0 + } + _ => syscall_error(Errno::EINVAL, "sigprocmask", "Invalid value for how"), + } + } + res +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man3/setitimer.3p.html +/// +/// This syscall allows a cage to set or retrieve the value of an interval timer. +/// Currently only `ITIMER_REAL` is supported, which decrements in real (wall-clock) +/// time and delivers `SIGALRM` upon expiration. +/// +/// For `ITIMER_REAL`: +/// - If `old_value` is provided, copies the current timer’s remaining time and interval +/// into it. +/// - If `new_value` is provided, updates the interval timer with the new durations. +/// For `ITIMER_VIRTUAL` and `ITIMER_PROF`, no action is taken (not implemented). +/// +/// ## Arguments +/// * `cageid` – The ID of the calling cage. +/// * `which_arg` / `which_arg_cageid` – Encoded argument specifying which timer to use +/// (`ITIMER_REAL`, `ITIMER_VIRTUAL`, `ITIMER_PROF`). Only `ITIMER_REAL` is implemented. +/// * `new_value_arg` / `new_value_arg_cageid` – Pointer to a new `itimerval` struct. +/// If non-null, this specifies the new timer settings. +/// * `old_value_arg` / `old_value_arg_cageid` – Pointer to an `itimerval` struct +/// where the previous timer value should be stored. If non-null, the current +/// timer is copied here before being changed. +/// +/// ## Returns +/// * `0` on success. +/// * Negative errno (`EFAULT`, etc.) on failure. +pub fn setitimer_syscall( + cageid: u64, + which_arg: u64, + which_arg_cageid: u64, + new_value_arg: u64, + new_value_arg_cageid: u64, + old_value_arg: u64, + old_value_arg_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + let which = sc_convert_sysarg_to_i32(which_arg, which_arg_cageid, cageid); + let new_value = sc_convert_itimerval(new_value_arg, new_value_arg_cageid, cageid); + let old_value = sc_convert_itimerval_mut(old_value_arg, old_value_arg_cageid, cageid); + // Validate that extra arguments are indeed unused. + if !(sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) { + return syscall_error(Errno::EFAULT, "setitimer", "Invalid extra arguments"); + } + + match which { + ITIMER_REAL => { + if let Some(some_old_value) = old_value { + let (curr_duration, next_duration) = self.interval_timer.get_itimer(); + some_old_value.it_value.tv_sec = curr_duration.as_secs() as i64; + some_old_value.it_value.tv_usec = curr_duration.subsec_millis() as i64; + some_old_value.it_interval.tv_sec = next_duration.as_secs() as i64; + some_old_value.it_interval.tv_usec = next_duration.subsec_millis() as i64; + } + + if let Some(some_new_value) = new_value { + let curr_duration = interface::RustDuration::new( + some_new_value.it_value.tv_sec as u64, + some_new_value.it_value.tv_usec as u32, + ); + let next_duration = interface::RustDuration::new( + some_new_value.it_interval.tv_sec as u64, + some_new_value.it_interval.tv_usec as u32, + ); + + self.interval_timer.set_itimer(curr_duration, next_duration); + } + } + + _ => { /* ITIMER_VIRTUAL and ITIMER_PROF is not implemented*/ } + } + 0 +} + +/// Those functions are required by wasmtime to create the first cage. `verbosity` indicates whether +/// detailed error messages will be printed if set +pub fn lindrustinit(verbosity: isize) { + let _ = VERBOSE.set(verbosity); //assigned to suppress unused result warning + cagetable_init(); + + fdtables::register_close_handlers(FDKIND_KERNEL, fdtables::NULL_FUNC, kernel_close); + + let utilcage = Cage { + cageid: 0, + cwd: RwLock::new(Arc::new(PathBuf::from("/"))), + parent: 0, + gid: AtomicI32::new(-1), + uid: AtomicI32::new(-1), + egid: AtomicI32::new(-1), + euid: AtomicI32::new(-1), + main_threadid: RwLock::new(0), + epoch_handler: DashMap::new(), + pending_signals: RwLock::new(vec![]), + signalhandler: DashMap::new(), + sigset: AtomicU64::new(0), + zombies: RwLock::new(vec![]), + child_num: AtomicU64::new(0), + vmmap: RwLock::new(Vmmap::new()), + }; + + add_cage( + 0, // cageid + utilcage, + ); + fdtables::init_empty_cage(0); + // Set the first 3 fd to STDIN / STDOUT / STDERR + // TODO: + // Replace the hardcoded values with variables (possibly by adding a LIND-specific constants file) + let dev_null = CString::new("/home/lind-wasm/src/RawPOSIX/tmp/dev/null").unwrap(); + + // Make sure that the standard file descriptor (stdin, stdout, stderr) is always valid, even if they + // are closed before. + // Standard input (fd = 0) is redirected to /dev/null + // Standard output (fd = 1) is redirected to /dev/null + // Standard error (fd = 2) is set to copy of stdout + unsafe { + libc::open(dev_null.as_ptr(), libc::O_RDONLY); + libc::open(dev_null.as_ptr(), libc::O_WRONLY); + libc::dup(1); + } + + // STDIN + fdtables::get_specific_virtual_fd( + 0, + STDIN_FILENO as u64, + FDKIND_KERNEL, + STDIN_FILENO as u64, + false, + 0, + ) + .unwrap(); + // STDOUT + fdtables::get_specific_virtual_fd( + 0, + STDOUT_FILENO as u64, + FDKIND_KERNEL, + STDOUT_FILENO as u64, + false, + 0, + ) + .unwrap(); + // STDERR + fdtables::get_specific_virtual_fd( + 0, + STDERR_FILENO as u64, + FDKIND_KERNEL, + STDERR_FILENO as u64, + false, + 0, + ) + .unwrap(); + + //init cage is its own parent + let initcage = Cage { + cageid: 1, + cwd: RwLock::new(Arc::new(PathBuf::from("/"))), + parent: 1, + gid: AtomicI32::new(-1), + uid: AtomicI32::new(-1), + egid: AtomicI32::new(-1), + euid: AtomicI32::new(-1), + main_threadid: RwLock::new(0), + epoch_handler: DashMap::new(), + signalhandler: DashMap::new(), + pending_signals: RwLock::new(vec![]), + sigset: AtomicU64::new(0), + zombies: RwLock::new(vec![]), + child_num: AtomicU64::new(0), + vmmap: RwLock::new(Vmmap::new()), + }; + + // Add cage to cagetable + add_cage( + 1, // cageid + initcage, + ); + + fdtables::init_empty_cage(1); + // Set the first 3 fd to STDIN / STDOUT / STDERR + // STDIN + fdtables::get_specific_virtual_fd( + 1, + STDIN_FILENO as u64, + FDKIND_KERNEL, + STDIN_FILENO as u64, + false, + 0, + ) + .unwrap(); + // STDOUT + fdtables::get_specific_virtual_fd( + 1, + STDOUT_FILENO as u64, + FDKIND_KERNEL, + STDOUT_FILENO as u64, + false, + 0, + ) + .unwrap(); + // STDERR + fdtables::get_specific_virtual_fd( + 1, + STDERR_FILENO as u64, + FDKIND_KERNEL, + STDERR_FILENO as u64, + false, + 0, + ) + .unwrap(); +} + +pub fn lindrustfinalize() { + let exitvec = cagetable_clear(); + + for cageid in exitvec { + exit_syscall( + cageid as u64, // target cageid + EXIT_SUCCESS as u64, // status arg + cageid as u64, // status arg's cageid + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ); + } +} + +/// Reference to Linux: https://man7.org/linux/man-pages/man3/exec.3.html +/// +/// In our implementation, WASM is responsible for handling functionalities such as loading and executing +/// the new program, preserving process attributes, and resetting memory and the stack. +/// +/// In RawPOSIX, the focus is on memory management inheritance and resource cleanup and release. Specifically, +/// RawPOSIX handles tasks such as clearing memory mappings, resetting shared memory, managing file descriptors +/// (closing or inheriting them based on the `should_cloexec` flag in fdtable), resetting semaphores, and +/// managing process attributes and threads (terminating unnecessary threads). This allows us to fully implement +/// the exec functionality while aligning with POSIX standards. Cage fields remained in exec(): +/// cageid, cwd, parent, interval_timer +pub fn exec_syscall( + cageid: u64, + arg1: u64, + arg1_cageid: u64, + arg2: u64, + arg2_cageid: u64, + arg3: u64, + arg3_cageid: u64, + arg4: u64, + arg4_cageid: u64, + arg5: u64, + arg5_cageid: u64, + arg6: u64, + arg6_cageid: u64, +) -> i32 { + // would sometimes check, sometimes be a no-op depending on the compiler settings + if !(sc_unusedarg(arg1, arg1_cageid) + && sc_unusedarg(arg2, arg2_cageid) + && sc_unusedarg(arg3, arg3_cageid) + && sc_unusedarg(arg4, arg4_cageid) + && sc_unusedarg(arg5, arg5_cageid) + && sc_unusedarg(arg6, arg6_cageid)) + { + return syscall_error(Errno::EFAULT, "exec", "Invalide Cage ID"); + } + + // Empty fd with flag should_cloexec + fdtables::empty_fds_for_exec(cageid); + + // Copy necessary data from current cage + let selfcage = get_cage(cageid).unwrap(); + + let zombies = selfcage.zombies.read(); + let cloned_zombies = zombies.clone(); + let child_num = selfcage.child_num.load(Relaxed); + drop(zombies); + + let newcage = Cage { + cageid: cageid, + cwd: RwLock::new(selfcage.cwd.read().clone()), + parent: selfcage.parent, + gid: AtomicI32::new(-1), + uid: AtomicI32::new(-1), + egid: AtomicI32::new(-1), + euid: AtomicI32::new(-1), + main_threadid: RwLock::new(0), + epoch_handler: DashMap::new(), + signalhandler: selfcage.signalhandler.clone(), + pending_signals: RwLock::new(vec![]), + sigset: AtomicU64::new(0), + zombies: RwLock::new(cloned_zombies), // When a process exec-ed, its child relationship should be perserved + child_num: AtomicU64::new(child_num), + vmmap: RwLock::new(Vmmap::new()), // Memory is cleared after exec + }; + + // Remove the original cage + remove_cage(cageid); + // Insert the new cage with same cageid + add_cage(cageid, newcage); + 0 +} diff --git a/src/sysdefs/src/constants/fs_const.rs b/src/sysdefs/src/constants/fs_const.rs index e0f8590d2..2bf70081f 100644 --- a/src/sysdefs/src/constants/fs_const.rs +++ b/src/sysdefs/src/constants/fs_const.rs @@ -11,6 +11,8 @@ pub const STDIN_FILENO: i32 = 0; // File descriptor for standard input pub const STDOUT_FILENO: i32 = 1; // File descriptor for standard output pub const STDERR_FILENO: i32 = 2; // File descriptor for standard error +pub const MAXFD: i32 = 1024; // Maximum number of file descriptors + // ===== Directory Entry Constant ===== // Source: include/dirent.h pub const DT_UNKNOWN: u8 = 0; diff --git a/src/sysdefs/src/constants/threei_const.rs b/src/sysdefs/src/constants/threei_const.rs new file mode 100644 index 000000000..a03efcb79 --- /dev/null +++ b/src/sysdefs/src/constants/threei_const.rs @@ -0,0 +1,6 @@ +/// Need to replace by either linux number or purposed more appropriate error num +/// Deregister/matchall should be large enough to avoid confusion +pub const THREEI_DEREGISTER: u64 = 500; +pub const THREEI_MATCHALL: u64 = 501; +pub const ELINDAPIABORTED: u64 = 0xFFFFFFFF; +pub const ELINDESRCH: u64 = 0xFFFFFFFF; diff --git a/src/sysdefs/src/data/net_struct.rs b/src/sysdefs/src/data/net_struct.rs index f86b47ca7..3dea5aec9 100644 --- a/src/sysdefs/src/data/net_struct.rs +++ b/src/sysdefs/src/data/net_struct.rs @@ -4,6 +4,7 @@ use std::str::from_utf8; use std::sync::atomic::{AtomicUsize, Ordering}; extern crate libc; +use libc::*; static mut UD_ID_COUNTER: AtomicUsize = AtomicUsize::new(0); @@ -239,3 +240,11 @@ pub struct SockaddrDummy { pub sa_family: u16, pub _sa_data: [u16; 14], } + +// create a sockaddr_un struct +pub fn create_sockaddr_un() -> sockaddr_un{ + sockaddr_un { + sun_family: 0, + sun_path: [0; 108], + } +} diff --git a/src/threei/src/threei.rs b/src/threei/src/threei.rs index f65af89d4..dd6e25154 100644 --- a/src/threei/src/threei.rs +++ b/src/threei/src/threei.rs @@ -818,6 +818,8 @@ pub fn copy_data_between_cages( ) -> u64 { // Check if destaddr has been set let destaddr = if destaddr == 0 { + let syscall_name: &'static str = "mmap_syscall"; + let syscall_name_ptr = syscall_name.as_ptr() as u64; // Map the memory region for the destination address, if user doesn't allocate the memory // This is a direct underlying RawPOSIX call, so the `name` field will not be used. // We pass `0` here as a placeholder in the 3rd argument to avoid any unnecessary performance overhead. diff --git a/src/typemap/src/fs_type_conversion.rs b/src/typemap/src/fs_type_conversion.rs new file mode 100644 index 000000000..f25bec5c9 --- /dev/null +++ b/src/typemap/src/fs_type_conversion.rs @@ -0,0 +1,176 @@ +//! File system's type conversion related API +//! +//! This file provides APIs for converting between different argument types and translation between path from +//! user's perspective to host's perspective +use cage; +pub use libc::*; +use std::env; +pub use std::ffi::{CStr, CString}; +use std::path::Component; +use std::path::PathBuf; +pub use std::{mem, ptr}; +pub use sysdefs::constants::fs_const; +use cage::get_cage; +use cage::translate_vmmap_addr; +use crate::syscall_type_conversion::get_cstr; + +/// If the `LIND_ROOT` environment variable is present at compile time, this will expand into an expression +/// of type Option<&'static str> whose value is Some of the value of the environment variable (a compilation +/// error will be emitted if the environment variable is not a valid Unicode string). If the environment +/// variable is not present, then this will expand to None, and will be set to default path. +pub const LIND_ROOT: &str = match option_env!("LIND_ROOT") { + Some(path) => path, + None => "/home/lind/lind-wasm/src/RawPOSIX/tmp", +}; + +/// Convert data type from `&str` to `PathBuf` +/// +/// ## Argument: +/// cpath: a path string slice in type &str +/// +/// ## Returns: +/// A `PathBuf` created from the input string. +pub fn convpath(cpath: &str) -> PathBuf { + PathBuf::from(cpath) +} + +/// Normalize receiving path arguments to eliminating `./..` and generate a canonicalized (but not +/// symlink-resolved) path. This function will adding the cage's current working directory at the +/// beginning, if given path argument is relative; or adding the virtual root `/` if given path +/// argument is absolute. +/// +/// ## Arguments: +/// origp: path to normalize. +/// cageid: cage ID of the `origp` +/// +/// ## Returns: +/// A `PathBuf` representing the normalized absolute path. +pub fn normpath(origp: PathBuf, cageid: u64) -> PathBuf { + let cage = cage::get_cage(cageid).unwrap(); + //If path is relative, prefix it with the current working directory, otherwise populate it with rootdir + let mut newp = if origp.is_relative() { + (**cage.cwd.read()).clone() + } else { + PathBuf::from("/") + }; + + for comp in origp.components() { + match comp { + //if we have a normal path component, push it on to our normed path + Component::Normal(_) => { + newp.push(comp); + } + + //if we have a .. path component, pop the last component off our normed path + Component::ParentDir => { + newp.pop(); + } + + //if we have a . path component (Or a root dir or a prefix(?)) do nothing + _ => {} + }; + } + newp +} + +/// This function first normalizes the path, then add `LIND_ROOT` at the beginning. +/// This function is mostly used by path argument translation function in `syscall_conv` +/// +/// ## Arguments: +/// - cageid: used for normalizing path +/// - path: the user seen path +/// +/// ## Returns: +/// - c_path: path location from host's perspective +pub fn add_lind_root(cageid: u64, path: &str) -> CString { + // Convert data type from &str into *const i8 + let relpath = normpath(convpath(path), cageid); + let relative_path = relpath.to_str().unwrap(); + + let full_path = format!("{}{}", LIND_ROOT, relative_path); + let c_path = CString::new(full_path).unwrap(); + c_path +} + +/// Translate a received virtual file descriptor (`virtual_fd`) to real kernel file descriptor. +/// +/// This function is used to translate a per-cage virtual file descriptor into the actual +/// kernel-level file descriptor managed by the `fdtables`. +/// +/// Optionally, when the `secure` feature is enabled, this function will verify that the +/// `arg_cageid` (the cage that owns the fd being translated) is allowed to interact with the +/// caller's `cageid` (the requesting cage). +/// +/// ## Arguments: +/// virtual_fd: The virutal file descriptor +/// arg_cageid: The cage that owns the virtual fd +/// cageid: The cage ID of current caller (only used when `secure` mode is enabled) +/// +/// ## Returns: +/// underlying kernel file descriptor +pub fn convert_fd_to_host(virtual_fd: u64, arg_cageid: u64, cageid: u64) -> i32 { + #[cfg(feature = "secure")] + { + if !validate_cageid(arg_cageid, cageid) { + return -1; + } + } + // Find corresponding virtual fd instance from `fdtable` subsystem + let wrappedvfd = fdtables::translate_virtual_fd(arg_cageid, virtual_fd); + if wrappedvfd.is_err() { + return -9; + } + let vfd = wrappedvfd.unwrap(); + // Actual kernel fd mapped with provided virtual fd + vfd.underfd as i32 +} + +/// Convert received path pointer into a normalized `CString` path in the host cage. +/// +/// This function first validates cross-cage access if `secure` feature is enabled. +/// After translating the given path pointer from virtual address to the real address, +/// this function reads and normalizes the path relative to the cage's CWD or root. +/// Finally prefixes the path with the host-defined `LIND_ROOT`, then constructs a `CString`. +/// +/// ## Arguments: +/// path_arg: virtual address of the path string +/// path_arg_cageid: The cage ID that owns the virtual address. +/// cageid: The cage ID making the system call +/// +/// ## Returns: +/// A `CString` representing the absolute path in the host perspective (kernel perspective). +pub fn sc_convert_path_to_host(path_arg: u64, path_arg_cageid: u64, cageid: u64) -> CString { + #[cfg(feature = "secure")] + { + if !validate_cageid(path_arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } + } + let cage = get_cage(path_arg_cageid).unwrap(); + let addr = translate_vmmap_addr(&cage, path_arg).unwrap(); + let path = match get_cstr(addr) { + Ok(path) => path, + Err(e) => panic!("{:?}", e), + }; + // We will create a new variable in host process to handle the path value + let relpath = normpath(convpath(path), path_arg_cageid); + let relative_path = relpath.to_str().unwrap(); + + // Check if exceeds the max path + #[cfg(feature = "secure")] + { + let total_length = LIND_ROOT.len() + relative_path.len(); + + if total_length >= PATH_MAX { + panic!("Path exceeds PATH_MAX (4096)"); + } + } + + // CString will handle the case when string is not terminated by `\0`, but will return error if `\0` is + // contained within the string. + let full_path = format!("{}{}", LIND_ROOT, relative_path); + match CString::new(full_path) { + Ok(c_path) => c_path, + Err(_) => panic!("String contains internal null byte"), + } +} diff --git a/src/typemap/src/network_type_conversion.rs b/src/typemap/src/network_type_conversion.rs new file mode 100644 index 000000000..1d6d01ee0 --- /dev/null +++ b/src/typemap/src/network_type_conversion.rs @@ -0,0 +1,121 @@ +//! Complex data structure type conversion API +//! +//! This file provides essential functions for handling and validating `u64` inputs, converting +//! them to various system-specific data types needed in system calls. It includes utilities +//! for transforming raw pointers to typed structures, such as complex structures like polling, +//! signal handling, timing, and socket-related types. +use crate::syscall_type_conversion::validate_cageid; +use sysdefs::data::fs_struct::PipeArray; +use sysdefs::data::net_struct::create_sockaddr_un; +use sysdefs::constants::err_const::{syscall_error, Errno}; +use sysdefs::constants::net_const::AF_UNIX; +use crate::fs_type_conversion::LIND_ROOT; +use std::ptr; +use libc::sockaddr_un; + +/// Convert a raw argument pointer into a mutable reference to a `PipeArray` +/// +/// This function interprets the given `u64` value as a raw pointer to a `PipeArray`, +/// and attempts to return a mutable reference to it. It is typically used in +/// syscall argument decoding, where the raw argument comes from Wasm and needs to be +/// reinterpreted into a Rust type. +/// +/// ## Arguments: +/// arg: a pointer to `PipeArray` +/// +/// ## Returns: +/// `Ok(&mut PipeArray)` if the pointer is non-null and safely transmutable +/// `Err(i32)` (with `EFAULT`) if the pointer is null, indicating an invalid memory reference +// pub fn get_pipearray<'a>(arg: u64, arg_cageid: u64, cageid: u64) -> Result<&'a mut PipeArray, i32> { +// #[cfg(feature = "secure")] +// { +// if !validate_cageid(arg_cageid, cageid) { +// panic!("Invalide Cage ID"); +// } +// } +// let pointer = arg as *mut PipeArray; +// if !pointer.is_null() { +// return Ok(unsafe { &mut *pointer }); +// } +// return Err(syscall_error( +// Errno::EFAULT, +// "typemap", +// "input data not valid", +// )); +// } + +pub fn get_pipearray<'a>(generic_argument: u64) -> Result<&'a mut PipeArray, i32> { + let pointer = generic_argument as *mut PipeArray; + if !pointer.is_null() { + return Ok(unsafe { &mut *pointer }); + } + return Err(syscall_error( + Errno::EFAULT, + "dispatcher", + "input data not valid", + )); +} + +/// converts a provided sockaddr pointer to a local `libc::sockaddr` pointer, +/// and returns the pointer and its length(for ipv4, ipv6). If the socket is UNIX, the path +/// is modified to include a LIND_ROOT prefix. +pub fn get_sockaddr(addr: *mut u8) -> (*mut libc::sockaddr, u32) { + let (finalsockaddr, addrlen) = if addr.is_null() { + // handle sockaddr conversion; if NULL, use empty pointer + (ptr::null::() as *const libc::sockaddr_un as *mut libc::sockaddr, 0) + } else { + // create a new sockaddr_un structure to hold the copied data + let mut new_sockaddr_struct = create_sockaddr_un(); + + // get a mutable pointer to that structure + let sockaddr_un_ptr: *mut sockaddr_un = &mut new_sockaddr_struct; + + unsafe { + // copy user's sockaddr to local buffer + ptr::copy_nonoverlapping(addr as *mut libc::sockaddr_un, sockaddr_un_ptr, 1); + + // if AF_UNIX socket, rewrite sun_path with LIND_ROOT prefix + if (*sockaddr_un_ptr).sun_family as i32 == AF_UNIX { + // get a mutable pointer to the beginning of the sun_path array + let sun_path_ptr = (*sockaddr_un_ptr).sun_path.as_mut_ptr(); + + // compute the original path length + let path_len = libc::strlen(sun_path_ptr); + + // get the length of LIND_ROOT prefix we want to insert + let lind_root_len: usize = LIND_ROOT.len(); + + // total new path length = LIND_ROOT + original path + let new_path_len = path_len + lind_root_len; + + // check if new path still fits within the 108-byte sun_path limit + if new_path_len < 108 { + // move the original path forward in memory by lind_root_len bytes + // make space for LIND_ROOT + libc::memmove( + sun_path_ptr.add(lind_root_len) as *mut libc::c_void, + sun_path_ptr as *const libc::c_void, + path_len, + ); + // copy the LIND_ROOT prefix into the beginning of sun_path + libc::memcpy( + sun_path_ptr as *mut libc::c_void, + LIND_ROOT.as_ptr() as *const libc::c_void, + lind_root_len, + ); + // clean the rest of sun_path after the new content + libc::memset( + sun_path_ptr.add(new_path_len) as *mut libc::c_void, + 0, + 108 - new_path_len, + ); + } + } + } + // return the pointer to our local sockaddr_un, cast to generic sockaddr, + // along with its size + (sockaddr_un_ptr as *mut libc::sockaddr, size_of::() as u32) + }; + + (finalsockaddr, addrlen) +} \ No newline at end of file diff --git a/src/typemap/src/syscall_type_conversion.rs b/src/typemap/src/syscall_type_conversion.rs new file mode 100644 index 000000000..5c13c5c8b --- /dev/null +++ b/src/typemap/src/syscall_type_conversion.rs @@ -0,0 +1,576 @@ +//! Basic primitive type conversion API +//! +//! This file defines conversion helpers for basic primitive types (e.g., `i32`, `u32`, `i64`). +//! These functions are used during syscall argument decoding and type-safe interpretation +//! within the RawPOSIX syscall layer (`src/syscalls/`). +use crate::fs_type_conversion::*; +use crate::network_type_conversion::*; +use cage::get_cage; +use cage::memory::mem_helper::*; +use fdtables; +use std::error::Error; +use std::str::Utf8Error; +use sysdefs::constants::err_const::{syscall_error, Errno}; +use sysdefs::constants::fs_const::{MAX_CAGEID, PATH_MAX}; +use sysdefs::data::fs_struct::{SigactionStruct, SigsetType, ITimerVal}; + +/// This function provides two operations: first, it translates path pointer address from WASM environment +/// to kernel system address; then, it adjusts the path from user's perspective to host's perspective, +/// which is adding `LIND_ROOT` before the path arguments. Considering actual syscall implementation +/// logic needs to pass string pointer to underlying rust libc, so this function will return `CString` +/// lways using arg_cageid to translate. (TODO: the logic here might be different according to 3i/grate +/// implementation) +/// - If arg_cageid != cageid: this call is sent by grate. We need to translate according to cage +/// - If arg_cageid == cageid: this call is sent by cage, we can use either one +/// +/// ## Arguments: +/// - cageid: required to do address translation for path pointer +/// - path_arg: the path pointer with address and contents from user's perspective. Address is +/// 32-bit (because of WASM feature). +/// +/// ## Returns: +/// - c_path: a `CString` variable stores the path from host's perspective +/// - will return error if total length exceed the MAX_PATH (which is 4096). We use `Box` here to +/// let upper functions do error handling. (ie: we want to ) +pub unsafe fn charstar_to_ruststr<'a>(cstr: *const i8) -> Result<&'a str, Utf8Error> { + std::ffi::CStr::from_ptr(cstr as *const _).to_str() //returns a result to be unwrapped later +} + +pub fn get_cstr<'a>(arg: u64) -> Result<&'a str, i32> { + let ptr = arg as *const i8; + if !ptr.is_null() { + if let Ok(data) = unsafe { charstar_to_ruststr(ptr) } { + return Ok(data); + } else { + return Err(-1); + } + } + + return Err(-1); +} + +/// Validate whether two cage ids are in valid range. This is used for security mode in +/// type conversion. +/// +/// ## Arguments: +/// cageid_1: first cage id +/// cageid_2: second cage id +/// +/// ## Returns: +/// true: both of them are valid +/// false: one of them or neither of them are valid +pub fn validate_cageid(cageid_1: u64, cageid_2: u64) -> bool { + if cageid_1 > MAX_CAGEID as u64 || cageid_2 > MAX_CAGEID as u64 || cageid_1 < 0 || cageid_2 < 0 + { + return false; + } + true +} + +/// `sc_convert_sysarg_to_i32` is the type conversion function used to convert the +/// argument's type from u64 to i32. When in `secure` mode, extra checks will be +/// performed through `get_i32()` function. (for example validating if all upper-bit +/// are 0; if cage ids are in valid range). The security mode can be enabled through +/// compilation flag of this library. Those calls will panic when failed the check +/// for security concerns +/// +/// `get_i32()` +/// +/// ## Arguments: +/// arg: the argument value +/// arg_cageid: the argument's cageid +/// cageid: source cageid (the cage execute this call) +/// +/// ## Returns: +/// Success: A converted i32 +/// Fail: panic +pub fn get_i32(arg: u64, arg_cageid: u64, cageid: u64) -> i32 { + if !validate_cageid(arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } + + if (arg & 0xFFFFFFFF_00000000) != 1 { + return (arg & 0xFFFFFFFF) as i32; + } + + panic!("Invalide argument"); +} + +/// ## Arguments: +/// arg: the argument value +/// arg_cageid: the argument's cageid +/// cageid: source cageid (the cage execute this call) +/// +/// ## Returns: +/// Success: A converted i32 +/// Fail: panic +pub fn sc_convert_sysarg_to_i32(arg: u64, arg_cageid: u64, cageid: u64) -> i32 { + #[cfg(feature = "fast")] + return arg as i32; + + #[cfg(feature = "secure")] + return get_i32(arg, arg_cageid, cageid); +} + +/// This function translates 64 bits uadd from the WASM context +/// into the corresponding host address value. Unlike the previous two functions, it returns +/// the translated address as a raw `u64` rather than a pointer. +/// +/// Input: +/// - uaddr_arg: the original 64-bit address from the WASM space +/// - uaddr_arg_cageid: the cage ID that owns the address +/// - cageid: the currently executing cage ID +/// +/// Output: +/// - Returns the translated 64-bit address in host space as a u64. +pub fn sc_convert_uaddr_to_host(uaddr_arg: u64, uaddr_arg_cageid: u64, cageid: u64) -> u64{ + let cage = get_cage(uaddr_arg_cageid).unwrap(); + let uaddr = translate_vmmap_addr(&cage, uaddr_arg).unwrap(); + return uaddr; +} + +/// This function translates a memory address from the WASM environment (user space) +/// to the corresponding host system address (kernel space). It is typically used when +/// the guest application passes a pointer argument to a syscall, and we need to dereference +/// it in the kernel context. +/// +/// Input: +/// - addr_arg: the raw 64-bit address from the user +/// - addr_arg_cageid: the cage ID where the address belongs to +/// - cageid: the current running cage's ID (used for checking context) +/// +/// Output: +/// - Returns a mutable pointer to host memory corresponding to the given address +/// from the guest. The pointer can be used for direct read/write operations. +pub fn sc_convert_addr_to_host(addr_arg: u64, addr_arg_cageid: u64, cageid: u64) -> *mut u8 { + let cage = get_cage(addr_arg_cageid).unwrap(); + let addr = translate_vmmap_addr(&cage, addr_arg).unwrap() as *mut u8; + return addr; +} + +/// This function translates a buffer pointer from the WASM environment to a host pointer. +/// It is typically used when a syscall needs to read a buffer (e.g., in `read`, `write`, etc). +/// +/// Input: +/// - buf_arg: the raw address of the buffer in WASM space +/// - buf_arg_cageid: the cage ID of the buffer address +/// - cageid: current running cage ID +/// +/// Output: +/// - Returns a constant (read-only) host pointer to the translated buffer. +/// Suitable for syscalls that only read from the buffer. +pub fn sc_convert_buf_to_host(buf_arg: u64, buf_arg_cageid: u64, cageid: u64) -> *const u8 { + let cage = get_cage(buf_arg_cageid).unwrap(); + let addr = translate_vmmap_addr(&cage, buf_arg).unwrap() as *mut u8; + return addr; +} + + + +/// `sc_convert_sysarg_to_u32` is the type conversion function used to convert the +/// argument's type from u64 to u32. When in `secure` mode, extra checks will be +/// performed through `get_u32()` function. (for example validating if all upper-bit +/// are 0; if cage ids are in valid range). The security mode can be enabled through +/// compilation flag of this library. Those calls will panic when failed the check +/// for security concerns +/// +/// `get_u32()` +/// ## Arguments: +/// arg: the argument value +/// arg_cageid: the argument's cageid +/// cageid: source cageid (the cage execute this call) +/// +/// ## Returns: +/// Success: A converted u32 +/// Fail: panic +pub fn get_u32(arg: u64, arg_cageid: u64, cageid: u64) -> u32 { + if !validate_cageid(arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } + + if (arg & 0xFFFFFFFF_00000000) != 1 { + return (arg & 0xFFFFFFFF) as u32; + } + + panic!("Invalide argument"); +} + +pub fn sc_convert_sysarg_to_i32_ref<'a>(arg: u64, arg_cageid: u64, cageid: u64) -> &'a mut i32 { + #[cfg(feature = "secure")] + { + if !validate_cageid(arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } + } + + let cage = get_cage(arg_cageid).unwrap(); + let addr = translate_vmmap_addr(&cage, arg).unwrap(); + return unsafe { &mut *((addr) as *mut i32) }; +} + +/// ## Arguments: +/// arg: the argument value +/// arg_cageid: the argument's cageid +/// cageid: source cageid (the cage execute this call) +/// +/// ## Returns: +/// Success: A converted u32 +/// Fail: panic +pub fn sc_convert_sysarg_to_u32(arg: u64, arg_cageid: u64, cageid: u64) -> u32 { + #[cfg(feature = "fast")] + return arg as u32; + + #[cfg(feature = "secure")] + return get_u32(arg); +} + +/// `sc_convert_sysarg_to_isize` is the type conversion function used to convert the +/// argument's type from u64 to isize. When in `secure` mode, extra checks will be +/// performed through `validate_cageid()` function (whether cage ids are in valid +/// range). The security mode can be enabled through compilation flag of this library. +/// Those calls will panic when failed the check for security concerns +/// +/// ## Arguments: +/// arg: argument value +/// arg_cageid: argument's cageid +/// cageid: source cageid (the cage executes the call) +/// +/// ## Returns: +/// Success: A converted isize +/// Fail: panic +pub fn sc_convert_sysarg_to_isize(arg: u64, arg_cageid: u64, cageid: u64) -> isize { + #[cfg(feature = "fast")] + return arg as isize; + + #[cfg(feature = "secure")] + if !validate_cageid(arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } +} + +/// `sc_convert_sysarg_to_usize` is the type conversion function used to convert the +/// argument's type from u64 to usize. When in `secure` mode, extra checks will be +/// performed through `validate_cageid()` function (whether cage ids are in valid +/// range). The security mode can be enabled through compilation flag of this library. +/// Those calls will panic when failed the check for security concerns +/// +/// ## Arguments: +/// arg: argument value +/// arg_cageid: argument's cageid +/// cageid: source cageid (the cage executes the call) +/// +/// ## Returns: +/// Success: A converted usize +/// Fail: panic +pub fn sc_convert_sysarg_to_usize(arg: u64, arg_cageid: u64, cageid: u64) -> usize { + #[cfg(feature = "fast")] + return arg as usize; + + #[cfg(feature = "secure")] + if !validate_cageid(arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } +} + +/// `sc_convert_sysarg_to_i64` is the type conversion function used to convert the +/// argument's type from u64 to i64. When in `secure` mode, extra checks will be +/// performed through `validate_cageid()` function (whether cage ids are in valid +/// range). The security mode can be enabled through compilation flag of this library. +/// Those calls will panic when failed the check for security concerns +/// +/// ## Arguments: +/// arg: argument value +/// arg_cageid: argument's cageid +/// cageid: source cageid (the cage executes the call) +/// +/// ## Returns: +/// Success: A converted i64 +/// Fail: panic +pub fn sc_convert_sysarg_to_i64(arg: u64, arg_cageid: u64, cageid: u64) -> i64 { + #[cfg(feature = "fast")] + return arg as i64; + + #[cfg(feature = "secure")] + if !validate_cageid(arg_cageid, cageid) { + panic!("Invalide Cage ID"); + } +} + +/// `sc_unusedarg()` is the security check function used to validate all unused args. This +/// will return true in default mode, and check if `arg` with `arg_cageid` are all null in +/// `secure` mode. +/// +/// ## Arguments: +/// arg: argument value +/// arg_cageid: argument's cageid +/// +/// ## Returns: +/// Always true in default mode. +/// In secure mode: +/// Return true if all null, false otherwise. +pub fn sc_unusedarg(arg: u64, arg_cageid: u64) -> bool { + #[cfg(feature = "fast")] + return true; + + #[cfg(feature = "secure")] + return !(arg | arg_cageid); +} + +/// This function translates the buffer pointer from user buffer address to system address, because we are +/// transferring between 32-bit WASM environment to 64-bit kernel +/// +/// ## Arguments: +/// - cageid: required to do address translation for buf pointer +/// - buf_arg: the buf pointer address, which is 32-bit because of WASM feature +/// +/// ## Returns: +/// - buf: actual system address, which is the actual position that stores data +pub fn sc_convert_buf(buf_arg: u64, arg_cageid: u64, cageid: u64) -> *const u8 { + // Get cage reference to translate address + let cage = get_cage(arg_cageid).unwrap(); + // Convert user buffer address to system address. We don't need to check permission here. + // Permission check has been handled in 3i + let buf = translate_vmmap_addr(&cage, buf_arg).unwrap() as *const u8; + buf +} + +/// Convert a user-provided pointer (u64) from a cage into a shared reference to +/// a `SigactionStruct`. +/// +/// # Arguments +/// * `act_arg` - The raw user pointer (u64). If `0`, this means "no struct". +/// * `act_arg_cageid` - The cage ID in which the pointer resides. +/// * `cageid` - The caller’s cage ID (can be used for cross-cage checks). +/// +/// # Returns +/// * `Some(&SigactionStruct)` if the pointer is nonzero and translation succeeds. +/// * `None` if `act_arg == 0`. +pub fn sc_convert_SigactionStruct<'a>( + act_arg: u64, + act_arg_cageid: u64, + _cageid: u64, +) -> Option<&'a SigactionStruct> { + #[cfg(feature = "secure")] + { + if !validate_cageid(act_arg_cageid, _cageid) { + return None; + } + } + // If we don't have act arg, return None + if act_arg == 0 { + return None; + } + + // Get cage reference to translate address + let cage = match get_cage(act_arg_cageid) { + Some(c) => c, + None => return None, + }; + + // Convert user buffer address to system address. We don't need to check permission here. + let addr = match translate_vmmap_addr(&cage, act_arg) { + Some(a) => a, + None => return None, + }; + + let ptr = addr as *const SigactionStruct; + unsafe { Some(&*ptr) } +} + +/// Convert a user-provided pointer (u64) from a cage into a mutable reference to +/// a `SigactionStruct`. +/// +/// # Arguments +/// * `act_arg` - The raw user pointer (u64). If `0`, this means "no struct". +/// * `act_arg_cageid` - The cage ID in which the pointer resides. +/// * `cageid` - The caller’s cage ID (can be used for cross-cage checks). +/// +/// # Returns +/// * `Some(&mut SigactionStruct)` if the pointer is nonzero and translation succeeds. +/// * `None` if `act_arg == 0`. +pub fn sc_convert_SigactionStruct_mut<'a>( + act_arg: u64, + act_arg_cageid: u64, + _cageid: u64, +) -> Option<&'a mut SigactionStruct> { + #[cfg(feature = "secure")] + { + if !validate_cageid(act_arg_cageid, _cageid) { + return None; + } + } + // If we don't have act arg, return None + if act_arg == 0 { + return None; + } + // Get cage reference to translate address + let cage = match get_cage(act_arg_cageid) { + Some(c) => c, + None => return None, + }; + // Convert user buffer address to system address. We don't need to check permission here. + let addr = match translate_vmmap_addr(&cage, act_arg) { + Some(a) => a, + None => return None, + }; + + let ptr = addr as *mut SigactionStruct; + unsafe { Some(&mut *ptr) } +} + +/// Convert a user-provided pointer (u64) from a cage into a mutable reference to +/// a `SigsetType`. +/// +/// # Arguments +/// * `set_arg` - The raw user pointer (u64). If `0`, this means "no struct". +/// * `set_arg_cageid` - The cage ID in which the pointer resides. +/// * `cageid` - The caller’s cage ID (can be used for cross-cage checks). +/// +/// # Returns +/// * `Some(&mut SigsetType)` if the pointer is nonzero and translation succeeds. +/// * `None` if `set_arg == 0`. +pub fn sc_convert_sigset(set_arg: u64, set_cageid: u64, cageid: u64) -> Option<&'static mut SigsetType> { + #[cfg(feature = "secure")] + { + if !validate_cageid(set_cageid, cageid) { + panic!("Invalide Cage ID"); + } + } + + if set_arg == 0 { + return None; // If the argument is 0, return None + } else { + let cage = get_cage(set_cageid).unwrap(); + match translate_vmmap_addr(&cage, set_arg) { + Ok(addr) => match get_constsigset(addr) { + Ok(val) => return val, + Err(_) => panic!("Failed to get SigsetType from address"), + } + Err(_) => panic!("Failed to get SigsetType from address"), // If translation fails, return None + } + } +} + +/// Convert a raw u64 address into a mutable reference to an `ITimerVal`. +/// +/// # Arguments +/// * `addr` – Raw address pointing to an `ITimerVal` structure. +/// +/// # Returns +/// * `Ok(Some(&mut ITimerVal))` if `addr` is non-null and successfully converted. +/// * `Err(-1)` if `addr` is null. +pub fn get_itimerval<'a>(addr: u64) -> Result, i32> { + let ptr = addr as *mut ITimerVal; + if !ptr.is_null() { + unsafe { + return Ok(&*ptr); + } + } + Err(-1) +} + +/// Convert a raw u64 address into an immutable reference to an `ITimerVal`. +/// +/// # Arguments +/// * `addr` – Raw address pointing to an `ITimerVal` structure. +/// +/// # Returns +/// * `Ok(Some(&ITimerVal))` if `addr` is non-null and successfully converted. +/// * `Err(-1)` if `addr` is null. +pub fn get_constitimerval<'a>(addr: u64) -> Result, i32> { + let ptr = addr as *const ITimerVal; + if !ptr.is_null() { + unsafe { + return Ok(&*ptr); + } + } + Err(-1) +} + +/// Translate a user-provided argument into an immutable reference to an `ITimerVal`. +/// +/// This is a higher-level wrapper that first resolves the cage memory mapping, +/// then converts the address into a reference using [`get_constitimerval`]. +/// +/// # Arguments +/// * `val_arg` – User-provided raw pointer (u64). +/// * `val_arg_cageid` – The cage ID in which `val_arg` resides. +/// * `cageid` – The calling cage ID (used for optional validation). +/// +/// # Returns +/// * `Some(&ITimerVal)` if `val_arg` is nonzero and translation succeeds. +/// * `None` if `val_arg == 0`. +/// +/// # Panics +/// * If cage lookup or address translation fails. +/// * If conversion to `ITimerVal` fails. +pub fn sc_convert_itimerval( + val_arg: u64, + val_arg_cageid: u64, + cageid: u64, +) -> Option<&ITimerVal> { + #[cfg(feature = "secure")] + { + if !validate_cageid(set_cageid, cageid) { + panic!("Invalide Cage ID"); + } + } + + let cage = get_cage(set_cageid).unwrap(); + + if val_arg == 0 { + None + } else { + match translate_vmmap_addr(&cage, val_arg) { + Ok(addr) => match get_constitimerval(addr) { + Ok(itimeval) => itimeval, + Err(_) => panic!("Failed to get ITimerVal from address"), + }, + Err(_) => panic!("Failed to get ITimerVal from address"), + } + } +} + +/// Translate a user-provided argument into a mutable reference to an `ITimerVal`. +/// +/// This is a higher-level wrapper that first resolves the cage memory mapping, +/// then converts the address into a mutable reference using [`get_itimerval`]. +/// +/// # Arguments +/// * `val_arg` – User-provided raw pointer (u64). +/// * `val_arg_cageid` – The cage ID in which `val_arg` resides. +/// * `cageid` – The calling cage ID (used for optional validation). +/// +/// # Returns +/// * `Some(&mut ITimerVal)` if `val_arg` is nonzero and translation succeeds. +/// * `None` if `val_arg == 0`. +/// +/// # Panics +/// * If cage lookup or address translation fails. +/// * If conversion to `ITimerVal` fails. +pub fn sc_convert_itimerval_mut( + val_arg: u64, + val_arg_cageid: u64, + cageid: u64, +) -> Option<&mut ITimerVal>{ + #[cfg(feature = "secure")] + { + if !validate_cageid(set_cageid, cageid) { + panic!("Invalide Cage ID"); + } + } + + let cage = get_cage(set_cageid).unwrap(); + + if val_arg == 0 { + None + } else { + match translate_vmmap_addr(&cage, val_arg) { + Ok(addr) => match get_itimerval(addr) { + Ok(itimeval) => itimeval, + Err(_) => panic!("Failed to get ITimerVal from address"), + }, + Err(_) => panic!("Failed to get ITimerVal from address"), + } + } +} diff --git a/src/wasmtime/Cargo.toml b/src/wasmtime/Cargo.toml index 553ac54f2..865adb135 100644 --- a/src/wasmtime/Cargo.toml +++ b/src/wasmtime/Cargo.toml @@ -64,6 +64,7 @@ threei = { workspace = true } cage = { workspace = true, optional = false, features = ["disable_signals"] } fdtables = { workspace = true } sysdefs = { workspace = true } +cage = { workspace = true } clap = { workspace = true } anyhow = { workspace = true, features = ['std'] } target-lexicon = { workspace = true } @@ -77,6 +78,7 @@ wasmparser = { workspace = true } tracing = { workspace = true } log = { workspace = true } humantime = { workspace = true } +parking_lot = { workspace = true } async-trait = { workspace = true } bytes = { workspace = true } @@ -347,6 +349,7 @@ criterion = { version = "0.5.0", default-features = false, features = ["html_rep rustc-hash = "1.1.0" libtest-mimic = "0.7.0" semver = { version = "1.0.17", default-features = false } +parking_lot = "0.12" # ============================================================================= # diff --git a/src/wasmtime/crates/lind-common/src/lib.rs b/src/wasmtime/crates/lind-common/src/lib.rs index ecb108272..7470338ea 100644 --- a/src/wasmtime/crates/lind-common/src/lib.rs +++ b/src/wasmtime/crates/lind-common/src/lib.rs @@ -102,7 +102,24 @@ impl LindCommonCtx { self.pid as u64, ) } + }; + let call_name_ptr = (call_name + start_address) as *const u8; + let mut len = 0; + + unsafe { + while *call_name_ptr.add(len) != 0 { + len += 1; + } + + let slice = std::slice::from_raw_parts(call_name_ptr, len); + let call_name_str = std::str::from_utf8_unchecked(slice); + + println!( + "pid={} call_number={} \x1b[32mcall_name=\"{}\"\x1b[0m \x1b[31mret={}\x1b[0m", + self.pid, call_number, call_name_str, ret + ); } + ret } // setjmp call. This function needs to be handled within wasmtime, but it is not an actual syscall so we use a different routine from lind_syscall diff --git a/src/wasmtime/crates/lind-multi-process/src/lib.rs b/src/wasmtime/crates/lind-multi-process/src/lib.rs index c5ff60417..d135fc2b5 100644 --- a/src/wasmtime/crates/lind-multi-process/src/lib.rs +++ b/src/wasmtime/crates/lind-multi-process/src/lib.rs @@ -1029,6 +1029,8 @@ impl< // for exec, we do not need to do rewind after unwinding is done store.set_asyncify_state(AsyncifyState::Normal); + let syscall_name: &'static str = "exec_syscall"; + let syscall_name_ptr = syscall_name.as_ptr() as u64; // to-do: exec should not change the process id/cage id, however, the exec call from rustposix takes an // argument to change the process id. If we pass the same cageid, it would cause some error // This is a direct underlying RawPOSIX call, so the `name` field will not be used. diff --git a/src/wasmtime/crates/lind-multi-process/src/signal.rs b/src/wasmtime/crates/lind-multi-process/src/signal.rs index b2e5eee3b..afb74577c 100644 --- a/src/wasmtime/crates/lind-multi-process/src/signal.rs +++ b/src/wasmtime/crates/lind-multi-process/src/signal.rs @@ -2,6 +2,7 @@ use sysdefs::constants::{SIG_DFL, SIG_IGN}; use wasmtime::{raise_trap, AsContext, AsContextMut, AsyncifyState, Caller, Trap}; use crate::LindHost; +use cage::signal::{thread_check_killed, lind_get_first_signal, lind_check_no_pending_signal, signal_epoch_reset, epoch_kill_all, lind_signal_init, lind_thread_exit}; // default signal handler actions enum SignalDefaultHandler { diff --git a/src/wasmtime/crates/rawposix b/src/wasmtime/crates/rawposix index a5ac4b4ee..e4642d9f1 120000 --- a/src/wasmtime/crates/rawposix +++ b/src/wasmtime/crates/rawposix @@ -1 +1 @@ -../../rawposix \ No newline at end of file +../../rawposix/ \ No newline at end of file diff --git a/src/wasmtime/crates/typemap b/src/wasmtime/crates/typemap index 69902a6e0..e26ef5a0c 120000 --- a/src/wasmtime/crates/typemap +++ b/src/wasmtime/crates/typemap @@ -1 +1 @@ -../../typemap \ No newline at end of file +../../typemap/ \ No newline at end of file diff --git a/src/wasmtime/crates/wasmtime/src/lib.rs b/src/wasmtime/crates/wasmtime/src/lib.rs index 962ef152e..8ebd0fa9f 100644 --- a/src/wasmtime/crates/wasmtime/src/lib.rs +++ b/src/wasmtime/crates/wasmtime/src/lib.rs @@ -355,9 +355,9 @@ impl MaybeUninitExt for core::mem::MaybeUninit { } #[cfg(feature = "runtime")] -mod runtime; +pub mod runtime; #[cfg(feature = "runtime")] -pub use runtime::*; +pub use runtime::*; #[cfg(any(feature = "cranelift", feature = "winch"))] mod compile; diff --git a/src/wasmtime/crates/wasmtime/src/runtime.rs b/src/wasmtime/crates/wasmtime/src/runtime.rs index f1347f4e6..23b3a17b3 100644 --- a/src/wasmtime/crates/wasmtime/src/runtime.rs +++ b/src/wasmtime/crates/wasmtime/src/runtime.rs @@ -21,7 +21,7 @@ pub(crate) mod types; pub(crate) mod uninhabited; pub(crate) mod v128; pub(crate) mod values; -pub(crate) mod vm; +pub mod vm; #[cfg(feature = "component-model")] pub mod component; diff --git a/src/wasmtime/crates/wasmtime/src/runtime/vm.rs b/src/wasmtime/crates/wasmtime/src/runtime/vm.rs index ff71a35a8..11a95084d 100644 --- a/src/wasmtime/crates/wasmtime/src/runtime/vm.rs +++ b/src/wasmtime/crates/wasmtime/src/runtime/vm.rs @@ -22,7 +22,7 @@ mod const_expr; mod export; mod gc; mod imports; -mod instance; +pub mod instance; mod memory; mod mmap; mod mmap_vec; diff --git a/tcc.log b/tcc.log new file mode 100644 index 000000000..594f0a199 --- /dev/null +++ b/tcc.log @@ -0,0 +1,1234 @@ +pid=1 call_number=228 call_name="syscall|clock_gettime" args=[1, 3f670, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=228 call_name="syscall|clock_gettime" ret=0 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[21000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=262144 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[1000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=397312 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3f57c, 3b, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +tcc version 0.9.28rc 2025-07-28 mob@de60286b* (i386 Linux) +pid=1 call_number=1 call_name="syscall|write" ret=59 +pid=1 call_number=2 call_name="syscall|open" args=[3f1c0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/lib/i386-linux-gnu/crt1.o"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3f0cc, 22, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/lib/i386-linux-gnu/crt1.o +pid=1 call_number=1 call_name="syscall|write" ret=34 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f138, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f16c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f0d8, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f10c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 2f8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=760 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40f90, 258, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=600 +pid=1 call_number=0 call_name="syscall|read" args=[3, 411e8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 274, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=628 +pid=1 call_number=0 call_name="syscall|read" args=[3, 412b0, 84, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=132 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41334, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 11c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=284 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41340, c0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=192 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41400, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 1dc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=476 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41410, 6e, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=110 +pid=1 call_number=0 call_name="syscall|read" args=[3, 4147e, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 34, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 409f0, 1c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=28 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40a0c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 50, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=80 +pid=1 call_number=0 call_name="syscall|read" args=[3, 415c0, 20, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=32 +pid=1 call_number=0 call_name="syscall|read" args=[3, 415e0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 70, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=112 +pid=1 call_number=0 call_name="syscall|read" args=[3, 415f0, 45, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=69 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41635, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 24c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=588 +pid=1 call_number=0 call_name="syscall|read" args=[3, 416e0, 18, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=24 +pid=1 call_number=0 call_name="syscall|read" args=[3, 416f8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, b5, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=181 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41770, 4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41774, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, bc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=188 +pid=1 call_number=0 call_name="syscall|read" args=[3, 417e0, 4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4 +pid=1 call_number=0 call_name="syscall|read" args=[3, 417e4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, c0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=192 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41808, 58, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=88 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41860, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 264, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=612 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40e80, 10, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=16 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40e90, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 118, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=280 +pid=1 call_number=0 call_name="syscall|read" args=[3, 418f0, 4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4 +pid=1 call_number=0 call_name="syscall|read" args=[3, 418f4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 11c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=284 +pid=1 call_number=0 call_name="syscall|read" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3f1c0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/lib/i386-linux-gnu/crti.o"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3f0cc, 22, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/lib/i386-linux-gnu/crti.o +pid=1 call_number=1 call_name="syscall|write" ret=34 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f138, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f16c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f0d8, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f10c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 1f0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=496 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40f90, 258, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=600 +pid=1 call_number=0 call_name="syscall|read" args=[3, 411e8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 168, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=360 +pid=1 call_number=0 call_name="syscall|read" args=[3, 412b0, 86, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=134 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41336, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 98, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=152 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41f00, 60, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=96 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41f60, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, f8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=248 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41b70, 48, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=72 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41bb8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 3c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=60 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41635, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 3c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=60 +pid=1 call_number=0 call_name="syscall|read" args=[3, 418f4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 3c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=60 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41f8c, 1c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=28 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41fa8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 58, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=88 +pid=1 call_number=0 call_name="syscall|read" args=[3, 409f0, 1f, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=31 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40a0f, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 140, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=320 +pid=1 call_number=0 call_name="syscall|read" args=[3, 419e0, 18, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=24 +pid=1 call_number=0 call_name="syscall|read" args=[3, 419f8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 80, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=128 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40ba0, 4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4 +pid=1 call_number=0 call_name="syscall|read" args=[3, 40ba4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 84, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=132 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41a60, 13, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=19 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41a73, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 158, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=344 +pid=1 call_number=0 call_name="syscall|read" args=[3, 407b0, 10, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=16 +pid=1 call_number=0 call_name="syscall|read" args=[3, 407c0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 97, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=151 +pid=1 call_number=0 call_name="syscall|read" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[406c1, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="hello.c"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3f52c, b, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> hello.c +pid=1 call_number=1 call_name="syscall|write" ret=11 +pid=1 call_number=9 call_name="syscall|mmap" args=[0, c1000, 3, 22, ffffffffffffffff, 0] +pid=1 call_number=9 call_name="syscall|mmap" ret=-794624 +pid=1 call_number=9 call_name="syscall|mmap" args=[0, c1000, 3, 22, ffffffffffffffff, 0] +pid=1 call_number=9 call_name="syscall|mmap" ret=-1589248 +pid=1 call_number=0 call_name="syscall|read" args=[3, 42694, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=84 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/stdio.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/stdio.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/stdio.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/stdio.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/stdio.h"] +pid=1 call_number=2 call_name="syscall|open" ret=4 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 18, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/stdio.h +pid=1 call_number=1 call_name="syscall|write" ret=24 +pid=1 call_number=0 call_name="syscall|read" args=[4, 4d334, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/libc-header-start.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/libc-header-start.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/libc-header-start.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/libc-header-start.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/libc-header-start.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 2a, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/libc-header-start.h +pid=1 call_number=1 call_name="syscall|write" ret=42 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4286 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1d, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/features.h +pid=1 call_number=1 call_name="syscall|write" ret=29 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/features-time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/features-time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/features-time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/features-time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/features-time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=7 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 25, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/features-time64.h +pid=1 call_number=1 call_name="syscall|write" ret=37 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1409 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=8 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 24, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/wordsize.h +pid=1 call_number=1 call_name="syscall|write" ret=36 +pid=1 call_number=0 call_name="syscall|read" args=[8, 56434, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=442 +pid=1 call_number=0 call_name="syscall|read" args=[8, 56434, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=8 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 24, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/timesize.h +pid=1 call_number=1 call_name="syscall|write" ret=36 +pid=1 call_number=0 call_name="syscall|read" args=[8, 56434, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1109 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=9 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 25, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/wordsize.h +pid=1 call_number=1 call_name="syscall|write" ret=37 +pid=1 call_number=0 call_name="syscall|read" args=[9, 58874, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=442 +pid=1 call_number=0 call_name="syscall|read" args=[9, 58874, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[9, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[8, 56434, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[7, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/stdc-predef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/stdc-predef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/stdc-predef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/stdc-predef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/stdc-predef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=7 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 21, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/stdc-predef.h +pid=1 call_number=1 call_name="syscall|write" ret=33 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=2462 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[7, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1476 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/sys/cdefs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/sys/cdefs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/sys/cdefs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/sys/cdefs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/sys/cdefs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=7 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1f, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/sys/cdefs.h +pid=1 call_number=1 call_name="syscall|write" ret=31 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=8 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 24, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/wordsize.h +pid=1 call_number=1 call_name="syscall|write" ret=36 +pid=1 call_number=0 call_name="syscall|read" args=[8, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=442 +pid=1 call_number=0 call_name="syscall|read" args=[8, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=8 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 27, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/long-double.h +pid=1 call_number=1 call_name="syscall|write" ret=39 +pid=1 call_number=0 call_name="syscall|read" args=[8, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=970 +pid=1 call_number=0 call_name="syscall|read" args=[8, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=2024 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[7, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/gnu/stubs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/gnu/stubs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/gnu/stubs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/gnu/stubs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/gnu/stubs.h"] +pid=1 call_number=2 call_name="syscall|open" ret=7 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1f, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/gnu/stubs.h +pid=1 call_number=1 call_name="syscall|write" ret=31 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=384 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/gnu/stubs-32.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/gnu/stubs-32.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/gnu/stubs-32.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/gnu/stubs-32.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/gnu/stubs-32.h"] +pid=1 call_number=2 call_name="syscall|open" ret=8 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 23, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/gnu/stubs-32.h +pid=1 call_number=1 call_name="syscall|write" ret=35 +pid=1 call_number=0 call_name="syscall|read" args=[8, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=449 +pid=1 call_number=0 call_name="syscall|read" args=[8, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[7, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/stddef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/stddef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/stddef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/stddef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/stddef.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1a, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/stddef.h +pid=1 call_number=1 call_name="syscall|write" ret=26 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1402 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1a, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/stdarg.h +pid=1 call_number=1 call_name="syscall|write" ret=26 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=2494 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1e, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types.h +pid=1 call_number=1 call_name="syscall|write" ret=30 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 22, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/wordsize.h +pid=1 call_number=1 call_name="syscall|write" ret=34 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=442 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/timesize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 22, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/timesize.h +pid=1 call_number=1 call_name="syscall|write" ret=34 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1109 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/wordsize.h"] +pid=1 call_number=2 call_name="syscall|open" ret=7 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 23, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/wordsize.h +pid=1 call_number=1 call_name="syscall|write" ret=35 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=442 +pid=1 call_number=0 call_name="syscall|read" args=[7, 53ff4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[7, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/typesizes.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/typesizes.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/typesizes.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/typesizes.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/typesizes.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 23, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/typesizes.h +pid=1 call_number=1 call_name="syscall|write" ret=35 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=3737 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/time64.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 20, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/time64.h +pid=1 call_number=1 call_name="syscall|write" ret=32 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1340 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=614 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/__fpos_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/__fpos_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/__fpos_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/__fpos_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types/__fpos_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 27, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types/__fpos_t.h +pid=1 call_number=1 call_name="syscall|write" ret=39 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=381 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 2b, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types/__mbstate_t.h +pid=1 call_number=1 call_name="syscall|write" ret=43 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=564 +pid=1 call_number=0 call_name="syscall|read" args=[6, 51bb4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/__fpos64_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/__fpos64_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/__fpos64_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/__fpos64_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types/__fpos64_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 29, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types/__fpos64_t.h +pid=1 call_number=1 call_name="syscall|write" ret=41 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=410 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/__mbstate_t.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/__FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/__FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/__FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/__FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types/__FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 25, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types/__FILE.h +pid=1 call_number=1 call_name="syscall|write" ret=37 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=110 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types/FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 23, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types/FILE.h +pid=1 call_number=1 call_name="syscall|write" ret=35 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=180 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types/struct_FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types/struct_FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types/struct_FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types/struct_FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/types/struct_FILE.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 2a, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/types/struct_FILE.h +pid=1 call_number=1 call_name="syscall|write" ret=42 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4104 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/types.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e840, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e840, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e840, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e840, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/stdarg.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/stdio_lim.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/stdio_lim.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/stdio_lim.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/stdio_lim.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/stdio_lim.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 22, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/stdio_lim.h +pid=1 call_number=1 call_name="syscall|write" ret=34 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1213 +pid=1 call_number=0 call_name="syscall|read" args=[5, 4f774, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[4, 4d334, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=5 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 1f, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/floatn.h +pid=1 call_number=1 call_name="syscall|write" ret=31 +pid=1 call_number=0 call_name="syscall|read" args=[5, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=4373 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/floatn-common.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/floatn-common.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/floatn-common.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/floatn-common.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/floatn-common.h"] +pid=1 call_number=2 call_name="syscall|open" ret=6 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 27, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/floatn-common.h +pid=1 call_number=1 call_name="syscall|write" ret=39 +pid=1 call_number=0 call_name="syscall|read" args=[6, 5a864, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/features.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/bits/long-double.h"] +pid=1 call_number=2 call_name="syscall|open" ret=7 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e71c, 26, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/include/bits/long-double.h +pid=1 call_number=1 call_name="syscall|write" ret=38 +pid=1 call_number=0 call_name="syscall|read" args=[7, 5cca4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=970 +pid=1 call_number=0 call_name="syscall|read" args=[7, 5cca4, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[7, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[6, 5a864, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1573 +pid=1 call_number=0 call_name="syscall|read" args=[6, 5a864, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[6, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[5, 58424, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[4, 4d334, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=8192 +pid=1 call_number=0 call_name="syscall|read" args=[4, 4d334, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=6600 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/include/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/i386-linux-gnu/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/include/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3e800, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/include/i386-linux-gnu/bits/floatn.h"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=0 call_name="syscall|read" args=[4, 4d334, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[3, 42694, 2000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=11 call_name="syscall|munmap" args=[fff3e000, c1000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=11 call_name="syscall|munmap" ret=0 +pid=1 call_number=11 call_name="syscall|munmap" args=[ffe7c000, c1000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=11 call_name="syscall|munmap" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3f0f0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/libc.so"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3f0f0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/lib/i386-linux-gnu/libc.so"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3f0f0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/lib/libc.so"] +pid=1 call_number=2 call_name="syscall|open" ret=-2 +pid=1 call_number=2 call_name="syscall|open" args=[3f0f0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/lib/i386-linux-gnu/libc.so"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3effc, 1f, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /lib/i386-linux-gnu/libc.so +pid=1 call_number=1 call_name="syscall|write" ret=31 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f068, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f09c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 2, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=291 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[3, 446c0, 124, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=291 +pid=1 call_number=0 call_name="syscall|read" args=[3, 447e3, 1, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3ebd0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/i686-linux-gnu/lib/libc.so.6"] +pid=1 call_number=2 call_name="syscall|open" ret=4 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3eabc, 25, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/i686-linux-gnu/lib/libc.so.6 +pid=1 call_number=1 call_name="syscall|write" ret=37 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eb28, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eb5c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eac8, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eafc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 22aa90, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=2271888 +pid=1 call_number=0 call_name="syscall|read" args=[4, 47cf0, 9d8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=2520 +pid=1 call_number=0 call_name="syscall|read" args=[4, 486c8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[21000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=401408 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 5554, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=21844 +pid=1 call_number=0 call_name="syscall|read" args=[4, 55f00, ce20, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52768 +pid=1 call_number=0 call_name="syscall|read" args=[4, 62d20, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 12374, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=74612 +pid=1 call_number=0 call_name="syscall|read" args=[4, 49560, 8968, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=35176 +pid=1 call_number=0 call_name="syscall|read" args=[4, 51ec8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 1acdc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=109788 +pid=1 call_number=0 call_name="syscall|read" args=[4, 538a0, 19c4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=6596 +pid=1 call_number=0 call_name="syscall|read" args=[4, 55264, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 1c6a0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=116384 +pid=1 call_number=0 call_name="syscall|read" args=[4, 55270, 684, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1668 +pid=1 call_number=0 call_name="syscall|read" args=[4, 558f4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 1cd24, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=118052 +pid=1 call_number=0 call_name="syscall|read" args=[4, 55cd0, 40, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=64 +pid=1 call_number=0 call_name="syscall|read" args=[4, 55d10, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 228dac, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=2264492 +pid=1 call_number=0 call_name="syscall|read" args=[4, 447f0, e8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=232 +pid=1 call_number=0 call_name="syscall|read" args=[4, 448d8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[2f000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=536576 +pid=1 call_number=3 call_name="syscall|close" args=[4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3ebd0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/i686-linux-gnu/lib/libc_nonshared.a"] +pid=1 call_number=2 call_name="syscall|open" ret=4 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3eabc, 2c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/i686-linux-gnu/lib/libc_nonshared.a +pid=1 call_number=1 call_name="syscall|write" ret=44 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eb28, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eb5c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=8 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eac0, 3c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=60 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3eafc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[4, 442f0, cc, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=204 +pid=1 call_number=0 call_name="syscall|read" args=[4, 443bc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3e790, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/i686-linux-gnu/lib/ld-linux.so.2"] +pid=1 call_number=2 call_name="syscall|open" ret=4 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3e67c, 29, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/i686-linux-gnu/lib/ld-linux.so.2 +pid=1 call_number=1 call_name="syscall|write" ret=41 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3e6e8, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3e71c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3e688, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[4, 3e6bc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 36a68, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=223848 +pid=1 call_number=0 call_name="syscall|read" args=[4, 45d80, 3e8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=1000 +pid=1 call_number=0 call_name="syscall|read" args=[4, 46168, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 460, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=1120 +pid=1 call_number=0 call_name="syscall|read" args=[4, 43760, 2a0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=672 +pid=1 call_number=0 call_name="syscall|read" args=[4, 43a00, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 700, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=1792 +pid=1 call_number=0 call_name="syscall|read" args=[4, 43d10, 2c3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=707 +pid=1 call_number=0 call_name="syscall|read" args=[4, 43fd3, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 9c4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=2500 +pid=1 call_number=0 call_name="syscall|read" args=[4, 48e90, 54, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=84 +pid=1 call_number=0 call_name="syscall|read" args=[4, 48ee4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, a18, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=2584 +pid=1 call_number=0 call_name="syscall|read" args=[4, 48d50, 110, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=272 +pid=1 call_number=0 call_name="syscall|read" args=[4, 48e60, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[4, 35f2c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=220972 +pid=1 call_number=0 call_name="syscall|read" args=[4, 436a0, b8, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=184 +pid=1 call_number=0 call_name="syscall|read" args=[4, 43758, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[4, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3f090, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/local/lib/tcc/libtcc1.a"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3ef9c, 20, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/local/lib/tcc/libtcc1.a +pid=1 call_number=1 call_name="syscall|write" ret=32 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f008, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f03c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=8 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3efa0, 3c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=60 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3efdc, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[3, 446c0, 12c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=300 +pid=1 call_number=0 call_name="syscall|read" args=[3, 447ec, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[3f0f0, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="/usr/lib/i386-linux-gnu/crtn.o"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3effc, 22, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +-> /usr/lib/i386-linux-gnu/crtn.o +pid=1 call_number=1 call_name="syscall|write" ret=34 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f068, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f09c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=0 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f008, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 3f03c, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, a8, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=168 +pid=1 call_number=0 call_name="syscall|read" args=[3, 464c0, 168, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=360 +pid=1 call_number=0 call_name="syscall|read" args=[3, 46628, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 5a, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=90 +pid=1 call_number=0 call_name="syscall|read" args=[3, 45810, 4b, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=75 +pid=1 call_number=0 call_name="syscall|read" args=[3, 4585b, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 34, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41653, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 34, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 418f4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 34, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=52 +pid=1 call_number=0 call_name="syscall|read" args=[3, 48098, 1c, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=28 +pid=1 call_number=0 call_name="syscall|read" args=[3, 480b4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 50, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=80 +pid=1 call_number=0 call_name="syscall|read" args=[3, 4589f, 5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=5 +pid=1 call_number=0 call_name="syscall|read" args=[3, 458a4, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 55, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=85 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41a73, 5, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=5 +pid=1 call_number=0 call_name="syscall|read" args=[3, 41a78, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=8 call_name="syscall|lseek" args=[3, 5a, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=8 call_name="syscall|lseek" ret=90 +pid=1 call_number=0 call_name="syscall|read" args=[3, 0, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=0 call_name="syscall|read" ret=0 +pid=1 call_number=3 call_name="syscall|close" args=[3, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=3 call_name="syscall|close" ret=0 +pid=1 call_number=87 call_name="syscall|unlink" args=[406e0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=87 call_name="syscall|unlink" ret=0 +pid=1 call_number=2 call_name="syscall|open" args=[406e0, 241, 1ff, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] [arg1_str="hello"] +pid=1 call_number=2 call_name="syscall|open" ret=3 +pid=1 call_number=72 call_name="syscall|fcntl" args=[3, 3, 0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=72 call_name="syscall|fcntl" ret=32769 +pid=1 call_number=1 call_name="syscall|write" args=[1, 3f45c, 9, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +<- hello +pid=1 call_number=1 call_name="syscall|write" ret=9 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f490, 34, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=52 +pid=1 call_number=1 call_name="syscall|write" args=[3, 491a0, 140, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=320 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 3f468, 28, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=40 +pid=1 call_number=1 call_name="syscall|write" args=[3, 44b50, 13, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=19 +pid=1 call_number=1 call_name="syscall|write" args=[3, 49560, 589, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1 call_name="syscall|write" ret=1417 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=729088 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[fffffffffffdd000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=729088 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=585728 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=585728 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[fffffffffffe7000, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=585728 +pid=1 call_number=1004 call_name="syscall|sbrk" args=[0, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef, deadbeefdeadbeef] +pid=1 call_number=1004 call_name="syscall|sbrk" ret=483328 diff --git a/tests/sfi-tests/close.c b/tests/sfi-tests/close.c new file mode 100644 index 000000000..503e243b7 --- /dev/null +++ b/tests/sfi-tests/close.c @@ -0,0 +1,31 @@ +#include +#include +#include +#include +#include + +#define LOOP_COUNT 1000000 + +long long gettimens() { + struct timespec tp; + clock_gettime(CLOCK_MONOTONIC, &tp); + return (long long)tp.tv_sec * 1000000000LL + tp.tv_nsec; +} + +int main(int argc, char *argv[]) { + int fd = -3; + long long start_time = gettimens(); + + for(int i = 0; i < LOOP_COUNT; i++) { + close(fd); + } + + // Get sum of time + long long end_time = gettimens(); + long long total_time = end_time - start_time; + // Average + long long average_time = total_time / LOOP_COUNT; + printf("%d close() calls, average time %lld ns\n", LOOP_COUNT, average_time); + fflush(NULL); + +} diff --git a/tests/sfi-tests/sfi-penalty.c b/tests/sfi-tests/sfi-penalty.c new file mode 100644 index 000000000..0e386c658 --- /dev/null +++ b/tests/sfi-tests/sfi-penalty.c @@ -0,0 +1,43 @@ +#include +#include +#include +#include +#include + +#define LOOP_COUNT 1000000 + +long long gettimens() { + struct timespec tp; + clock_gettime(CLOCK_MONOTONIC, &tp); + return (long long)tp.tv_sec * 1000000000LL + tp.tv_nsec; +} + +unsigned long long fibonacci(int n) { + if (n <= 1) return n; + volatile unsigned long long a = 0, b = 1, c; + for (int i = 2; i <= n; i++) { + c = a + b; + a = b; + b = c; + } + return b; +} + +int main() { + unsigned long long sum = 0; + + long long start_time = gettimens(); + + for (int i = 0; i < LOOP_COUNT; i++) { + sum += fibonacci(1000); + } + + long long end_time = gettimens(); + long long total_time = (end_time - start_time) / 1000000; + fprintf(stderr, "start: %lld\n", start_time); + fprintf(stderr, "end: %lld\n", end_time); + fprintf(stderr, "total: %lld\n", total_time); + fflush(stderr); + + return 0; +} \ No newline at end of file