@deroll/cmio 0.1.0

package/deps/machine-guest-tools/sys-utils/libcmt/src/io-mock.c

@@ -0,0 +1,319 @@
+/* Copyright Cartesi and individual authors (see AUTHORS)
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "libcmt/io.h"
+#include "libcmt/util.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/** track the number of open "devices". Mimic the kernel driver behavior by limiting it to 1 */
+static int open_count = 0;
+
+int cmt_io_init(cmt_io_driver_t *_me) {
+    if (!_me) {
+        return -EINVAL;
+    }
+    if (open_count) {
+        return -EBUSY;
+    }
+
+    open_count++;
+    cmt_io_driver_mock_t *me = &_me->mock;
+
+    size_t tx_length = 2U << 20; // 2MB
+    size_t rx_length = 2U << 20; // 2MB
+    cmt_buf_init(me->tx, tx_length, malloc(tx_length));
+    cmt_buf_init(me->rx, rx_length, malloc(rx_length));
+
+    if (!me->tx->begin || !me->rx->begin) {
+        free(me->tx->begin);
+        free(me->rx->begin);
+        return -ENOMEM;
+    }
+
+    char *inputs = getenv("CMT_INPUTS");
+    if (inputs) {
+        cmt_buf_init(&me->inputs_left, strlen(inputs), inputs);
+    } else {
+        cmt_buf_init(&me->inputs_left, 0, "");
+    }
+
+    // in case the user writes something before loading any input
+    strcpy(me->input_filename, "none");
+    strcpy(me->input_fileext, ".bin");
+
+    me->input_seq = 0;
+    me->output_seq = 0;
+    me->report_seq = 0;
+    me->exception_seq = 0;
+    me->gio_seq = 0;
+
+    return 0;
+}
+
+void cmt_io_fini(cmt_io_driver_t *_me) {
+    if (!_me) {
+        return;
+    }
+
+    if (open_count == 0) {
+        return;
+    }
+
+    open_count--;
+    cmt_io_driver_mock_t *me = &_me->mock;
+
+    free(me->tx->begin);
+    free(me->rx->begin);
+
+    memset(_me, 0, sizeof(*_me));
+}
+
+cmt_buf_t cmt_io_get_tx(cmt_io_driver_t *me) {
+    cmt_buf_t empty = {NULL, NULL};
+    if (!me) {
+        return empty;
+    }
+    return *me->mock.tx;
+}
+
+cmt_buf_t cmt_io_get_rx(cmt_io_driver_t *me) {
+    cmt_buf_t empty = {NULL, NULL};
+    if (!me) {
+        return empty;
+    }
+    return *me->mock.rx;
+}
+
+static int load_next_input(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    cmt_buf_t current_input;
+    char filepath[128] = {0};
+    if (!cmt_buf_split_by_comma(&current_input, &me->inputs_left)) {
+        return -EINVAL;
+    }
+    // NOLINTNEXTLINE(cert-err34-c,clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling)
+    if (sscanf((char *) current_input.begin, "%d:%127[^,]", &me->input_type, filepath) != 2) {
+        return -EINVAL;
+    }
+
+    size_t file_length = 0;
+    int rc = cmt_util_read_whole_file(filepath, cmt_buf_length(me->rx), me->rx->begin, &file_length);
+    if (rc) {
+        if (cmt_util_debug_enabled()) {
+            (void) fprintf(stderr, "failed to load \"%s\". %s\n", filepath, strerror(-rc));
+        }
+        return rc;
+    }
+    // NOLINTNEXTLINE(clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling)
+    if (sscanf(filepath, " %127[^.]%15s", me->input_filename, me->input_fileext) != 2) {
+        if (cmt_util_debug_enabled()) {
+            (void) fprintf(stderr, "failed to parse filename: \"%s\"\n", filepath);
+        }
+        return -EINVAL;
+    }
+    rr->reason = me->input_type;
+    rr->data = file_length;
+
+    me->output_seq = 0;
+    me->report_seq = 0;
+    me->exception_seq = 0;
+
+    if (cmt_util_debug_enabled()) {
+        (void) fprintf(stderr, "processing filename: \"%s\" (%lu), type: %d\n", filepath, file_length, me->input_type);
+    }
+    return 0;
+}
+
+static int store_output(cmt_io_driver_mock_t *me, const char *filepath, struct cmt_io_yield *rr) {
+    if (rr->data > cmt_buf_length(me->rx)) {
+        return -ENOBUFS;
+    }
+
+    int rc = cmt_util_write_whole_file(filepath, rr->data, me->tx->begin);
+    if (rc) {
+        (void) fprintf(stderr, "failed to store \"%s\". %s\n", filepath, strerror(-rc));
+        return rc;
+    }
+    if (cmt_util_debug_enabled()) {
+        (void) fprintf(stderr, "wrote filename: \"%s\" (%u)\n", filepath, rr->data);
+    }
+    return 0;
+}
+
+static int store_next_output(cmt_io_driver_mock_t *me, char *ns, int *seq, struct cmt_io_yield *rr) {
+    char filepath[128 + 32 + 8 + 16];
+    // NOLINTNEXTLINE(cert-err33-c, clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling)
+    snprintf(filepath, sizeof filepath, "%s.%s%d%s", me->input_filename, ns, (*seq)++, me->input_fileext);
+    return store_output(me, filepath, rr);
+}
+
+static int mock_progress(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    (void) me;
+    if (rr->cmd != HTIF_YIELD_CMD_AUTOMATIC) {
+        (void) fprintf(stderr, "Expected cmd to be AUTOMATIC\n");
+        return -EINVAL;
+    }
+    (void) fprintf(stderr, "Progress: %6.2f\n", (double) rr->data / 10);
+    return 0;
+}
+
+static int mock_rx_accepted(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    if (rr->cmd != HTIF_YIELD_CMD_MANUAL) {
+        (void) fprintf(stderr, "Expected cmd to be MANUAL\n");
+        return -EINVAL;
+    }
+    if (me->input_seq++) { // skip the first
+        char filepath[128 + 32 + 8 + 16];
+        // NOLINTNEXTLINE(cert-err33-c, clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling)
+        snprintf(filepath, sizeof filepath, "%s.outputs_root_hash%s", me->input_filename, me->input_fileext);
+        int rc = store_output(me, filepath, rr);
+        if (rc) {
+            return rc;
+        }
+    }
+    if (load_next_input(me, rr)) {
+        return -ENODATA;
+    }
+    return 0;
+}
+
+static int mock_rx_rejected(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    if (rr->cmd != HTIF_YIELD_CMD_MANUAL) {
+        (void) fprintf(stderr, "Expected cmd to be MANUAL\n");
+        return -EINVAL;
+    }
+    (void) fprintf(stderr, "%s:%d no revert for the mock implementation\n", __FILE__, __LINE__);
+    if (load_next_input(me, rr)) {
+        return -ENOSYS;
+    }
+    return 0;
+}
+
+static int mock_tx_output(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    if (rr->cmd != HTIF_YIELD_CMD_AUTOMATIC) {
+        (void) fprintf(stderr, "Expected cmd to be AUTOMATIC\n");
+        return -EINVAL;
+    }
+    return store_next_output(me, "output-", &me->output_seq, rr);
+}
+
+static int mock_tx_report(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    if (rr->cmd != HTIF_YIELD_CMD_AUTOMATIC) {
+        (void) fprintf(stderr, "Expected cmd to be AUTOMATIC\n");
+        return -EINVAL;
+    }
+    return store_next_output(me, "report-", &me->report_seq, rr);
+}
+
+static int mock_tx_exception(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    if (rr->cmd != HTIF_YIELD_CMD_MANUAL) {
+        (void) fprintf(stderr, "Expected cmd to be MANUAL\n");
+        return -EINVAL;
+    }
+    return store_next_output(me, "exception-", &me->exception_seq, rr);
+}
+
+static int mock_tx_gio(cmt_io_driver_mock_t *me, struct cmt_io_yield *rr) {
+    int rc = 0;
+    if (rr->cmd != HTIF_YIELD_CMD_MANUAL) {
+        (void) fprintf(stderr, "Expected cmd to be MANUAL\n");
+        return -EINVAL;
+    }
+
+    rc = store_next_output(me, "gio-", &me->gio_seq, rr);
+    if (rc) {
+        return rc;
+    }
+
+    rc = load_next_input(me, rr);
+    if (rc) {
+        return rc;
+    }
+    return 0;
+}
+
+/* These behaviours are defined by the cartesi-machine emulator */
+static int cmt_io_yield_inner(cmt_io_driver_t *_me, struct cmt_io_yield *rr) {
+    cmt_io_driver_mock_t *me = &_me->mock;
+
+    if (rr->cmd == HTIF_YIELD_CMD_MANUAL) {
+        switch (rr->reason) {
+            case HTIF_YIELD_MANUAL_REASON_RX_ACCEPTED:
+                return mock_rx_accepted(me, rr);
+            case HTIF_YIELD_MANUAL_REASON_RX_REJECTED:
+                return mock_rx_rejected(me, rr);
+            case HTIF_YIELD_MANUAL_REASON_TX_EXCEPTION:
+                return mock_tx_exception(me, rr);
+            default:
+                return mock_tx_gio(me, rr);
+        }
+    } else if (rr->cmd == HTIF_YIELD_CMD_AUTOMATIC) {
+        switch (rr->reason) {
+            case HTIF_YIELD_AUTOMATIC_REASON_PROGRESS:
+                return mock_progress(me, rr);
+            case HTIF_YIELD_AUTOMATIC_REASON_TX_OUTPUT:
+                return mock_tx_output(me, rr);
+            case HTIF_YIELD_AUTOMATIC_REASON_TX_REPORT:
+                return mock_tx_report(me, rr);
+            default:
+                return -EINVAL;
+        }
+    } else {
+        return -EINVAL;
+    }
+
+    return 0;
+}
+
+/* emulate io.c:cmt_io_yield behavior (go and check it does if you change it) */
+int cmt_io_yield(cmt_io_driver_t *_me, struct cmt_io_yield *rr) {
+    if (!_me) {
+        return -EINVAL;
+    }
+    if (!rr) {
+        return -EINVAL;
+    }
+
+    bool debug = cmt_util_debug_enabled();
+    if (debug) {
+        (void) fprintf(stderr,
+            "tohost {\n"
+            "\t.dev = %d,\n"
+            "\t.cmd = %d,\n"
+            "\t.reason = %d,\n"
+            "\t.data = %d,\n"
+            "};\n",
+            rr->dev, rr->cmd, rr->reason, rr->data);
+    }
+    int rc = cmt_io_yield_inner(_me, rr);
+    if (rc) {
+        return rc;
+    }
+
+    if (debug) {
+        (void) fprintf(stderr,
+            "fromhost {\n"
+            "\t.dev = %d,\n"
+            "\t.cmd = %d,\n"
+            "\t.reason = %d,\n"
+            "\t.data = %d,\n"
+            "};\n",
+            rr->dev, rr->cmd, rr->reason, rr->data);
+    }
+    return rc;
+}

package/deps/machine-guest-tools/sys-utils/libcmt/src/io.c

@@ -0,0 +1,164 @@
+/* Copyright Cartesi and individual authors (see AUTHORS)
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "libcmt/io.h"
+#include "libcmt/util.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <linux/cartesi/cmio.h>
+
+int cmt_io_init(cmt_io_driver_t *_me) {
+    int rc = 0;
+
+    if (!_me) {
+        return -EINVAL;
+    }
+    cmt_io_driver_ioctl_t *me = &_me->ioctl;
+    me->fd = open("/dev/cmio", O_RDWR);
+
+    if (me->fd < 0) {
+        rc = -errno;
+        return rc;
+    }
+
+    struct cmio_setup setup;
+    if (ioctl(me->fd, IOCTL_CMIO_SETUP, &setup)) {
+        rc = -errno;
+        goto do_close;
+    }
+
+    void *tx = mmap((void *) setup.tx.data, setup.tx.length, PROT_READ | PROT_WRITE, MAP_SHARED, me->fd, 0);
+    if (tx == MAP_FAILED) {
+        rc = -errno;
+        goto do_close;
+    }
+
+    void *rx = mmap((void *) setup.rx.data, setup.rx.length, PROT_READ, MAP_SHARED, me->fd, 0);
+    if (rx == MAP_FAILED) {
+        rc = -errno;
+        goto do_unmap;
+    }
+
+    cmt_buf_init(me->tx, setup.tx.length, tx);
+    cmt_buf_init(me->rx, setup.rx.length, rx);
+    return 0;
+
+do_unmap:
+    munmap(tx, setup.tx.length);
+do_close:
+    close(me->fd);
+    return rc;
+}
+
+void cmt_io_fini(cmt_io_driver_t *_me) {
+    if (!_me) {
+        return;
+    }
+    cmt_io_driver_ioctl_t *me = &_me->ioctl;
+
+    munmap(me->tx->begin, cmt_buf_length(me->tx));
+    munmap(me->rx->begin, cmt_buf_length(me->rx));
+    close(me->fd);
+
+    memset(me, 0, sizeof(*me));
+    me->fd = -1;
+}
+
+cmt_buf_t cmt_io_get_tx(cmt_io_driver_t *me) {
+    const cmt_buf_t empty = {NULL, NULL};
+    if (!me) {
+        return empty;
+    }
+    return *me->ioctl.tx;
+}
+
+cmt_buf_t cmt_io_get_rx(cmt_io_driver_t *me) {
+    const cmt_buf_t empty = {NULL, NULL};
+    if (!me) {
+        return empty;
+    }
+    return *me->ioctl.rx;
+}
+
+static uint64_t pack(struct cmt_io_yield *rr) {
+    // clang-format off
+    return ((uint64_t) rr->dev    << 56)
+    |      ((uint64_t) rr->cmd    << 56 >>  8)
+    |      ((uint64_t) rr->reason << 48 >> 16)
+    |      ((uint64_t) rr->data   << 32 >> 32);
+    // clang-format on
+}
+
+static struct cmt_io_yield unpack(uint64_t x) {
+    // clang-format off
+    struct cmt_io_yield out = {
+        x       >> 56,
+        x <<  8 >> 56,
+        x << 16 >> 48,
+        x << 32 >> 32,
+    };
+    // clang-format on
+    return out;
+}
+
+/* io-mock.c:cmt_io_yield emulates this behavior (go and check it does if you change it) */
+int cmt_io_yield(cmt_io_driver_t *_me, struct cmt_io_yield *rr) {
+    if (!_me) {
+        return -EINVAL;
+    }
+    if (!rr) {
+        return -EINVAL;
+    }
+    cmt_io_driver_ioctl_t *me = &_me->ioctl;
+
+    bool debug = cmt_util_debug_enabled();
+    if (debug) {
+        (void) fprintf(stderr,
+            "tohost {\n"
+            "\t.dev = %d,\n"
+            "\t.cmd = %d,\n"
+            "\t.reason = %d,\n"
+            "\t.data = %d,\n"
+            "};\n",
+            rr->dev, rr->cmd, rr->reason, rr->data);
+    }
+    uint64_t req = pack(rr);
+    if (ioctl(me->fd, IOCTL_CMIO_YIELD, &req)) {
+        return -errno;
+    }
+    *rr = unpack(req);
+
+    if (debug) {
+        (void) fprintf(stderr,
+            "fromhost {\n"
+            "\t.dev = %d,\n"
+            "\t.cmd = %d,\n"
+            "\t.reason = %d,\n"
+            "\t.data = %d,\n"
+            "};\n",
+            rr->dev, rr->cmd, rr->reason, rr->data);
+    }
+    return 0;
+}

package/deps/machine-guest-tools/sys-utils/libcmt/src/keccak.c

@@ -0,0 +1,156 @@
+/* Copyright Cartesi and individual authors (see AUTHORS)
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "libcmt/keccak.h"
+#include "libcmt/abi.h"
+
+#include <string.h>
+
+// Helper macros for stringification
+#define TO_STRING_HELPER(X) #X
+#define TO_STRING(X) TO_STRING_HELPER(X)
+
+// Define loop unrolling depending on the compiler
+#if defined(__clang__)
+#define UNROLL_LOOP(n) _Pragma(TO_STRING(unroll(n)))
+#elif defined(__GNUC__) && !defined(__clang__)
+#define UNROLL_LOOP(n) _Pragma(TO_STRING(GCC unroll(n)))
+#else
+#define UNROLL_LOOP(n)
+#endif
+
+#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
+
+/** Initialize a keccak state
+ * @note don't port. use @ref cmt_keccak_init */
+// clang-format off
+#define CMT_KECCAK_INIT(STATE)                                                                                         \
+    {                                                                                                                  \
+        .st.q = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },                        \
+        .pt = 0, .rsiz = 200 - 2 * CMT_KECCAK_LENGTH,                                                                  \
+    }
+
+// clang-format on
+
+static void keccakf(uint64_t st[25]) {
+    // clang-format off
+    const uint64_t keccakf_rndc[24] = {
+        0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000, 0x000000000000808b,
+        0x0000000080000001, 0x8000000080008081, 0x8000000000008009, 0x000000000000008a, 0x0000000000000088,
+        0x0000000080008009, 0x000000008000000a, 0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+        0x8000000000008003, 0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,
+        0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
+    };
+    const int keccakf_rotc[24] = { 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14,
+        27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44 };
+    const int keccakf_piln[24] = { 10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4,
+        15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1 };
+    // clang-format on
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+    for (int i = 0; i < 25; i++) {
+        st[i] = __builtin_bswap64((uint64_t *) (st[i]));
+    }
+#endif
+
+    for (int r = 0; r < 24; r++) {
+        uint64_t t = 0;
+        uint64_t bc[5];
+
+        // Theta
+        UNROLL_LOOP(5)
+        for (int i = 0; i < 5; i++) {
+            bc[i] = st[i] ^ st[i + 5] ^ st[i + 10] ^ st[i + 15] ^ st[i + 20];
+        }
+
+        UNROLL_LOOP(5)
+        for (int i = 0; i < 5; i++) {
+            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1);
+            for (int j = 0; j < 25; j += 5) {
+                st[j + i] ^= t;
+            }
+        }
+
+        // Rho Pi
+        t = st[1];
+        UNROLL_LOOP(24)
+        for (int i = 0; i < 24; i++) {
+            int j = keccakf_piln[i];
+            bc[0] = st[j];
+            st[j] = ROTL64(t, keccakf_rotc[i]);
+            t = bc[0];
+        }
+
+        //  Chi
+        UNROLL_LOOP(25)
+        for (int j = 0; j < 25; j += 5) {
+            for (int i = 0; i < 5; i++) {
+                bc[i] = st[j + i];
+            }
+            for (int i = 0; i < 5; i++) {
+                st[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5];
+            }
+        }
+
+        //  Iota
+        st[0] ^= keccakf_rndc[r];
+    }
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+    for (int i = 0; i < 25; i++) {
+        st[i] = __builtin_bswap64(st[i]);
+    }
+#endif
+}
+
+void cmt_keccak_init(cmt_keccak_t *state) {
+    *state = (cmt_keccak_t) CMT_KECCAK_INIT(state);
+}
+
+void cmt_keccak_update(cmt_keccak_t *state, size_t n, const void *data) {
+    int j = state->pt;
+    for (size_t i = 0; i < n; i++) {
+        state->st.b[j++] ^= ((const uint8_t *) data)[i];
+        if (j >= state->rsiz) {
+            keccakf(state->st.q);
+            j = 0;
+        }
+    }
+    state->pt = j;
+}
+
+void cmt_keccak_final(cmt_keccak_t *state, void *md) {
+    state->st.b[state->pt] ^= 0x01;
+    state->st.b[state->rsiz - 1] ^= 0x80;
+    keccakf(state->st.q);
+
+    for (int i = 0; i < CMT_KECCAK_LENGTH; i++) {
+        ((uint8_t *) md)[i] = state->st.b[i];
+    }
+}
+
+uint8_t *cmt_keccak_data(size_t length, const void *data, uint8_t md[CMT_KECCAK_LENGTH]) {
+    cmt_keccak_t c[1];
+    cmt_keccak_init(c);
+    cmt_keccak_update(c, length, data);
+    cmt_keccak_final(c, md);
+    return md;
+}
+
+uint32_t cmt_keccak_funsel(const char *decl) {
+    uint8_t md[32];
+    cmt_keccak_data(strlen(decl), decl, md);
+    return CMT_ABI_FUNSEL(md[0], md[1], md[2], md[3]);
+}