Index: abi/include/abi/ipc/methods.h =================================================================== --- abi/include/abi/ipc/methods.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ abi/include/abi/ipc/methods.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -39,5 +39,5 @@ /* Well known phone descriptors */ -static cap_phone_handle_t const PHONE_NS = (cap_phone_handle_t) (CAP_NIL + 1); +static cap_phone_handle_t const PHONE_INITIAL = (cap_phone_handle_t) (CAP_NIL + 1); /** Kernel IPC interfaces Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ boot/Makefile.common (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -76,5 +76,6 @@ $(USPACE_PATH)/srv/bd/rd/rd \ $(USPACE_PATH)/srv/vfs/vfs \ - $(USPACE_PATH)/srv/logger/logger + $(USPACE_PATH)/srv/logger/logger \ + $(USPACE_PATH)/srv/taskman/taskman ifeq ($(RDFMT),tmpfs) Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/Makefile (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -120,4 +120,5 @@ srv/taskmon \ srv/sysman \ + srv/taskman \ srv/vfs \ srv/bd/sata_bd \ Index: uspace/app/trace/ipcp.c =================================================================== --- uspace/app/trace/ipcp.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/app/trace/ipcp.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -302,5 +302,7 @@ } - if ((phone == PHONE_NS) && (method == IPC_M_CONNECT_ME_TO) && + // TODO obsoleted (initial phone needn't to be phone to NS anymore) + // actually what connections should it monitor? + if ((phone == PHONE_INITIAL) && (method == IPC_M_CONNECT_ME_TO) && (retval == 0)) { /* Connected to a service (through NS) */ Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/Makefile (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -165,4 +165,5 @@ generic/arg_parse.c \ generic/stats.c \ + generic/taskman.c \ generic/assert.c \ generic/bsearch.c \ Index: uspace/lib/c/generic/async/client.c =================================================================== --- uspace/lib/c/generic/async/client.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/async/client.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -124,6 +124,6 @@ static fibril_rmutex_t message_mutex; -/** Naming service session */ -async_sess_t session_ns; +/** Primary session (spawn parent, later naming service) */ +async_sess_t *session_primary = NULL; /** Message data */ @@ -168,25 +168,46 @@ static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv); + +static async_sess_t *create_session_primary(void) +{ + async_sess_t *session = (async_sess_t *) malloc(sizeof(async_sess_t)); + + if (session != NULL) { + session_ns->iface = 0; + session->mgmt = EXCHANGE_ATOMIC; + session->phone = PHONE_INITIAL; + session->arg1 = 0; + session->arg2 = 0; + session->arg3 = 0; + + fibril_mutex_initialize(&session->remote_state_mtx); + session->remote_state_data = NULL; + + list_initialize(&session->exch_list); + fibril_mutex_initialize(&session->mutex); + atomic_set(&session->refcnt, 0); + &session.exchanges = 0; + } + + return session; +} + + /** Initialize the async framework. * */ -void __async_client_init(void) +void __async_client_init(async_sess_t *session) { if (fibril_rmutex_initialize(&message_mutex) != EOK) abort(); - session_ns.iface = 0; - session_ns.mgmt = EXCHANGE_ATOMIC; - session_ns.phone = PHONE_NS; - session_ns.arg1 = 0; - session_ns.arg2 = 0; - session_ns.arg3 = 0; - - fibril_mutex_initialize(&session_ns.remote_state_mtx); - session_ns.remote_state_data = NULL; - - list_initialize(&session_ns.exch_list); - fibril_mutex_initialize(&session_ns.mutex); - session_ns.exchanges = 0; + if (session == NULL) { + session_primary = create_session_primary(); + } else { + session_primary = session; + } + + if (session_primary == NULL) + abort(); } @@ -807,4 +828,19 @@ *out_phone = (cap_phone_handle_t) ipc_get_arg5(&result); return EOK; +} + +/** Injects another session instead of original primary session + * + * @param session Session to naming service. + * + * @return old primary session (to spawn parent) + */ +async_sess_t *async_session_primary_swap(async_sess_t *session) +{ + assert(session_primary->phone == PHONE_INITIAL); + + async_sess_t *old_primary = session_primary; + session_primary = session; + return old_primary; } Index: uspace/lib/c/generic/async/server.c =================================================================== --- uspace/lib/c/generic/async/server.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/async/server.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -216,4 +216,5 @@ } +static async_client_conn_t implicit_connection = NULL; static fibril_rmutex_t client_mutex; static hash_table_t client_hash_table; @@ -964,6 +965,11 @@ /* Route the call according to its request label */ errno_t rc = route_call(call); - if (rc == EOK) + if (rc == EOK) { return; + } else if (implicit_connection != NULL) { + async_new_connection(call->in_task_id, call->in_phone_hash, + callid, call, implicit_connection, NULL); + return; + } // TODO: Log the error. Index: uspace/lib/c/generic/libc.c =================================================================== --- uspace/lib/c/generic/libc.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/libc.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -103,7 +103,12 @@ } #endif - + + /* Setup async framework */ __async_server_init(); - __async_client_init(); + if (__pcb == NULL) { + __async_client_init(NULL); + } else { + __async_client_init(__pcb->session_primary); + } __async_ports_init(); Index: uspace/lib/c/generic/loader.c =================================================================== --- uspace/lib/c/generic/loader.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/loader.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -33,15 +33,16 @@ */ +#include +#include #include #include +#include +#include +#include #include -#include +#include +#include #include -#include -#include -#include -#include #include -#include #include "private/loader.h" @@ -67,5 +68,5 @@ async_sess_t *sess = - service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0); + service_connect_blocking(SERVICE_TASKMAN, TASKMAN_CONNECT_TO_LOADER, 0); if (sess == NULL) { free(ldr); Index: uspace/lib/c/generic/ns.c =================================================================== --- uspace/lib/c/generic/ns.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/ns.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -41,13 +41,13 @@ /* - * XXX ns does not know about session_ns, so we create an extra session for + * XXX ns does not know about session_primary, so we create an extra session for * actual communicaton */ -static async_sess_t *sess_ns = NULL; +static async_sess_t *sess_primary = NULL; errno_t service_register(service_t service, iface_t iface, async_port_handler_t handler, void *data) { - async_sess_t *sess = ns_session_get(); + async_sess_t *sess = get_session_primary(); if (sess == NULL) return EIO; @@ -81,5 +81,5 @@ async_set_fallback_port_handler(handler, data); - async_sess_t *sess = ns_session_get(); + async_sess_t *sess = get_session_primary(); if (sess == NULL) return EIO; @@ -105,5 +105,5 @@ async_sess_t *service_connect(service_t service, iface_t iface, sysarg_t arg3) { - async_sess_t *sess = ns_session_get(); + async_sess_t *sess = get_session_primary(); if (sess == NULL) return NULL; @@ -133,5 +133,5 @@ sysarg_t arg3) { - async_sess_t *sess = ns_session_get(); + async_sess_t *sess = get_session_primary(); if (sess == NULL) return NULL; @@ -157,5 +157,5 @@ errno_t ns_ping(void) { - async_sess_t *sess = ns_session_get(); + async_sess_t *sess = get_session_primary(); if (sess == NULL) return EIO; @@ -168,31 +168,18 @@ } -errno_t ns_intro(task_id_t id) -{ - async_exch_t *exch; - async_sess_t *sess = ns_session_get(); - if (sess == NULL) - return EIO; - exch = async_exchange_begin(sess); - errno_t rc = async_req_2_0(exch, NS_ID_INTRO, LOWER32(id), UPPER32(id)); - async_exchange_end(exch); - - return rc; -} - -async_sess_t *ns_session_get(void) +async_sess_t *get_session_primary(void) { async_exch_t *exch; - if (sess_ns == NULL) { - exch = async_exchange_begin(&session_ns); - sess_ns = async_connect_me_to(exch, 0, 0, 0); + if (sess_primary == NULL) { + exch = async_exchange_begin(&session_primary); + sess_primary = async_connect_me_to(exch, 0, 0, 0); async_exchange_end(exch); - if (sess_ns == NULL) + if (sess_primary == NULL) return NULL; } - return sess_ns; + return sess_primary; } Index: uspace/lib/c/generic/private/async.h =================================================================== --- uspace/lib/c/generic/private/async.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/private/async.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -96,5 +96,5 @@ extern void __async_server_init(void); extern void __async_server_fini(void); -extern void __async_client_init(void); +extern void __async_client_init(async_sess_t *); extern void __async_client_fini(void); extern void __async_ports_init(void); Index: uspace/lib/c/generic/private/ns.h =================================================================== --- uspace/lib/c/generic/private/ns.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/private/ns.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -38,5 +38,5 @@ #include -extern async_sess_t session_ns; +extern async_sess_t *session_primary; #endif Index: uspace/lib/c/generic/task.c =================================================================== --- uspace/lib/c/generic/task.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/generic/task.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -325,9 +325,10 @@ errno_t task_setup_wait(task_id_t id, task_wait_t *wait) { - async_sess_t *sess_ns = ns_session_get(); + async_sess_t *sess_ns = get_session_primary(); if (sess_ns == NULL) return EIO; async_exch_t *exch = async_exchange_begin(sess_ns); + wait->aid = async_send_2(exch, NS_TASK_WAIT, LOWER32(id), UPPER32(id), &wait->result); @@ -407,5 +408,5 @@ errno_t task_retval(int val) { - async_sess_t *sess_ns = ns_session_get(); + async_sess_t *sess_ns = get_session_primary(); if (sess_ns == NULL) return EIO; Index: uspace/lib/c/generic/taskman.c =================================================================== --- uspace/lib/c/generic/taskman.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) +++ uspace/lib/c/generic/taskman.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -0,0 +1,92 @@ +/* + * 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 libc + * @{ + */ +/** @file + */ + +#include +#include +#include + +#include + +//TODO better filename? +#include "private/ns.h" + +static int taskman_ask_callback(async_sess_t *session_tm) +{ + async_exch_t *exch = async_exchange_begin(session_tm); + int rc = async_connect_to_me( + exch, TASKMAN_LOADER_CALLBACK, 0, 0, NULL, NULL); + async_exchange_end(exch); + + return rc; +} + +static async_sess_t *taskman_connect_to_ns(async_sess_t *session_tm) +{ + async_exch_t *exch = async_exchange_begin(session_tm); + async_sess_t *session_ns = async_connect_me_to(EXCHANGE_ATOMIC, + exch, TASKMAN_LOADER_TO_NS, 0, 0); + async_exchange_end(exch); + + return session_ns; +} + +/** Set up phones upon being spawned by taskman + * + * Assumes primary session exists that is connected to taskman. + * After handshake, taskman is connected to us (see, it's opposite) and broker + * session is set up according to taskman. + * + * + * @return Session to broker (naming service) or NULL (sets errno). + */ +async_sess_t *taskman_handshake(void) +{ + printf("%s:%i\n", __func__, __LINE__); + + int rc = taskman_ask_callback(session_primary); + if (rc != EOK) { + errno = rc; + return NULL; + } + + async_sess_t *session_ns = taskman_connect_to_ns(session_primary); + if (session_ns == NULL) { + errno = ENOENT; + } + + return session_ns; +} + +/** @} + */ Index: uspace/lib/c/include/async.h =================================================================== --- uspace/lib/c/include/async.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/include/async.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -131,4 +131,6 @@ extern void *async_get_client_data_by_id(task_id_t); extern void async_put_client_data_by_id(task_id_t); + +extern void async_set_implicit_connection(async_client_conn_t); extern errno_t async_create_port(iface_t, async_port_handler_t, void *, @@ -274,4 +276,5 @@ extern sysarg_t async_get_label(void); +extern async_sess_t *async_session_primary_swap(async_sess_t *); extern async_sess_t *async_connect_me_to(async_exch_t *, iface_t, sysarg_t, sysarg_t); Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/include/ipc/services.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -43,8 +43,8 @@ typedef enum { SERVICE_NONE = 0, - SERVICE_LOADER = FOURCC('l', 'o', 'a', 'd'), SERVICE_VFS = FOURCC('v', 'f', 's', ' '), SERVICE_LOC = FOURCC('l', 'o', 'c', ' '), SERVICE_SYSMAN = FOURCC('s', 'y', 's', 'm'), + SERVICE_TASKMAN = FOURCC('t', 's', 'k', 'm'), SERVICE_LOGGER = FOURCC('l', 'o', 'g', 'g'), SERVICE_DEVMAN = FOURCC('d', 'e', 'v', 'n'), Index: uspace/lib/c/include/ipc/taskman.h =================================================================== --- uspace/lib/c/include/ipc/taskman.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) +++ uspace/lib/c/include/ipc/taskman.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -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. + */ + +/** @addtogroup libcipc + * @{ + */ +/** @file + */ + +#ifndef LIBC_IPC_TASKMAN_H_ +#define LIBC_IPC_TASKMAN_H_ + +#include + + +typedef enum { + TASKMAN_HELLO = IPC_FIRST_USER_METHOD, +} taskman_request_t; + +typedef enum { + TASKMAN_CONNECT_TO_LOADER = 0, + TASKMAN_LOADER_TO_NS, + TASKMAN_LOADER_CALLBACK, + TASKMAN_CONTROL +} taskman_interface_t; + +#endif + +/** @} + */ Index: uspace/lib/c/include/loader/pcb.h =================================================================== --- uspace/lib/c/include/loader/pcb.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/include/loader/pcb.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -46,4 +46,8 @@ }; +/* Forward declaration */ +struct async_sess; +typedef struct async_sess async_sess_t; + /** Program Control Block. * @@ -57,4 +61,7 @@ entry_point_t entry; + /** Primary session to broker. */ + async_sess_t *session_primary; + /** Current working directory. */ char *cwd; Index: uspace/lib/c/include/ns.h =================================================================== --- uspace/lib/c/include/ns.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/lib/c/include/ns.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -47,5 +47,4 @@ extern errno_t ns_ping(void); -extern errno_t ns_intro(task_id_t); extern async_sess_t *ns_session_get(void); Index: uspace/lib/c/include/taskman.h =================================================================== --- uspace/lib/c/include/taskman.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) +++ uspace/lib/c/include/taskman.h (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -0,0 +1,45 @@ +/* + * 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 libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_TASKMAN_H_ +#define LIBC_TASKMAN_H_ + +#include + +extern async_sess_t *taskman_handshake(void); + +#endif + +/** @} + */ Index: uspace/srv/loader/main.c =================================================================== --- uspace/srv/loader/main.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/srv/loader/main.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -34,11 +34,14 @@ * * The program loader is a special init binary. Its image is used - * to create a new task upon a @c task_spawn syscall. The syscall - * returns the id of a phone connected to the newly created task. - * - * The caller uses this phone to send the pathname and various other + * to create a new task upon a @c task_spawn syscall. It has a phone connected + * to the caller of te syscall. The formal caller (taskman) performs a + * handshake with loader so that apparent caller can communicate with the + * loader. + * + * The apparent caller uses his phone to send the pathname and various other * information to the loader. This is normally done by the C library * and completely hidden from applications. */ + #include @@ -47,14 +50,18 @@ #include #include -#include -#include -#include +#include +#include +#include +#include #include #include -#include +#include +#include +#include +#include #include -#include -#include -#include +#include +#include +#include #include #include @@ -73,4 +80,7 @@ /** The Program control block */ static pcb_t pcb; + +/** Primary IPC session */ +static async_sess_t *session_primary = NULL; /** Current working directory */ @@ -92,4 +102,9 @@ /** Used to limit number of connections to one. */ static bool connected = false; + +/** Ensure synchronization of handshake and connection fibrils. */ +static bool handshake_complete = false; +FIBRIL_MUTEX_INITIALIZE(handshake_mtx); +FIBRIL_CONDVAR_INITIALIZE(handshake_cv); static void ldr_get_taskid(ipc_call_t *req) @@ -319,4 +334,6 @@ DPRINTF("PCB set.\n"); + pcb.session_primary = session_primary; + pcb.cwd = cwd; @@ -373,4 +390,11 @@ static void ldr_connection(ipc_call_t *icall, void *arg) { + /* Wait for handshake */ + fibril_mutex_lock(&handshake_mtx); + while (!handshake_complete) { + fibril_condvar_wait(&handshake_cv, &handshake_mtx); + } + fibril_mutex_unlock(&handshake_mtx); + /* Already have a connection? */ if (connected) { @@ -428,22 +452,45 @@ } +static errno_t ldr_taskman_handshake(void) +{ + errno_t retval = EOK; + + fibril_mutex_lock(&handshake_mtx); + session_primary = taskman_handshake(); + if (session_primary == NULL) { + retval = errno; + goto finish; + } + + async_sess_t *session_tm = async_session_primary_swap(session_primary); + (void)async_hangup(session_tm); + + handshake_complete = true; + +finish: + fibril_condvar_signal(&handshake_cv); + fibril_mutex_unlock(&handshake_mtx); + + return retval; +} + /** Program loader main function. */ int main(int argc, char *argv[]) { - /* Introduce this task to the NS (give it our task ID). */ - task_id_t id = task_get_id(); - errno_t rc = ns_intro(id); - if (rc != EOK) + /* Set a handler of incomming connections. */ + async_set_fallback_port_handler(ldr_connection, NULL); + + /* Handshake with taskman */ + int rc = ldr_taskman_handshake(); + if (rc != EOK) { + DPRINTF("Failed taskman handshake (%i).\n", errno); return rc; - - /* Register at naming service. */ - rc = service_register(SERVICE_LOADER, INTERFACE_LOADER, - ldr_connection, NULL); - if (rc != EOK) - return rc; - + } + + /* Handle client connections */ async_manager(); - + //TODO retval? + /* Never reached */ return 0; Index: uspace/srv/ns/Makefile =================================================================== --- uspace/srv/ns/Makefile (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/srv/ns/Makefile (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -35,5 +35,4 @@ ns.c \ service.c \ - clonable.c \ task.c Index: pace/srv/ns/clonable.c =================================================================== --- uspace/srv/ns/clonable.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ (revision ) @@ -1,147 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * 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 ns - * @{ - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "clonable.h" -#include "ns.h" - -/** Request for connection to a clonable service. */ -typedef struct { - link_t link; - service_t service; - iface_t iface; - ipc_call_t call; -} cs_req_t; - -/** List of clonable-service connection requests. */ -static list_t cs_req; - -errno_t ns_clonable_init(void) -{ - list_initialize(&cs_req); - return EOK; -} - -/** Return true if @a service is clonable. */ -bool ns_service_is_clonable(service_t service, iface_t iface) -{ - return (service == SERVICE_LOADER) && (iface == INTERFACE_LOADER); -} - -/** Register clonable service. - * - * @param call Pointer to call structure. - * - */ -void ns_clonable_register(ipc_call_t *call) -{ - link_t *req_link = list_first(&cs_req); - if (req_link == NULL) { - /* There was no pending connection request. */ - printf("%s: Unexpected clonable server.\n", NAME); - async_answer_0(call, EBUSY); - return; - } - - cs_req_t *csr = list_get_instance(req_link, cs_req_t, link); - list_remove(req_link); - - /* Currently we can only handle a single type of clonable service. */ - assert(ns_service_is_clonable(csr->service, csr->iface)); - - async_answer_0(call, EOK); - - async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE); - if (sess == NULL) - async_answer_0(call, EIO); - - async_exch_t *exch = async_exchange_begin(sess); - async_forward_1(&csr->call, exch, csr->iface, - ipc_get_arg3(&csr->call), IPC_FF_NONE); - async_exchange_end(exch); - - free(csr); - async_hangup(sess); -} - -/** Connect client to clonable service. - * - * @param service Service to be connected to. - * @param iface Interface to be connected to. - * @param call Pointer to call structure. - * - * @return Zero on success or a value from @ref errno.h. - * - */ -void ns_clonable_forward(service_t service, iface_t iface, ipc_call_t *call) -{ - assert(ns_service_is_clonable(service, iface)); - - cs_req_t *csr = malloc(sizeof(cs_req_t)); - if (csr == NULL) { - async_answer_0(call, ENOMEM); - return; - } - - /* Spawn a loader. */ - errno_t rc = loader_spawn("loader"); - - if (rc != EOK) { - free(csr); - async_answer_0(call, rc); - return; - } - - link_initialize(&csr->link); - csr->service = service; - csr->iface = iface; - csr->call = *call; - - /* - * We can forward the call only after the server we spawned connects - * to us. Meanwhile we might need to service more connection requests. - * Thus we store the call in a queue. - */ - list_append(&csr->link, &cs_req); -} - -/** - * @} - */ Index: pace/srv/ns/clonable.h =================================================================== --- uspace/srv/ns/clonable.h (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ (revision ) @@ -1,51 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * 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 ns - * @{ - */ - -#ifndef NS_CLONABLE_H__ -#define NS_CLONABLE_H__ - -#include -#include -#include -#include - -extern errno_t ns_clonable_init(void); - -extern bool ns_service_is_clonable(service_t, iface_t); -extern void ns_clonable_register(ipc_call_t *); -extern void ns_clonable_forward(service_t, iface_t, ipc_call_t *); - -#endif - -/** - * @} - */ Index: uspace/srv/ns/ns.c =================================================================== --- uspace/srv/ns/ns.c (revision 103939e306be2c8479c923b22f2b89e6530d9111) +++ uspace/srv/ns/ns.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -46,5 +46,4 @@ #include "ns.h" #include "service.h" -#include "clonable.h" #include "task.h" @@ -61,10 +60,5 @@ * Client requests to be connected to a service. */ - if (ns_service_is_clonable(service, iface)) { - ns_clonable_forward(service, iface, icall); - } else { - ns_service_forward(service, iface, icall); - } - + ns_service_forward(service, iface, icall); return; } @@ -92,10 +86,5 @@ * Server requests service registration. */ - if (ns_service_is_clonable(service, iface)) { - ns_clonable_register(&call); - continue; - } else { - retval = ns_service_register(service, iface); - } + retval = ns_service_register(service, iface); break; @@ -116,5 +105,7 @@ break; case NS_RETVAL: - retval = ns_task_retval(&call); + // TODO move to taskman + retval = EOK; + //retval = ns_task_retval(&call); break; default: @@ -140,8 +131,4 @@ return rc; - rc = ns_clonable_init(); - if (rc != EOK) - return rc; - rc = task_init(); if (rc != EOK) Index: uspace/srv/taskman/Makefile =================================================================== --- uspace/srv/taskman/Makefile (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) +++ uspace/srv/taskman/Makefile (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -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. +# + +USPACE_PREFIX = ../.. +BINARY = taskman +STATIC_NEEDED = y + +SOURCES = \ + main.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/taskman/main.c =================================================================== --- uspace/srv/taskman/main.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) +++ uspace/srv/taskman/main.c (revision 0a8f070c890fb7e10df2f1aa71289773d26926dc) @@ -0,0 +1,181 @@ +/* + * 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 +#include +#include +#include +#include +#include + +#define NAME "taskman" + +//TODO move to appropriate header file +extern async_sess_t *session_primary; + +typedef struct { + link_t link; + async_sess_t *sess; +} sess_ref_t; + +static prodcons_t sess_queue; + + +/* + * Static functions + */ +static void connect_to_loader(ipc_callid_t iid, ipc_call_t *icall) +{ + /* Spawn a loader. */ + int rc = loader_spawn("loader"); + + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } + + /* Wait until spawned task presents itself to us. */ + link_t *link = prodcons_consume(&sess_queue); + sess_ref_t *sess_ref = list_get_instance(link, sess_ref_t, link); + + /* Forward the connection request (strip interface arg). */ + async_exch_t *exch = async_exchange_begin(sess_ref->sess); + rc = async_forward_fast(iid, exch, + IPC_GET_ARG2(*icall), + IPC_GET_ARG3(*icall), + 0, IPC_FF_NONE); + async_exchange_end(exch); + + free(sess_ref); + + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } + + /* Everything OK. */ +} + +static void loader_to_ns(ipc_callid_t iid, ipc_call_t *icall) +{ + /* Do no accept connection request, forward it instead. */ + async_exch_t *exch = async_exchange_begin(session_primary); + int rc = async_forward_fast(iid, exch, 0, 0, 0, IPC_FF_NONE); + async_exchange_end(exch); + + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } +} + +static void loader_callback(ipc_callid_t iid, ipc_call_t *icall) +{ + // TODO check that loader is expected, would probably discard prodcons + // scheme + + /* Preallocate session container */ + sess_ref_t *sess_ref = malloc(sizeof(sess_ref_t)); + if (sess_ref == NULL) { + async_answer_0(iid, ENOMEM); + } + + + /* Create callback connection */ + sess_ref->sess = async_callback_receive_start(EXCHANGE_ATOMIC, icall); + if (sess_ref->sess == NULL) { + //TODO different error code? + async_answer_0(iid, EINVAL); + return; + } + async_answer_0(iid, EOK); + + link_initialize(&sess_ref->link); + prodcons_produce(&sess_queue, &sess_ref->link); +} + +static void taskman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + taskman_interface_t iface = IPC_GET_ARG1(*icall); + switch (iface) { + case TASKMAN_CONNECT_TO_LOADER: + connect_to_loader(iid, icall); + break; + case TASKMAN_LOADER_TO_NS: + loader_to_ns(iid, icall); + break; + default: + /* Unknown interface */ + async_answer_0(iid, ENOENT); + } +} + +static void implicit_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + taskman_interface_t iface = IPC_GET_ARG1(*icall); + switch (iface) { + case TASKMAN_LOADER_CALLBACK: + loader_callback(iid, icall); + break; + default: + /* Unknown interface on implicit connection */ + async_answer_0(iid, EHANGUP); + } +} + +/** Build hard coded configuration */ + + +int main(int argc, char *argv[]) +{ + printf(NAME ": HelenOS task manager\n"); + + prodcons_initialize(&sess_queue); + + /* We're service too */ + int rc = service_register(SERVICE_TASKMAN); + if (rc != EOK) { + printf("Cannot register at naming service (%i).", rc); + return rc; + } + + /* Start sysman server */ + async_set_client_connection(taskman_connection); + async_set_implicit_connection(implicit_connection); + + printf(NAME ": Accepting connections\n"); + //TODO task_retval(EOK); + async_manager(); + + /* not reached */ + return 0; +}