21 Dec, 2011

1 commit

  • -> #2 (&tty->write_wait){-.-...}:

    is a lot more informative than:

    -> #2 (key#19){-.....}:

    Signed-off-by: Peter Zijlstra
    Cc: Andrew Morton
    Cc: Linus Torvalds
    Link: http://lkml.kernel.org/n/tip-8zpopbny51023rdb0qq67eye@git.kernel.org
    Signed-off-by: Ingo Molnar

    Peter Zijlstra
     

31 Oct, 2011

1 commit

  • The changed files were only including linux/module.h for the
    EXPORT_SYMBOL infrastructure, and nothing else. Revector them
    onto the isolated export header for faster compile times.

    Nothing to see here but a whole lot of instances of:

    -#include
    +#include

    This commit is only changing the kernel dir; next targets
    will probably be mm, fs, the arch dirs, etc.

    Signed-off-by: Paul Gortmaker

    Paul Gortmaker
     

31 Mar, 2011

1 commit


27 Oct, 2010

1 commit


10 Aug, 2009

1 commit

  • Give waitqueue spinlocks their own lockdep classes when they
    are initialised from init_waitqueue_head(). This means that
    struct wait_queue::func functions can operate other waitqueues.

    This is used by CacheFiles to catch the page from a backing fs
    being unlocked and to wake up another thread to take a copy of
    it.

    Signed-off-by: Peter Zijlstra
    Signed-off-by: David Howells
    Tested-by: Takashi Iwai
    Cc: linux-cachefs@redhat.com
    Cc: torvalds@osdl.org
    Cc: akpm@linux-foundation.org
    LKML-Reference:
    Signed-off-by: Ingo Molnar

    Peter Zijlstra
     

14 Apr, 2009

1 commit

  • '777c6c5 wait: prevent exclusive waiter starvation' made
    __wake_up_common() global to be used from abort_exclusive_wait().

    It was needed to do a wake-up with the waitqueue lock held while
    passing down a key to the wake-up function.

    Since '4ede816 epoll keyed wakeups: add __wake_up_locked_key() and
    __wake_up_sync_key()' there is an appropriate wrapper for this case:
    __wake_up_locked_key().

    Use it here and make __wake_up_common() private to the scheduler
    again.

    Signed-off-by: Johannes Weiner
    Cc: Andrew Morton
    Cc: Peter Zijlstra
    LKML-Reference:
    Signed-off-by: Ingo Molnar

    Johannes Weiner
     

06 Feb, 2009

1 commit

  • With exclusive waiters, every process woken up through the wait queue must
    ensure that the next waiter down the line is woken when it has finished.

    Interruptible waiters don't do that when aborting due to a signal. And if
    an aborting waiter is concurrently woken up through the waitqueue, noone
    will ever wake up the next waiter.

    This has been observed with __wait_on_bit_lock() used by
    lock_page_killable(): the first contender on the queue was aborting when
    the actual lock holder woke it up concurrently. The aborted contender
    didn't acquire the lock and therefor never did an unlock followed by
    waking up the next waiter.

    Add abort_exclusive_wait() which removes the process' wait descriptor from
    the waitqueue, iff still queued, or wakes up the next waiter otherwise.
    It does so under the waitqueue lock. Racing with a wake up means the
    aborting process is either already woken (removed from the queue) and will
    wake up the next waiter, or it will remove itself from the queue and the
    concurrent wake up will apply to the next waiter after it.

    Use abort_exclusive_wait() in __wait_event_interruptible_exclusive() and
    __wait_on_bit_lock() when they were interrupted by other means than a wake
    up through the queue.

    [akpm@linux-foundation.org: coding-style fixes]
    Reported-by: Chris Mason
    Signed-off-by: Johannes Weiner
    Mentored-by: Oleg Nesterov
    Cc: Peter Zijlstra
    Cc: Matthew Wilcox
    Cc: Chuck Lever
    Cc: Nick Piggin
    Cc: Ingo Molnar
    Cc: ["after some testing"]
    Signed-off-by: Andrew Morton
    Signed-off-by: Linus Torvalds

    Johannes Weiner
     

17 Oct, 2008

1 commit

  • is_sync_wait() is used to distinguish between sync and async waits.
    Basically sync waits are the ones initialized with init_waitqueue_entry()
    and async ones with init_waitqueue_func_entry(). The sync/async
    distinction is used only in prepare_to_wait[_exclusive]() and its only
    function is to skip setting the current task state if the wait is async.
    This has a few problems.

    * No one uses it. None of func_entry users use prepare_to_wait()
    functions, so the code path never gets executed.

    * The distinction is bogus. Maybe back when func_entry is used only
    by aio but it's now also used by epoll and in future possibly by 9p
    and poll/select.

    * Taking @state as argument and ignoring it silenly depending on how
    @wait is initialized is just a bad error-prone API.

    * It prevents func_entry waits from using wait->private for no good
    reason.

    This patch kills is_sync_wait() and the associated code paths from
    prepare_to_wait[_exclusive](). As there was no user of these code paths,
    this patch doesn't cause any behavior difference.

    Signed-off-by: Tejun Heo
    Acked-by: Ingo Molnar
    Signed-off-by: Andrew Morton
    Signed-off-by: Linus Torvalds

    Tejun Heo
     

09 Feb, 2008

1 commit


07 Dec, 2007

1 commit


09 May, 2007

1 commit


11 Jul, 2006

1 commit

  • allyesconfig vmlinux size delta:

    text data bss dec filename
    20736884 6073834 3075176 29885894 vmlinux.before
    20721009 6073966 3075176 29870151 vmlinux.after

    ~18 bytes per callsite, 15K of text size (~0.1%) saved.

    (as an added bonus this also removes a lockdep annotation.)

    Signed-off-by: Ingo Molnar
    Signed-off-by: Andrew Morton
    Signed-off-by: Linus Torvalds

    Ingo Molnar
     

04 Jul, 2006

1 commit


01 Jul, 2006

1 commit


17 Apr, 2005

1 commit

  • Initial git repository build. I'm not bothering with the full history,
    even though we have it. We can create a separate "historical" git
    archive of that later if we want to, and in the meantime it's about
    3.2GB when imported into git - space that would just make the early
    git days unnecessarily complicated, when we don't have a lot of good
    infrastructure for it.

    Let it rip!

    Linus Torvalds