Merge branch 'for-2.6.38/core' of git://git.kernel.dk/linux-2.6-block
[linux-2.6.git] / block / blk-map.c
index 955d75c..e663ac2 100644 (file)
@@ -5,6 +5,7 @@
 #include <linux/module.h>
 #include <linux/bio.h>
 #include <linux/blkdev.h>
+#include <scsi/sg.h>           /* for struct sg_iovec */
 
 #include "blk.h"
 
@@ -19,11 +20,10 @@ int blk_rq_append_bio(struct request_queue *q, struct request *rq,
                rq->biotail->bi_next = bio;
                rq->biotail = bio;
 
-               rq->data_len += bio->bi_size;
+               rq->__data_len += bio->bi_size;
        }
        return 0;
 }
-EXPORT_SYMBOL(blk_rq_append_bio);
 
 static int __blk_rq_unmap_user(struct bio *bio)
 {
@@ -40,7 +40,8 @@ static int __blk_rq_unmap_user(struct bio *bio)
 }
 
 static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
-                            void __user *ubuf, unsigned int len)
+                            struct rq_map_data *map_data, void __user *ubuf,
+                            unsigned int len, gfp_t gfp_mask)
 {
        unsigned long uaddr;
        struct bio *bio, *orig_bio;
@@ -53,15 +54,17 @@ static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
         * direct dma. else, set up kernel bounce buffers
         */
        uaddr = (unsigned long) ubuf;
-       if (!(uaddr & queue_dma_alignment(q)) &&
-           !(len & queue_dma_alignment(q)))
-               bio = bio_map_user(q, NULL, uaddr, len, reading);
+       if (blk_rq_aligned(q, uaddr, len) && !map_data)
+               bio = bio_map_user(q, NULL, uaddr, len, reading, gfp_mask);
        else
-               bio = bio_copy_user(q, uaddr, len, reading);
+               bio = bio_copy_user(q, map_data, uaddr, len, reading, gfp_mask);
 
        if (IS_ERR(bio))
                return PTR_ERR(bio);
 
+       if (map_data && map_data->null_mapped)
+               bio->bi_flags |= (1 << BIO_NULL_MAPPED);
+
        orig_bio = bio;
        blk_queue_bounce(q, &bio);
 
@@ -83,17 +86,19 @@ static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
 }
 
 /**
- * blk_rq_map_user - map user data to a request, for REQ_BLOCK_PC usage
+ * blk_rq_map_user - map user data to a request, for REQ_TYPE_BLOCK_PC usage
  * @q:         request queue where request should be inserted
  * @rq:                request structure to fill
+ * @map_data:   pointer to the rq_map_data holding pages (if necessary)
  * @ubuf:      the user buffer
  * @len:       length of user data
+ * @gfp_mask:  memory allocation flags
  *
  * Description:
- *    Data will be mapped directly for zero copy io, if possible. Otherwise
+ *    Data will be mapped directly for zero copy I/O, if possible. Otherwise
  *    a kernel bounce buffer is used.
  *
- *    A matching blk_rq_unmap_user() must be issued at the end of io, while
+ *    A matching blk_rq_unmap_user() must be issued at the end of I/O, while
  *    still in process context.
  *
  *    Note: The mapped bio may need to be bounced through blk_queue_bounce()
@@ -103,15 +108,19 @@ static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
  *    unmapping.
  */
 int blk_rq_map_user(struct request_queue *q, struct request *rq,
-                   void __user *ubuf, unsigned long len)
+                   struct rq_map_data *map_data, void __user *ubuf,
+                   unsigned long len, gfp_t gfp_mask)
 {
        unsigned long bytes_read = 0;
        struct bio *bio = NULL;
        int ret;
 
-       if (len > (q->max_hw_sectors << 9))
+       if (len > (queue_max_hw_sectors(q) << 9))
                return -EINVAL;
-       if (!len || !ubuf)
+       if (!len)
+               return -EINVAL;
+
+       if (!ubuf && (!map_data || !map_data->null_mapped))
                return -EINVAL;
 
        while (bytes_read != len) {
@@ -130,36 +139,46 @@ int blk_rq_map_user(struct request_queue *q, struct request *rq,
                if (end - start > BIO_MAX_PAGES)
                        map_len -= PAGE_SIZE;
 
-               ret = __blk_rq_map_user(q, rq, ubuf, map_len);
+               ret = __blk_rq_map_user(q, rq, map_data, ubuf, map_len,
+                                       gfp_mask);
                if (ret < 0)
                        goto unmap_rq;
                if (!bio)
                        bio = rq->bio;
                bytes_read += ret;
                ubuf += ret;
+
+               if (map_data)
+                       map_data->offset += ret;
        }
 
-       rq->buffer = rq->data = NULL;
+       if (!bio_flagged(bio, BIO_USER_MAPPED))
+               rq->cmd_flags |= REQ_COPY_USER;
+
+       rq->buffer = NULL;
        return 0;
 unmap_rq:
        blk_rq_unmap_user(bio);
+       rq->bio = NULL;
        return ret;
 }
 EXPORT_SYMBOL(blk_rq_map_user);
 
 /**
- * blk_rq_map_user_iov - map user data to a request, for REQ_BLOCK_PC usage
+ * blk_rq_map_user_iov - map user data to a request, for REQ_TYPE_BLOCK_PC usage
  * @q:         request queue where request should be inserted
  * @rq:                request to map data to
+ * @map_data:   pointer to the rq_map_data holding pages (if necessary)
  * @iov:       pointer to the iovec
  * @iov_count: number of elements in the iovec
  * @len:       I/O byte count
+ * @gfp_mask:  memory allocation flags
  *
  * Description:
- *    Data will be mapped directly for zero copy io, if possible. Otherwise
+ *    Data will be mapped directly for zero copy I/O, if possible. Otherwise
  *    a kernel bounce buffer is used.
  *
- *    A matching blk_rq_unmap_user() must be issued at the end of io, while
+ *    A matching blk_rq_unmap_user() must be issued at the end of I/O, while
  *    still in process context.
  *
  *    Note: The mapped bio may need to be bounced through blk_queue_bounce()
@@ -169,30 +188,56 @@ EXPORT_SYMBOL(blk_rq_map_user);
  *    unmapping.
  */
 int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
-                       struct sg_iovec *iov, int iov_count, unsigned int len)
+                       struct rq_map_data *map_data, struct sg_iovec *iov,
+                       int iov_count, unsigned int len, gfp_t gfp_mask)
 {
        struct bio *bio;
+       int i, read = rq_data_dir(rq) == READ;
+       int unaligned = 0;
 
        if (!iov || iov_count <= 0)
                return -EINVAL;
 
-       /* we don't allow misaligned data like bio_map_user() does.  If the
-        * user is using sg, they're expected to know the alignment constraints
-        * and respect them accordingly */
-       bio = bio_map_user_iov(q, NULL, iov, iov_count,
-                               rq_data_dir(rq) == READ);
+       for (i = 0; i < iov_count; i++) {
+               unsigned long uaddr = (unsigned long)iov[i].iov_base;
+
+               if (!iov[i].iov_len)
+                       return -EINVAL;
+
+               if (uaddr & queue_dma_alignment(q)) {
+                       unaligned = 1;
+                       break;
+               }
+       }
+
+       if (unaligned || (q->dma_pad_mask & len) || map_data)
+               bio = bio_copy_user_iov(q, map_data, iov, iov_count, read,
+                                       gfp_mask);
+       else
+               bio = bio_map_user_iov(q, NULL, iov, iov_count, read, gfp_mask);
+
        if (IS_ERR(bio))
                return PTR_ERR(bio);
 
        if (bio->bi_size != len) {
+               /*
+                * Grab an extra reference to this bio, as bio_unmap_user()
+                * expects to be able to drop it twice as it happens on the
+                * normal IO completion path
+                */
+               bio_get(bio);
                bio_endio(bio, 0);
-               bio_unmap_user(bio);
+               __blk_rq_unmap_user(bio);
                return -EINVAL;
        }
 
+       if (!bio_flagged(bio, BIO_USER_MAPPED))
+               rq->cmd_flags |= REQ_COPY_USER;
+
+       blk_queue_bounce(q, &bio);
        bio_get(bio);
        blk_rq_bio_prep(q, rq, bio);
-       rq->buffer = rq->data = NULL;
+       rq->buffer = NULL;
        return 0;
 }
 EXPORT_SYMBOL(blk_rq_map_user_iov);
@@ -204,7 +249,7 @@ EXPORT_SYMBOL(blk_rq_map_user_iov);
  * Description:
  *    Unmap a rq previously mapped by blk_rq_map_user(). The caller must
  *    supply the original rq->bio from the blk_rq_map_user() return, since
- *    the io completion may have changed rq->bio.
+ *    the I/O completion may have changed rq->bio.
  */
 int blk_rq_unmap_user(struct bio *bio)
 {
@@ -230,33 +275,56 @@ int blk_rq_unmap_user(struct bio *bio)
 EXPORT_SYMBOL(blk_rq_unmap_user);
 
 /**
- * blk_rq_map_kern - map kernel data to a request, for REQ_BLOCK_PC usage
+ * blk_rq_map_kern - map kernel data to a request, for REQ_TYPE_BLOCK_PC usage
  * @q:         request queue where request should be inserted
  * @rq:                request to fill
  * @kbuf:      the kernel buffer
  * @len:       length of user data
  * @gfp_mask:  memory allocation flags
+ *
+ * Description:
+ *    Data will be mapped directly if possible. Otherwise a bounce
+ *    buffer is used. Can be called multple times to append multple
+ *    buffers.
  */
 int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
                    unsigned int len, gfp_t gfp_mask)
 {
+       int reading = rq_data_dir(rq) == READ;
+       unsigned long addr = (unsigned long) kbuf;
+       int do_copy = 0;
        struct bio *bio;
+       int ret;
 
-       if (len > (q->max_hw_sectors << 9))
+       if (len > (queue_max_hw_sectors(q) << 9))
                return -EINVAL;
        if (!len || !kbuf)
                return -EINVAL;
 
-       bio = bio_map_kern(q, kbuf, len, gfp_mask);
+       do_copy = !blk_rq_aligned(q, addr, len) || object_is_on_stack(kbuf);
+       if (do_copy)
+               bio = bio_copy_kern(q, kbuf, len, gfp_mask, reading);
+       else
+               bio = bio_map_kern(q, kbuf, len, gfp_mask);
+
        if (IS_ERR(bio))
                return PTR_ERR(bio);
 
        if (rq_data_dir(rq) == WRITE)
-               bio->bi_rw |= (1 << BIO_RW);
+               bio->bi_rw |= REQ_WRITE;
+
+       if (do_copy)
+               rq->cmd_flags |= REQ_COPY_USER;
+
+       ret = blk_rq_append_bio(q, rq, bio);
+       if (unlikely(ret)) {
+               /* request is too big */
+               bio_put(bio);
+               return ret;
+       }
 
-       blk_rq_bio_prep(q, rq, bio);
        blk_queue_bounce(q, &rq->bio);
-       rq->buffer = rq->data = NULL;
+       rq->buffer = NULL;
        return 0;
 }
 EXPORT_SYMBOL(blk_rq_map_kern);