[PATCH] reset real_timer target on exec leader change

[pandora-kernel.git] / fs / aio.c

diff --git a/fs/aio.c b/fs/aio.c
index 40517f3..06d7d43 100644 (file)
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -40,9 +40,6 @@
 #define dprintk(x...)  do { ; } while (0)
 #endif
 
-static long aio_run = 0; /* for testing only */
-static long aio_wakeups = 0; /* for testing only */
-
 /*------ sysctl variables----*/
 atomic_t aio_nr = ATOMIC_INIT(0);      /* current system wide number of aio requests */
 unsigned aio_max_nr = 0x10000; /* system wide maximum number of aio requests */
@@ -61,6 +58,7 @@ static DEFINE_SPINLOCK(fput_lock);
 static LIST_HEAD(fput_head);
 
 static void aio_kick_handler(void *);
+static void aio_queue_work(struct kioctx *);
 
 /* aio_setup
  *     Creates the slab caches used by the aio routines, panic on
@@ -617,7 +615,6 @@ static inline int __queue_kicked_iocb(struct kiocb *iocb)
        if (list_empty(&iocb->ki_run_list)) {
                list_add_tail(&iocb->ki_run_list,
                        &ctx->run_list);
-               iocb->ki_queued++;
                return 1;
        }
        return 0;
@@ -658,10 +655,8 @@ static ssize_t aio_run_iocb(struct kiocb *iocb)
        }
 
        if (!(iocb->ki_retried & 0xff)) {
-               pr_debug("%ld retry: %d of %d (kick %ld, Q %ld run %ld, wake %ld)\n",
-                       iocb->ki_retried,
-                       iocb->ki_nbytes - iocb->ki_left, iocb->ki_nbytes,
-                       iocb->ki_kicked, iocb->ki_queued, aio_run, aio_wakeups);
+               pr_debug("%ld retry: %d of %d\n", iocb->ki_retried,
+                       iocb->ki_nbytes - iocb->ki_left, iocb->ki_nbytes);
        }
 
        if (!(retry = iocb->ki_retry)) {
@@ -753,6 +748,14 @@ out:
                 * has already been kicked */
                if (kiocbIsKicked(iocb)) {
                        __queue_kicked_iocb(iocb);
+
+                       /*
+                        * __queue_kicked_iocb will always return 1 here, because
+                        * iocb->ki_run_list is empty at this point so it should
+                        * be safe to unconditionally queue the context into the
+                        * work queue.
+                        */
+                       aio_queue_work(ctx);
                }
        }
        return ret;
@@ -768,7 +771,6 @@ out:
 static int __aio_run_iocbs(struct kioctx *ctx)
 {
        struct kiocb *iocb;
-       int count = 0;
        LIST_HEAD(run_list);
 
        list_splice_init(&ctx->run_list, &run_list);
@@ -783,9 +785,7 @@ static int __aio_run_iocbs(struct kioctx *ctx)
                aio_run_iocb(iocb);
                if (__aio_put_req(ctx, iocb))  /* drop extra ref */
                        put_ioctx(ctx);
-               count++;
        }
-       aio_run++;
        if (!list_empty(&ctx->run_list))
                return 1;
        return 0;
@@ -884,10 +884,8 @@ static void queue_kicked_iocb(struct kiocb *iocb)
        spin_lock_irqsave(&ctx->ctx_lock, flags);
        run = __queue_kicked_iocb(iocb);
        spin_unlock_irqrestore(&ctx->ctx_lock, flags);
-       if (run) {
+       if (run)
                aio_queue_work(ctx);
-               aio_wakeups++;
-       }
 }
 
 /*
@@ -907,7 +905,6 @@ void fastcall kick_iocb(struct kiocb *iocb)
                return;
        }
 
-       iocb->ki_kicked++;
        /* If its already kicked we shouldn't queue it again */
        if (!kiocbTryKick(iocb)) {
                queue_kicked_iocb(iocb);
@@ -1003,10 +1000,8 @@ int fastcall aio_complete(struct kiocb *iocb, long res, long res2)
 
        pr_debug("added to ring %p at [%lu]\n", iocb, tail);
 
-       pr_debug("%ld retries: %d of %d (kicked %ld, Q %ld run %ld wake %ld)\n",
-               iocb->ki_retried,
-               iocb->ki_nbytes - iocb->ki_left, iocb->ki_nbytes,
-               iocb->ki_kicked, iocb->ki_queued, aio_run, aio_wakeups);
+       pr_debug("%ld retries: %d of %d\n", iocb->ki_retried,
+               iocb->ki_nbytes - iocb->ki_left, iocb->ki_nbytes);
 put_rq:
        /* everything turned out well, dispose of the aiocb. */
        ret = __aio_put_req(ctx, iocb);
@@ -1114,7 +1109,6 @@ static int read_events(struct kioctx *ctx,
        int                     i = 0;
        struct io_event         ent;
        struct aio_timeout      to;
-       int                     event_loop = 0; /* testing only */
        int                     retry = 0;
 
        /* needed to zero any padding within an entry (there shouldn't be 
@@ -1181,7 +1175,6 @@ retry:
                        if (to.timed_out)       /* Only check after read evt */
                                break;
                        schedule();
-                       event_loop++;
                        if (signal_pending(tsk)) {
                                ret = -EINTR;
                                break;
@@ -1209,9 +1202,6 @@ retry:
        if (timeout)
                clear_timeout(&to);
 out:
-       pr_debug("event loop executed %d times\n", event_loop);
-       pr_debug("aio_run %ld\n", aio_run);
-       pr_debug("aio_wakeups %ld\n", aio_wakeups);
        return i ? i : ret;
 }
 
@@ -1526,10 +1516,6 @@ int fastcall io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
        init_waitqueue_func_entry(&req->ki_wait, aio_wake_function);
        INIT_LIST_HEAD(&req->ki_wait.task_list);
        req->ki_retried = 0;
-       req->ki_kicked = 0;
-       req->ki_queued = 0;
-       aio_run = 0;
-       aio_wakeups = 0;
 
        ret = aio_setup_iocb(req);
 
@@ -1537,10 +1523,14 @@ int fastcall io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
                goto out_put_req;
 
        spin_lock_irq(&ctx->ctx_lock);
-       list_add_tail(&req->ki_run_list, &ctx->run_list);
-       /* drain the run list */
-       while (__aio_run_iocbs(ctx))
-               ;
+       if (likely(list_empty(&ctx->run_list))) {
+               aio_run_iocb(req);
+       } else {
+               list_add_tail(&req->ki_run_list, &ctx->run_list);
+               /* drain the run list */
+               while (__aio_run_iocbs(ctx))
+                       ;
+       }
        spin_unlock_irq(&ctx->ctx_lock);
        aio_put_req(req);       /* drop extra ref to req */
        return 0;