Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 8b6cd5c in mainline for kernel/generic/src/ipc/ipcrsc.c


Ignore:
Timestamp:
2018-10-29T20:55:36Z (4 years ago)
Author:
Jakub Jermar <jakub@…>
Children:
8048931c
Parents:
f230cbd
Message:

Remove outdated comment

File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/ipc/ipcrsc.c

    rf230cbd r8b6cd5c  
    3131 */
    3232/** @file
    33  */
    34 
    35 /*
    36  * IPC resources management
    37  *
    38  * The goal of this source code is to properly manage IPC resources and allow
    39  * straight and clean clean-up procedure upon task termination.
    40  *
    41  * The pattern of usage of the resources is:
    42  * - allocate a capability and phone kernel object (do not publish yet),
    43  *   connect to the answerbox, and finally publish the capability
    44  * - disconnect connected phone (some messages might be on the fly)
    45  * - find phone capability and send a message using phone
    46  * - answer message to phone
    47  * - hangup phone (the caller has hung up)
    48  * - hangup phone (the answerbox is exiting)
    49  *
    50  * Locking strategy
    51  *
    52  * - To use a phone, disconnect a phone etc., the phone must be first locked and
    53  *   then checked that it is connected
    54  * - To connect an allocated phone it need not be locked (assigning pointer is
    55  *   atomic on all platforms)
    56  *
    57  * - To answer a message, the answerbox must be locked
    58  * - The locking of phone and answerbox is done at the ipc_ level.
    59  *   It is perfectly correct to pass unconnected phone to these functions and
    60  *   proper reply will be generated.
    61  *
    62  * Locking order
    63  *
    64  * - first phone, then answerbox
    65  *   + Easy locking on calls
    66  *   - Very hard traversing list of phones when disconnecting because the phones
    67  *     may disconnect during traversal of list of connected phones. The only
    68  *     possibility is try_lock with restart of list traversal.
    69  *
    70  * Destroying is less frequent, this approach is taken.
    71  *
    72  * Phone call
    73  *
    74  * *** Connect_me_to ***
    75  * The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives
    76  * 'phoneid' of the connecting phone as an ARG5. If it answers with RETVAL=EOK,
    77  * the phone call is accepted, otherwise it is refused.
    78  *
    79  * *** Connect_to_me ***
    80  * The caller sends IPC_M_CONNECT_TO_ME.
    81  * The server receives an automatically opened phoneid. If it accepts
    82  * (RETVAL=EOK), it can use the phoneid immediately. Possible race condition can
    83  * arise, when the client receives messages from new connection before getting
    84  * response for connect_to_me message. Userspace should implement handshake
    85  * protocol that would control it.
    86  *
    87  * Phone hangup
    88  *
    89  * *** The caller hangs up (sys_ipc_hangup) ***
    90  * - The phone is disconnected (no more messages can be sent over this phone),
    91  *   all in-progress messages are correctly handled. The answerbox receives
    92  *   IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async calls
    93  *   are answered, the phone is deallocated.
    94  *
    95  * *** The answerbox hangs up (ipc_answer(EHANGUP))
    96  * - The phone is disconnected. EHANGUP response code is sent to the calling
    97  *   task. All new calls through this phone get a EHUNGUP error code, the task
    98  *   is expected to call sys_ipc_hangup after cleaning up its internal
    99  *   structures.
    100  *
    101  *
    102  * Call forwarding
    103  *
    104  * The call can be forwarded, so that the answer to call is passed directly to
    105  * the original sender. However, this poses special problems regarding routing
    106  * of hangup messages.
    107  *
    108  * sys_ipc_hangup -> IPC_M_PHONE_HUNGUP
    109  * - this message CANNOT be forwarded
    110  *
    111  * EHANGUP during forward
    112  * - The *forwarding* phone will be closed, EFORWARD is sent to receiver.
    113  *
    114  * EHANGUP, ENOENT during forward
    115  * - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD
    116  *
    117  * Cleanup strategy
    118  *
    119  * 1) Disconnect all our phones ('ipc_phone_hangup').
    120  *
    121  * 2) Disconnect all phones connected to answerbox.
    122  *
    123  * 3) Answer all messages in 'calls' and 'dispatched_calls' queues with
    124  *    appropriate error code (EHANGUP, EFORWARD).
    125  *
    126  * 4) Wait for all async answers to arrive and dispose of them.
    127  *
    12833 */
    12934
Note: See TracChangeset for help on using the changeset viewer.