13 files changed, 80 insertions, 62 deletions

diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index 66e55288178..a09ead19f9c 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -26,8 +26,7 @@ int blk_queue_ordered(struct request_queue *q, unsigned ordered,
 {
         if (ordered & (QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH) &&
             prepare_flush_fn == NULL) {
-                printk(KERN_ERR "%s: prepare_flush_fn required\n",
-                                                                __FUNCTION__);
+                printk(KERN_ERR "%s: prepare_flush_fn required\n", __func__);
                 return -EINVAL;
         }
 
diff --git a/block/blk-core.c b/block/blk-core.c
index 5d09f8c5602..2987fe47b5e 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -54,15 +54,16 @@ static DEFINE_PER_CPU(struct list_head, blk_cpu_done);
 
 static void drive_stat_acct(struct request *rq, int new_io)
 {
+        struct hd_struct *part;
         int rw = rq_data_dir(rq);
 
         if (!blk_fs_request(rq) || !rq->rq_disk)
                 return;
 
-        if (!new_io) {
-                __all_stat_inc(rq->rq_disk, merges[rw], rq->sector);
-        } else {
-                struct hd_struct *part = get_part(rq->rq_disk, rq->sector);
+        part = get_part(rq->rq_disk, rq->sector);
+        if (!new_io)
+                __all_stat_inc(rq->rq_disk, part, merges[rw], rq->sector);
+        else {
                 disk_round_stats(rq->rq_disk);
                 rq->rq_disk->in_flight++;
                 if (part) {
@@ -136,7 +137,7 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
 
                 if (unlikely(nbytes > bio->bi_size)) {
                         printk(KERN_ERR "%s: want %u bytes done, %u left\n",
-                               __FUNCTION__, nbytes, bio->bi_size);
+                               __func__, nbytes, bio->bi_size);
                         nbytes = bio->bi_size;
                 }
 
@@ -253,9 +254,11 @@ EXPORT_SYMBOL(__generic_unplug_device);
  **/
 void generic_unplug_device(struct request_queue *q)
 {
-        spin_lock_irq(q->queue_lock);
-        __generic_unplug_device(q);
-        spin_unlock_irq(q->queue_lock);
+        if (blk_queue_plugged(q)) {
+                spin_lock_irq(q->queue_lock);
+                __generic_unplug_device(q);
+                spin_unlock_irq(q->queue_lock);
+        }
 }
 EXPORT_SYMBOL(generic_unplug_device);
 
@@ -1536,10 +1539,11 @@ static int __end_that_request_first(struct request *req, int error,
         }
 
         if (blk_fs_request(req) && req->rq_disk) {
+                struct hd_struct *part = get_part(req->rq_disk, req->sector);
                 const int rw = rq_data_dir(req);
 
-                all_stat_add(req->rq_disk, sectors[rw],
-                             nr_bytes >> 9, req->sector);
+                all_stat_add(req->rq_disk, part, sectors[rw],
+                                nr_bytes >> 9, req->sector);
         }
 
         total_bytes = bio_nbytes = 0;
@@ -1566,8 +1570,7 @@ static int __end_that_request_first(struct request *req, int error,
                         if (unlikely(bio->bi_idx >= bio->bi_vcnt)) {
                                 blk_dump_rq_flags(req, "__end_that");
                                 printk(KERN_ERR "%s: bio idx %d >= vcnt %d\n",
-                                                __FUNCTION__, bio->bi_idx,
-                                                bio->bi_vcnt);
+                                       __func__, bio->bi_idx, bio->bi_vcnt);
                                 break;
                         }
 
@@ -1726,8 +1729,8 @@ static void end_that_request_last(struct request *req, int error)
                 const int rw = rq_data_dir(req);
                 struct hd_struct *part = get_part(disk, req->sector);
 
-                __all_stat_inc(disk, ios[rw], req->sector);
-                __all_stat_add(disk, ticks[rw], duration, req->sector);
+                __all_stat_inc(disk, part, ios[rw], req->sector);
+                __all_stat_add(disk, part, ticks[rw], duration, req->sector);
                 disk_round_stats(disk);
                 disk->in_flight--;
                 if (part) {
diff --git a/block/blk-ioc.c b/block/blk-ioc.c
index e34df7c9fc3..012f065ac8e 100644
--- a/block/blk-ioc.c
+++ b/block/blk-ioc.c
@@ -41,8 +41,8 @@ int put_io_context(struct io_context *ioc)
                 rcu_read_lock();
                 if (ioc->aic && ioc->aic->dtor)
                         ioc->aic->dtor(ioc->aic);
-                rcu_read_unlock();
                 cfq_dtor(ioc);
+                rcu_read_unlock();
 
                 kmem_cache_free(iocontext_cachep, ioc);
                 return 1;
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 73b23562af2..651136aae76 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -149,9 +149,9 @@ static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio,
 static int blk_hw_contig_segment(struct request_queue *q, struct bio *bio,
                                  struct bio *nxt)
 {
-        if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
+        if (!bio_flagged(bio, BIO_SEG_VALID))
                 blk_recount_segments(q, bio);
-        if (unlikely(!bio_flagged(nxt, BIO_SEG_VALID)))
+        if (!bio_flagged(nxt, BIO_SEG_VALID))
                 blk_recount_segments(q, nxt);
         if (!BIOVEC_VIRT_MERGEABLE(__BVEC_END(bio), __BVEC_START(nxt)) ||
             BIOVEC_VIRT_OVERSIZE(bio->bi_hw_back_size + nxt->bi_hw_front_size))
@@ -312,9 +312,9 @@ int ll_back_merge_fn(struct request_queue *q, struct request *req,
                         q->last_merge = NULL;
                 return 0;
         }
-        if (unlikely(!bio_flagged(req->biotail, BIO_SEG_VALID)))
+        if (!bio_flagged(req->biotail, BIO_SEG_VALID))
                 blk_recount_segments(q, req->biotail);
-        if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
+        if (!bio_flagged(bio, BIO_SEG_VALID))
                 blk_recount_segments(q, bio);
         len = req->biotail->bi_hw_back_size + bio->bi_hw_front_size;
         if (BIOVEC_VIRT_MERGEABLE(__BVEC_END(req->biotail), __BVEC_START(bio))
@@ -352,9 +352,9 @@ int ll_front_merge_fn(struct request_queue *q, struct request *req,
                 return 0;
         }
         len = bio->bi_hw_back_size + req->bio->bi_hw_front_size;
-        if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
+        if (!bio_flagged(bio, BIO_SEG_VALID))
                 blk_recount_segments(q, bio);
-        if (unlikely(!bio_flagged(req->bio, BIO_SEG_VALID)))
+        if (!bio_flagged(req->bio, BIO_SEG_VALID))
                 blk_recount_segments(q, req->bio);
         if (BIOVEC_VIRT_MERGEABLE(__BVEC_END(bio), __BVEC_START(req->bio)) &&
             !BIOVEC_VIRT_OVERSIZE(len)) {
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 6089384ab06..bb93d4c3277 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -168,8 +168,8 @@ void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
 {
         if ((max_sectors << 9) < PAGE_CACHE_SIZE) {
                 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
-                printk(KERN_INFO "%s: set to minimum %d\n", __FUNCTION__,
-                                                        max_sectors);
+                printk(KERN_INFO "%s: set to minimum %d\n",
+                       __func__, max_sectors);
         }
 
         if (BLK_DEF_MAX_SECTORS > max_sectors)
@@ -196,8 +196,8 @@ void blk_queue_max_phys_segments(struct request_queue *q,
 {
         if (!max_segments) {
                 max_segments = 1;
-                printk(KERN_INFO "%s: set to minimum %d\n", __FUNCTION__,
-                                                        max_segments);
+                printk(KERN_INFO "%s: set to minimum %d\n",
+                       __func__, max_segments);
         }
 
         q->max_phys_segments = max_segments;
@@ -220,8 +220,8 @@ void blk_queue_max_hw_segments(struct request_queue *q,
 {
         if (!max_segments) {
                 max_segments = 1;
-                printk(KERN_INFO "%s: set to minimum %d\n", __FUNCTION__,
-                                                        max_segments);
+                printk(KERN_INFO "%s: set to minimum %d\n",
+                       __func__, max_segments);
         }
 
         q->max_hw_segments = max_segments;
@@ -241,8 +241,8 @@ void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
 {
         if (max_size < PAGE_CACHE_SIZE) {
                 max_size = PAGE_CACHE_SIZE;
-                printk(KERN_INFO "%s: set to minimum %d\n", __FUNCTION__,
-                                                        max_size);
+                printk(KERN_INFO "%s: set to minimum %d\n",
+                       __func__, max_size);
         }
 
         q->max_segment_size = max_size;
@@ -357,8 +357,8 @@ void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
 {
         if (mask < PAGE_CACHE_SIZE - 1) {
                 mask = PAGE_CACHE_SIZE - 1;
-                printk(KERN_INFO "%s: set to minimum %lx\n", __FUNCTION__,
-                                                        mask);
+                printk(KERN_INFO "%s: set to minimum %lx\n",
+                       __func__, mask);
         }
 
         q->seg_boundary_mask = mask;
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index e85c4013e8a..304ec73ab82 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -146,11 +146,13 @@ static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
         unsigned long nm;
         ssize_t ret = queue_var_store(&nm, page, count);
 
+        spin_lock_irq(q->queue_lock);
         if (nm)
-               set_bit(QUEUE_FLAG_NOMERGES, &q->queue_flags);
+                queue_flag_set(QUEUE_FLAG_NOMERGES, q);
         else
-               clear_bit(QUEUE_FLAG_NOMERGES, &q->queue_flags);
+                queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
 
+        spin_unlock_irq(q->queue_lock);
         return ret;
 }
 
diff --git a/block/blk-tag.c b/block/blk-tag.c
index e176ddbe599..32667beb03e 100644
--- a/block/blk-tag.c
+++ b/block/blk-tag.c
@@ -70,7 +70,7 @@ void __blk_queue_free_tags(struct request_queue *q)
         __blk_free_tags(bqt);
 
         q->queue_tags = NULL;
-        queue_flag_clear(QUEUE_FLAG_QUEUED, q);
+        queue_flag_clear_unlocked(QUEUE_FLAG_QUEUED, q);
 }
 
 /**
@@ -98,7 +98,7 @@ EXPORT_SYMBOL(blk_free_tags);
  **/
 void blk_queue_free_tags(struct request_queue *q)
 {
-        queue_flag_clear(QUEUE_FLAG_QUEUED, q);
+        queue_flag_clear_unlocked(QUEUE_FLAG_QUEUED, q);
 }
 EXPORT_SYMBOL(blk_queue_free_tags);
 
@@ -112,7 +112,7 @@ init_tag_map(struct request_queue *q, struct blk_queue_tag *tags, int depth)
         if (q && depth > q->nr_requests * 2) {
                 depth = q->nr_requests * 2;
                 printk(KERN_ERR "%s: adjusted depth to %d\n",
-                                __FUNCTION__, depth);
+                       __func__, depth);
         }
 
         tag_index = kzalloc(depth * sizeof(struct request *), GFP_ATOMIC);
@@ -171,6 +171,9 @@ EXPORT_SYMBOL(blk_init_tags);
  * @q:  the request queue for the device
  * @depth:  the maximum queue depth supported
  * @tags: the tag to use
+ *
+ * Queue lock must be held here if the function is called to resize an
+ * existing map.
  **/
 int blk_queue_init_tags(struct request_queue *q, int depth,
                         struct blk_queue_tag *tags)
@@ -197,7 +200,7 @@ int blk_queue_init_tags(struct request_queue *q, int depth,
          * assign it, all done
          */
         q->queue_tags = tags;
-        queue_flag_set(QUEUE_FLAG_QUEUED, q);
+        queue_flag_set_unlocked(QUEUE_FLAG_QUEUED, q);
         INIT_LIST_HEAD(&q->tag_busy_list);
         return 0;
 fail:
@@ -296,13 +299,13 @@ void blk_queue_end_tag(struct request_queue *q, struct request *rq)
 
         if (unlikely(bqt->tag_index[tag] == NULL))
                 printk(KERN_ERR "%s: tag %d is missing\n",
-                       __FUNCTION__, tag);
+                       __func__, tag);
 
         bqt->tag_index[tag] = NULL;
 
         if (unlikely(!test_bit(tag, bqt->tag_map))) {
                 printk(KERN_ERR "%s: attempt to clear non-busy tag (%d)\n",
-                       __FUNCTION__, tag);
+                       __func__, tag);
                 return;
         }
         /*
@@ -340,7 +343,7 @@ int blk_queue_start_tag(struct request_queue *q, struct request *rq)
         if (unlikely((rq->cmd_flags & REQ_QUEUED))) {
                 printk(KERN_ERR
                        "%s: request %p for device [%s] already tagged %d",
-                       __FUNCTION__, rq,
+                       __func__, rq,
                        rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->tag);
                 BUG();
         }
diff --git a/block/blktrace.c b/block/blktrace.c
index 568588cd16b..b2cbb4e5d76 100644
--- a/block/blktrace.c
+++ b/block/blktrace.c
@@ -476,7 +476,7 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
 
         switch (cmd) {
         case BLKTRACESETUP:
-                strcpy(b, bdevname(bdev, b));
+                bdevname(bdev, b);
                 ret = blk_trace_setup(q, b, bdev->bd_dev, arg);
                 break;
         case BLKTRACESTART:
diff --git a/block/bsg.c b/block/bsg.c
index 23ea4fd1a66..f0b7cd34321 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -57,7 +57,7 @@ enum {
 #undef BSG_DEBUG
 
 #ifdef BSG_DEBUG
-#define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ##args)
+#define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ##args)
 #else
 #define dprintk(fmt, args...)
 #endif
@@ -174,7 +174,11 @@ unlock:
 static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,
                                 struct sg_io_v4 *hdr, int has_write_perm)
 {
-        memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
+        if (hdr->request_len > BLK_MAX_CDB) {
+                rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);
+                if (!rq->cmd)
+                        return -ENOMEM;
+        }
 
         if (copy_from_user(rq->cmd, (void *)(unsigned long)hdr->request,
                            hdr->request_len))
@@ -211,8 +215,6 @@ bsg_validate_sgv4_hdr(struct request_queue *q, struct sg_io_v4 *hdr, int *rw)
 
         if (hdr->guard != 'Q')
                 return -EINVAL;
-        if (hdr->request_len > BLK_MAX_CDB)
-                return -EINVAL;
         if (hdr->dout_xfer_len > (q->max_sectors << 9) ||
             hdr->din_xfer_len > (q->max_sectors << 9))
                 return -EIO;
@@ -302,6 +304,8 @@ bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr)
         }
         return rq;
 out:
+        if (rq->cmd != rq->__cmd)
+                kfree(rq->cmd);
         blk_put_request(rq);
         if (next_rq) {
                 blk_rq_unmap_user(next_rq->bio);
@@ -455,6 +459,8 @@ static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
                 ret = rq->errors;
 
         blk_rq_unmap_user(bio);
+        if (rq->cmd != rq->__cmd)
+                kfree(rq->cmd);
         blk_put_request(rq);
 
         return ret;
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index f4e1006c253..b399c62936e 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -1142,6 +1142,17 @@ static void cfq_put_queue(struct cfq_queue *cfqq)
         kmem_cache_free(cfq_pool, cfqq);
 }
 
+static void
+__call_for_each_cic(struct io_context *ioc,
+                    void (*func)(struct io_context *, struct cfq_io_context *))
+{
+        struct cfq_io_context *cic;
+        struct hlist_node *n;
+
+        hlist_for_each_entry_rcu(cic, n, &ioc->cic_list, cic_list)
+                func(ioc, cic);
+}
+
 /*
  * Call func for each cic attached to this ioc.
  */
@@ -1149,12 +1160,8 @@ static void
 call_for_each_cic(struct io_context *ioc,
                   void (*func)(struct io_context *, struct cfq_io_context *))
 {
-        struct cfq_io_context *cic;
-        struct hlist_node *n;
-
         rcu_read_lock();
-        hlist_for_each_entry_rcu(cic, n, &ioc->cic_list, cic_list)
-                func(ioc, cic);
+        __call_for_each_cic(ioc, func);
         rcu_read_unlock();
 }
 
@@ -1198,7 +1205,7 @@ static void cfq_free_io_context(struct io_context *ioc)
          * should be ok to iterate over the known list, we will see all cic's
          * since no new ones are added.
          */
-        call_for_each_cic(ioc, cic_free_func);
+        __call_for_each_cic(ioc, cic_free_func);
 }
 
 static void cfq_exit_cfqq(struct cfq_data *cfqd, struct cfq_queue *cfqq)
@@ -1296,10 +1303,10 @@ static void cfq_init_prio_data(struct cfq_queue *cfqq, struct io_context *ioc)
                 printk(KERN_ERR "cfq: bad prio %x\n", ioprio_class);
         case IOPRIO_CLASS_NONE:
                 /*
-                 * no prio set, place us in the middle of the BE classes
+                 * no prio set, inherit CPU scheduling settings
                  */
                 cfqq->ioprio = task_nice_ioprio(tsk);
-                cfqq->ioprio_class = IOPRIO_CLASS_BE;
+                cfqq->ioprio_class = task_nice_ioclass(tsk);
                 break;
         case IOPRIO_CLASS_RT:
                 cfqq->ioprio = task_ioprio(ioc);
diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index c70d0b6f666..c23177e4623 100644
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -555,7 +555,7 @@ static int compat_blk_trace_setup(struct block_device *bdev, char __user *arg)
         if (copy_from_user(&cbuts, arg, sizeof(cbuts)))
                 return -EFAULT;
 
-        strcpy(b, bdevname(bdev, b));
+        bdevname(bdev, b);
 
         buts = (struct blk_user_trace_setup) {
                 .act_mask = cbuts.act_mask,
diff --git a/block/elevator.c b/block/elevator.c
index ac5310ef827..980f8ae147b 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -650,7 +650,7 @@ void elv_insert(struct request_queue *q, struct request *rq, int where)
 
         default:
                 printk(KERN_ERR "%s: bad insertion point %d\n",
-                       __FUNCTION__, where);
+                       __func__, where);
                 BUG();
         }
 
@@ -808,8 +808,7 @@ struct request *elv_next_request(struct request_queue *q)
                         rq->cmd_flags |= REQ_QUIET;
                         end_queued_request(rq, 0);
                 } else {
-                        printk(KERN_ERR "%s: bad return=%d\n", __FUNCTION__,
-                                                                ret);
+                        printk(KERN_ERR "%s: bad return=%d\n", __func__, ret);
                         break;
                 }
         }
diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index ffa3720e6ca..78199c08ec9 100644
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -33,13 +33,12 @@
 #include <scsi/scsi_cmnd.h>
 
 /* Command group 3 is reserved and should never be used.  */
-const unsigned char scsi_command_size[8] =
+const unsigned char scsi_command_size_tbl[8] =
 {
         6, 10, 10, 12,
         16, 12, 10, 10
 };
-
-EXPORT_SYMBOL(scsi_command_size);
+EXPORT_SYMBOL(scsi_command_size_tbl);
 
 #include <scsi/sg.h>