Index: uspace/lib/c/include/ipc/common.h =================================================================== --- uspace/lib/c/include/ipc/common.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/lib/c/include/ipc/common.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -39,5 +39,8 @@ #include -#define IPC_FLAG_BLOCKING 0x01 +#define IPC_FLAG_BLOCKING 0x01 +// TODO autostart flag may be united with blocking, this should be later made +// implicit, documented or refactor pairs of xxx and xxx_blocking methods +#define IPC_FLAG_AUTOSTART 0x02 typedef ipc_data_t ipc_call_t; Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/lib/c/include/ipc/services.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -40,4 +40,5 @@ #include +/** Name of service brokered by NS */ typedef enum { SERVICE_NONE = 0, @@ -45,4 +46,5 @@ SERVICE_VFS = FOURCC('v', 'f', 's', ' '), SERVICE_LOC = FOURCC('l', 'o', 'c', ' '), + SERVICE_SYSMAN = FOURCC('s', 'y', 's', 'm'), SERVICE_LOGGER = FOURCC('l', 'o', 'g', 'g'), SERVICE_DEVMAN = FOURCC('d', 'e', 'v', 'n'), @@ -64,4 +66,7 @@ #define SERVICE_NAME_VOLSRV "volsrv" +#define LOC_DEVICE_NAMESPACE "devices" +#define LOC_UNIT_NAMESPACE_SEPARATOR "__" + #endif Index: uspace/lib/c/include/ipc/sysman.h =================================================================== --- uspace/lib/c/include/ipc/sysman.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/c/include/ipc/sysman.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libcipc + * @{ + */ +/** @file + */ + +#ifndef LIBC_IPC_SYSMAN_H_ +#define LIBC_IPC_SYSMAN_H_ + +#include + +typedef enum { + SYSMAN_BROKER_REGISTER = IPC_FIRST_USER_METHOD, + SYSMAN_BROKER_IPC_FWD, + SYSMAN_BROKER_MAIN_EXP_ADDED, + SYSMAN_BROKER_EXP_ADDED, + SYSMAN_BROKER_EXP_REMOVED, + SYSMAN_CTL_UNIT_START +} sysman_ipc_method_t; + +typedef enum { + SYSMAN_PORT_BROKER = 0, + SYSMAN_PORT_CTL, + SYSMAN_PORT_MAX_ +} sysman_interface_t; + +#endif + +/** @} + */ Index: uspace/lib/sysman/Makefile =================================================================== --- uspace/lib/sysman/Makefile (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/Makefile (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,38 @@ +# +# Copyright (c) 2015 Michal Koutny +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libsysman +EXTRA_CFLAGS += -I./include + +SOURCES = \ + src/broker.c \ + src/ctl.c \ + src/sysman.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/sysman/include/sysman/broker.h =================================================================== --- uspace/lib/sysman/include/sysman/broker.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/include/sysman/broker.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SYSMAN_BROKER_H +#define _SYSMAN_BROKER_H + +#include +#include + +int sysman_broker_register(void); + +void sysman_ipc_forwarded(task_id_t, const char *); + +void sysman_main_exposee_added(const char *, task_id_t); + +void sysman_exposee_added(const char *); +void sysman_exposee_removed(const char *); + +#endif Index: uspace/lib/sysman/include/sysman/ctl.h =================================================================== --- uspace/lib/sysman/include/sysman/ctl.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/include/sysman/ctl.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SYSMAN_CTL_H +#define _SYSMAN_CTL_H + +#include + +int sysman_unit_start(const char *, int); + +#endif Index: uspace/lib/sysman/include/sysman/sysman.h =================================================================== --- uspace/lib/sysman/include/sysman/sysman.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/include/sysman/sysman.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SYSMAN_SYSMAN_H +#define _SYSMAN_SYSMAN_H + +#include +#include + +async_exch_t *sysman_exchange_begin(sysman_interface_t); + +void sysman_exchange_end(async_exch_t *); + +#endif Index: uspace/lib/sysman/include/sysman/unit.h =================================================================== --- uspace/lib/sysman/include/sysman/unit.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/include/sysman/unit.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SYSMAN_UNIT_H +#define _SYSMAN_UNIT_H + +#define UNIT_NAME_SEPARATOR '.' + +#define UNIT_CFG_TYPE_NAME "cfg" +#define UNIT_MNT_TYPE_NAME "mnt" +#define UNIT_TGT_TYPE_NAME "tgt" +#define UNIT_SVC_TYPE_NAME "svc" + +#endif Index: uspace/lib/sysman/src/broker.c =================================================================== --- uspace/lib/sysman/src/broker.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/src/broker.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include + +int sysman_broker_register(void) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_BROKER); + + int rc = async_req_0_0(exch, SYSMAN_BROKER_REGISTER); + sysman_exchange_end(exch); + + return rc; +} + +void sysman_ipc_forwarded(task_id_t caller, const char *dst_unit_name) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_BROKER); + + aid_t req = async_send_1(exch, SYSMAN_BROKER_IPC_FWD, caller, NULL); + (void)async_data_write_start(exch, dst_unit_name, str_size(dst_unit_name)); + sysman_exchange_end(exch); + + async_forget(req); +} + +void sysman_main_exposee_added(const char *unit_name, task_id_t caller) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_BROKER); + + aid_t req = async_send_1(exch, SYSMAN_BROKER_MAIN_EXP_ADDED, caller, NULL); + (void)async_data_write_start(exch, unit_name, str_size(unit_name)); + sysman_exchange_end(exch); + + async_forget(req); +} + +void sysman_exposee_added(const char *exposee) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_BROKER); + + aid_t req = async_send_0(exch, SYSMAN_BROKER_EXP_ADDED, NULL); + (void)async_data_write_start(exch, exposee, str_size(exposee)); + sysman_exchange_end(exch); + + async_forget(req); +} + +void sysman_exposee_removed(const char *exposee) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_BROKER); + + aid_t req = async_send_0(exch, SYSMAN_BROKER_EXP_REMOVED, NULL); + (void)async_data_write_start(exch, exposee, str_size(exposee)); + sysman_exchange_end(exch); + + async_forget(req); +} + + Index: uspace/lib/sysman/src/ctl.c =================================================================== --- uspace/lib/sysman/src/ctl.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/src/ctl.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include + +int sysman_unit_start(const char *unit_name, int flags) +{ + async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL); + + aid_t req = async_send_1(exch, SYSMAN_CTL_UNIT_START, flags, NULL); + sysarg_t rc = async_data_write_start(exch, unit_name, str_size(unit_name)); + sysman_exchange_end(exch); + + if (rc != EOK) { + async_forget(req); + return rc; + } + + async_wait_for(req, &rc); + return rc; +} Index: uspace/lib/sysman/src/sysman.c =================================================================== --- uspace/lib/sysman/src/sysman.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/lib/sysman/src/sysman.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +static async_sess_t *sysman_sess[SYSMAN_PORT_MAX_] = {NULL}; + +async_exch_t *sysman_exchange_begin(sysman_interface_t iface) +{ + // TODO need special session for each iface! + if (sysman_sess[iface] == NULL) { + // TODO serialize vs parallel + sysman_sess[iface] = service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_SYSMAN, iface, 0); + } + + if (sysman_sess[iface] == NULL) { + return NULL; + } + + return async_exchange_begin(sysman_sess[iface]); +} + +void sysman_exchange_end(async_exch_t *exch) +{ + async_exchange_end(exch); +} + Index: uspace/srv/devman/devman.h =================================================================== --- uspace/srv/devman/devman.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/devman/devman.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -48,5 +48,4 @@ #define NAME "devman" -#define LOC_DEVICE_NAMESPACE "devices" #define LOC_SEPARATOR '\\' Index: uspace/srv/devman/loc.c =================================================================== --- uspace/srv/devman/loc.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/devman/loc.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -31,4 +31,5 @@ */ +#include #include #include Index: uspace/srv/locsrv/Makefile =================================================================== --- uspace/srv/locsrv/Makefile (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/locsrv/Makefile (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -29,4 +29,6 @@ USPACE_PREFIX = ../.. +LIBS = $(LIBSYSMAN_PREFIX)/libsysman.a +EXTRA_CFLAGS += -I$(LIBSYSMAN_PREFIX)/include BINARY = locsrv STATIC_NEEDED = y Index: uspace/srv/locsrv/locsrv.c =================================================================== --- uspace/srv/locsrv/locsrv.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/locsrv/locsrv.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -36,17 +36,19 @@ */ +#include +#include +#include +#include #include -#include -#include -#include -#include -#include #include #include +#include +#include +#include #include #include #include -#include -#include +#include +#include #include "category.h" @@ -331,4 +333,36 @@ free(service->name); free(service); +} + +static int loc_service_request_start(const char *ns_name, const char *name) +{ + char *service_name = NULL; + + if (str_cmp(ns_name, LOC_DEVICE_NAMESPACE) == 0) { + asprintf(&service_name, "%s", SERVICE_NAME_DEVMAN); + } else if (str_cmp(ns_name, "") == 0) { + asprintf(&service_name, "%s", name); + } else { + asprintf(&service_name, "%s%s%s", + ns_name, LOC_UNIT_NAMESPACE_SEPARATOR, name); + } + if (service_name == NULL) { + return ENOMEM; + } + + char *unit_name; + asprintf(&unit_name, "%s%c%s", + service_name, UNIT_NAME_SEPARATOR, UNIT_SVC_TYPE_NAME); + if (unit_name == NULL) { + free(service_name); + return ENOMEM; + } + + printf("%s(%s) before\n", __func__, unit_name); + int rc = sysman_unit_start(unit_name, IPC_FLAG_BLOCKING); + printf("%s(%s) after %i\n", __func__, unit_name, rc); + free(unit_name); + free(service_name); + return rc; } @@ -531,4 +565,7 @@ list_append(&service->server_services, &service->server->services); + + printf("%s: broadcast new service '%s/%s'\n", NAME, namespace->name, + service->name); fibril_mutex_unlock(&service->server->services_mutex); @@ -542,5 +579,6 @@ * */ -static void loc_service_unregister(ipc_call_t *icall, loc_server_t *server) +static void loc_service_unregister(ipc_callid_t iid, ipc_call_t *icall, + loc_server_t *server) { loc_service_t *svc; @@ -762,5 +800,6 @@ fibril_mutex_lock(&services_list_mutex); const loc_service_t *svc; - + int flags = ipc_get_arg1(*icall); + recheck: @@ -771,23 +810,39 @@ /* - * Device was not found. + * Service was not found. */ if (svc == NULL) { - if (ipc_get_arg1(icall) & IPC_FLAG_BLOCKING) { - /* Blocking lookup */ + printf("%s: service '%s/%s' not found\n", NAME, ns_name, name); + if (flags & (IPC_FLAG_AUTOSTART | IPC_FLAG_BLOCKING)) { + /* TODO: + * consider non-blocking service start, return + * some dummy id and block only after connection + * request (actually makes more sense as those who asks + * for ID might be someone else than those connecting) + */ + if (flags & IPC_FLAG_AUTOSTART) { + rc = loc_service_request_start(ns_name, name); + if (rc != EOK) { + goto finish; + } + } + fibril_condvar_wait(&services_list_cv, &services_list_mutex); goto recheck; } - - async_answer_0(icall, ENOENT); - free(ns_name); - free(name); - fibril_mutex_unlock(&services_list_mutex); - return; - } - - async_answer_1(icall, EOK, svc->id); - + rc = ENOENT; + } else { + printf("%s: service '%s/%s' FOUND\n", NAME, ns_name, name); + rc = EOK; + } + +finish: + if (rc == EOK) { + async_answer_1(iid, EOK, svc->id); + } else { + async_answer_0(iid, rc); + } + fibril_mutex_unlock(&services_list_mutex); free(ns_name); @@ -1565,4 +1620,11 @@ if (rc != EOK) { printf("%s: Error while registering broker service: %s\n", NAME, str_error(rc)); + + /* Let sysman know we are broker */ + printf("%s: sysman_broker_register : pre\n", NAME); + rc = sysman_broker_register(); + printf("%s: sysman_broker_register : post\n", NAME); + if (rc != EOK) { + printf("%s: Error registering at sysman (%i)\n", NAME, rc); return rc; } Index: uspace/srv/sysman/Makefile =================================================================== --- uspace/srv/sysman/Makefile (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/Makefile (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -30,5 +30,8 @@ USPACE_PREFIX = ../.. LIBS = $(LIBCONF_PREFIX)/libconf.a -EXTRA_CFLAGS += -I. -I./units -I$(LIBCONF_PREFIX)/include +EXTRA_CFLAGS += -I. \ + -I./units \ + -I$(LIBCONF_PREFIX)/include \ + -I$(LIBSYSMAN_PREFIX)/include BINARY = sysman STATIC_NEEDED = y @@ -36,4 +39,6 @@ SOURCES = \ configuration.c \ + connection_broker.c \ + connection_ctl.c \ dep.c \ job.c \ @@ -44,4 +49,5 @@ units/unit_mnt.c \ units/unit_tgt.c \ + units/unit_svc.c \ util.c Index: uspace/srv/sysman/configuration.c =================================================================== --- uspace/srv/sysman/configuration.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/configuration.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -148,4 +148,8 @@ } +/** Remove all uncommited units and edges from configuratio + * + * Memory used by removed object is released. + */ void configuration_rollback(void) { @@ -186,5 +190,5 @@ * * @return EOK on success - * @return ENONENT when one or more resolution fails, information is logged + * @return ENOENT when one or more resolution fails, information is logged */ int configuration_resolve_dependecies(void) Index: uspace/srv/sysman/connection_broker.c =================================================================== --- uspace/srv/sysman/connection_broker.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/srv/sysman/connection_broker.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include "connection_broker.h" +#include "log.h" + +static void sysman_broker_register(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + async_answer_0(iid, EOK); + // TODO implement +} + +static void sysman_ipc_forwarded(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + async_answer_0(iid, ENOTSUP); + // TODO implement +} + +static void sysman_main_exposee_added(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + async_answer_0(iid, ENOTSUP); + // TODO implement +} + +static void sysman_exposee_added(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + async_answer_0(iid, ENOTSUP); + // TODO implement +} + +static void sysman_exposee_removed(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + async_answer_0(iid, ENOTSUP); + // TODO implement +} + +void sysman_connection_broker(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + /* First, accept connection */ + async_answer_0(iid, EOK); + + while (true) { + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) { + /* Client disconnected */ + break; + } + + switch (IPC_GET_IMETHOD(call)) { + case SYSMAN_BROKER_REGISTER: + sysman_broker_register(callid, &call); + break; + case SYSMAN_BROKER_IPC_FWD: + sysman_ipc_forwarded(callid, &call); + break; + case SYSMAN_BROKER_MAIN_EXP_ADDED: + sysman_main_exposee_added(callid, &call); + break; + case SYSMAN_BROKER_EXP_ADDED: + sysman_exposee_added(callid, &call); + break; + case SYSMAN_BROKER_EXP_REMOVED: + sysman_exposee_removed(callid, &call); + break; + default: + async_answer_0(callid, ENOENT); + } + } +} + + Index: uspace/srv/sysman/connection_broker.h =================================================================== --- uspace/srv/sysman/connection_broker.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/srv/sysman/connection_broker.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SYSMAN_CONNECTION_BROKER_H +#define SYSMAN_CONNECTION_BROKER_H + +#include + +extern void sysman_connection_broker(ipc_callid_t, ipc_call_t *); + +#endif Index: uspace/srv/sysman/connection_ctl.c =================================================================== --- uspace/srv/sysman/connection_ctl.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/srv/sysman/connection_ctl.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +#include "configuration.h" +#include "connection_ctl.h" +#include "job.h" +#include "log.h" +#include "sysman.h" + + +static ipc_callid_t *box_callid(ipc_callid_t iid) +{ + ipc_callid_t *result = malloc(sizeof(ipc_callid_t)); + if (result) { + *result = iid; + } + return result; +} + +static void answer_callback(void *object, void *arg) +{ + job_t *job = object; + assert(job->state == JOB_FINISHED); + assert(job->retval != JOB_UNDEFINED_); + + ipc_callid_t *iid_ptr = arg; + // TODO use descriptive return value (probably refactor job retval) + sysarg_t retval = (job->retval == JOB_OK) ? EOK : EIO; + async_answer_0(*iid_ptr, retval); + free(iid_ptr); + job_del_ref(&job); +} + +static void sysman_unit_start(ipc_callid_t iid, ipc_call_t *icall) +{ + char *unit_name = NULL; + sysarg_t retval; + + int rc = async_data_write_accept((void **) &unit_name, true, + 0, 0, 0, NULL); + if (rc != EOK) { + retval = rc; + goto answer; + } + + int flags = IPC_GET_ARG1(*icall); + sysman_log(LVL_DEBUG2, "%s(%s, %x)", __func__, unit_name, flags); + + unit_t *unit = configuration_find_unit_by_name(unit_name); + if (unit == NULL) { + retval = ENOENT; + goto answer; + } + + if (!(flags & IPC_FLAG_BLOCKING)) { + retval = sysman_queue_job(unit, STATE_STARTED, NULL, NULL); + goto answer; + } + + ipc_callid_t *iid_ptr = box_callid(iid); + if (iid_ptr == NULL) { + retval = ENOMEM; + goto answer; + } + retval = sysman_queue_job(unit, STATE_STARTED, &answer_callback, + iid_ptr); + if (retval != EOK) { + goto answer; + } + + /* Answer asynchronously from callback */ + goto finish; + +answer: + async_answer_0(iid, retval); +finish: + free(unit_name); +} + +void sysman_connection_ctl(ipc_callid_t iid, ipc_call_t *icall) +{ + sysman_log(LVL_DEBUG2, "%s", __func__); + /* First, accept connection */ + async_answer_0(iid, EOK); + + while (true) { + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) { + /* Client disconnected */ + break; + } + + switch (IPC_GET_IMETHOD(call)) { + case SYSMAN_CTL_UNIT_START: + sysman_unit_start(callid, &call); + break; + default: + async_answer_0(callid, ENOENT); + } + } +} + Index: uspace/srv/sysman/connection_ctl.h =================================================================== --- uspace/srv/sysman/connection_ctl.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/srv/sysman/connection_ctl.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SYSMAN_CONNECTION_CTL_H +#define SYSMAN_CONNECTION_CTL_H + +#include + +extern void sysman_connection_ctl(ipc_callid_t, ipc_call_t *); + +#endif Index: uspace/srv/sysman/dep.c =================================================================== --- uspace/srv/sysman/dep.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/dep.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -36,8 +36,8 @@ static void dep_dependency_init(unit_dependency_t *dep) { + memset(dep, 0, sizeof(*dep)); link_initialize(&dep->dependants); link_initialize(&dep->dependencies); - dep->dependency_name = NULL; dep->state = DEP_EMBRYO; } Index: uspace/srv/sysman/job.c =================================================================== --- uspace/srv/sysman/job.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/job.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -73,4 +73,5 @@ assert(job); assert(u); + memset(job, 0, sizeof(*job)); link_initialize(&job->job_queue); @@ -101,9 +102,4 @@ return false; } -} - -static bool job_is_runnable(job_t *job) -{ - return job->state == JOB_QUEUED && job->blocking_jobs == 0; } @@ -126,7 +122,4 @@ } - - - static void job_destroy(job_t **job_ptr) { @@ -145,4 +138,33 @@ free(job); *job_ptr = NULL; +} + +static bool job_is_runnable(job_t *job) +{ + return job->state == JOB_QUEUED && job->blocking_jobs == 0; +} + +/** Pop next runnable job + * + * @return runnable job or NULL when there's none + */ +static job_t *job_queue_pop_runnable(void) +{ + job_t *result = NULL; + + /* Select first runnable job */ + list_foreach(job_queue, job_queue, job_t, candidate) { + if (job_is_runnable(candidate)) { + result = candidate; + break; + } + } + if (result) { + /* Remove job from queue and pass reference to caller */ + list_remove(&result->job_queue); + result->state = JOB_DEQUEUED; + } + + return result; } @@ -163,9 +185,9 @@ /* * Currently we have strict strategy not permitting - * multiple jobs for one unit in the queue. + * multiple jobs for one unit in the queue at a time. */ if ((*new_job_it)->unit == queued_job->unit) { sysman_log(LVL_ERROR, - "Cannot queue multiple jobs foor unit '%s'", + "Cannot queue multiple jobs for unit '%s'", unit_name((*new_job_it)->unit)); return EEXIST; @@ -184,42 +206,19 @@ } -/** Pop next runnable job - * - * @return runnable job or NULL when there's none - */ -job_t *job_queue_pop_runnable(void) -{ - job_t *result = NULL; - link_t *first_link = list_first(&job_queue); - bool first_iteration = true; - - list_foreach_safe(job_queue, cur_link, next_link) { - result = list_get_instance(cur_link, job_t, job_queue); - if (job_is_runnable(result)) { - break; - } else if (!first_iteration && cur_link == first_link) { - result = NULL; - break; - } else { - /* - * We make no assuptions about ordering of jobs in the - * queue, so just move the job to the end of the queue. - * If there are exist topologic ordering, eventually - * jobs will be reordered. Furthermore when if there - * exists any runnable job, it's always found. - */ - list_remove(cur_link); - list_append(cur_link, &job_queue); - } - first_iteration = false; - } - - if (result) { - /* Remove job from queue and pass refernce to caller */ - list_remove(&result->job_queue); - result->state = JOB_DEQUEUED; - } - - return result; +/** Process all jobs that aren't transitively blocked + * + * Job can be blocked either by another job or by an incoming event, that will + * be queued after this job_queue_process call. + * + * TODO Write down rules from where this function can be called, to avoid stack + * overflow. + */ +void job_queue_process(void) +{ + job_t *job; + while ((job = job_queue_pop_runnable())) { + job_run(job); + job_del_ref(&job); + } } @@ -242,9 +241,23 @@ */ fifo_push(jobs_fifo, main_job); - job_t *job; job_add_ref(main_job); - while ((job = fifo_pop(jobs_fifo)) != NULL) { - /* No refcount increase, pass it to the closure */ - dyn_array_append(job_closure, job_ptr_t, job); + while (jobs_fifo.head != jobs_fifo.tail) { + job_t *job = fifo_pop(jobs_fifo); + + // TODO more sophisticated check? (unit that is in transitional + // state cannot have currently multiple jobs queued) + if (job->target_state == job->unit->state) { + /* + * Job would do nothing, finish it on spot. + * No need to continue BFS search from it. + */ + job->retval = JOB_OK; + job_finish(job); + job_del_ref(&job); + continue; + } else { + /* No refcount increase, pass it to the closure */ + dyn_array_append(job_closure, job_ptr_t, job); + } /* Traverse dependencies edges */ @@ -379,5 +392,5 @@ /* Add reference for the event */ job_add_ref(job); - sysman_raise_event(&sysman_event_job_changed, job); -} - + sysman_raise_event(&sysman_event_job_finished, job); +} + Index: uspace/srv/sysman/job.h =================================================================== --- uspace/srv/sysman/job.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/job.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -37,4 +37,5 @@ #include "unit.h" +// TODO simplify queue states /** Run state of job */ typedef enum { @@ -77,5 +78,5 @@ extern void job_queue_init(void); extern int job_queue_add_jobs(dyn_array_t *); -extern job_t *job_queue_pop_runnable(void); +extern void job_queue_process(void); extern int job_create_closure(job_t *, dyn_array_t *); Index: uspace/srv/sysman/log.h =================================================================== --- uspace/srv/sysman/log.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/log.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -37,5 +37,5 @@ * that would use logger as soon as it's ready. */ -#define sysman_log(level, fmt, ...) printf("sysman: " fmt "\n", __VA_ARGS__) +#define sysman_log(level, fmt, ...) printf("sysman: " fmt "\n", ##__VA_ARGS__) #endif Index: uspace/srv/sysman/main.c =================================================================== --- uspace/srv/sysman/main.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/main.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -30,4 +30,7 @@ #include #include +#include +#include +#include #include #include @@ -35,4 +38,6 @@ #include "configuration.h" +#include "connection_broker.h" +#include "connection_ctl.h" #include "dep.h" #include "job.h" @@ -43,41 +48,80 @@ #define NAME "sysman" -static void sysman_connection(ipc_callid_t callid, ipc_call_t *call, void *arg) -{ - /* TODO handle client connections */ +#define INITRD_DEVICE "bd/initrd" +#define INITRD_MOUNT_POINT "/" +#define INITRD_CFG_PATH "/cfg/sysman" + +#define TARGET_INIT "initrd.tgt" +#define TARGET_ROOTFS "rootfs.tgt" +#define TARGET_DEFAULT "default.tgt" + +#define UNIT_MNT_INITRD "initrd.mnt" +#define UNIT_CFG_INITRD "init.cfg" + +static const char *target_sequence[] = { + TARGET_INIT, + TARGET_ROOTFS, + TARGET_DEFAULT, + NULL +}; + +/* + * Forward declarations + */ +static void prepare_and_run_job(const char **target_name_ptr); + +/* + * Static functions + */ + +static void sysman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + sysman_interface_t iface = IPC_GET_ARG1(*icall); + switch (iface) { + case SYSMAN_PORT_BROKER: + sysman_connection_broker(iid, icall); + break; + case SYSMAN_PORT_CTL: + sysman_connection_ctl(iid, icall); + break; + default: + /* Unknown interface */ + async_answer_0(iid, ENOENT); + } } /** Build hard coded configuration */ -static job_t *create_entry_configuration(void) { - int result = EOK; +static int create_entry_configuration(void) { + int rc; unit_t *mnt_initrd = NULL; unit_t *cfg_init = NULL; - unit_t *tgt_default = NULL; + unit_t *tgt_init = NULL; mnt_initrd = unit_create(UNIT_MOUNT); if (mnt_initrd == NULL) { - result = ENOMEM; + rc = ENOMEM; goto fail; } - mnt_initrd->name = str_dup("initrd.mnt"); - // TODO Use RDFMT - CAST_MNT(mnt_initrd)->type = str_dup("ext4fs"); - CAST_MNT(mnt_initrd)->mountpoint = str_dup("/"); - CAST_MNT(mnt_initrd)->device = str_dup("bd/initrd"); + mnt_initrd->name = str_dup(UNIT_MNT_INITRD); + CAST_MNT(mnt_initrd)->type = str_dup(STRING(RDFMT)); + CAST_MNT(mnt_initrd)->mountpoint = str_dup(INITRD_MOUNT_POINT); + CAST_MNT(mnt_initrd)->device = str_dup(INITRD_DEVICE); + CAST_MNT(mnt_initrd)->autostart = false; + CAST_MNT(mnt_initrd)->blocking = true; cfg_init = unit_create(UNIT_CONFIGURATION); if (cfg_init == NULL) { - result = ENOMEM; + rc = ENOMEM; goto fail; } - cfg_init->name = str_dup("init.cfg"); - CAST_CFG(cfg_init)->path = str_dup("/cfg/sysman"); + cfg_init->name = str_dup(UNIT_CFG_INITRD); + CAST_CFG(cfg_init)->path = str_dup(INITRD_CFG_PATH); - tgt_default = unit_create(UNIT_TARGET); - if (tgt_default == NULL) { - result = ENOMEM; + tgt_init = unit_create(UNIT_TARGET); + if (tgt_init == NULL) { + rc = ENOMEM; goto fail; } - tgt_default->name = str_dup("default.tgt"); + tgt_init->name = str_dup(TARGET_INIT); @@ -89,37 +133,69 @@ configuration_add_unit(mnt_initrd); configuration_add_unit(cfg_init); - configuration_add_unit(tgt_default); - - result = dep_add_dependency(tgt_default, cfg_init); - if (result != EOK) { - goto fail; - } - - result = dep_add_dependency(cfg_init, mnt_initrd); - if (result != EOK) { - goto fail; + configuration_add_unit(tgt_init); + + rc = dep_add_dependency(tgt_init, cfg_init); + if (rc != EOK) { + goto rollback; + } + + rc = dep_add_dependency(cfg_init, mnt_initrd); + if (rc != EOK) { + goto rollback; } configuration_commit(); - job_t *first_job = job_create(tgt_default, STATE_STARTED); - if (first_job == NULL) { - goto fail; - } - return first_job; + return EOK; fail: - // TODO cannot destroy units after they're added to configuration - unit_destroy(&tgt_default); + unit_destroy(&tgt_init); unit_destroy(&cfg_init); unit_destroy(&mnt_initrd); - return NULL; -} - -static void first_job_handler(void *object, void *unused) + return rc; + +rollback: + configuration_rollback(); + return rc; +} + +static void sequence_job_handler(void *object, void *arg) { job_t *job = object; - sysman_log(LVL_DEBUG, "First job retval: %i.", job->retval); + if (job->retval == JOB_FAILED) { + sysman_log(LVL_ERROR, "Failed to start '%s'.", unit_name(job->unit)); + job_del_ref(&job); + return; + } job_del_ref(&job); + + const char **target_name_ptr = arg; + prepare_and_run_job(target_name_ptr + 1); +} + +static void prepare_and_run_job(const char **target_name_ptr) +{ + const char *target_name = *target_name_ptr; + + if (target_name == NULL) { + sysman_log(LVL_NOTE, "All initial units started."); + return; + } + + /* Previous targets should have loaded new units */ + unit_t *tgt = configuration_find_unit_by_name(target_name); + if (tgt == NULL) { + sysman_log(LVL_ERROR, + "Expected unit '%s' not found in configuration.", + target_name); + return; + } + + int rc = sysman_queue_job(tgt, STATE_STARTED, &sequence_job_handler, + target_name_ptr); + + if (rc != EOK) { + sysman_log(LVL_FATAL, "Cannot create job for '%s'.", target_name); + } } @@ -136,8 +212,12 @@ /* - * Create initial configuration while we are in a single fibril, keep - * the job and run it when event loop is running. - */ - job_t *first_job = create_entry_configuration(); + * Create initial configuration while we are in a single fibril + */ + int rc = create_entry_configuration(); + if (rc != EOK) { + sysman_log(LVL_FATAL, + "Could not create initial configuration (%i).", rc); + return rc; + } /* @@ -148,15 +228,14 @@ fibril_add_ready(event_loop_fibril); - /* Queue first job for processing */ - job_add_ref(first_job); - sysman_object_observer(first_job, &first_job_handler, NULL); - job_add_ref(first_job); - sysman_raise_event(&sysman_event_job_process, first_job); - - /* - * Releasing our own reference (could be merged with previous add_ref, - * this is more explicit though. - */ - job_del_ref(&first_job); + /* Queue first job from sequence */ + prepare_and_run_job(&target_sequence[0]); + + /* We're service too */ + rc = service_register(SERVICE_SYSMAN); + if (rc != EOK) { + sysman_log(LVL_FATAL, + "Cannot register at naming service (%i).", rc); + return rc; + } /* Start sysman server */ Index: uspace/srv/sysman/sysman.c =================================================================== --- uspace/srv/sysman/sysman.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/sysman.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -35,4 +35,5 @@ #include "log.h" #include "sysman.h" +#include "unit.h" @@ -150,8 +151,31 @@ /* Process event */ - sysman_log(LVL_DEBUG2, "process(%p, %p)", event->handler, event->data); + sysman_log(LVL_DEBUG2, "process_event(%p, %p)", + event->handler, event->data); event->handler(event->data); free(event); } +} + +/** Create and queue job for unit + * + * @param[in] callback callback must explicitly delete reference to job + */ +int sysman_queue_job(unit_t *unit, unit_state_t target_state, + callback_handler_t callback, void *callback_arg) +{ + job_t *job = job_create(unit, target_state); + if (job == NULL) { + return ENOMEM; + } + + job_add_ref(job); + sysman_object_observer(job, callback, callback_arg); + + job_add_ref(job); + sysman_raise_event(&sysman_event_job_process, job); + + job_del_ref(&job); + return EOK; } @@ -226,7 +250,7 @@ // NOTE must run in main event loop fibril -void sysman_event_job_process(void *arg) -{ - job_t *job = arg; +void sysman_event_job_process(void *data) +{ + job_t *job = data; dyn_array_t job_closure; dyn_array_initialize(&job_closure, job_ptr_t, 0); @@ -250,6 +274,5 @@ job_del_ref(&job); - // TODO explain why calling asynchronously - sysman_raise_event(&sysman_event_job_queue_run, NULL); + job_queue_process(); return; @@ -265,19 +288,29 @@ } - -void sysman_event_job_queue_run(void *unused) -{ - job_t *job; - while ((job = job_queue_pop_runnable())) { - job_run(job); - job_del_ref(&job); - } -} - -void sysman_event_job_changed(void *object) -{ - notify_observers(object); +void sysman_event_job_finished(void *data) +{ + notify_observers(data); /* Unreference the event data */ - job_t *job = object; + job_t *job = data; job_del_ref(&job); -} + + /* The finished job, might have been blocking */ + job_queue_process(); +} + +void sysman_event_unit_exposee_created(void *data) +{ + unit_t *unit = data; + unit_exposee_created(unit); +} + +void sysman_event_unit_failed(void *data) +{ + unit_t *unit = data; + unit_fail(unit); +} + +void sysman_event_unit_state_changed(void *data) +{ + notify_observers(data); +} Index: uspace/srv/sysman/sysman.h =================================================================== --- uspace/srv/sysman/sysman.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/sysman.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -37,15 +37,17 @@ extern void sysman_events_init(void); +extern int sysman_events_loop(void *); +extern int sysman_queue_job(unit_t *, unit_state_t, callback_handler_t, void *); -extern int sysman_events_loop(void *); extern void sysman_raise_event(event_handler_t, void *); - extern int sysman_object_observer(void *, callback_handler_t, void *); extern void sysman_event_job_process(void *); -extern void sysman_event_job_queue_run(void *); -extern void sysman_event_job_changed(void *); +extern void sysman_event_job_finished(void *); +extern void sysman_event_unit_exposee_created(void *); +extern void sysman_event_unit_failed(void *); +extern void sysman_event_unit_state_changed(void *); #endif Index: uspace/srv/sysman/unit.c =================================================================== --- uspace/srv/sysman/unit.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/unit.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -37,14 +37,17 @@ #include #include +#include #include "dep.h" #include "log.h" +#include "sysman.h" #include "unit.h" /** Virtual method table for each unit type */ unit_vmt_t *unit_type_vmts[] = { - [UNIT_TARGET] = &unit_tgt_ops, - [UNIT_MOUNT] = &unit_mnt_ops, - [UNIT_CONFIGURATION] = &unit_cfg_ops + [UNIT_CONFIGURATION] = &unit_cfg_vmt, + [UNIT_MOUNT] = &unit_mnt_vmt, + [UNIT_TARGET] = &unit_tgt_vmt, + [UNIT_SERVICE] = &unit_svc_vmt }; @@ -61,10 +64,8 @@ assert(unit); - // TODO is this necessary? - memset(unit, 0, sizeof(unit_t)); + size_t size = unit_type_vmts[type]->size; + memset(unit, 0, size); unit->type = type; - unit->name = NULL; - unit->state = STATE_EMBRYO; @@ -103,22 +104,4 @@ } - -/** Issue request to restarter to start a unit - * - * Ideally this function is non-blocking synchronous, however, some units - * cannot be started synchronously and thus return from this function generally - * means that start was requested. - * - * Check state of the unit for actual result, start method can end in states: - * - STATE_STARTED, (succesful synchronous start) - * - STATE_STARTING, (succesful asynchronous start request) - * - STATE_FAILED. (error occured) - */ -int unit_start(unit_t *unit) -{ - sysman_log(LVL_DEBUG, "%s('%s')", __func__, unit_name(unit)); - return UNIT_VMT(unit)->start(unit); -} - int unit_load(unit_t *unit, ini_configuration_t *ini_conf, text_parse_t *text_parse) @@ -140,14 +123,51 @@ } +/** Issue request to restarter to start a unit + * + * Ideally this function is non-blocking synchronous, however, some units + * cannot be started synchronously and thus return from this function generally + * means that start was requested. + * + * Check state of the unit for actual result, start method can end in states: + * - STATE_STARTED, (succesful synchronous start) + * - STATE_STARTING, (succesful asynchronous start request) + * - STATE_FAILED. (unit state changed and error occured) + */ +int unit_start(unit_t *unit) +{ + sysman_log(LVL_DEBUG, "%s('%s')", __func__, unit_name(unit)); + return UNIT_VMT(unit)->start(unit); +} + +void unit_exposee_created(unit_t *unit) +{ + sysman_log(LVL_DEBUG, "%s('%s')", __func__, unit_name(unit)); + return UNIT_VMT(unit)->exposee_created(unit); +} + +void unit_fail(unit_t *unit) +{ + sysman_log(LVL_DEBUG, "%s('%s')", __func__, unit_name(unit)); + return UNIT_VMT(unit)->fail(unit); +} + +void unit_notify_state(unit_t *unit) +{ + sysman_raise_event(&sysman_event_unit_state_changed, unit); +} + unit_type_t unit_type_name_to_type(const char *type_name) { - if (str_cmp(type_name, "cfg") == 0) + if (str_cmp(type_name, UNIT_CFG_TYPE_NAME) == 0) return UNIT_CONFIGURATION; - else if (str_cmp(type_name, "mnt") == 0) + else if (str_cmp(type_name, UNIT_MNT_TYPE_NAME) == 0) return UNIT_MOUNT; - else if (str_cmp(type_name, "tgt") == 0) + else if (str_cmp(type_name, UNIT_TGT_TYPE_NAME) == 0) return UNIT_TARGET; + + else if (str_cmp(type_name, UNIT_SVC_TYPE_NAME) == 0) + return UNIT_SERVICE; else @@ -160,7 +180,4 @@ return unit->name ? unit->name : ""; } - - - bool unit_parse_unit_list(const char *value, void *dst, text_parse_t *parse, Index: uspace/srv/sysman/unit.h =================================================================== --- uspace/srv/sysman/unit.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/unit.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -45,4 +45,5 @@ UNIT_MOUNT, UNIT_CONFIGURATION, + UNIT_SERVICE } unit_type_t; @@ -73,17 +74,19 @@ #include "unit_mnt.h" #include "unit_tgt.h" +#include "unit_svc.h" -#define DEFINE_CAST(NAME, TYPE, ENUM_TYPE) \ - static inline TYPE *CAST_##NAME(unit_t *u) \ - { \ - if (u->type == ENUM_TYPE) \ - return (TYPE *)u; \ - else \ - return NULL; \ - } \ +#define DEFINE_CAST(NAME, TYPE, ENUM_TYPE) \ + static inline TYPE *CAST_##NAME(unit_t *u) \ + { \ + if (u->type == ENUM_TYPE) \ + return (TYPE *)u; \ + else \ + return NULL; \ + } \ DEFINE_CAST(CFG, unit_cfg_t, UNIT_CONFIGURATION) DEFINE_CAST(MNT, unit_mnt_t, UNIT_MOUNT) DEFINE_CAST(TGT, unit_tgt_t, UNIT_TARGET) +DEFINE_CAST(SVC, unit_svc_t, UNIT_SERVICE) struct unit_vmt { @@ -97,15 +100,21 @@ int (*start)(unit_t *); + + void (*exposee_created)(unit_t *); + + void (*fail)(unit_t *); }; extern unit_vmt_t *unit_type_vmts[]; -#define DEFINE_UNIT_VMT(PREFIX) \ - unit_vmt_t PREFIX##_ops = { \ - .size = sizeof(PREFIX##_t), \ - .init = &PREFIX##_init, \ - .load = &PREFIX##_load, \ - .destroy = &PREFIX##_destroy, \ - .start = &PREFIX##_start \ +#define DEFINE_UNIT_VMT(PREFIX) \ + unit_vmt_t PREFIX##_vmt = { \ + .size = sizeof(PREFIX##_t), \ + .init = &PREFIX##_init, \ + .load = &PREFIX##_load, \ + .destroy = &PREFIX##_destroy, \ + .start = &PREFIX##_start, \ + .exposee_created = &PREFIX##_exposee_created, \ + .fail = &PREFIX##_fail \ }; @@ -115,9 +124,10 @@ extern void unit_destroy(unit_t **); -// TODO add flags argument with explicit notification? -extern void unit_set_state(unit_t *, unit_state_t); - extern int unit_load(unit_t *, ini_configuration_t *, text_parse_t *); extern int unit_start(unit_t *); +extern void unit_exposee_created(unit_t *); +extern void unit_fail(unit_t *); + +extern void unit_notify_state(unit_t *); extern unit_type_t unit_type_name_to_type(const char *); Index: uspace/srv/sysman/units/unit_cfg.c =================================================================== --- uspace/srv/sysman/units/unit_cfg.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/units/unit_cfg.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -36,4 +36,5 @@ #include #include +#include #include "configuration.h" @@ -66,6 +67,6 @@ text_parse_init(&text_parse); - const char *last_dot = str_rchr(filename, '.'); - if (last_dot == NULL) { + const char *last_sep = str_rchr(filename, UNIT_NAME_SEPARATOR); + if (last_sep == NULL) { rc = EINVAL; goto finish; @@ -73,5 +74,5 @@ const char *unit_name = filename; - const char *unit_type_name = last_dot + 1; + const char *unit_type_name = last_sep + 1; unit_type_t unit_type = unit_type_name_to_type(unit_type_name); @@ -195,9 +196,5 @@ unit_cfg_t *u_cfg = CAST_CFG(unit); assert(u_cfg); - - u_cfg->path = NULL; -} - - +} static void unit_cfg_destroy(unit_t *unit) @@ -243,4 +240,16 @@ } +static void unit_cfg_exposee_created(unit_t *unit) +{ + /* Configuration has no exposees. */ + assert(false); +} + +static void unit_cfg_fail(unit_t *unit) +{ + /* Configuration cannot async fail. */ + assert(false); +} + DEFINE_UNIT_VMT(unit_cfg) Index: uspace/srv/sysman/units/unit_cfg.h =================================================================== --- uspace/srv/sysman/units/unit_cfg.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/units/unit_cfg.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -38,5 +38,5 @@ } unit_cfg_t; -extern unit_vmt_t unit_cfg_ops; +extern unit_vmt_t unit_cfg_vmt; #endif Index: uspace/srv/sysman/units/unit_mnt.c =================================================================== --- uspace/srv/sysman/units/unit_mnt.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/units/unit_mnt.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -32,6 +32,8 @@ #include #include +#include #include "log.h" +#include "sysman.h" #include "unit.h" @@ -39,18 +41,81 @@ static config_item_t unit_configuration[] = { - {"What", &config_parse_string, offsetof(unit_mnt_t, device), NULL}, - {"Where", &config_parse_string, offsetof(unit_mnt_t, mountpoint), NULL}, - {"Type", &config_parse_string, offsetof(unit_mnt_t, type), NULL}, + {"What", &config_parse_string, offsetof(unit_mnt_t, device), NULL}, + {"Where", &config_parse_string, offsetof(unit_mnt_t, mountpoint), NULL}, + {"Type", &config_parse_string, offsetof(unit_mnt_t, type), NULL}, + {"Autostart", &config_parse_bool, offsetof(unit_mnt_t, autostart), "true"}, + {"Blocking", &config_parse_bool, offsetof(unit_mnt_t, blocking), "true"}, CONFIGURATION_ITEM_SENTINEL }; +typedef struct { + char *type; + char *mountpoint; + char *device; + char *options; + unsigned int flags; + unsigned int instance; + + unit_t *unit; + bool owner; +} mount_data_t; + +static void mount_data_destroy(mount_data_t **mnt_data_ptr) +{ + assert(mnt_data_ptr); + if (*mnt_data_ptr == NULL) { + return; + } + + mount_data_t *mnt_data = *mnt_data_ptr; + free(mnt_data->type); + free(mnt_data->mountpoint); + free(mnt_data->device); + free(mnt_data->options); + + free(mnt_data); + *mnt_data_ptr = NULL; +} + +static bool mount_data_copy(mount_data_t *src, mount_data_t **dst_ptr) +{ + mount_data_t *dst = malloc(sizeof(mount_data_t)); + if (dst == NULL) { + goto fail; + } + + dst->type = str_dup(src->type); + if (dst->type == NULL) + goto fail; + + dst->mountpoint = str_dup(src->mountpoint); + if (dst->mountpoint == NULL) + goto fail; + + dst->device = str_dup(src->device); + if (dst->device == NULL) + goto fail; + + dst->options = src->options ? str_dup(src->options) : NULL; + if (src->options != NULL && dst->options == NULL) + goto fail; + + dst->flags = src->flags; + dst->instance = src->instance; + dst->unit = src->unit; + dst->owner = true; + + *dst_ptr = dst; + return true; + +fail: + mount_data_destroy(&dst); + return false; +} + static void unit_mnt_init(unit_t *unit) { unit_mnt_t *u_mnt = CAST_MNT(unit); assert(u_mnt); - - u_mnt->type = NULL; - u_mnt->mountpoint = NULL; - u_mnt->device = NULL; } @@ -60,6 +125,4 @@ unit_mnt_t *u_mnt = CAST_MNT(unit); - sysman_log(LVL_DEBUG2, "%s, %p, %p, %p", __func__, - u_mnt->type, u_mnt->mountpoint, u_mnt->device); free(u_mnt->type); free(u_mnt->mountpoint); @@ -85,10 +148,49 @@ } +static int mount_exec(void *arg) +{ + mount_data_t *mnt_data = arg; + /*sysman_log(LVL_DEBUG2, "%s(%p, %p, %p, %p, %x, %u)", + __func__, + mnt_data->type, mnt_data->mountpoint, mnt_data->device, mnt_data->options, + mnt_data->flags, mnt_data->instance);*/ + int rc = mount(mnt_data->type, mnt_data->mountpoint, mnt_data->device, + mnt_data->options ? mnt_data->options : "", + mnt_data->flags, mnt_data->instance); + + if (rc == EOK) { + sysman_log(LVL_DEBUG, "Mount ('%s') mounted", + unit_name(mnt_data->unit)); + /* + * Emulate future VFS broker fibril that notifies about created + * exposee. + * Difference: It'll notify exposee name only, we'll have to + * match it... + */ + sysman_raise_event(&sysman_event_unit_exposee_created, + mnt_data->unit); + } else { + sysman_log(LVL_ERROR, "Mount ('%s') failed (%i)", + unit_name(mnt_data->unit), rc); + /* + * Think about analogy of this event, probably timeout or sthing + */ + sysman_raise_event(&sysman_event_unit_failed, + mnt_data->unit); + } + + if (mnt_data->owner) { + mount_data_destroy(&mnt_data); + } + + return EOK; +} + static int unit_mnt_start(unit_t *unit) { - // TODO replace with non-blocking - const bool blocking = true; unit_mnt_t *u_mnt = CAST_MNT(unit); assert(u_mnt); + /* autostart implies blocking */ + assert(!u_mnt->autostart || u_mnt->blocking); @@ -96,31 +198,52 @@ assert(unit->state == STATE_STOPPED); - - // TODO use other mount parameters - int rc = mount(u_mnt->type, u_mnt->mountpoint, u_mnt->device, "", - blocking ? IPC_FLAG_BLOCKING : 0, 0); - - if (blocking) { - if (rc == EOK) { - sysman_log(LVL_DEBUG, "Mount ('%s') mounted", unit_name(unit)); - unit->state = STATE_STARTED; - } else { - sysman_log(LVL_ERROR, "Mount ('%s') failed (%i)", - unit_name(unit), rc); - unit->state = STATE_FAILED; + mount_data_t mnt_data; + memset(&mnt_data, 0, sizeof(mnt_data)); + mnt_data.type = u_mnt->type; + mnt_data.mountpoint = u_mnt->mountpoint; + mnt_data.device = u_mnt->device; + /* TODO use other mount parameters + * mnt_data.options = u_mnt->options; + * mnt_data.instance = u_mnt->instance; + */ + + mnt_data.flags |= u_mnt->blocking ? IPC_FLAG_BLOCKING : 0; + mnt_data.flags |= u_mnt->autostart ? IPC_FLAG_AUTOSTART : 0; + mnt_data.unit = unit; + + if (u_mnt->blocking) { + mount_data_t *heap_mnt_data = NULL; + if (!mount_data_copy(&mnt_data, &heap_mnt_data)) { + return ENOMEM; } + fid_t fib = fibril_create(&mount_exec, heap_mnt_data); + unit->state = STATE_STARTING; + fibril_add_ready(fib); } else { - if (rc == EOK) { - sysman_log(LVL_DEBUG, "Mount ('%s') requested", unit_name(unit)); - unit->state = STATE_STARTING; - } else { - sysman_log(LVL_ERROR, "Mount ('%s') request failed (%i)", - unit_name(unit), rc); - unit->state = STATE_FAILED; - } - } - - return rc; -} + unit->state = STATE_STARTING; + mount_exec(&mnt_data); + } + + return EOK; +} + +static void unit_mnt_exposee_created(unit_t *unit) +{ + assert(CAST_MNT(unit)); + assert(unit->state == STATE_STOPPED || unit->state == STATE_STARTING); + + unit->state = STATE_STARTED; + unit_notify_state(unit); +} + +static void unit_mnt_fail(unit_t *unit) +{ + assert(CAST_MNT(unit)); + assert(unit->state == STATE_STARTING); + + unit->state = STATE_FAILED; + unit_notify_state(unit); +} + DEFINE_UNIT_VMT(unit_mnt) Index: uspace/srv/sysman/units/unit_mnt.h =================================================================== --- uspace/srv/sysman/units/unit_mnt.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/units/unit_mnt.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -38,7 +38,13 @@ char *mountpoint; char *device; + + /** Should be underlying units (FS server, device) be autostarted */ + bool autostart; + + /** Should mount call be blocking */ + bool blocking; } unit_mnt_t; -extern unit_vmt_t unit_mnt_ops; +extern unit_vmt_t unit_mnt_vmt; #endif Index: uspace/srv/sysman/units/unit_svc.c =================================================================== --- uspace/srv/sysman/units/unit_svc.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/srv/sysman/units/unit_svc.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include // temporary +#include +#include + +#include "log.h" +#include "unit.h" + +static const char *section_name = "Service"; + +static config_item_t unit_configuration[] = { + {"ExecStart", &config_parse_string, offsetof(unit_svc_t, exec_start), NULL}, + CONFIGURATION_ITEM_SENTINEL +}; + +static void unit_svc_init(unit_t *unit) +{ + unit_svc_t *u_svc = CAST_SVC(unit); + assert(u_svc); +} + +static void unit_svc_destroy(unit_t *unit) +{ + assert(unit->type == UNIT_SERVICE); + unit_svc_t *u_svc = CAST_SVC(unit); + + free(u_svc->exec_start); +} + +static int unit_svc_load(unit_t *unit, ini_configuration_t *ini_conf, + text_parse_t *text_parse) +{ + unit_svc_t *u_svc = CAST_SVC(unit); + assert(u_svc); + + ini_section_t *section = ini_get_section(ini_conf, section_name); + if (section == NULL) { + sysman_log(LVL_ERROR, + "Expected section '%s' in configuration of unit '%s'", + section_name, unit_name(unit)); + return ENOENT; + } + + return config_load_ini_section(unit_configuration, section, u_svc, + text_parse); +} + +static int unit_svc_start(unit_t *unit) +{ + unit_svc_t *u_svc = CAST_SVC(unit); + assert(u_svc); + + + // TODO think about unit's lifecycle (is STOPPED only acceptable?) + assert(unit->state == STATE_STOPPED); + + // TODO extend the simple implementation + const char *args[] = {"warn", NULL}; + int rc = task_spawnv(NULL, NULL, u_svc->exec_start, args); + if (rc != EOK) { + unit->state = STATE_FAILED; + return rc; + } + + /* + * This is temporary workaround, until proper reporting from brokers + * about exposees will work. We assume the service succesfully starts + * in a moment. + */ + unit->state = STATE_STARTING; + async_usleep(20000); + unit->state = STATE_STARTED; + + if (console_kcon()) { + sysman_log(LVL_DEBUG2, "%s: Kconsole grabbed.", __func__); + } else { + sysman_log(LVL_DEBUG2, "%s: no kconsole.", __func__); + } + + return EOK; +} + +static void unit_svc_exposee_created(unit_t *unit) +{ + // TODO implement +} + +static void unit_svc_fail(unit_t *unit) +{ + // TODO implement +} + +DEFINE_UNIT_VMT(unit_svc) + Index: uspace/srv/sysman/units/unit_svc.h =================================================================== --- uspace/srv/sysman/units/unit_svc.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) +++ uspace/srv/sysman/units/unit_svc.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2015 Michal Koutny + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SYSMAN_UNIT_SVC_H +#define SYSMAN_UNIT_SVC_H + +#include "unit.h" + +typedef struct { + unit_t unit; + + char *exec_start; + +} unit_svc_t; + +extern unit_vmt_t unit_svc_vmt; + +#endif + Index: uspace/srv/sysman/units/unit_tgt.c =================================================================== --- uspace/srv/sysman/units/unit_tgt.c (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/units/unit_tgt.c (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -63,4 +63,16 @@ } +static void unit_tgt_exposee_created(unit_t *unit) +{ + /* Target has no exposees. */ + assert(false); +} + +static void unit_tgt_fail(unit_t *unit) +{ + // TODO define semantics and implement +} + + DEFINE_UNIT_VMT(unit_tgt) Index: uspace/srv/sysman/units/unit_tgt.h =================================================================== --- uspace/srv/sysman/units/unit_tgt.h (revision 2dda1d498af4053267f8bb5714b994ecc0c1fad9) +++ uspace/srv/sysman/units/unit_tgt.h (revision 55597121963d38bcb50c5dcebe5d3835eb37d411) @@ -36,5 +36,5 @@ } unit_tgt_t; -extern unit_vmt_t unit_tgt_ops; +extern unit_vmt_t unit_tgt_vmt; #endif