kernel/generic/src/ipc/ipcrsc.c

   1 /*
   2  * Copyright (c) 2006 Ondrej Palkovsky
   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 kernel_generic_ipc
  30  * @{
  31  */
  32 /** @file
  33  */
  34
  35 #include <synch/spinlock.h>
  36 #include <ipc/ipc.h>
  37 #include <arch.h>
  38 #include <proc/task.h>
  39 #include <ipc/ipcrsc.h>
  40 #include <assert.h>
  41 #include <abi/errno.h>
  42 #include <cap/cap.h>
  43 #include <mm/slab.h>
  44 #include <stdlib.h>
  45
  46 static void phone_destroy(void *arg)
  47 {
  48         phone_t *phone = (phone_t *) arg;
  49         if (phone->hangup_call)
  50                 kobject_put(phone->hangup_call->kobject);
  51         slab_free(phone_cache, phone);
  52 }
  53
  54 kobject_ops_t phone_kobject_ops = {
  55         .destroy = phone_destroy
  56 };
  57
  58 /** Allocate new phone in the specified task.
  59  *
  60  * @param[in]  task     Task for which to allocate a new phone.
  61  * @param[in]  publish  If true, the new capability will be published.
  62  * @param[out] phandle  New phone capability handle.
  63  * @param[out] kobject  New phone kobject.
  64  *
  65  * @return  An error code if a new capability cannot be allocated.
  66  */
  67 errno_t phone_alloc(task_t *task, bool publish, cap_phone_handle_t *phandle,
  68     kobject_t **kobject)
  69 {
  70         cap_handle_t handle;
  71         errno_t rc = cap_alloc(task, &handle);
  72         if (rc == EOK) {
  73                 phone_t *phone = slab_alloc(phone_cache, FRAME_ATOMIC);
  74                 if (!phone) {
  75                         cap_free(TASK, handle);
  76                         return ENOMEM;
  77                 }
  78                 kobject_t *kobj = kobject_alloc(FRAME_ATOMIC);
  79                 if (!kobj) {
  80                         cap_free(TASK, handle);
  81                         slab_free(phone_cache, phone);
  82                         return ENOMEM;
  83                 }
  84                 call_t *hcall = ipc_call_alloc();
  85                 if (!hcall) {
  86                         cap_free(TASK, handle);
  87                         slab_free(phone_cache, phone);
  88                         free(kobj);
  89                         return ENOMEM;
  90                 }
  91
  92                 ipc_phone_init(phone, task);
  93                 phone->state = IPC_PHONE_CONNECTING;
  94                 phone->hangup_call = hcall;
  95
  96                 kobject_initialize(kobj, KOBJECT_TYPE_PHONE, phone);
  97                 phone->kobject = kobj;
  98
  99                 if (publish)
 100                         cap_publish(task, handle, kobj);
 101
 102                 *phandle = handle;
 103                 if (kobject)
 104                         *kobject = kobj;
 105         }
 106         return rc;
 107 }
 108
 109 /** Free slot from a disconnected phone.
 110  *
 111  * All already sent messages will be correctly processed.
 112  *
 113  * @param handle Phone capability handle of the phone to be freed.
 114  *
 115  */
 116 void phone_dealloc(cap_phone_handle_t handle)
 117 {
 118         kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_PHONE);
 119         if (!kobj)
 120                 return;
 121
 122         kobject_put(kobj);
 123         cap_free(TASK, handle);
 124 }
 125
 126 /** @}
 127  */