Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-23 04:31:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove struct task_struct::io_wait

Browse Source 
Hell knows what happened in commit 63b05203af57e7de4f3bb63b8b81d43bc196d32b
during 2.6.9 development.  Commit introduced io_wait field which remained
write-only than and still remains write-only.

Also garbage collect macros which "use" io_wait.

Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alexey Dobriyan 2007-10-18 03:04:56 -07:00 committed by Linus Torvalds
parent 9cd9a0058d
commit 6212e3a388
4 changed files with 2 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
fs/aio.c
View File

@ -710,18 +710,9 @@ static ssize_t aio_run_iocb(struct kiocb *iocb)
/*
* Now we are all set to call the retry method in async
* context. By setting this thread's io_wait context
* to point to the wait queue entry inside the currently
* running iocb for the duration of the retry, we ensure
* that async notification wakeups are queued by the
* operation instead of blocking waits, and when notified,
* cause the iocb to be kicked for continuation (through
* the aio_wake_function callback).
* context.
*/
BUG_ON(current->io_wait != NULL);
current->io_wait = &iocb->ki_wait;
ret = retry(iocb);
current->io_wait = NULL;
if (ret != -EIOCBRETRY && ret != -EIOCBQUEUED) {
BUG_ON(!list_empty(&iocb->ki_wait.task_list));
@ -1508,10 +1499,7 @@ static ssize_t aio_setup_iocb(struct kiocb *kiocb)
* Simply triggers a retry of the operation via kick_iocb.
*
* This callback is specified in the wait queue entry in
* a kiocb (current->io_wait points to this wait queue
* entry when an aio operation executes; it is used
* instead of a synchronous wait when an i/o blocking
* condition is encountered during aio).
* a kiocb.
*
* Note:
* This routine is executed with the wait queue lock held.

12
include/linux/aio.h
View File

@ -232,18 +232,6 @@ int FASTCALL(io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
__put_ioctx(kioctx); \
} while (0)
#define in_aio() (unlikely(!is_sync_wait(current->io_wait)))
/* may be used for debugging */
#define warn_if_async() \
do { \
if (in_aio()) { \
printk(KERN_ERR "%s(%s:%d) called in async context!\n", \
__FUNCTION__, __FILE__, __LINE__); \
dump_stack(); \
} \
} while (0)
#define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait)
#include <linux/aio_abi.h>

7
include/linux/sched.h
View File

@ -1110,13 +1110,6 @@ struct task_struct {
unsigned long ptrace_message;
siginfo_t *last_siginfo; /* For ptrace use. */
/*
* current io wait handle: wait queue entry to use for io waits
* If this thread is processing aio, this points at the waitqueue
* inside the currently handled kiocb. It may be NULL (i.e. default
* to a stack based synchronous wait) if its doing sync IO.
*/
wait_queue_t *io_wait;
#ifdef CONFIG_TASK_XACCT
/* i/o counters(bytes read/written, #syscalls */
u64 rchar, wchar, syscr, syscw;

1
kernel/fork.c
View File

@ -1084,7 +1084,6 @@ static struct task_struct *copy_process(unsigned long clone_flags,
p->security = NULL;
#endif
p->io_context = NULL;
p->io_wait = NULL;
p->audit_context = NULL;
cpuset_fork(p);
#ifdef CONFIG_NUMA