Skip to content

GitLab

Switch branch/tag
  1. 27 Jun, 2006 2 commits
  3. 26 Jun, 2006 1 commit
  5. 25 Jun, 2006 4 commits
  7. 23 Jun, 2006 1 commit
  9. 17 Jun, 2006 1 commit
  11. 01 May, 2006 1 commit
  13. 19 Apr, 2006 1 commit
  15. 11 Apr, 2006 1 commit
    • Jens Axboe's avatar
      [PATCH] splice: add direct fd <-> fd splicing support · b92ce558
      Jens Axboe authored 
      
It's more efficient for sendfile() emulation. Basically we cache an
internal private pipe and just use that as the intermediate area for
pages. Direct splicing is not available from sys_splice(), it is only
meant to be used for sendfile() emulation.

Additional patch from Ingo Molnar to avoid the PIPE_BUFFERS loop at
exit for the normal fast path.
Signed-off-by: default avatarJens Axboe <axboe@suse.de>
      b92ce558
  17. 31 Mar, 2006 1 commit
    • Eric W. Biederman's avatar
      [PATCH] task: RCU protect task->usage · 8c7904a0
      Eric W. Biederman authored 
      
A big problem with rcu protected data structures that are also reference
counted is that you must jump through several hoops to increase the reference
count.  I think someone finally implemented atomic_inc_not_zero(&count) to
automate the common case.  Unfortunately this means you must special case the
rcu access case.

When data structures are only visible via rcu in a manner that is not
determined by the reference count on the object (i.e.  tasks are visible until
their zombies are reaped) there is a much simpler technique we can employ.
Simply delaying the decrement of the reference count until the rcu interval is
over.

What that means is that the proc code that looks up a task and later
wants to sleep can now do:

rcu_read_lock();
task = find_task_by_pid(some_pid);
if (task) {
	get_task_struct(task);
}
rcu_read_unlock();

The effect on the rest of the kernel is that put_task_struct becomes cheaper
and immediate, and in the case where the task has been reaped it frees the
task immediate instead of unnecessarily waiting an until the rcu interval is
over.

Cleanup of task_struct does not happen when its reference count drops to
zero, instead cleanup happens when release_task is called.  Tasks can only
be looked up via rcu before release_task is called.  All rcu protected
members of task_struct are freed by release_task.

Therefore we can move call_rcu from put_task_struct into release_task.  And
we can modify release_task to not immediately release the reference count
but instead have it call put_task_struct from the function it gives to
call_rcu.

The end result:

- get_task_struct is safe in an rcu context where we have just looked
  up the task.

- put_task_struct() simplifies into its old pre rcu self.

This reorganization also makes put_task_struct uncallable from modules as
it is not exported but it does not appear to be called from any modules so
this should not be an issue, and is trivially fixed.
Signed-off-by: default avatarEric W. Biederman <ebiederm@xmission.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
      8c7904a0
  19. 28 Mar, 2006 14 commits
  21. 27 Mar, 2006 2 commits
  23. 23 Mar, 2006 1 commit
  25. 18 Mar, 2006 1 commit
  27. 20 Feb, 2006 1 commit
  29. 14 Jan, 2006 2 commits
  31. 11 Jan, 2006 1 commit
  33. 10 Jan, 2006 2 commits
  35. 09 Jan, 2006 1 commit
  37. 08 Jan, 2006 2 commits