lkml.org 
[lkml]   [2017]   [Oct]   [26]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Subject[PATCH v3 0/6] ANDROID: binder: RT priority inheritance
    Date
    Changes since v2 [1]:
    - All patches in v2 not related to priority inheritance were merged,
    and hence removed from this series
    - Fixed using the wrong mask in node scheduler policy calculation,
    originally reported by Ganesh Mahendran <opensource.ganesh@gmail.com>
    - Fixed using an uninitialized value for desired_prio,
    originally reported by Ganesh Mahendran <opensource.ganesh@gmail.com>

    Changes since v1 [2]:
    - added more detailed commit messages and comments to the priority
    inheritance patches, including rationale for not using
    schet_setscheduler() directly, or rt_mutex prio inheritance.
    No functional changes.

    [1]: https://lkml.kernel.org/r/20170831080430.118765-1-maco@android.com
    [2]: https://lkml.kernel.org/r/20170825093335.100892-1-maco@android.com

    ---

    This patch series introduces support for priority inheritance of real-time
    scheduling policies in binder. With the introduction of Android Treble,
    functionality that used to be in a single process is now split over two or
    more processes, which communicate using binder IPC. For latency sensitive
    operations such as sensor events, Bluetooth audio and rendering, inheriting
    the (real-time) priority of the caller is crucial to meet requirements.

    The implementation in this series directly calls into the scheduler to
    modify priorities, since I haven't found a way to make this work correctly
    with rt_mutex or other existing priority inheritance mechanisms. The main
    reasons a PI rt_mutex doesn't work well are the following:
    1) Binder supports asynchronous transactions, where a caller isn't blocked
    on a result; therefore, the caller also couldn't block on a rt_mutex.
    2) Binder supports the concept of 'node priority', where the priority of a
    call is not determined by the caller, but by the endpoint the caller
    calls in to.
    3) There may not necessarily be any binder threads waiting to handle a
    transaction, so the caller doesn't always have a thread to change the
    priority of; instead, the first thread to pick up the work changes its
    own priority.
    4) rt_mutex doesn't support non-RT policies (though a patch was sent to
    LKML once to address this).

    More details in the patches themselves. I have found the current approach
    to be reliable, but I'm happy to look into suggestions to make this work
    with rt_mutex, or use other infrastructure.

    All patches have already been reviewed by Android engineers and are
    merged in Android's common kernel trees.

    Martijn Coenen (6):
    ANDROID: binder: add support for RT prio inheritance.
    ANDROID: binder: add min sched_policy to node.
    ANDROID: binder: improve priority inheritance.
    ANDROID: binder: add RT inheritance flag to node.
    ANDROID: binder: don't check prio permissions on restore.
    ANDROID: binder: Add tracing for binder priority inheritance.

    drivers/android/binder.c | 294 ++++++++++++++++++++++++++++++++----
    drivers/android/binder_trace.h | 24 +++
    include/uapi/linux/android/binder.h | 49 +++++-
    3 files changed, 334 insertions(+), 33 deletions(-)

    --
    2.15.0.rc2.357.g7e34df9404-goog

    \
     
     \ /
      Last update: 2017-10-26 16:08    [W:4.224 / U:0.044 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site