koffi 0.9.5 → 0.9.8

package/src/util.cc

@@ -12,6 +12,7 @@
 // along with this program. If not, see https://www.gnu.org/licenses/.
 
 #include "vendor/libcc/libcc.hh"
+#include "call.hh"
 #include "ffi.hh"
 #include "util.hh"
 
@@ -53,13 +54,30 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
 {
     bool match = false;
 
-    napi_type_tag tag = { instance->tag_lower, (uint64_t)marker };
-    napi_check_object_type_tag(value.Env(), value, &tag, &match);
+    if (!IsNullOrUndefined(value)) {
+        napi_type_tag tag = { instance->tag_lower, (uint64_t)marker };
+        napi_check_object_type_tag(value.Env(), value, &tag, &match);
+    }
 
     return match;
 }
 
-const char *CopyNodeString(const Napi::Value &value, Allocator *alloc)
+CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func)
+    : env(env), instance(instance), func(func),
+      stack_mem(&instance->stack_mem), heap_mem(&instance->heap_mem),
+      old_stack_mem(instance->stack_mem), old_heap_mem(instance->heap_mem)
+{
+    RG_ASSERT(AlignUp(stack_mem->ptr, 16) == stack_mem->ptr);
+    RG_ASSERT(AlignUp(stack_mem->end(), 16) == stack_mem->end());
+}
+
+CallData::~CallData()
+{
+    instance->stack_mem = old_stack_mem;
+    instance->heap_mem = old_heap_mem;
+}
+
+const char *CallData::PushString(const Napi::Value &value)
 {
     RG_ASSERT(value.IsString());
 
@@ -72,20 +90,23 @@ const char *CopyNodeString(const Napi::Value &value, Allocator *alloc)
 
     Span<char> buf;
     buf.len = (Size)len + 1;
-    buf.ptr = (char *)Allocator::Allocate(alloc, buf.len);
+    if (RG_UNLIKELY(!AllocHeap(buf.len, 1, &buf.ptr)))
+        return nullptr;
 
-    status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
-    RG_ASSERT(status == napi_ok);
+    if (RG_UNLIKELY(napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len) != napi_ok)) {
+        ThrowError<Napi::Error>(env, "Failed to convert string to UTF-8");
+        return nullptr;
+    }
 
     return buf.ptr;
 }
 
-bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc, uint8_t *dest)
+bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
 {
     Napi::Env env = obj.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    RG_ASSERT(obj.IsObject());
+    RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
     dest = AlignUp(dest, type->align);
@@ -126,7 +147,7 @@ bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc,
                     return false;
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
+                int64_t v = CopyNumber<int64_t>(value);
                 memcpy(dest, &v, member.type->size); // Little Endian
             } break;
             case PrimitiveKind::Float32: {
@@ -135,7 +156,7 @@ bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc,
                     return false;
                 }
 
-                float f = CopyNodeNumber<float>(value);
+                float f = CopyNumber<float>(value);
                 memcpy(dest, &f, 4);
             } break;
             case PrimitiveKind::Float64: {
@@ -144,7 +165,7 @@ bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc,
                     return false;
                 }
 
-                double d = CopyNodeNumber<double>(value);
+                double d = CopyNumber<double>(value);
                 memcpy(dest, &d, 8);
             } break;
             case PrimitiveKind::String: {
@@ -153,7 +174,9 @@ bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc,
                     return false;
                 }
 
-                const char *str = CopyNodeString(value, alloc);
+                const char *str = PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return false;
                 *(const char **)dest = str;
             } break;
             case PrimitiveKind::Pointer: {
@@ -168,13 +191,13 @@ bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc,
             } break;
 
             case PrimitiveKind::Record: {
-                if (RG_UNLIKELY(!value.IsObject())) {
+                if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
                     return false;
                 }
 
                 Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, member.type, alloc, dest))
+                if (!PushObject(obj, member.type, dest))
                     return false;
             } break;
         }
@@ -185,14 +208,13 @@ bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc,
     return true;
 }
 
-Napi::Object PopObject(Napi::Env env, const uint8_t *ptr, const TypeInfo *type)
+void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
 {
+    Napi::Env env = obj.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
-    Napi::Object obj = Napi::Object::New(env);
-
     ptr = AlignUp(ptr, type->align);
 
     for (const RecordMember &member: type->members) {
@@ -268,29 +290,47 @@ Napi::Object PopObject(Napi::Env env, const uint8_t *ptr, const TypeInfo *type)
 
         ptr += member.type->size;
     }
-
-    return obj;
 }
 
-void DumpStack(const FunctionInfo *func, Span<const uint8_t> sp)
+void PopOutArguments(Span<const OutObject> objects)
 {
-    PrintLn(stderr, "%!..+---- %1 ----%!0", func->name);
+    for (const OutObject &obj: objects) {
+        PopObject(obj.obj, obj.ptr, obj.type);
+    }
+}
 
-    PrintLn(stderr, "Parameters:");
-    for (Size i = 0; i < func->parameters.len; i++) {
-        const ParameterInfo &param = func->parameters[i];
-        PrintLn(stderr, "  %1 = %2", i, param.type->name);
+static void DumpMemory(const char *type, Span<const uint8_t> bytes)
+{
+    if (bytes.len) {
+        PrintLn(stderr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
+
+        for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
+            Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
+                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
+                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
+                Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
+            }
+            PrintLn(stderr);
+        }
     }
+}
+
+void CallData::DumpDebug() const
+{
+    PrintLn(stderr, "%!..+---- %1 ----%!0", func->name);
 
-    PrintLn(stderr, "Stack (%1 bytes) at 0x%2:", sp.len, sp.ptr);
-    for (const uint8_t *ptr = sp.begin(); ptr < sp.end();) {
-        Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16), FmtArg((ptr - sp.begin()) / 8).Pad(-4),
-                                                                 FmtArg(ptr - sp.begin()).Pad(-4));
-        for (int i = 0; ptr < sp.end() && i < 8; i++, ptr++) {
-            Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
+    if (func->parameters.len) {
+        PrintLn(stderr, "Parameters:");
+        for (Size i = 0; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            PrintLn(stderr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
         }
-        PrintLn(stderr);
     }
+    PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
+
+    DumpMemory("Stack", GetStack());
+    DumpMemory("Heap", GetHeap());
 }
 
 }

package/src/util.hh

@@ -21,30 +21,34 @@ namespace RG {
 
 struct InstanceData;
 
+template <typename T, typename... Args>
+void ThrowError(Napi::Env env, const char *msg, Args... args)
+{
+    char buf[1024];
+    Fmt(buf, msg, args...);
+
+    auto err = T::New(env, buf);
+    err.ThrowAsJavaScriptException();
+}
+
 static inline Size AlignLen(Size len, Size align)
 {
     Size aligned = (len + align - 1) / align * align;
     return aligned;
 }
 
-static inline uint8_t *AlignUp(uint8_t *ptr, Size align)
+template <typename T>
+static inline T *AlignUp(T *ptr, Size align)
 {
     uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) / align * align);
-    return aligned;
-}
-static inline const uint8_t *AlignUp(const uint8_t *ptr, Size align)
-{
-    const uint8_t *aligned = (const uint8_t *)(((uintptr_t)ptr + align - 1) / align * align);
-    return aligned;
+    return (T *)aligned;
 }
 
-template <typename T, typename... Args>
-static void ThrowError(Napi::Env env, const char *msg, Args... args)
+template <typename T>
+static inline T *AlignDown(T *ptr, Size align)
 {
-    char buf[1024];
-    Fmt(buf, msg, args...);
-
-    T::New(env, buf).ThrowAsJavaScriptException();
+    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr / align * align);
+    return (T *)aligned;
 }
 
 // Can be slow, only use for error messages
@@ -53,8 +57,104 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value);
 void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker);
 bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *marker);
 
+static inline bool IsNullOrUndefined(Napi::Value value)
+{
+    return value.IsNull() || value.IsUndefined();
+}
+
+static inline bool IsObject(Napi::Value value)
+{
+    return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
+}
+
+class CallData {
+    Napi::Env env;
+    InstanceData *instance;
+    const FunctionInfo *func;
+
+    Span<uint8_t> *stack_mem;
+    Span<uint8_t> *heap_mem;
+
+    Span<uint8_t> old_stack_mem;
+    Span<uint8_t> old_heap_mem;
+
+public:
+    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
+    ~CallData();
+
+    Span<uint8_t> GetStack() const
+    {
+        uint8_t *sp = stack_mem->end();
+        Size len = old_stack_mem.end() - sp;
+
+        return MakeSpan(sp, len);
+    }
+    uint8_t *GetSP() const { return stack_mem->end(); };
+
+    Span<uint8_t> GetHeap() const
+    {
+        uint8_t *ptr = old_heap_mem.ptr;
+        Size len = heap_mem->ptr - ptr;
+
+        return MakeSpan(ptr, len);
+    }
+
+    template <typename T>
+    bool AllocStack(Size size, Size align, T **out_ptr);
+    template <typename T>
+    bool AllocHeap(Size size, Size align, T **out_ptr);
+
+    const char *PushString(const Napi::Value &value);
+    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest);
+
+    void DumpDebug() const;
+};
+
 template <typename T>
-T CopyNodeNumber(const Napi::Value &value)
+bool CallData::AllocStack(Size size, Size align, T **out_ptr)
+{
+    uint8_t *ptr = AlignDown(stack_mem->end() - size, align);
+    Size delta = stack_mem->end() - ptr;
+
+    if (RG_UNLIKELY(stack_mem->len < delta)) {
+        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
+        return false;
+    }
+
+    if (instance->debug) {
+        memset(ptr, 0, delta);
+    }
+
+    stack_mem->len -= delta;
+
+    *out_ptr = (T *)ptr;
+    return true;
+}
+
+template <typename T>
+bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
+{
+    uint8_t *ptr = AlignUp(heap_mem->ptr, align);
+    Size delta = size + (ptr - heap_mem->ptr);
+
+    if (RG_UNLIKELY(delta > heap_mem->len)) {
+        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
+        return false;
+    }
+
+    if (instance->debug) {
+        memset(heap_mem->ptr, 0, (size_t)delta);
+    }
+
+    heap_mem->ptr += delta;
+    heap_mem->len -= delta;
+
+    *out_ptr = (T *)ptr;
+    return true;
+}
+
+template <typename T>
+T CopyNumber(const Napi::Value &value)
 {
     RG_ASSERT(value.IsNumber() || value.IsBigInt());
 
@@ -70,11 +170,20 @@ T CopyNodeNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
-const char *CopyNodeString(const Napi::Value &value, Allocator *alloc);
+void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
+static inline Napi::Object PopObject(Napi::Env env, const uint8_t *ptr, const TypeInfo *type)
+{
+    Napi::Object obj = Napi::Object::New(env);
+    PopObject(obj, ptr, type);
+    return obj;
+}
 
-bool PushObject(const Napi::Object &obj, const TypeInfo *type, Allocator *alloc, uint8_t *dest);
-Napi::Object PopObject(Napi::Env env, const uint8_t *ptr, const TypeInfo *type);
+struct OutObject {
+    Napi::Object obj;
+    const uint8_t *ptr;
+    const TypeInfo *type;
+};
 
-void DumpStack(const FunctionInfo *func, Span<const uint8_t> sp);
+void PopOutArguments(Span<const OutObject> objects);
 
 }

package/test/files/node32.cmd

@@ -0,0 +1,6 @@
+@echo off
+
+setlocal
+set PATH=C:\Node32;%PATH%
+
+%*

package/test/files/node64.cmd

@@ -0,0 +1,6 @@
+@echo off
+
+setlocal
+set PATH=C:\Node64;%PATH%
+
+%*

package/test/registry/machines.json

@@ -0,0 +1,185 @@
+{
+    "debian_arm32": {
+        "name": "Debian ARM32",
+
+        "qemu": {
+            "binary": "qemu-system-arm",
+            "arguments": ["-M", "virt", "-cpu", "cortex-a15", "-m", "2G", "-smp", 2, "-kernel", "vmlinuz-5.10.0-12-armmp-lpae", "-initrd", "initrd.img-5.10.0-12-armmp-lpae", "-append", "root=/dev/vda2 apparmor=0", "-drive", "if=none,file=disk.qcow2,format=qcow2,id=hd", "-device", "virtio-blk-device,drive=hd", "-netdev", "user,id=mynet,hostfwd=tcp::22201-:22", "-device", "virtio-net-device,netdev=mynet", "-vnc", "127.0.0.1:11"]
+        },
+
+        "info": {
+            "version": 3,
+            "platform": "linux",
+            "arch": "arm",
+
+            "ssh_port": 22201,
+            "vnc_port": 5911,
+
+            "username": "debian",
+            "password": "debian",
+
+            "shutdown": "sudo poweroff"
+        },
+
+        "tests": {
+            "Linux ARM32": {
+                "directory": "/home/debian/luigi",
+                "build": "npm install --production",
+                "commands": {
+                    "Test Raylib": "xvfb-run node test/tests/raylib.js",
+                    "Test Misc": "node test/tests/misc.js"
+                }
+            }
+        }
+    },
+
+    "debian_arm64": {
+        "name": "Debian ARM64",
+
+        "qemu": {
+            "binary": "qemu-system-aarch64",
+            "arguments": ["-M", "virt", "-cpu", "cortex-a53", "-m", "2G", "-smp", 2, "-kernel", "vmlinuz-5.10.0-12-arm64", "-initrd", "initrd.img-5.10.0-12-arm64", "-append", "root=/dev/vda2 apparmor=0", "-drive", "if=none,file=disk.qcow2,format=qcow2,id=hd", "-device", "virtio-blk-device,drive=hd", "-netdev", "user,id=mynet,hostfwd=tcp::22202-:22", "-device", "virtio-net-device,netdev=mynet", "-vnc", "127.0.0.1:12"]
+        },
+
+        "info": {
+            "version": 3,
+            "platform": "linux",
+            "arch": "arm64",
+
+            "ssh_port": 22202,
+            "vnc_port": 5912,
+
+            "username": "debian",
+            "password": "debian",
+
+            "shutdown": "sudo poweroff"
+        },
+
+        "tests": {
+            "Linux ARM64": {
+                "directory": "/home/debian/luigi",
+                "build": "npm install --production",
+                "commands": {
+                    "Test Raylib": "xvfb-run node test/tests/raylib.js",
+                    "Test Misc": "node test/tests/misc.js"
+                }
+            }
+        }
+    },
+
+    "debian_i386": {
+        "name": "Debian i386",
+
+        "qemu": {
+            "binary": "qemu-system-i386",
+            "arguments": ["-cpu", "max", "-m", "2G", "-smp", 2, "-kernel", "vmlinuz-5.10.0-12-686-pae", "-initrd", "initrd.img-5.10.0-12-686-pae", "-append", "root=/dev/sda1 apparmor=0", "-hda", "disk.qcow2", "-netdev", "user,id=mynet,hostfwd=tcp::22203-:22", "-device", "e1000,netdev=mynet", "-vnc", "127.0.0.1:13"]
+        },
+
+        "info": {
+            "version": 3,
+            "platform": "linux",
+            "arch": "ia32",
+
+            "ssh_port": 22203,
+            "vnc_port": 5913,
+
+            "username": "debian",
+            "password": "debian",
+
+            "shutdown": "sudo poweroff"
+        },
+
+        "tests": {
+            "Linux i386": {
+                "directory": "/home/debian/luigi",
+                "build": "npm install --production",
+                "commands": {
+                    "Test Raylib": "xvfb-run node test/tests/raylib.js",
+                    "Test Misc": "node test/tests/misc.js"
+                }
+            }
+        }
+    },
+
+    "debian_x64": {
+        "name": "Debian x64",
+
+        "qemu": {
+            "binary": "qemu-system-x86_64",
+            "arguments": ["-m", "2G", "-smp", 2, "-kernel", "vmlinuz-5.10.0-12-amd64", "-initrd", "initrd.img-5.10.0-12-amd64", "-append", "root=/dev/sda1 apparmor=0", "-hda", "disk.qcow2", "-netdev", "user,id=mynet,hostfwd=tcp::22204-:22", "-device", "e1000,netdev=mynet", "-vnc", "127.0.0.1:14"]
+        },
+
+        "info": {
+            "version": 3,
+            "platform": "linux",
+            "arch": "x64",
+
+            "ssh_port": 22204,
+            "vnc_port": 5914,
+
+            "username": "debian",
+            "password": "debian",
+
+            "shutdown": "sudo poweroff"
+        },
+
+        "tests": {
+            "Linux x64": {
+                "directory": "/home/debian/luigi",
+                "build": "npm install --production",
+                "commands": {
+                    "Test Raylib": "xvfb-run node test/tests/raylib.js",
+                    "Test Misc": "node test/tests/misc.js"
+                }
+            }
+        }
+    },
+
+    "windows": {
+        "name": "Windows",
+
+        "qemu": {
+            "binary": "qemu-system-x86_64",
+            "arguments": ["-m", "3G", "-smp", 4, "-rtc", "clock=host,base=localtime", "-bios", "bios.bin", "-hda", "disk.qcow2", "-netdev", "user,id=mynet,hostfwd=tcp::22205-:22", "-device", "e1000,netdev=mynet", "-vga", "std", "-device", "qemu-xhci", "-device", "usb-tablet", "-vnc", "127.0.0.1:15"]
+        },
+
+        "info": {
+            "version": 6,
+            "platform": "win32",
+            "arch": "x64",
+
+            "ssh_port": 22205,
+            "vnc_port": 5915,
+
+            "username": "windows",
+            "password": "windows",
+
+            "shutdown": "shutdown -s -t 0"
+        },
+
+        "uploads": {
+            "node32.cmd": "C:/Node32/node32.cmd",
+            "node64.cmd": "C:/Node64/node64.cmd"
+        },
+
+        "tests": {
+            "Windows i386": {
+                "directory": "C:/Users/windows/Desktop/luigi32",
+                "build": "C:\\Node32\\node32.cmd npm install --production",
+                "commands": {
+                    "Test Raylib": "seatsh C:\\Node32\\node32.cmd node test/tests/raylib.js",
+                    "Test Misc": "C:\\Node32\\node32.cmd node test/tests/misc.js"
+                }
+            },
+
+            "Windows x64": {
+                "directory": "C:/Users/windows/Desktop/luigi64",
+                "build": "C:\\Node64\\node64.cmd npm install --production",
+                "commands": {
+                    "Test Raylib": "seatsh C:\\Node64\\node64.cmd node test/tests/raylib.js",
+                    "Test Misc": "C:\\Node64\\node64.cmd node test/tests/misc.js"
+                }
+            }
+        }
+    }
+}

package/test/registry/sha256sum.txt

@@ -0,0 +1,24 @@
+06e9d52c1720fca412803e3b07c4b228ff113e303f4c7ab94665319d832bbfb7 *qemu/windows/VERSION
+8d70e4e0a82be12689c7c21ff6f5031bc59ee3650fc8f31a9a3f10a5a7f6d267 *qemu/windows/install.sh
+f8c9a1638a3fc2cdd214f2cbcad6fee0e3b2c9383942bbd49b3915bb4c3da102 *qemu/windows/bios.bin
+dd89b05e8324c4ccc552c3e23787d28f384e082f8c42d360fb8960c0acd41c03 *qemu/windows/disk.qcow2
+1121cfccd5913f0a63fec40a6ffd44ea64f9dc135c66634ba001d10bcf4302a2 *qemu/debian_x64/VERSION
+ba418d2d602981fe324ae7a1a608b0f2d8d7c6113d03a429cc402e24ddc81311 *qemu/debian_x64/vmlinuz-5.10.0-12-amd64
+4d44622e8ce058017c08051d694b8e5afe9ff406b6ad91c17ebc4ec43d205c42 *qemu/debian_x64/install.sh
+e349fd503c943541f24a91198ef29c1df26f120fd294a4a01426bbf46d7423f1 *qemu/debian_x64/initrd.img-5.10.0-12-amd64
+c84dc75dcfcd9ceeb969d6d1d2d4c37ef9c5edfa3c5dd93c6073588a2b02be63 *qemu/debian_x64/disk.qcow2
+1121cfccd5913f0a63fec40a6ffd44ea64f9dc135c66634ba001d10bcf4302a2 *qemu/debian_arm64/VERSION
+79c324a3901d8864628e804ac6490ca372782f836c6ea7d9e9843bd066247274 *qemu/debian_arm64/install.sh
+d05326434988381b4048a2e4aeac08497487d17f0cddb3b5ab69123a5d7be9ea *qemu/debian_arm64/vmlinuz-5.10.0-12-arm64
+b582530fdfbcd347f9a371e059a93b42e68258b2526d7ac1f9facefb89f3194d *qemu/debian_arm64/initrd.img-5.10.0-12-arm64
+272d3d5d8b9a8d9505f0c236c92fbcdab4a118127b18727ca91fdc955927124f *qemu/debian_arm64/disk.qcow2
+1121cfccd5913f0a63fec40a6ffd44ea64f9dc135c66634ba001d10bcf4302a2 *qemu/debian_arm32/VERSION
+1b3784d44757394f8b318b85c2afda659ead4487e31600e635d0512eb41ce718 *qemu/debian_arm32/vmlinuz-5.10.0-12-armmp-lpae
+bb37ce287d9d262f467a4b88d0c45220f0d1abfa8e579511322c0c4572dd7774 *qemu/debian_arm32/install.sh
+fbbc2ed94c4a7bb22341f621e0226b71b8c3498f9a2cf4f7028af1c5c2b95006 *qemu/debian_arm32/initrd.img-5.10.0-12-armmp-lpae
+f52cd3988a0b8a5cd74f0cc3b3a36231f53618309d8ea9e98e056205bd1f8afb *qemu/debian_arm32/disk.qcow2
+ed05b84b7759ec945bb5422305a3a3c5b61d89e231844656ea31e07d89451a20 *qemu/debian_i386/vmlinuz-5.10.0-12-686-pae
+1121cfccd5913f0a63fec40a6ffd44ea64f9dc135c66634ba001d10bcf4302a2 *qemu/debian_i386/VERSION
+292a61c415a99a9c63a9337f1e074bea6c5df594e16bc40ded76141963c67ea4 *qemu/debian_i386/install.sh
+8dc1360e1c23ea21931f5eb94461d15fac6bcec00cf42bf1e590b7fb937e80c1 *qemu/debian_i386/initrd.img-5.10.0-12-686-pae
+338602d969f953cd88c2df736b9f8f7ee53029d233c83c7398258ae5bcb4e286 *qemu/debian_i386/disk.qcow2