[wasmtime] Implement basic WASIp2 components support

Signed-off-by: Maximilian Hüter <[email protected]>

Author: t4chib4ne

src/libcrun/handlers/wasmtime.c

@@ -15,6 +15,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with crun.  If not, see <http://www.gnu.org/licenses/>.
  */
+#include <wasmtime/store.h>
 #define _GNU_SOURCE
 
 #include <config.h>
@@ -151,7 +152,6 @@ libwasmtime_run_module (void *cookie, char *const argv[], wasm_engine_t *engine,
   // Load needed functions
   void (*wasm_engine_delete) (wasm_engine_t *);
   void (*wasm_byte_vec_delete) (wasm_byte_vec_t *);
-  void (*wasm_byte_vec_new_uninitialized) (wasm_byte_vec_t *, size_t);
   wasi_config_t *(*wasi_config_new) (const char *);
   wasmtime_store_t *(*wasmtime_store_new) (wasm_engine_t *engine, void *data, void (*finalizer) (void *));
   wasmtime_context_t *(*wasmtime_store_context) (wasmtime_store_t *store);
@@ -197,7 +197,6 @@ libwasmtime_run_module (void *cookie, char *const argv[], wasm_engine_t *engine,
 
   wasm_engine_delete = dlsym (cookie, "wasm_engine_delete");
   wasm_byte_vec_delete = dlsym (cookie, "wasm_byte_vec_delete");
-  wasm_byte_vec_new_uninitialized = dlsym (cookie, "wasm_byte_vec_new_uninitialized");
   wasi_config_new = dlsym (cookie, "wasi_config_new");
   wasi_config_set_argv = dlsym (cookie, "wasi_config_set_argv");
   wasmtime_store_new = dlsym (cookie, "wasmtime_store_new");
@@ -221,7 +220,7 @@ libwasmtime_run_module (void *cookie, char *const argv[], wasm_engine_t *engine,
   wasi_config_preopen_dir = dlsym (cookie, "wasi_config_preopen_dir");
 
   if (wasm_engine_delete == NULL || wasm_byte_vec_delete == NULL
-      || wasm_byte_vec_new_uninitialized == NULL || wasi_config_new == NULL || wasmtime_store_new == NULL
+      || wasi_config_new == NULL || wasmtime_store_new == NULL
       || wasmtime_store_context == NULL || wasmtime_linker_new == NULL || wasmtime_linker_define_wasi == NULL
       || wasmtime_module_new == NULL || wasi_config_inherit_argv == NULL || wasi_config_inherit_stdout == NULL
       || wasi_config_inherit_stdin == NULL || wasi_config_inherit_stderr == NULL
@@ -316,7 +315,173 @@ libwasmtime_run_module (void *cookie, char *const argv[], wasm_engine_t *engine,
 static void
 libwasmtime_run_component (void *cookie, char *const argv[], wasm_engine_t *engine, wasm_byte_vec_t *wasm)
 {
-  error (EXIT_FAILURE, 0, "running components is not yet implemented!");
+  const char *wasi_cli_run_interface = "wasi:cli/[email protected]";
+  const char *wasi_cli_run_interface_run = "run";
+  wasm_byte_vec_t error_message;
+
+  // Load needed functions
+  void (*wasm_engine_delete) (wasm_engine_t *);
+  void (*wasm_byte_vec_delete) (wasm_byte_vec_t *);
+  wasmtime_store_t *(*wasmtime_store_new) (wasm_engine_t *engine, void *data, void (*finalizer) (void *));
+  void (*wasmtime_store_delete) (wasmtime_store_t *store);
+  wasmtime_context_t *(*wasmtime_store_context) (wasmtime_store_t *store);
+  wasmtime_error_t *(*wasmtime_component_new) (
+      const wasm_engine_t *engine,
+      const uint8_t *buf,
+      size_t len,
+      wasmtime_component_t **component_out);
+  wasmtime_wasip2_config_t *(*wasmtime_wasip2_config_new) (void);
+  void (*wasmtime_wasip2_config_inherit_stdin) (wasmtime_wasip2_config_t *config);
+  void (*wasmtime_wasip2_config_inherit_stdout) (wasmtime_wasip2_config_t *config);
+  void (*wasmtime_wasip2_config_inherit_stderr) (wasmtime_wasip2_config_t *config);
+  void (*wasmtime_context_set_wasip2) (wasmtime_context_t *context, wasmtime_wasip2_config_t *config);
+  wasmtime_component_linker_t *(*wasmtime_component_linker_new) (wasm_engine_t *engine);
+  wasmtime_error_t *(*wasmtime_component_linker_add_wasip2) (wasmtime_component_linker_t *linker);
+  wasmtime_error_t *(*wasmtime_component_linker_instantiate) (
+      const wasmtime_component_linker_t *linker,
+      wasmtime_context_t *context,
+      const wasmtime_component_t *component,
+      wasmtime_component_instance_t *instance_out);
+  wasmtime_component_export_index_t *(*wasmtime_component_get_export_index) (
+      wasmtime_component_t *component,
+      wasmtime_component_export_index_t *index,
+      const char *name,
+      size_t name_len);
+  wasmtime_component_export_index_t *(*wasmtime_component_instance_get_export_index) (
+      const wasmtime_component_instance_t *instance,
+      wasmtime_context_t *context,
+      const wasmtime_component_export_index_t *instance_export_index,
+      const char *name,
+      size_t name_len);
+  bool (*wasmtime_component_instance_get_func) (
+      const wasmtime_component_instance_t *instance,
+      wasmtime_context_t *context,
+      const wasmtime_component_export_index_t *export_index,
+      wasmtime_component_func_t *func_out);
+  wasmtime_error_t *(*wasmtime_component_func_call) (
+      const wasmtime_component_func_t *func,
+      wasmtime_context_t *context,
+      const wasmtime_component_val_t *args,
+      size_t args_size,
+      wasmtime_component_val_t *results,
+      size_t results_size);
+  void (*wasmtime_component_export_index_delete) (wasmtime_component_export_index_t *export_index);
+  void (*wasmtime_component_delete) (wasmtime_component_t *c);
+  void (*wasmtime_component_linker_delete) (wasmtime_component_linker_t *linker);
+  void (*wasmtime_error_message) (const wasmtime_error_t *error, wasm_name_t *message);
+  void (*wasmtime_error_delete) (wasmtime_error_t *error);
+
+  wasm_engine_delete = dlsym (cookie, "wasm_engine_delete");
+  wasm_byte_vec_delete = dlsym (cookie, "wasm_byte_vec_delete");
+  wasmtime_store_new = dlsym (cookie, "wasmtime_store_new");
+  wasmtime_store_delete = dlsym (cookie, "wasmtime_store_delete");
+  wasmtime_store_context = dlsym (cookie, "wasmtime_store_context");
+  wasmtime_component_new = dlsym (cookie, "wasmtime_component_new");
+  wasmtime_wasip2_config_new = dlsym (cookie, "wasmtime_wasip2_config_new");
+  wasmtime_wasip2_config_inherit_stdin = dlsym (cookie, "wasmtime_wasip2_config_inherit_stdin");
+  wasmtime_wasip2_config_inherit_stdout = dlsym (cookie, "wasmtime_wasip2_config_inherit_stdout");
+  wasmtime_wasip2_config_inherit_stderr = dlsym (cookie, "wasmtime_wasip2_config_inherit_stderr");
+  wasmtime_context_set_wasip2 = dlsym (cookie, "wasmtime_context_set_wasip2");
+  wasmtime_component_linker_new = dlsym (cookie, "wasmtime_component_linker_new");
+  wasmtime_component_linker_add_wasip2 = dlsym (cookie, "wasmtime_component_linker_add_wasip2");
+  wasmtime_component_linker_instantiate = dlsym (cookie, "wasmtime_component_linker_instantiate");
+  wasmtime_component_get_export_index = dlsym (cookie, "wasmtime_component_get_export_index");
+  wasmtime_component_instance_get_export_index = dlsym (cookie, "wasmtime_component_instance_get_export_index");
+  wasmtime_component_instance_get_func = dlsym (cookie, "wasmtime_component_instance_get_func");
+  wasmtime_component_func_call = dlsym (cookie, "wasmtime_component_func_call");
+  wasmtime_component_export_index_delete = dlsym (cookie, "wasmtime_component_export_index_delete");
+  wasmtime_component_delete = dlsym (cookie, "wasmtime_component_delete");
+  wasmtime_component_linker_delete = dlsym (cookie, "wasmtime_component_linker_delete");
+  wasmtime_error_message = dlsym (cookie, "wasmtime_error_message");
+  wasmtime_error_delete = dlsym (cookie, "wasmtime_error_delete");
+
+  // Set up wasmtime context
+  wasmtime_store_t *store = wasmtime_store_new (engine, NULL, NULL);
+  assert (store != NULL);
+  wasmtime_context_t *context = wasmtime_store_context (store);
+
+  // Compile wasm component
+  wasmtime_component_t *component = NULL;
+  wasmtime_error_t *err = wasmtime_component_new (engine, (uint8_t *) wasm->data, wasm->size, &component);
+  if (! component || err != NULL)
+    {
+      wasmtime_error_message (err, &error_message);
+      wasmtime_error_delete (err);
+      error (EXIT_FAILURE, 0, "failed to compile component: %.*s", (int) error_message.size, error_message.data);
+    }
+  wasm_byte_vec_delete (wasm);
+
+  // Set up WASIp2 config
+  wasmtime_wasip2_config_t *wasi_config = wasmtime_wasip2_config_new ();
+  assert (wasi_config != NULL);
+
+  wasmtime_wasip2_config_inherit_stdin (wasi_config);
+  wasmtime_wasip2_config_inherit_stdout (wasi_config);
+  wasmtime_wasip2_config_inherit_stderr (wasi_config);
+  // TODO: argv
+  wasmtime_context_set_wasip2 (context, wasi_config);
+
+  // Get wasi exposing linker
+  wasmtime_component_linker_t *linker = wasmtime_component_linker_new (engine);
+  err = wasmtime_component_linker_add_wasip2 (linker);
+  if (err != NULL)
+    {
+      wasmtime_error_message (err, &error_message);
+      wasmtime_error_delete (err);
+      error (EXIT_FAILURE, 0, "failed to add WASIp2 to linker: %.*s", (int) error_message.size, error_message.data);
+    }
+
+  // Instantiate the component
+  wasmtime_component_instance_t component_inst = {};
+  err = wasmtime_component_linker_instantiate (linker, context, component, &component_inst);
+  if (err != NULL)
+    {
+      wasmtime_error_message (err, &error_message);
+      wasmtime_error_delete (err);
+      error (EXIT_FAILURE, 0, "failed to instantiate component: %.*s", (int) error_message.size, error_message.data);
+    }
+
+  // Get index of the run interface in wasi/cli world
+  wasmtime_component_export_index_t *run_interface_idx = wasmtime_component_instance_get_export_index (
+      &component_inst,
+      context,
+      NULL,
+      wasi_cli_run_interface,
+      strlen (wasi_cli_run_interface));
+  assert (run_interface_idx != NULL);
+  // Get index of the run function
+  wasmtime_component_export_index_t *run_func_idx = wasmtime_component_instance_get_export_index (
+      &component_inst,
+      context,
+      run_interface_idx,
+      wasi_cli_run_interface_run,
+      strlen (wasi_cli_run_interface_run));
+  assert (run_func_idx != NULL);
+
+  // Actually retrieve the func
+  wasmtime_component_func_t run_func = {};
+  if (! wasmtime_component_instance_get_func (&component_inst, context, run_func_idx, &run_func))
+    {
+      error (EXIT_FAILURE, 0, "failed to retrieve run function");
+    }
+
+  // Call the func
+  wasmtime_component_val_t result = {};
+  err = wasmtime_component_func_call (&run_func, context, NULL, 0, &result, 1);
+  if (err != NULL)
+    {
+      wasmtime_error_message (err, &error_message);
+      wasmtime_error_delete (err);
+      error (EXIT_FAILURE, 0, "error calling run function: %.*s", (int) error_message.size, error_message.data);
+    }
+
+  // Clean everything
+  wasmtime_component_export_index_delete (run_func_idx);
+  wasmtime_component_export_index_delete (run_interface_idx);
+  wasmtime_component_linker_delete (linker);
+  wasmtime_component_delete (component);
+  wasmtime_store_delete (store);
+  wasm_engine_delete (engine);
 }
 
 static int