[PATCH] Generic HDLC WAN drivers - disable netif_carrier_off()

[safe/jmp/linux-2.6] / fs / direct-io.c

diff --git a/fs/direct-io.c b/fs/direct-io.c
index 5a674a0..3931e7f 100644 (file)
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -66,6 +66,7 @@ struct dio {
        struct bio *bio;                /* bio under assembly */
        struct inode *inode;
        int rw;
+       loff_t i_size;                  /* i_size when submitted */
        int lock_type;                  /* doesn't change */
        unsigned blkbits;               /* doesn't change */
        unsigned blkfactor;             /* When we're using an alignment which
@@ -161,6 +162,7 @@ static int dio_refill_pages(struct dio *dio)
        up_read(&current->mm->mmap_sem);
 
        if (ret < 0 && dio->blocks_available && (dio->rw == WRITE)) {
+               struct page *page = ZERO_PAGE(dio->curr_user_address);
                /*
                 * A memory fault, but the filesystem has some outstanding
                 * mapped blocks.  We need to use those blocks up to avoid
@@ -168,7 +170,8 @@ static int dio_refill_pages(struct dio *dio)
                 */
                if (dio->page_errors == 0)
                        dio->page_errors = ret;
-               dio->pages[0] = ZERO_PAGE(dio->curr_user_address);
+               page_cache_get(page);
+               dio->pages[0] = page;
                dio->head = 0;
                dio->tail = 1;
                ret = 0;
@@ -214,7 +217,7 @@ static struct page *dio_get_page(struct dio *dio)
 static void dio_complete(struct dio *dio, loff_t offset, ssize_t bytes)
 {
        if (dio->end_io && dio->result)
-               dio->end_io(dio->inode, offset, bytes, dio->map_bh.b_private);
+               dio->end_io(dio->iocb, offset, bytes, dio->map_bh.b_private);
        if (dio->lock_type == DIO_LOCKING)
                up_read(&dio->inode->i_alloc_sem);
 }
@@ -230,17 +233,29 @@ static void finished_one_bio(struct dio *dio)
        spin_lock_irqsave(&dio->bio_lock, flags);
        if (dio->bio_count == 1) {
                if (dio->is_async) {
+                       ssize_t transferred;
+                       loff_t offset;
+
                        /*
                         * Last reference to the dio is going away.
                         * Drop spinlock and complete the DIO.
                         */
                        spin_unlock_irqrestore(&dio->bio_lock, flags);
-                       dio_complete(dio, dio->block_in_file << dio->blkbits,
-                                       dio->result);
+
+                       /* Check for short read case */
+                       transferred = dio->result;
+                       offset = dio->iocb->ki_pos;
+
+                       if ((dio->rw == READ) &&
+                           ((offset + transferred) > dio->i_size))
+                               transferred = dio->i_size - offset;
+
+                       dio_complete(dio, offset, transferred);
+
                        /* Complete AIO later if falling back to buffered i/o */
                        if (dio->result == dio->size ||
                                ((dio->rw == READ) && dio->result)) {
-                               aio_complete(dio->iocb, dio->result, 0);
+                               aio_complete(dio->iocb, transferred, 0);
                                kfree(dio);
                                return;
                        } else {
@@ -951,6 +966,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        dio->page_errors = 0;
        dio->result = 0;
        dio->iocb = iocb;
+       dio->i_size = i_size_read(inode);
 
        /*
         * BIO completion state.