wash/photon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed struct cleanup to struct launch_ctx

Browse Source
This commit is contained in:
max 🍓
2022-05-26 11:53:27 +01:00
parent 4bbf10e7ef
commit c952d9cad4
1 changed files with 238 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

476
photon/libc/sys/horizon/launch.c
View File

@@ -44,7 +44,7 @@
static char g_launch_error[1024] = {}; static char g_launch_error[1024] = {};
struct cleanup { struct launch_ctx {
/* list of handles that were opened by launch() that should be closed if an error occurs */ /* list of handles that were opened by launch() that should be closed if an error occurs */
mx_handle_t *auto_handles; mx_handle_t *auto_handles;
size_t auto_handle_count; size_t auto_handle_count;
@@ -153,26 +153,26 @@ static int validate_argv(int argc, const char **argv)
return 0; return 0;
} }
static int validate_fds(const struct launch_info *info, struct cleanup *cleanup) static int validate_fds(const struct launch_info *info, struct launch_ctx *ctx)
{ {
cleanup->fd = calloc(LAUNCH_MAX_FDS, sizeof(int)); ctx->fd = calloc(LAUNCH_MAX_FDS, sizeof(int));
bool auto_stdio = true; bool auto_stdio = true;
if (info->flags & LAUNCH_SET_FD) { if (info->flags & LAUNCH_SET_FD) {
memcpy(cleanup->fd, info->fd, sizeof info->fd); memcpy(ctx->fd, info->fd, sizeof info->fd);
auto_stdio = false; auto_stdio = false;
} else { } else {
for (int i = 0; i < LAUNCH_MAX_FDS; i++) { for (int i = 0; i < LAUNCH_MAX_FDS; i++) {
cleanup->fd[i] = i; ctx->fd[i] = i;
} }
} }
for (size_t i = 0; i < LAUNCH_MAX_FDS; i++) { for (size_t i = 0; i < LAUNCH_MAX_FDS; i++) {
int fd = cleanup->fd[i]; int fd = ctx->fd[i];
bool inherited = false; bool inherited = false;
if (fd == FD_INHERIT) { if (fd == FD_INHERIT) {
fd = cleanup->fd[i] = i; fd = ctx->fd[i] = i;
inherited = true; inherited = true;
} }
@@ -186,7 +186,7 @@ static int validate_fds(const struct launch_info *info, struct cleanup *cleanup)
} }
if (inherited || auto_stdio) { if (inherited || auto_stdio) {
cleanup->fd[i] = FD_NONE; ctx->fd[i] = FD_NONE;
} else { } else {
set_error_msg("file descriptor %d (launch_info.fd[%zu]) is invalid", fd, i); set_error_msg("file descriptor %d (launch_info.fd[%zu]) is invalid", fd, i);
return EBADF; return EBADF;
@@ -233,14 +233,14 @@ static int validate_ns(int flags, const struct namespace_entry *ns, size_t count
return 0; return 0;
} }
static int collect_names(const struct launch_info *info, struct cleanup *cleanup) static int collect_names(const struct launch_info *info, struct launch_ctx *ctx)
{ {
size_t ns_count = info->ns_count; size_t ns_count = info->ns_count;
const struct namespace_entry *ns = info->ns; const struct namespace_entry *ns = info->ns;
if (info->flags & LAUNCH_INHERIT_NS) { if (info->flags & LAUNCH_INHERIT_NS) {
ns_count = cleanup->inherited_ns_len; ns_count = ctx->inherited_ns_len;
ns = cleanup->inherited_ns; ns = ctx->inherited_ns;
} }
size_t name_count = ns_count; size_t name_count = ns_count;
@@ -259,16 +259,16 @@ static int collect_names(const struct launch_info *info, struct cleanup *cleanup
names[name_count - 1] = info->cwd.path; names[name_count - 1] = info->cwd.path;
} }
cleanup->names = names; ctx->names = names;
cleanup->name_count = name_count; ctx->name_count = name_count;
return 0; return 0;
} }
static int count_handles(const struct launch_info *info, struct cleanup *cleanup) static int count_handles(const struct launch_info *info, struct launch_ctx *ctx)
{ {
size_t all_handles = 0, auto_handles = 0; size_t all_handles = 0, auto_handles = 0;
for (size_t i = 0; i < LAUNCH_MAX_FDS; i++) { for (size_t i = 0; i < LAUNCH_MAX_FDS; i++) {
if (cleanup->fd[i] != FD_NONE) { if (ctx->fd[i] != FD_NONE) {
all_handles++; all_handles++;
auto_handles++; auto_handles++;
} }
@@ -279,8 +279,8 @@ static int count_handles(const struct launch_info *info, struct cleanup *cleanup
bool auto_ns = false; bool auto_ns = false;
if (info->flags & LAUNCH_INHERIT_NS) { if (info->flags & LAUNCH_INHERIT_NS) {
ns_len = cleanup->inherited_ns_len; ns_len = ctx->inherited_ns_len;
ns = cleanup->inherited_ns; ns = ctx->inherited_ns;
auto_ns = true; auto_ns = true;
} }
@@ -326,23 +326,23 @@ static int count_handles(const struct launch_info *info, struct cleanup *cleanup
all_handles += info->handle_count; all_handles += info->handle_count;
cleanup->auto_handle_count = auto_handles; ctx->auto_handle_count = auto_handles;
cleanup->b_handle_count = all_handles; ctx->b_handle_count = all_handles;
cleanup->auto_handles = calloc(cleanup->auto_handle_count, sizeof *cleanup->auto_handles); ctx->auto_handles = calloc(ctx->auto_handle_count, sizeof *ctx->auto_handles);
cleanup->b_handles = calloc(cleanup->b_handle_count, sizeof *cleanup->b_handles); ctx->b_handles = calloc(ctx->b_handle_count, sizeof *ctx->b_handles);
return 0; return 0;
} }
static int collect_handles(const struct launch_info *info, struct cleanup *cleanup) static int collect_handles(const struct launch_info *info, struct launch_ctx *ctx)
{ {
memcpy(cleanup->b_handles, info->handles, info->handle_count * sizeof *info->handles); memcpy(ctx->b_handles, info->handles, info->handle_count * sizeof *info->handles);
size_t b_idx = info->handle_count; size_t b_idx = info->handle_count;
size_t auto_idx = 0; size_t auto_idx = 0;
for (int i = 0; i < LAUNCH_MAX_FDS; i++) { for (int i = 0; i < LAUNCH_MAX_FDS; i++) {
int fd = cleanup->fd[i]; int fd = ctx->fd[i];
if (fd == FD_NONE) { if (fd == FD_NONE) {
continue; continue;
} }
@@ -365,23 +365,23 @@ static int collect_handles(const struct launch_info *info, struct cleanup *clean
return EBADF; return EBADF;
} }
cleanup->b_handles[b_idx].info = MX_B_HND(MX_B_FD, i); ctx->b_handles[b_idx].info = MX_B_HND(MX_B_FD, i);
cleanup->b_handles[b_idx].handle = fd_handle; ctx->b_handles[b_idx].handle = fd_handle;
b_idx++; b_idx++;
cleanup->auto_handles[auto_idx++] = fd_handle; ctx->auto_handles[auto_idx++] = fd_handle;
cleanup->stdio[i] = fd_handle; ctx->stdio[i] = fd_handle;
} }
if (info->flags & LAUNCH_INHERIT_NS) { if (info->flags & LAUNCH_INHERIT_NS) {
for (size_t i = 0; i < cleanup->inherited_ns_len; i++) { for (size_t i = 0; i < ctx->inherited_ns_len; i++) {
const struct namespace_entry *ent = &cleanup->inherited_ns[i]; const struct namespace_entry *ent = &ctx->inherited_ns[i];
cleanup->b_handles[b_idx].info = MX_B_HND(MX_B_NS_DIR, i); ctx->b_handles[b_idx].info = MX_B_HND(MX_B_NS_DIR, i);
cleanup->b_handles[b_idx].handle = ent->handle; ctx->b_handles[b_idx].handle = ent->handle;
b_idx++; b_idx++;
cleanup->auto_handles[auto_idx++] = ent->handle; ctx->auto_handles[auto_idx++] = ent->handle;
} }
return 0; return 0;
@@ -421,196 +421,196 @@ static int collect_handles(const struct launch_info *info, struct cleanup *clean
return EBADF; return EBADF;
} }
cleanup->b_handles[b_idx].info = MX_B_HND(MX_B_NS_DIR, i); ctx->b_handles[b_idx].info = MX_B_HND(MX_B_NS_DIR, i);
cleanup->b_handles[b_idx].handle = ns_handle; ctx->b_handles[b_idx].handle = ns_handle;
b_idx++; b_idx++;
if (is_auto) { if (is_auto) {
cleanup->auto_handles[auto_idx++] = ns_handle; ctx->auto_handles[auto_idx++] = ns_handle;
} }
} }
return 0; return 0;
} }
static void fail_cleanup(struct cleanup *cleanup) static void fail_cleanup(struct launch_ctx *ctx)
{ {
if (cleanup->exec_vmo) { if (ctx->exec_vmo) {
mx_handle_close(cleanup->exec_vmo); mx_handle_close(ctx->exec_vmo);
} }
if (cleanup->auto_handles) { if (ctx->auto_handles) {
for (size_t i = 0; i < cleanup->auto_handle_count; i++) { for (size_t i = 0; i < ctx->auto_handle_count; i++) {
if (cleanup->auto_handles[i]) { if (ctx->auto_handles[i]) {
mx_handle_close(cleanup->auto_handles[i]); mx_handle_close(ctx->auto_handles[i]);
} }
} }
free(cleanup->auto_handles); free(ctx->auto_handles);
} }
if (cleanup->inherited_ns) { if (ctx->inherited_ns) {
for (size_t i = 0; i < cleanup->inherited_ns_len; i++) { for (size_t i = 0; i < ctx->inherited_ns_len; i++) {
struct namespace_entry *ent = &cleanup->inherited_ns[i]; struct namespace_entry *ent = &ctx->inherited_ns[i];
free((char *)ent->path); free((char *)ent->path);
mx_handle_close(ent->handle); mx_handle_close(ent->handle);
} }
free(cleanup->inherited_ns); free(ctx->inherited_ns);
cleanup->inherited_ns = NULL; ctx->inherited_ns = NULL;
cleanup->inherited_ns_len = 0; ctx->inherited_ns_len = 0;
} }
if (cleanup->names) { if (ctx->names) {
free(cleanup->names); free(ctx->names);
cleanup->names = NULL; ctx->names = NULL;
cleanup->name_count = 0; ctx->name_count = 0;
} }
if (cleanup->b_handles) { if (ctx->b_handles) {
free(cleanup->b_handles); free(ctx->b_handles);
} }
__elf_image_cleanup(&cleanup->exec); __elf_image_cleanup(&ctx->exec);
__elf_image_cleanup(&cleanup->vdso); __elf_image_cleanup(&ctx->vdso);
if (cleanup->interp_vmo) { if (ctx->interp_vmo) {
mx_handle_close(cleanup->interp_vmo); mx_handle_close(ctx->interp_vmo);
cleanup->interp_vmo = MX_NULL_HANDLE; ctx->interp_vmo = MX_NULL_HANDLE;
} }
if (cleanup->interp_path) { if (ctx->interp_path) {
free(cleanup->interp_path); free(ctx->interp_path);
cleanup->interp_path = NULL; ctx->interp_path = NULL;
} }
if (cleanup->new_vmar) { if (ctx->new_vmar) {
mx_handle_close(cleanup->new_vmar); mx_handle_close(ctx->new_vmar);
cleanup->new_vmar = MX_NULL_HANDLE; ctx->new_vmar = MX_NULL_HANDLE;
} }
if (cleanup->stack_vmo) { if (ctx->stack_vmo) {
mx_handle_close(cleanup->stack_vmo); mx_handle_close(ctx->stack_vmo);
cleanup->stack_vmo = MX_NULL_HANDLE; ctx->stack_vmo = MX_NULL_HANDLE;
} }
if (cleanup->new_task) { if (ctx->new_task) {
mx_handle_close(cleanup->new_task); mx_handle_close(ctx->new_task);
cleanup->new_task = MX_NULL_HANDLE; ctx->new_task = MX_NULL_HANDLE;
} }
if (cleanup->bootstrap_local) { if (ctx->bootstrap_local) {
mx_handle_close(cleanup->bootstrap_local); mx_handle_close(ctx->bootstrap_local);
cleanup->bootstrap_local = MX_NULL_HANDLE; ctx->bootstrap_local = MX_NULL_HANDLE;
} }
if (cleanup->bootstrap_remote) { if (ctx->bootstrap_remote) {
mx_handle_close(cleanup->bootstrap_remote); mx_handle_close(ctx->bootstrap_remote);
cleanup->bootstrap_remote = MX_NULL_HANDLE; ctx->bootstrap_remote = MX_NULL_HANDLE;
} }
if (cleanup->fd) { if (ctx->fd) {
free(cleanup->fd); free(ctx->fd);
cleanup->fd = NULL; ctx->fd = NULL;
} }
if (cleanup->ldsvc_version == LDV1_VERSION && cleanup->ldsvc.handle) { if (ctx->ldsvc_version == LDV1_VERSION && ctx->ldsvc.handle) {
mx_handle_close(cleanup->ldsvc.handle); mx_handle_close(ctx->ldsvc.handle);
cleanup->ldsvc.handle = MX_NULL_HANDLE; ctx->ldsvc.handle = MX_NULL_HANDLE;
} else if (cleanup->ldsvc_version == LDV2_VERSION && cleanup->ldsvc.sock) { } else if (ctx->ldsvc_version == LDV2_VERSION && ctx->ldsvc.sock) {
xpc_socket_destroy(cleanup->ldsvc.sock); xpc_socket_destroy(ctx->ldsvc.sock);
cleanup->ldsvc.sock = NULL; ctx->ldsvc.sock = NULL;
} }
} }
static void success_cleanup(struct cleanup *cleanup) static void success_cleanup(struct launch_ctx *ctx)
{ {
if (cleanup->exec_vmo) { if (ctx->exec_vmo) {
mx_handle_close(cleanup->exec_vmo); mx_handle_close(ctx->exec_vmo);
} }
if (cleanup->auto_handles) { if (ctx->auto_handles) {
for (size_t i = 0; i < cleanup->auto_handle_count; i++) { for (size_t i = 0; i < ctx->auto_handle_count; i++) {
if (cleanup->auto_handles[i]) { if (ctx->auto_handles[i]) {
mx_handle_close(cleanup->auto_handles[i]); mx_handle_close(ctx->auto_handles[i]);
} }
} }
free(cleanup->auto_handles); free(ctx->auto_handles);
} }
if (cleanup->inherited_ns) { if (ctx->inherited_ns) {
for (size_t i = 0; i < cleanup->inherited_ns_len; i++) { for (size_t i = 0; i < ctx->inherited_ns_len; i++) {
struct namespace_entry *ent = &cleanup->inherited_ns[i]; struct namespace_entry *ent = &ctx->inherited_ns[i];
free((char *)ent->path); free((char *)ent->path);
mx_handle_close(ent->handle); mx_handle_close(ent->handle);
} }
free(cleanup->inherited_ns); free(ctx->inherited_ns);
cleanup->inherited_ns = NULL; ctx->inherited_ns = NULL;
cleanup->inherited_ns_len = 0; ctx->inherited_ns_len = 0;
} }
if (cleanup->names) { if (ctx->names) {
free(cleanup->names); free(ctx->names);
cleanup->names = NULL; ctx->names = NULL;
cleanup->name_count = 0; ctx->name_count = 0;
} }
if (cleanup->b_handles) { if (ctx->b_handles) {
free(cleanup->b_handles); free(ctx->b_handles);
} }
__elf_image_cleanup(&cleanup->exec); __elf_image_cleanup(&ctx->exec);
__elf_image_cleanup(&cleanup->vdso); __elf_image_cleanup(&ctx->vdso);
if (cleanup->interp_vmo) { if (ctx->interp_vmo) {
mx_handle_close(cleanup->interp_vmo); mx_handle_close(ctx->interp_vmo);
cleanup->interp_vmo = MX_NULL_HANDLE; ctx->interp_vmo = MX_NULL_HANDLE;
} }
if (cleanup->interp_path) { if (ctx->interp_path) {
free(cleanup->interp_path); free(ctx->interp_path);
cleanup->interp_path = NULL; ctx->interp_path = NULL;
} }
if (cleanup->stack_vmo) { if (ctx->stack_vmo) {
mx_handle_close(cleanup->stack_vmo); mx_handle_close(ctx->stack_vmo);
cleanup->stack_vmo = MX_NULL_HANDLE; ctx->stack_vmo = MX_NULL_HANDLE;
} }
if (cleanup->new_vmar) { if (ctx->new_vmar) {
mx_handle_close(cleanup->new_vmar); mx_handle_close(ctx->new_vmar);
cleanup->new_vmar = MX_NULL_HANDLE; ctx->new_vmar = MX_NULL_HANDLE;
} }
if (cleanup->bootstrap_local) { if (ctx->bootstrap_local) {
mx_handle_close(cleanup->bootstrap_local); mx_handle_close(ctx->bootstrap_local);
cleanup->bootstrap_local = MX_NULL_HANDLE; ctx->bootstrap_local = MX_NULL_HANDLE;
} }
if (cleanup->fd) { if (ctx->fd) {
free(cleanup->fd); free(ctx->fd);
cleanup->fd = NULL; ctx->fd = NULL;
} }
if (cleanup->ldsvc_version == LDV1_VERSION && cleanup->ldsvc.handle) { if (ctx->ldsvc_version == LDV1_VERSION && ctx->ldsvc.handle) {
mx_handle_close(cleanup->ldsvc.handle); mx_handle_close(ctx->ldsvc.handle);
cleanup->ldsvc.handle = MX_NULL_HANDLE; ctx->ldsvc.handle = MX_NULL_HANDLE;
} else if (cleanup->ldsvc_version == LDV2_VERSION && cleanup->ldsvc.sock) { } else if (ctx->ldsvc_version == LDV2_VERSION && ctx->ldsvc.sock) {
xpc_socket_destroy(cleanup->ldsvc.sock); xpc_socket_destroy(ctx->ldsvc.sock);
cleanup->ldsvc.sock = NULL; ctx->ldsvc.sock = NULL;
} }
} }
static int inherit_namespace(const struct launch_info *info, struct cleanup *cleanup) static int inherit_namespace(const struct launch_info *info, struct launch_ctx *ctx)
{ {
if (!(info->flags & LAUNCH_INHERIT_NS)) { if (!(info->flags & LAUNCH_INHERIT_NS)) {
return 0; return 0;
} }
cleanup->inherited_ns = mio_namespace_export(mio_global_namespace(), &cleanup->inherited_ns_len); ctx->inherited_ns = mio_namespace_export(mio_global_namespace(), &ctx->inherited_ns_len);
return cleanup->inherited_ns ? 0 : -1; return ctx->inherited_ns ? 0 : -1;
} }
static mx_handle_t request_v1(mx_handle_t ldsvc, const char *name) static mx_handle_t request_v1(mx_handle_t ldsvc, const char *name)
@@ -684,13 +684,13 @@ static mx_handle_t request_v2(xpc_socket ldsvc, const char *name)
return vmo; return vmo;
} }
static mx_handle_t request_image(struct cleanup *cleanup, const char *name) static mx_handle_t request_image(struct launch_ctx *ctx, const char *name)
{ {
switch (cleanup->ldsvc_version) { switch (ctx->ldsvc_version) {
case 0: case 0:
return request_v1(cleanup->ldsvc.handle, name); return request_v1(ctx->ldsvc.handle, name);
case 1: case 1:
return request_v2(cleanup->ldsvc.sock, name); return request_v2(ctx->ldsvc.sock, name);
default: default:
return MX_NULL_HANDLE; return MX_NULL_HANDLE;
} }
@@ -714,7 +714,7 @@ static const char *get_name_from_path(const struct launch_info *info)
return e; return e;
} }
static int load_exec(const struct launch_info *info, struct cleanup *cleanup) static int load_exec(const struct launch_info *info, struct launch_ctx *ctx)
{ {
mx_handle_t local_vmar = mx_bootstrap_handle_get(MX_B_VMAR_ROOT); mx_handle_t local_vmar = mx_bootstrap_handle_get(MX_B_VMAR_ROOT);
mx_handle_t self_task = mx_bootstrap_handle_get(MX_B_TASK_SELF); mx_handle_t self_task = mx_bootstrap_handle_get(MX_B_TASK_SELF);
@@ -727,74 +727,74 @@ static int load_exec(const struct launch_info *info, struct cleanup *cleanup)
char interp_path[1024]; char interp_path[1024];
interp_path[0] = '\0'; interp_path[0] = '\0';
__elf_get_interp_path(cleanup->exec_vmo, interp_path, sizeof interp_path); __elf_get_interp_path(ctx->exec_vmo, interp_path, sizeof interp_path);
mx_handle_t real_exec = cleanup->exec_vmo; mx_handle_t real_exec = ctx->exec_vmo;
if (*interp_path != '\0') { if (*interp_path != '\0') {
real_exec = request_image(cleanup, interp_path); real_exec = request_image(ctx, interp_path);
if (real_exec == MX_NULL_HANDLE) { if (real_exec == MX_NULL_HANDLE) {
set_error_msg("cannot open program interpreter '%s'", interp_path); set_error_msg("cannot open program interpreter '%s'", interp_path);
return ENOENT; return ENOENT;
} }
cleanup->interp_vmo = real_exec; ctx->interp_vmo = real_exec;
cleanup->interp_path = strdup(interp_path); ctx->interp_path = strdup(interp_path);
} }
const char *new_task_name = get_name_from_path(info); const char *new_task_name = get_name_from_path(info);
mx_status_t status = mx_task_create(self_task, mx_status_t status = mx_task_create(self_task,
new_task_name, strlen(new_task_name), new_task_name, strlen(new_task_name),
0, &cleanup->new_task, &cleanup->new_vmar); 0, &ctx->new_task, &ctx->new_vmar);
if (status != MX_OK) { if (status != MX_OK) {
return mio_errno_from_mx_status(status); return mio_errno_from_mx_status(status);
} }
__elf_image_init(local_vmar, cleanup->new_vmar, &cleanup->exec); __elf_image_init(local_vmar, ctx->new_vmar, &ctx->exec);
if (__elf_image_load_image(&cleanup->exec, real_exec)) { if (__elf_image_load_image(&ctx->exec, real_exec)) {
set_error_msg("cannot load %s image", cleanup->interp_vmo ? "interpreter" : "executable"); set_error_msg("cannot load %s image", ctx->interp_vmo ? "interpreter" : "executable");
return ENOEXEC; return ENOEXEC;
} }
__elf_image_init(local_vmar, cleanup->new_vmar, &cleanup->vdso); __elf_image_init(local_vmar, ctx->new_vmar, &ctx->vdso);
if (__elf_image_load_image(&cleanup->vdso, vdso_vmo)) { if (__elf_image_load_image(&ctx->vdso, vdso_vmo)) {
set_error_msg("cannot load vDSO image"); set_error_msg("cannot load vDSO image");
return ENOEXEC; return ENOEXEC;
} }
if (__elf_image_link(&cleanup->exec, &cleanup->vdso)) { if (__elf_image_link(&ctx->exec, &ctx->vdso)) {
set_error_msg("cannot link %s image", cleanup->interp_vmo ? "interpreter" : "executable"); set_error_msg("cannot link %s image", ctx->interp_vmo ? "interpreter" : "executable");
return ENOEXEC; return ENOEXEC;
} }
cleanup->entry_point = __elf_image_entry_point(&cleanup->exec); ctx->entry_point = __elf_image_entry_point(&ctx->exec);
return 0; return 0;
} }
static int allocate_stack(struct cleanup *cleanup) static int allocate_stack(struct launch_ctx *ctx)
{ {
mx_status_t status = mx_vmo_create(DEFAULT_STACK_SZ, 0, &cleanup->stack_vmo); mx_status_t status = mx_vmo_create(DEFAULT_STACK_SZ, 0, &ctx->stack_vmo);
if (status != MX_OK) { if (status != MX_OK) {
set_error_msg("cannot allocate stack for new process: %s", mx_status_to_string(status)); set_error_msg("cannot allocate stack for new process: %s", mx_status_to_string(status));
return mio_errno_from_mx_status(status); return mio_errno_from_mx_status(status);
} }
mx_vaddr_t stack_buf; mx_vaddr_t stack_buf;
status = mx_vmar_map(cleanup->new_vmar, MX_VM_PERM_READ | MX_VM_PERM_WRITE, status = mx_vmar_map(ctx->new_vmar, MX_VM_PERM_READ | MX_VM_PERM_WRITE,
0, cleanup->stack_vmo, 0, DEFAULT_STACK_SZ, &stack_buf); 0, ctx->stack_vmo, 0, DEFAULT_STACK_SZ, &stack_buf);
if (status != MX_OK) { if (status != MX_OK) {
set_error_msg("cannot map stack for new process: %s", mx_status_to_string(status)); set_error_msg("cannot map stack for new process: %s", mx_status_to_string(status));
return mio_errno_from_mx_status(status); return mio_errno_from_mx_status(status);
} }
cleanup->stack_ptr = stack_buf + DEFAULT_STACK_SZ; ctx->stack_ptr = stack_buf + DEFAULT_STACK_SZ;
return 0; return 0;
} }
static int get_ldv1_handle(mx_handle_t handle, struct cleanup *cleanup) static int get_ldv1_handle(mx_handle_t handle, struct launch_ctx *ctx)
{ {
mx_handle_t t0, t1; mx_handle_t t0, t1;
mx_tunnel_create(&t0, &t1); mx_tunnel_create(&t0, &t1);
@@ -823,12 +823,12 @@ static int get_ldv1_handle(mx_handle_t handle, struct cleanup *cleanup)
return ENOLINK; return ENOLINK;
} }
cleanup->ldsvc_version = LDV1_VERSION; ctx->ldsvc_version = LDV1_VERSION;
cleanup->ldsvc.handle = t1; ctx->ldsvc.handle = t1;
return 0; return 0;
} }
static int get_ldv2_handle(mx_handle_t handle, struct cleanup *cleanup) static int get_ldv2_handle(mx_handle_t handle, struct launch_ctx *ctx)
{ {
xpc_socket sock = xpc_socket_create(XPC_SOCKET_REQUESTER); xpc_socket sock = xpc_socket_create(XPC_SOCKET_REQUESTER);
xpc_socket_connect_tunnel(sock, handle); xpc_socket_connect_tunnel(sock, handle);
@@ -857,12 +857,12 @@ static int get_ldv2_handle(mx_handle_t handle, struct cleanup *cleanup)
xpc_socket_release_tunnel(sock, NULL); xpc_socket_release_tunnel(sock, NULL);
xpc_socket_connect_tunnel(sock, t0); xpc_socket_connect_tunnel(sock, t0);
cleanup->ldsvc_version = LDV2_VERSION; ctx->ldsvc_version = LDV2_VERSION;
cleanup->ldsvc.sock = sock; ctx->ldsvc.sock = sock;
return 0; return 0;
} }
static int open_ldv2_handle(struct cleanup *cleanup) static int open_ldv2_handle(struct launch_ctx *ctx)
{ {
int ldsvc_fd = open("/svc/horizon.sys.LoaderService/0", O_RDWR); int ldsvc_fd = open("/svc/horizon.sys.LoaderService/0", O_RDWR);
if (ldsvc_fd == -1) { if (ldsvc_fd == -1) {
@@ -876,13 +876,13 @@ static int open_ldv2_handle(struct cleanup *cleanup)
xpc_socket sock = xpc_socket_create(XPC_SOCKET_REQUESTER); xpc_socket sock = xpc_socket_create(XPC_SOCKET_REQUESTER);
xpc_socket_connect_tunnel(sock, handle); xpc_socket_connect_tunnel(sock, handle);
cleanup->ldsvc_version = LDV2_VERSION; ctx->ldsvc_version = LDV2_VERSION;
cleanup->ldsvc.sock = sock; ctx->ldsvc.sock = sock;
return 0; return 0;
} }
static int get_ldsvc_handle(struct cleanup *cleanup) static int get_ldsvc_handle(struct launch_ctx *ctx)
{ {
size_t nr_handles; size_t nr_handles;
const mx_bootstrap_handle_t *handles = mx_bootstrap_handle_get_all(&nr_handles); const mx_bootstrap_handle_t *handles = mx_bootstrap_handle_get_all(&nr_handles);
@@ -905,11 +905,11 @@ static int get_ldsvc_handle(struct cleanup *cleanup)
int err = 0; int err = 0;
if (handle == MX_NULL_HANDLE) { if (handle == MX_NULL_HANDLE) {
err = open_ldv2_handle(cleanup); err = open_ldv2_handle(ctx);
} else if (version == LDV1_VERSION) { } else if (version == LDV1_VERSION) {
err = get_ldv1_handle(handle, cleanup); err = get_ldv1_handle(handle, ctx);
} else if (version == LDV2_VERSION) { } else if (version == LDV2_VERSION) {
err = get_ldv2_handle(handle, cleanup); err = get_ldv2_handle(handle, ctx);
} else { } else {
set_error_msg("no connection to loader service"); set_error_msg("no connection to loader service");
return ENOLINK; return ENOLINK;
@@ -1010,18 +1010,18 @@ static mx_handle_t *raw_handles(mx_bootstrap_handle_t *handles, size_t count)
return out; return out;
} }
static int send_interp_bootstrap_message(const struct launch_info *args, struct cleanup *cleanup) static int send_interp_bootstrap_message(const struct launch_info *args, struct launch_ctx *ctx)
{ {
mx_handle_t vdso_vmo = mx_bootstrap_handle_get(MX_B_VMO_VDSO); mx_handle_t vdso_vmo = mx_bootstrap_handle_get(MX_B_VMO_VDSO);
mx_handle_t ldsvc = MX_NULL_HANDLE; mx_handle_t ldsvc = MX_NULL_HANDLE;
if (cleanup->ldsvc_version == 0) { if (ctx->ldsvc_version == 0) {
ldsvc = cleanup->ldsvc.handle; ldsvc = ctx->ldsvc.handle;
cleanup->ldsvc.handle = MX_NULL_HANDLE; ctx->ldsvc.handle = MX_NULL_HANDLE;
} else { } else {
xpc_socket_release_tunnel(cleanup->ldsvc.sock, &ldsvc); xpc_socket_release_tunnel(ctx->ldsvc.sock, &ldsvc);
xpc_socket_destroy(cleanup->ldsvc.sock); xpc_socket_destroy(ctx->ldsvc.sock);
cleanup->ldsvc.sock = NULL; ctx->ldsvc.sock = NULL;
} }
/* required handles for interpreter: /* required handles for interpreter:
@@ -1033,21 +1033,21 @@ static int send_interp_bootstrap_message(const struct launch_info *args, struct
* exec vmar * exec vmar
*/ */
mx_bootstrap_handle_t handles[] = { mx_bootstrap_handle_t handles[] = {
ARG_HANDLE(cleanup->new_task, MX_B_HND(MX_B_TASK_SELF, 0)), ARG_HANDLE(ctx->new_task, MX_B_HND(MX_B_TASK_SELF, 0)),
ARG_HANDLE(cleanup->exec_vmo, MX_B_HND(MX_B_VMO_EXEC, 0)), ARG_HANDLE(ctx->exec_vmo, MX_B_HND(MX_B_VMO_EXEC, 0)),
ARG_HANDLE(cleanup->new_vmar, MX_B_HND(MX_B_VMAR_ROOT, 0)), ARG_HANDLE(ctx->new_vmar, MX_B_HND(MX_B_VMAR_ROOT, 0)),
ARG_HANDLE(cleanup->exec.remote_exec_vmar, MX_B_HND(MX_B_VMAR_EXEC, 0)), ARG_HANDLE(ctx->exec.remote_exec_vmar, MX_B_HND(MX_B_VMAR_EXEC, 0)),
ARG_HANDLE(vdso_vmo, MX_B_HND(MX_B_VMO_VDSO, 0)), ARG_HANDLE(vdso_vmo, MX_B_HND(MX_B_VMO_VDSO, 0)),
ARG_HANDLE(ldsvc, MX_B_HND(MX_B_TUNNEL_LDSVC, cleanup->ldsvc_version)), ARG_HANDLE(ldsvc, MX_B_HND(MX_B_TUNNEL_LDSVC, ctx->ldsvc_version)),
ARG_HANDLE(cleanup->stdio[0], MX_B_HND(MX_B_FD, 0)), ARG_HANDLE(ctx->stdio[0], MX_B_HND(MX_B_FD, 0)),
ARG_HANDLE(cleanup->stdio[1], MX_B_HND(MX_B_FD, 1)), ARG_HANDLE(ctx->stdio[1], MX_B_HND(MX_B_FD, 1)),
ARG_HANDLE(cleanup->stdio[2], MX_B_HND(MX_B_FD, 2)), ARG_HANDLE(ctx->stdio[2], MX_B_HND(MX_B_FD, 2)),
}; };
static size_t handle_count = sizeof handles / sizeof handles[0]; static size_t handle_count = sizeof handles / sizeof handles[0];
const char *argv[] = { const char *argv[] = {
cleanup->interp_path, ctx->interp_path,
args->path, args->path,
}; };
const int argc = sizeof argv / sizeof *argv; const int argc = sizeof argv / sizeof *argv;
@@ -1062,7 +1062,7 @@ static int send_interp_bootstrap_message(const struct launch_info *args, struct
handle_count, handles, handle_count, handles,
&msg_len, &raw_handles); &msg_len, &raw_handles);
mx_tunnel_write_etc(cleanup->bootstrap_local, mx_tunnel_write_etc(ctx->bootstrap_local,
MX_TUNNEL_DUPLICATE_HANDLES, MX_TUNNEL_DUPLICATE_HANDLES,
msg, msg_len, msg, msg_len,
raw_handles, handle_count); raw_handles, handle_count);
@@ -1072,11 +1072,11 @@ static int send_interp_bootstrap_message(const struct launch_info *args, struct
return 0; return 0;
} }
static int send_exec_bootstrap_message(const struct launch_info *args, struct cleanup *cleanup) static int send_exec_bootstrap_message(const struct launch_info *args, struct launch_ctx *ctx)
{ {
mx_bootstrap_handle_t *default_handles = mx_bootstrap_handle_t *default_handles =
cleanup->b_handles ctx->b_handles
+ cleanup->b_handle_count + ctx->b_handle_count
- NR_DEFAULT_HANDLES; - NR_DEFAULT_HANDLES;
mx_handle_t vdso_vmo = mx_bootstrap_handle_get(MX_B_VMO_VDSO); mx_handle_t vdso_vmo = mx_bootstrap_handle_get(MX_B_VMO_VDSO);
@@ -1090,12 +1090,12 @@ static int send_exec_bootstrap_message(const struct launch_info *args, struct cl
* MX_B_TUNNEL_BTSTP * MX_B_TUNNEL_BTSTP
*/ */
int tmp = 0; int tmp = 0;
default_handles[tmp++] = ARG_HANDLE(cleanup->new_task, MX_B_HND(MX_B_TASK_SELF, 0)); default_handles[tmp++] = ARG_HANDLE(ctx->new_task, MX_B_HND(MX_B_TASK_SELF, 0));
default_handles[tmp++] = ARG_HANDLE(vdso_vmo, MX_B_HND(MX_B_VMO_VDSO, 0)); default_handles[tmp++] = ARG_HANDLE(vdso_vmo, MX_B_HND(MX_B_VMO_VDSO, 0));
default_handles[tmp++] = ARG_HANDLE(cleanup->exec_vmo, MX_B_HND(MX_B_VMO_EXEC, 0)); default_handles[tmp++] = ARG_HANDLE(ctx->exec_vmo, MX_B_HND(MX_B_VMO_EXEC, 0));
default_handles[tmp++] = ARG_HANDLE(cleanup->new_vmar, MX_B_HND(MX_B_VMAR_ROOT, 0)); default_handles[tmp++] = ARG_HANDLE(ctx->new_vmar, MX_B_HND(MX_B_VMAR_ROOT, 0));
default_handles[tmp++] = ARG_HANDLE(cleanup->exec.remote_exec_vmar, MX_B_HND(MX_B_VMAR_EXEC, 0)); default_handles[tmp++] = ARG_HANDLE(ctx->exec.remote_exec_vmar, MX_B_HND(MX_B_VMAR_EXEC, 0));
default_handles[tmp++] = ARG_HANDLE(cleanup->bootstrap_remote, MX_B_HND(MX_B_TUNNEL_BTSTP, 0)); default_handles[tmp++] = ARG_HANDLE(ctx->bootstrap_remote, MX_B_HND(MX_B_TUNNEL_BTSTP, 0));
mx_handle_t *raw_handles; mx_handle_t *raw_handles;
@@ -1103,130 +1103,130 @@ static int send_exec_bootstrap_message(const struct launch_info *args, struct cl
mx_bootstrap_msg_t *msg = build_bootstrap_message( mx_bootstrap_msg_t *msg = build_bootstrap_message(
args->argc, args->argv, args->argc, args->argv,
0, NULL, 0, NULL,
cleanup->name_count, cleanup->names, ctx->name_count, ctx->names,
cleanup->b_handle_count, cleanup->b_handles, ctx->b_handle_count, ctx->b_handles,
&msg_len, &raw_handles); &msg_len, &raw_handles);
mx_tunnel_write_etc(cleanup->bootstrap_local, mx_tunnel_write_etc(ctx->bootstrap_local,
MX_TUNNEL_DUPLICATE_HANDLES, MX_TUNNEL_DUPLICATE_HANDLES,
msg, msg_len, msg, msg_len,
raw_handles, cleanup->b_handle_count); raw_handles, ctx->b_handle_count);
free(raw_handles); free(raw_handles);
free(msg); free(msg);
return 0; return 0;
} }
static int send_bootstrap_messages(const struct launch_info *args, struct cleanup *cleanup) static int send_bootstrap_messages(const struct launch_info *args, struct launch_ctx *ctx)
{ {
if (cleanup->interp_vmo) { if (ctx->interp_vmo) {
send_interp_bootstrap_message(args, cleanup); send_interp_bootstrap_message(args, ctx);
} }
send_exec_bootstrap_message(args, cleanup); send_exec_bootstrap_message(args, ctx);
return 0; return 0;
} }
int launch(const struct launch_info *args, mx_handle_t *out_task) int launch(const struct launch_info *args, mx_handle_t *out_task)
{ {
struct cleanup cleanup = {}; struct launch_ctx ctx = {};
int err = get_ldsvc_handle(&cleanup); int err = get_ldsvc_handle(&ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
if (!args->path) { if (!args->path) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(EFAULT); RET_ERR(EFAULT);
} }
err = validate_argv(args->argc, args->argv); err = validate_argv(args->argc, args->argv);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = validate_fds(args, &cleanup); err = validate_fds(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = validate_ns(args->flags, args->ns, args->ns_count); err = validate_ns(args->flags, args->ns, args->ns_count);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = inherit_namespace(args, &cleanup); err = inherit_namespace(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = count_handles(args, &cleanup); err = count_handles(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = collect_handles(args, &cleanup); err = collect_handles(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = collect_names(args, &cleanup); err = collect_names(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
int exec_fd = open(args->path, O_RDONLY); int exec_fd = open(args->path, O_RDONLY);
if (exec_fd == -1) { if (exec_fd == -1) {
int error = errno; int error = errno;
fail_cleanup(&cleanup); fail_cleanup(&ctx);
set_error_msg("cannot open file '%s': %s", args->path, strerror(error)); set_error_msg("cannot open file '%s': %s", args->path, strerror(error));
RET_ERR(error); RET_ERR(error);
} }
err = mio_map_file(exec_fd, &cleanup.exec_vmo); err = mio_map_file(exec_fd, &ctx.exec_vmo);
close(exec_fd); close(exec_fd);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
set_error_msg("cannot map file '%s': %s", args->path, strerror(-err)); set_error_msg("cannot map file '%s': %s", args->path, strerror(-err));
RET_ERR(-err); RET_ERR(-err);
} }
err = load_exec(args, &cleanup); err = load_exec(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
err = allocate_stack(&cleanup); err = allocate_stack(&ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
mx_tunnel_create(&cleanup.bootstrap_local, &cleanup.bootstrap_remote); mx_tunnel_create(&ctx.bootstrap_local, &ctx.bootstrap_remote);
err = send_bootstrap_messages(args, &cleanup); err = send_bootstrap_messages(args, &ctx);
if (err != 0) { if (err != 0) {
fail_cleanup(&cleanup); fail_cleanup(&ctx);
RET_ERR(err); RET_ERR(err);
} }
success_cleanup(&cleanup); success_cleanup(&ctx);
set_error_msg("success"); set_error_msg("success");
mx_task_start(cleanup.new_task, cleanup.entry_point, cleanup.stack_ptr, cleanup.bootstrap_remote, 0); mx_task_start(ctx.new_task, ctx.entry_point, ctx.stack_ptr, ctx.bootstrap_remote, 0);
mx_handle_close(cleanup.bootstrap_remote); mx_handle_close(ctx.bootstrap_remote);
*out_task = cleanup.new_task; *out_task = ctx.new_task;
return 0; return 0;
} }