lkml.org 
[lkml]   [2008]   [Feb]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH [RT] 05/14] rearrange rt_spin_lock sleep
    Date
    The current logic makes rather coarse adjustments to current->state since
    it is planning on sleeping anyway. We want to eventually move to an
    adaptive (e.g. optional sleep) algorithm, so we tighten the scope of the
    adjustments to bracket the schedule(). This should yield correct behavior
    with or without the adaptive features that are added later in the series.
    We add it here as a separate patch for greater review clarity on smaller
    changes.

    Signed-off-by: Gregory Haskins <ghaskins@novell.com>
    ---

    kernel/rtmutex.c | 20 +++++++++++++++-----
    1 files changed, 15 insertions(+), 5 deletions(-)

    diff --git a/kernel/rtmutex.c b/kernel/rtmutex.c
    index a2b00cc..15fc6e6 100644
    --- a/kernel/rtmutex.c
    +++ b/kernel/rtmutex.c
    @@ -661,6 +661,14 @@ rt_spin_lock_fastunlock(struct rt_mutex *lock,
    slowfn(lock);
    }

    +static inline void
    +update_current(unsigned long new_state, unsigned long *saved_state)
    +{
    + unsigned long state = xchg(&current->state, new_state);
    + if (unlikely(state == TASK_RUNNING))
    + *saved_state = TASK_RUNNING;
    +}
    +
    /*
    * Slow path lock function spin_lock style: this variant is very
    * careful not to miss any non-lock wakeups.
    @@ -700,7 +708,8 @@ rt_spin_lock_slowlock(struct rt_mutex *lock)
    * saved_state accordingly. If we did not get a real wakeup
    * then we return with the saved state.
    */
    - saved_state = xchg(&current->state, TASK_UNINTERRUPTIBLE);
    + saved_state = current->state;
    + smp_mb();

    for (;;) {
    unsigned long saved_flags;
    @@ -732,14 +741,15 @@ rt_spin_lock_slowlock(struct rt_mutex *lock)

    debug_rt_mutex_print_deadlock(&waiter);

    - schedule_rt_mutex(lock);
    + update_current(TASK_UNINTERRUPTIBLE, &saved_state);
    + if (waiter.task)
    + schedule_rt_mutex(lock);
    + else
    + update_current(TASK_RUNNING_MUTEX, &saved_state);

    spin_lock_irqsave(&lock->wait_lock, flags);
    current->flags |= saved_flags;
    current->lock_depth = saved_lock_depth;
    - state = xchg(&current->state, TASK_UNINTERRUPTIBLE);
    - if (unlikely(state == TASK_RUNNING))
    - saved_state = TASK_RUNNING;
    }

    state = xchg(&current->state, saved_state);


    \
     
     \ /
      Last update: 2008-02-21 16:59    [W:0.022 / U:1.096 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site