Changes in / [30f1a25:67f11a0] in mainline


Ignore:
Location:
kernel/generic
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/cap/cap.h

    r30f1a25 r67f11a0  
    6464struct phone;
    6565
    66 struct kobject;
    6766typedef struct kobject_ops {
    68         bool (*reclaim)(struct kobject *);
    6967        void (*destroy)(void *);
    7068} kobject_ops_t;

  • kernel/generic/include/ipc/ipc.h

    r30f1a25 r67f11a0  
    8282        waitq_t wq;
    8383
     84        /**
     85         * Number of answers the answerbox is expecting to eventually arrive.
     86         */
     87        atomic_t active_calls;
     88
    8489        /** Phones connected to this answerbox. */
    8590        list_t connected_phones;
    … …  
    177182extern slab_cache_t *phone_cache;
    178183
    179 extern answerbox_t *ipc_phone_0;
     184extern answerbox_t *ipc_box_0;
    180185
    181186extern void ipc_init(void);

  • kernel/generic/include/ipc/ipcrsc.h

    r30f1a25 r67f11a0  
    4040#include <cap/cap.h>
    4141
    42 extern errno_t phone_alloc(task_t *, cap_handle_t *);
    43 extern bool phone_connect(cap_handle_t, answerbox_t *);
     42extern errno_t phone_alloc(task_t *, bool, cap_handle_t *, kobject_t **);
    4443extern void phone_dealloc(cap_handle_t);
    4544

  • kernel/generic/src/cap/cap.c

    r30f1a25 r67f11a0  
    235235}
    236236
    237 static bool cap_reclaimer(ht_link_t *link, void *arg)
    238 {
    239         cap_t **result = (cap_t **) arg;
    240         cap_t *cap = hash_table_get_inst(link, cap_t, caps_link);
    241 
    242         if (cap->state == CAP_STATE_PUBLISHED && cap->kobject->ops->reclaim &&
    243             cap->kobject->ops->reclaim(cap->kobject)) {
    244                 kobject_t *kobj = cap_unpublish(cap->task, cap->handle,
    245                     cap->kobject->type);
    246                 kobject_put(kobj);
    247                 cap_initialize(cap, cap->task, cap->handle);
    248                 *result = cap;
    249                 return false;
    250         }
    251 
    252         return true;
    253 }
    254 
    255237/** Allocate new capability
    256238 *
    … …  
    263245errno_t cap_alloc(task_t *task, cap_handle_t *handle)
    264246{
    265         cap_t *cap = NULL;
    266 
    267         /*
    268          * First of all, see if we can reclaim a capability. Note that this
    269          * feature is only temporary and capability reclamaition will eventually
    270          * be phased out.
    271          */
    272         mutex_lock(&task->cap_info->lock);
    273         hash_table_apply(&task->cap_info->caps, cap_reclaimer, &cap);
    274 
    275         /*
    276          * If we don't have a capability by now, try to allocate a new one.
    277          */
     247        mutex_lock(&task->cap_info->lock);
     248        cap_t *cap = slab_alloc(cap_cache, FRAME_ATOMIC);
    278249        if (!cap) {
    279                 cap = slab_alloc(cap_cache, FRAME_ATOMIC);
    280                 if (!cap) {
    281                         mutex_unlock(&task->cap_info->lock);
    282                         return ENOMEM;
    283                 }
    284                 uintptr_t hbase;
    285                 if (!ra_alloc(task->cap_info->handles, 1, 1, &hbase)) {
    286                         slab_free(cap_cache, cap);
    287                         mutex_unlock(&task->cap_info->lock);
    288                         return ENOMEM;
    289                 }
    290                 cap_initialize(cap, task, (cap_handle_t) hbase);
    291                 hash_table_insert(&task->cap_info->caps, &cap->caps_link);
    292         }
     250                mutex_unlock(&task->cap_info->lock);
     251                return ENOMEM;
     252        }
     253        uintptr_t hbase;
     254        if (!ra_alloc(task->cap_info->handles, 1, 1, &hbase)) {
     255                slab_free(cap_cache, cap);
     256                mutex_unlock(&task->cap_info->lock);
     257                return ENOMEM;
     258        }
     259        cap_initialize(cap, task, (cap_handle_t) hbase);
     260        hash_table_insert(&task->cap_info->caps, &cap->caps_link);
    293261
    294262        cap->state = CAP_STATE_ALLOCATED;

  • kernel/generic/src/ipc/ipc.c

    r30f1a25 r67f11a0  
    6363static void ipc_forget_call(call_t *);
    6464
    65 /** Open channel that is assigned automatically to new tasks */
    66 answerbox_t *ipc_phone_0 = NULL;
     65/** Answerbox that new tasks are automatically connected to */
     66answerbox_t *ipc_box_0 = NULL;
    6767
    6868static slab_cache_t *call_cache;
    … …  
    147147        list_initialize(&box->answers);
    148148        list_initialize(&box->irq_notifs);
     149        atomic_set(&box->active_calls, 0);
    149150        box->task = task;
    150151}
    … …  
    160161bool ipc_phone_connect(phone_t *phone, answerbox_t *box)
    161162{
    162         bool active;
     163        bool connected;
    163164
    164165        mutex_lock(&phone->lock);
    165166        irq_spinlock_lock(&box->lock, true);
    166167
    167         active = box->active;
    168         if (active) {
     168        connected = box->active && (phone->state == IPC_PHONE_CONNECTING);
     169        if (connected) {
    169170                phone->state = IPC_PHONE_CONNECTED;
    170171                phone->callee = box;
    … …  
    176177        mutex_unlock(&phone->lock);
    177178
    178         if (!active) {
     179        if (!connected) {
    179180                /* We still have phone->kobject's reference; drop it */
    180181                kobject_put(phone->kobject);
    181182        }
    182183
    183         return active;
     184        return connected;
    184185}
    185186
    … …  
    350351        } else {
    351352                atomic_inc(&phone->active_calls);
     353                if (call->callerbox)
     354                        atomic_inc(&call->callerbox->active_calls);
     355                else
     356                        atomic_inc(&caller->answerbox.active_calls);
     357                kobject_add_ref(phone->kobject);
    352358                call->sender = caller;
    353359                call->active = true;
    … …  
    439445/** Disconnect phone from answerbox.
    440446 *
    441  * This call leaves the phone in the HUNGUP state. The change to 'free' is done
    442  * lazily later.
     447 * This call leaves the phone in the hung-up state. The phone is destroyed when
     448 * its last active call is answered and there are no references to it.
    443449 *
    444450 * @param phone Phone structure to be hung up.
    … …  
    563569                list_remove(&request->ab_link);
    564570                atomic_dec(&request->caller_phone->active_calls);
     571                atomic_dec(&box->active_calls);
     572                kobject_put(request->caller_phone->kobject);
    565573        } else if (!list_empty(&box->calls)) {
    566574                /* Count received call */
    … …  
    707715
    708716        atomic_dec(&call->caller_phone->active_calls);
     717        atomic_dec(&TASK->answerbox.active_calls);
     718        kobject_put(call->caller_phone->kobject);
    709719
    710720        SYSIPC_OP(request_forget, call);
    … …  
    746756}
    747757
    748 static bool phone_cap_wait_cb(cap_t *cap, void *arg)
    749 {
    750         phone_t *phone = cap->kobject->phone;
    751         bool *restart = (bool *) arg;
    752 
    753         mutex_lock(&phone->lock);
    754         if ((phone->state == IPC_PHONE_HUNGUP) &&
    755             (atomic_get(&phone->active_calls) == 0)) {
    756                 phone->state = IPC_PHONE_FREE;
    757                 phone->callee = NULL;
    758         }
    759 
    760         /*
    761          * We might have had some IPC_PHONE_CONNECTING phones at the beginning
    762          * of ipc_cleanup(). Depending on whether these were forgotten or
    763          * answered, they will eventually enter the IPC_PHONE_FREE or
    764          * IPC_PHONE_CONNECTED states, respectively.  In the latter case, the
    765          * other side may slam the open phones at any time, in which case we
    766          * will get an IPC_PHONE_SLAMMED phone.
    767          */
    768         if ((phone->state == IPC_PHONE_CONNECTED) ||
    769             (phone->state == IPC_PHONE_SLAMMED)) {
    770                 mutex_unlock(&phone->lock);
    771                 ipc_phone_hangup(phone);
    772                 /*
    773                  * Now there may be one extra active call, which needs to be
    774                  * forgotten.
    775                  */
    776                 ipc_forget_all_active_calls();
    777                 *restart = true;
    778                 return false;
    779         }
    780 
    781         /*
    782          * If the hangup succeeded, it has sent a HANGUP message, the IPC is now
    783          * in HUNGUP state, we wait for the reply to come
    784          */
    785         if (phone->state != IPC_PHONE_FREE) {
    786                 mutex_unlock(&phone->lock);
    787                 return false;
    788         }
    789 
    790         mutex_unlock(&phone->lock);
    791         return true;
    792 }
    793 
    794 /** Wait for all answers to asynchronous calls to arrive. */
    795 static void ipc_wait_for_all_answered_calls(void)
    796 {
    797         call_t *call;
    798         bool restart;
    799 
    800 restart:
    801         /*
    802          * Go through all phones, until they are all free.
    803          * Locking is needed as there may be connection handshakes in progress.
    804          */
    805         restart = false;
    806         if (caps_apply_to_kobject_type(TASK, KOBJECT_TYPE_PHONE,
    807             phone_cap_wait_cb, &restart)) {
    808                 /* Got into cleanup */
    809                 return;
    810         }
    811         if (restart)
    812                 goto restart;
    813 
    814         call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT,
    815             SYNCH_FLAGS_NONE);
    816         assert(call->flags & (IPC_CALL_ANSWERED | IPC_CALL_NOTIF));
    817 
    818         SYSIPC_OP(answer_process, call);
    819 
    820         kobject_put(call->kobject);
    821         goto restart;
    822 }
    823 
    824758static bool phone_cap_cleanup_cb(cap_t *cap, void *arg)
    825759{
    … …  
    830764        cap_free(cap->task, cap->handle);
    831765        return true;
     766}
     767
     768/** Wait for all answers to asynchronous calls to arrive. */
     769static void ipc_wait_for_all_answered_calls(void)
     770{
     771        while (atomic_get(&TASK->answerbox.active_calls) != 0) {
     772                call_t *call = ipc_wait_for_call(&TASK->answerbox,
     773                    SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
     774                assert(call->flags & (IPC_CALL_ANSWERED | IPC_CALL_NOTIF));
     775
     776                SYSIPC_OP(answer_process, call);
     777
     778                kobject_put(call->kobject);
     779
     780                /*
     781                 * Now there may be some new phones and new hangup calls to
     782                 * immediately forget.
     783                 */
     784                caps_apply_to_kobject_type(TASK, KOBJECT_TYPE_PHONE,
     785                    phone_cap_cleanup_cb, NULL);
     786                ipc_forget_all_active_calls();
     787        }
    832788}
    833789
    … …  
    869825        irq_spinlock_unlock(&TASK->answerbox.lock, true);
    870826
    871         /* Disconnect all our phones ('ipc_phone_hangup') */
     827        /* Hangup all phones and destroy all phone capabilities */
    872828        caps_apply_to_kobject_type(TASK, KOBJECT_TYPE_PHONE,
    873829            phone_cap_cleanup_cb, NULL);
    874830
    875         /* Unsubscribe from any event notifications. */
     831        /* Unsubscribe from any event notifications */
    876832        event_cleanup_answerbox(&TASK->answerbox);
    877833
    … …  
    899855        ipc_forget_all_active_calls();
    900856        ipc_wait_for_all_answered_calls();
     857
     858        assert(atomic_get(&TASK->answerbox.active_calls) == 0);
    901859}
    902860
    … …  
    968926                        break;
    969927                case IPC_PHONE_HUNGUP:
    970                         printf("hung up by %p", phone->callee);
     928                        printf("hung up to %p", phone->callee);
    971929                        break;
    972930                default:
    … …  
    1004962        irq_spinlock_lock(&task->lock, true);
    1005963        irq_spinlock_lock(&task->answerbox.lock, false);
     964
     965        printf("Active calls: %" PRIun "\n",
     966            atomic_get(&task->answerbox.active_calls));
    1006967
    1007968#ifdef __32_BITS__

  • kernel/generic/src/ipc/ipcrsc.c

    r30f1a25 r67f11a0  
    3939 *
    4040 * The pattern of usage of the resources is:
    41  * - allocate empty phone capability slot, connect | deallocate slot
     41 * - allocate a capability and phone kernel object (do not publish yet),
     42 *   connect to the answerbox, and finally publish the capability
    4243 * - disconnect connected phone (some messages might be on the fly)
    43  * - find phone in slot and send a message using phone
     44 * - find phone capability and send a message using phone
    4445 * - answer message to phone
    4546 * - hangup phone (the caller has hung up)
    … …  
    5354 *   atomic on all platforms)
    5455 *
    55  * - To find an empty phone capability slot, the TASK must be locked
    5656 * - To answer a message, the answerbox must be locked
    5757 * - The locking of phone and answerbox is done at the ipc_ level.
    … …  
    7373 * *** Connect_me_to ***
    7474 * The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives
    75  * 'phoneid' of the connecting phone as an ARG5. If it answers with RETVAL=0,
    76  * the phonecall is accepted, otherwise it is refused.
     75 * 'phoneid' of the connecting phone as an ARG5. If it answers with RETVAL=EOK,
     76 * the phone call is accepted, otherwise it is refused.
    7777 *
    7878 * *** Connect_to_me ***
    7979 * The caller sends IPC_M_CONNECT_TO_ME.
    8080 * The server receives an automatically opened phoneid. If it accepts
    81  * (RETVAL=0), it can use the phoneid immediately. Possible race condition can
     81 * (RETVAL=EOK), it can use the phoneid immediately. Possible race condition can
    8282 * arise, when the client receives messages from new connection before getting
    8383 * response for connect_to_me message. Userspace should implement handshake
    … …  
    9595 * - The phone is disconnected. EHANGUP response code is sent to the calling
    9696 *   task. All new calls through this phone get a EHUNGUP error code, the task
    97  *   is expected to send an sys_ipc_hangup after cleaning up its internal
     97 *   is expected to call sys_ipc_hangup after cleaning up its internal
    9898 *   structures.
    9999 *
    … …  
    137137#include <mm/slab.h>
    138138
    139 static bool phone_reclaim(kobject_t *kobj)
    140 {
    141         bool gc = false;
    142 
    143         mutex_lock(&kobj->phone->lock);
    144         if (kobj->phone->state == IPC_PHONE_HUNGUP &&
    145             atomic_get(&kobj->phone->active_calls) == 0)
    146                 gc = true;
    147         mutex_unlock(&kobj->phone->lock);
    148 
    149         return gc;
    150 }
    151 
    152139static void phone_destroy(void *arg)
    153140{
    … …  
    157144
    158145static kobject_ops_t phone_kobject_ops = {
    159         .reclaim = phone_reclaim,
    160146        .destroy = phone_destroy
    161147};
    … …  
    164150/** Allocate new phone in the specified task.
    165151 *
    166  * @param task  Task for which to allocate a new phone.
    167  *
    168  * @param[out] out_handle  New phone capability handle.
     152 * @param[in]  task     Task for which to allocate a new phone.
     153 * @param[in]  publish  If true, the new capability will be published.
     154 * @param[out] phandle  New phone capability handle.
     155 * @param[out] kobject  New phone kobject.
    169156 *
    170157 * @return  An error code if a new capability cannot be allocated.
    171158 */
    172 errno_t phone_alloc(task_t *task, cap_handle_t *out_handle)
     159errno_t phone_alloc(task_t *task, bool publish, cap_handle_t *phandle,
     160    kobject_t **kobject)
    173161{
    174162        cap_handle_t handle;
    … …  
    180168                        return ENOMEM;
    181169                }
    182                 kobject_t *kobject = malloc(sizeof(kobject_t), FRAME_ATOMIC);
    183                 if (!kobject) {
     170                kobject_t *kobj = malloc(sizeof(kobject_t), FRAME_ATOMIC);
     171                if (!kobj) {
    184172                        cap_free(TASK, handle);
    185173                        slab_free(phone_cache, phone);
    … …  
    190178                phone->state = IPC_PHONE_CONNECTING;
    191179
    192                 kobject_initialize(kobject, KOBJECT_TYPE_PHONE, phone,
     180                kobject_initialize(kobj, KOBJECT_TYPE_PHONE, phone,
    193181                    &phone_kobject_ops);
    194                 phone->kobject = kobject;
    195 
    196                 cap_publish(task, handle, kobject);
    197 
    198                 *out_handle = handle;
     182                phone->kobject = kobj;
     183
     184                if (publish)
     185                        cap_publish(task, handle, kobj);
     186
     187                *phandle = handle;
     188                if (kobject)
     189                        *kobject = kobj;
    199190        }
    200191        return rc;
    … …  
    214205                return;
    215206
    216         assert(kobj->phone);
    217         assert(kobj->phone->state == IPC_PHONE_CONNECTING);
    218 
    219207        kobject_put(kobj);
    220208        cap_free(TASK, handle);
    221209}
    222210
    223 /** Connect phone to a given answerbox.
    224  *
    225  * @param handle  Capability handle of the phone to be connected.
    226  * @param box     Answerbox to which to connect the phone.
    227  * @return        True if the phone was connected, false otherwise.
    228  */
    229 bool phone_connect(cap_handle_t handle, answerbox_t *box)
    230 {
    231         kobject_t *phone_obj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
    232         if (!phone_obj)
    233                 return false;
    234 
    235         assert(phone_obj->phone->state == IPC_PHONE_CONNECTING);
    236 
    237         /* Hand over phone_obj reference to the answerbox */
    238         return ipc_phone_connect(phone_obj->phone, box);
    239 }
    240 
    241211/** @}
    242212 */

  • kernel/generic/src/ipc/kbox.c

    r30f1a25 r67f11a0  
    253253        /* Allocate a new phone. */
    254254        cap_handle_t phone_handle;
    255         errno_t rc = phone_alloc(TASK, &phone_handle);
     255        errno_t rc = phone_alloc(TASK, true, &phone_handle, NULL);
    256256        if (rc != EOK) {
    257257                mutex_unlock(&task->kb.cleanup_lock);

  • kernel/generic/src/ipc/ops/conctmeto.c

    r30f1a25 r67f11a0  
    4242static errno_t request_preprocess(call_t *call, phone_t *phone)
    4343{
     44        /*
     45         * Create the new phone and capability, but don't publish them yet.
     46         * That will be done once the phone is connected.
     47         */
    4448        cap_handle_t phone_handle;
    45         errno_t rc = phone_alloc(TASK, &phone_handle);
    46 
    47         /* Remember the phone capability or that an error occured. */
    48         call->priv = (rc == EOK) ? phone_handle : -1;
    49 
     49        kobject_t *phone_obj;
     50        errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
    5051        if (rc != EOK) {
     52                call->priv = -1;
    5153                return rc;
    5254        }
    5355
    54         /* Set arg5 for server */
    55         kobject_t *phone_obj = kobject_get(TASK, phone_handle,
    56             KOBJECT_TYPE_PHONE);
    5756        /* Hand over phone_obj's reference to ARG5 */
    5857        IPC_SET_ARG5(call->data, (sysarg_t) phone_obj->phone);
     58
     59        /* Remember the handle */
     60        call->priv = phone_handle;
    5961
    6062        return EOK;
    … …  
    6567        cap_handle_t phone_handle = (cap_handle_t) call->priv;
    6668
    67         if (phone_handle < 0) {
     69        if (phone_handle < 0)
    6870                return EOK;
    69         }
    7071
    71         phone_dealloc(phone_handle);
    7272        /* Hand over reference from ARG5 to phone->kobject */
    7373        phone_t *phone = (phone_t *) IPC_GET_ARG5(call->data);
    74         /* Drop phone_obj's reference */
     74        /* Drop phone->kobject's reference */
    7575        kobject_put(phone->kobject);
     76        cap_free(TASK, phone_handle);
     77
    7678        return EOK;
    7779}
    … …  
    8284        phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata);
    8385
    84         /* If the user accepted call, connect */
     86        /*
     87         * Get an extra reference and pass it in the answer data.
     88         */
     89        kobject_add_ref(phone->kobject);
     90        IPC_SET_ARG5(answer->data, (sysarg_t) phone);
     91
     92        /* If the user accepted the call, connect */
    8593        if (IPC_GET_RETVAL(answer->data) == EOK) {
    8694                /* Hand over reference from phone to the answerbox */
    … …  
    96104{
    97105        cap_handle_t phone_handle = (cap_handle_t) answer->priv;
     106        phone_t *phone = (phone_t *) IPC_GET_ARG5(answer->data);
    98107
    99108        if (IPC_GET_RETVAL(answer->data)) {
    100109                if (phone_handle >= 0) {
    101110                        /*
    102                          * The phone was indeed allocated and now needs
    103                          * to be deallocated.
     111                         * Cleanup the unpublished capability and drop
     112                         * phone->kobject's reference.
    104113                         */
    105                         phone_dealloc(phone_handle);
     114                        kobject_put(phone->kobject);
     115                        cap_free(TASK, phone_handle);
    106116                }
    107117        } else {
     118                /*
     119                 * Publish the capability. Publishing the capability this late
     120                 * is important for ipc_cleanup() where we want to have a
     121                 * capability for each phone that wasn't hung up by the user.
     122                 */
     123                cap_publish(TASK, phone_handle, phone->kobject);
     124
    108125                IPC_SET_ARG5(answer->data, phone_handle);
    109126        }

  • kernel/generic/src/ipc/ops/concttome.c

    r30f1a25 r67f11a0  
    4343{
    4444        cap_handle_t phone_handle;
    45         errno_t rc = phone_alloc(TASK, &phone_handle);
     45        kobject_t *phone_obj;
     46        errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
     47        call->priv = (sysarg_t) phone_obj;
    4648        IPC_SET_ARG5(call->data, (rc == EOK) ? phone_handle : -1);
    4749        return 0;
    … …  
    5153{
    5254        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
     55        kobject_t *phone_obj = (kobject_t *) answer->priv;
    5356
    54         if (phone_handle >= 0)
    55                 phone_dealloc(phone_handle);
     57        if (phone_handle >= 0) {
     58                kobject_put(phone_obj);
     59                cap_free(TASK, phone_handle);
     60        }
    5661
    5762        return EOK;
    … …  
    6166{
    6267        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
     68        kobject_t *phone_obj = (kobject_t *) answer->priv;
    6369
    6470        if (IPC_GET_RETVAL(answer->data) != EOK) {
    … …  
    6672                answer_cleanup(answer, olddata);
    6773        } else if (phone_handle >= 0) {
    68                 /* The connection was accepted */
    69                 if (phone_connect(phone_handle, &answer->sender->answerbox)) {
     74                /*
     75                 * The connection was accepted
     76                 */
     77
     78                /*
     79                 * We need to create another reference as the one we have now
     80                 * will be consumed by ipc_phone_connect().
     81                 */
     82                kobject_add_ref(phone_obj);
     83
     84                if (ipc_phone_connect(phone_obj->phone,
     85                    &answer->sender->answerbox)) {
     86                        /* Pass the reference to the capability */
     87                        cap_publish(TASK, phone_handle, phone_obj);
    7088                        /* Set 'phone hash' as ARG5 of response */
    71                         kobject_t *phone_obj = kobject_get(TASK, phone_handle,
    72                             KOBJECT_TYPE_PHONE);
    7389                        IPC_SET_ARG5(answer->data,
    7490                            (sysarg_t) phone_obj->phone);
    75                         kobject_put(phone_obj);
    7691                } else {
    7792                        /* The answerbox is shutting down. */

  • kernel/generic/src/ipc/sysipc.c

    r30f1a25 r67f11a0  
    724724sys_errno_t sys_ipc_hangup(sysarg_t handle)
    725725{
    726         kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
     726        kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_PHONE);
    727727        if (!kobj)
    728728                return ENOENT;
    … …  
    730730        errno_t rc = ipc_phone_hangup(kobj->phone);
    731731        kobject_put(kobj);
     732        cap_free(TASK, handle);
    732733        return rc;
    733734}

  • kernel/generic/src/main/kinit.c

    r30f1a25 r67f11a0  
    265265                                    PERM_IO_MANAGER | PERM_IRQ_REG);
    266266
    267                                 if (!ipc_phone_0) {
    268                                         ipc_phone_0 = &programs[i].task->answerbox;
     267                                if (!ipc_box_0) {
     268                                        ipc_box_0 = &programs[i].task->answerbox;
    269269                                        /*
    270                                          * Hold the first task so that the
    271                                          * ipc_phone_0 remains a valid pointer
     270                                         * Hold the first task so that
     271                                         * ipc_box_0 remains a valid pointer
    272272                                         * even if the first task exits for
    273273                                         * whatever reason.

  • kernel/generic/src/proc/task.c

    r30f1a25 r67f11a0  
    129129        size_t tasks_left;
    130130
    131         if (ipc_phone_0) {
    132                 task_t *task_0 = ipc_phone_0->task;
    133                 ipc_phone_0 = NULL;
     131        if (ipc_box_0) {
     132                task_t *task_0 = ipc_box_0->task;
     133                ipc_box_0 = NULL;
    134134                /*
    135135                 * The first task is held by kinit(), we need to release it or
    … …  
    243243#endif
    244244
    245         if ((ipc_phone_0) &&
    246             (container_check(ipc_phone_0->task->container, task->container))) {
     245        if ((ipc_box_0) &&
     246            (container_check(ipc_box_0->task->container, task->container))) {
    247247                cap_handle_t phone_handle;
    248                 errno_t rc = phone_alloc(task, &phone_handle);
     248                errno_t rc = phone_alloc(task, true, &phone_handle, NULL);
    249249                if (rc != EOK) {
    250250                        task->as = NULL;
    … …  
    256256                kobject_t *phone_obj = kobject_get(task, phone_handle,
    257257                    KOBJECT_TYPE_PHONE);
    258                 (void) ipc_phone_connect(phone_obj->phone, ipc_phone_0);
     258                (void) ipc_phone_connect(phone_obj->phone, ipc_box_0);
    259259        }
    260260
Note: See TracChangeset for help on using the changeset viewer.