uspace/srv/ns/clonable.c

   1 /*
   2  * Copyright (c) 2009 Martin Decky
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup ns
  30  * @{
  31  */
  32
  33 #include <ipc/ipc.h>
  34 #include <ipc/services.h>
  35 #include <adt/list.h>
  36 #include <bool.h>
  37 #include <errno.h>
  38 #include <assert.h>
  39 #include <stdio.h>
  40 #include <malloc.h>
  41 #include <loader/loader.h>
  42 #include "clonable.h"
  43 #include "ns.h"
  44
  45 /** Request for connection to a clonable service. */
  46 typedef struct {
  47         link_t link;
  48         sysarg_t service;
  49         ipc_call_t call;
  50         ipc_callid_t callid;
  51 } cs_req_t;
  52
  53 /** List of clonable-service connection requests. */
  54 static list_t cs_req;
  55
  56 int clonable_init(void)
  57 {
  58         list_initialize(&cs_req);
  59         return EOK;
  60 }
  61
  62 /** Return true if @a service is clonable. */
  63 bool service_clonable(int service)
  64 {
  65         return (service == SERVICE_LOAD);
  66 }
  67
  68 /** Register clonable service.
  69  *
  70  * @param service Service to be registered.
  71  * @param phone   Phone to be used for connections to the service.
  72  * @param call    Pointer to call structure.
  73  *
  74  */
  75 void register_clonable(sysarg_t service, sysarg_t phone, ipc_call_t *call,
  76     ipc_callid_t callid)
  77 {
  78         link_t *req_link;
  79
  80         req_link = list_first(&cs_req);
  81         if (req_link == NULL) {
  82                 /* There was no pending connection request. */
  83                 printf("%s: Unexpected clonable server.\n", NAME);
  84                 ipc_answer_0(callid, EBUSY);
  85                 return;
  86         }
  87
  88         cs_req_t *csr = list_get_instance(req_link, cs_req_t, link);
  89         list_remove(req_link);
  90
  91         /* Currently we can only handle a single type of clonable service. */
  92         assert(csr->service == SERVICE_LOAD);
  93
  94         ipc_answer_0(callid, EOK);
  95
  96         ipc_forward_fast(csr->callid, phone, IPC_GET_ARG2(csr->call),
  97             IPC_GET_ARG3(csr->call), 0, IPC_FF_NONE);
  98
  99         free(csr);
 100         ipc_hangup(phone);
 101 }
 102
 103 /** Connect client to clonable service.
 104  *
 105  * @param service Service to be connected to.
 106  * @param call    Pointer to call structure.
 107  * @param callid  Call ID of the request.
 108  *
 109  * @return Zero on success or a value from @ref errno.h.
 110  *
 111  */
 112 void connect_to_clonable(sysarg_t service, ipc_call_t *call,
 113     ipc_callid_t callid)
 114 {
 115         assert(service == SERVICE_LOAD);
 116
 117         cs_req_t *csr = malloc(sizeof(cs_req_t));
 118         if (csr == NULL) {
 119                 ipc_answer_0(callid, ENOMEM);
 120                 return;
 121         }
 122
 123         /* Spawn a loader. */
 124         int rc = loader_spawn("loader");
 125
 126         if (rc < 0) {
 127                 free(csr);
 128                 ipc_answer_0(callid, rc);
 129                 return;
 130         }
 131
 132         link_initialize(&csr->link);
 133         csr->service = service;
 134         csr->call = *call;
 135         csr->callid = callid;
 136
 137         /*
 138          * We can forward the call only after the server we spawned connects
 139          * to us. Meanwhile we might need to service more connection requests.
 140          * Thus we store the call in a queue.
 141          */
 142         list_append(&csr->link, &cs_req);
 143 }
 144
 145 /**
 146  * @}
 147  */