| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #pragma once |
| |
| #include <zircon/compiler.h> |
| #include <zircon/types.h> |
| |
| __BEGIN_CDECLS |
| |
| typedef struct async_dispatcher async_dispatcher_t; // From <lib/async/dispatcher.h> |
| |
| // These functions provide an implementation of the shared library loading |
| // service. See system/fidl/fuchsia-ldsvc/ldsvc.fidl for a definition of the protocol. |
| // |
| // These implementations are compatible with |dl_set_loader_service| and are |
| // primarily used by devmgr, fshost, and appmgr to provide shared libraries to |
| // the processes they create. |
| // |
| // Terms: |
| // |
| // "loader service": A channel that speaks the protocol expected by |
| // dl_set_loader_service(). The service behind the channel receives |
| // load requests (e.g., "libhid.so") and returns VMOs that contain |
| // the data associated with that name. |
| // "system loader service": A loader service, provided by the system, |
| // that is shared by multiple processes. |
| |
| typedef struct loader_service loader_service_t; |
| |
| // Create a new file-system backed loader service capable of handling |
| // any number of clients. |
| // |
| // Requests will be processed on the given |async|. If |async| is NULL, this |
| // library will create a new thread and listen for requests on that thread. |
| zx_status_t loader_service_create_fs(async_dispatcher_t* dispatcher, loader_service_t** out); |
| |
| // Create a new file-descriptor backed loader service capable of handling any |
| // number of clients. |
| // |
| // Requests will be processed on the given |async|. If |async| is NULL, this |
| // library will create a new thread and listen for requests on that thread. |
| // Paths and objects will be loaded relative to |root_dir_fd|, and the loader |
| // service will take ownership of |root_dir_fd|. |
| zx_status_t loader_service_create_fd(async_dispatcher_t* dispatcher, |
| int root_dir_fd, |
| loader_service_t** out); |
| |
| // Returns a new dl_set_loader_service-compatible loader service channel. |
| zx_status_t loader_service_connect(loader_service_t* svc, zx_handle_t* out); |
| |
| // Same as connect except caller provides the channel endpoint (which |
| // is connected on success, closed on failure). |
| zx_status_t loader_service_attach(loader_service_t* svc, zx_handle_t channel); |
| |
| typedef struct loader_service_ops { |
| // attempt to load a shared library from suitable library paths. |
| zx_status_t (*load_object)(void* ctx, const char* name, zx_handle_t* vmo); |
| |
| // attempt to load a script interpreter or debug config file |
| zx_status_t (*load_abspath)(void* ctx, const char* path, zx_handle_t* vmo); |
| |
| // attempt to publish a data sink |
| // takes ownership of the provided vmo on both success and failure. |
| zx_status_t (*publish_data_sink)(void* ctx, const char* name, zx_handle_t vmo); |
| |
| // finalize the loader service (optional) |
| // called shortly before the loader service is destroyed |
| void (*finalizer)(void* ctx); |
| } loader_service_ops_t; |
| |
| // Create a loader service backed by custom loader ops. |
| // |
| // Requests will be processed on the given |async|. If |async| is NULL, this |
| // library will create a new thread and listen for requests on that thread. |
| zx_status_t loader_service_create(async_dispatcher_t* dispatcher, |
| const loader_service_ops_t* ops, |
| void* ctx, |
| loader_service_t** out); |
| |
| // After this function returns, |svc| will destroy itself once there are no |
| // longer any outstanding connections. |
| // |
| // The |finalizer| in |loader_service_ops_t| will be called shortly before |svc| |
| // destroys itself. |
| zx_status_t loader_service_release(loader_service_t* svc); |
| |
| __END_CDECLS |