Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block

* 'for-linus' of git://git.kernel.dk/linux-2.6-block:
  block: remove __generic_unplug_device() from exports
  block: move q->unplug_work initialization
  blktrace: pass zfcp driver data
  blktrace: add support for driver data
  block: fix current kernel-doc warnings
  block: only call ->request_fn when the queue is not stopped
  block: simplify string handling in elv_iosched_store()
  block: fix kernel-doc for blk_alloc_devt()
  block: fix nr_phys_segments miscalculation bug
  block: add partition attribute for partition number
  block: add BIG FAT WARNING to CONFIG_DEBUG_BLOCK_EXT_DEVT
  softirq: Add support for triggering softirq work on softirqs.

6 files changed, 46 insertions, 22 deletions

diff --git a/block/blk-core.c b/block/blk-core.c
index 9e79a485e4f3..c3df30cfb3fc 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -257,7 +257,6 @@ void __generic_unplug_device(struct request_queue *q)
 
         q->request_fn(q);
 }
-EXPORT_SYMBOL(__generic_unplug_device);
 
 /**
  * generic_unplug_device - fire a request queue
@@ -325,6 +324,9 @@ EXPORT_SYMBOL(blk_unplug);
 
 static void blk_invoke_request_fn(struct request_queue *q)
 {
+        if (unlikely(blk_queue_stopped(q)))
+                return;
+
         /*
          * one level of recursion is ok and is much faster than kicking
          * the unplug handling
@@ -399,8 +401,13 @@ void blk_sync_queue(struct request_queue *q)
 EXPORT_SYMBOL(blk_sync_queue);
 
 /**
- * blk_run_queue - run a single device queue
+ * __blk_run_queue - run a single device queue
  * @q:  The queue to run
+ *
+ * Description:
+ *    See @blk_run_queue. This variant must be called with the queue lock
+ *    held and interrupts disabled.
+ *
  */
 void __blk_run_queue(struct request_queue *q)
 {
@@ -418,6 +425,12 @@ EXPORT_SYMBOL(__blk_run_queue);
 /**
  * blk_run_queue - run a single device queue
  * @q: The queue to run
+ *
+ * Description:
+ *    Invoke request handling on this queue, if it has pending work to do.
+ *    May be used to restart queueing when a request has completed. Also
+ *    See @blk_start_queueing.
+ *
  */
 void blk_run_queue(struct request_queue *q)
 {
@@ -501,6 +514,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
         init_timer(&q->unplug_timer);
         setup_timer(&q->timeout, blk_rq_timed_out_timer, (unsigned long) q);
         INIT_LIST_HEAD(&q->timeout_list);
+        INIT_WORK(&q->unplug_work, blk_unplug_work);
 
         kobject_init(&q->kobj, &blk_queue_ktype);
 
@@ -884,7 +898,8 @@ EXPORT_SYMBOL(blk_get_request);
  *
  * This is basically a helper to remove the need to know whether a queue
  * is plugged or not if someone just wants to initiate dispatch of requests
- * for this queue.
+ * for this queue. Should be used to start queueing on a device outside
+ * of ->request_fn() context. Also see @blk_run_queue.
  *
  * The queue lock must be held with interrupts disabled.
  */
@@ -1003,8 +1018,9 @@ static void part_round_stats_single(int cpu, struct hd_struct *part,
 }
 
 /**
- * part_round_stats()   - Round off the performance stats on a struct
- * disk_stats.
+ * part_round_stats() - Round off the performance stats on a struct disk_stats.
+ * @cpu: cpu number for stats access
+ * @part: target partition
  *
  * The average IO queue length and utilisation statistics are maintained
  * by observing the current state of the queue length and the amount of
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 908d3e11ac52..8681cd6f9911 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -77,12 +77,20 @@ void blk_recalc_rq_segments(struct request *rq)
                         continue;
                 }
 new_segment:
+                if (nr_phys_segs == 1 && seg_size > rq->bio->bi_seg_front_size)
+                        rq->bio->bi_seg_front_size = seg_size;
+
                 nr_phys_segs++;
                 bvprv = bv;
                 seg_size = bv->bv_len;
                 highprv = high;
         }
 
+        if (nr_phys_segs == 1 && seg_size > rq->bio->bi_seg_front_size)
+                rq->bio->bi_seg_front_size = seg_size;
+        if (seg_size > rq->biotail->bi_seg_back_size)
+                rq->biotail->bi_seg_back_size = seg_size;
+
         rq->nr_phys_segments = nr_phys_segs;
 }
 
@@ -106,7 +114,8 @@ static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio,
         if (!test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags))
                 return 0;
 
-        if (bio->bi_size + nxt->bi_size > q->max_segment_size)
+        if (bio->bi_seg_back_size + nxt->bi_seg_front_size >
+            q->max_segment_size)
                 return 0;
 
         if (!bio_has_data(bio))
@@ -309,6 +318,8 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
                                 struct request *next)
 {
         int total_phys_segments;
+        unsigned int seg_size =
+                req->biotail->bi_seg_back_size + next->bio->bi_seg_front_size;
 
         /*
          * First check if the either of the requests are re-queued
@@ -324,8 +335,13 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
                 return 0;
 
         total_phys_segments = req->nr_phys_segments + next->nr_phys_segments;
-        if (blk_phys_contig_segment(q, req->biotail, next->bio))
+        if (blk_phys_contig_segment(q, req->biotail, next->bio)) {
+                if (req->nr_phys_segments == 1)
+                        req->bio->bi_seg_front_size = seg_size;
+                if (next->nr_phys_segments == 1)
+                        next->biotail->bi_seg_back_size = seg_size;
                 total_phys_segments--;
+        }
 
         if (total_phys_segments > q->max_phys_segments)
                 return 0;
diff --git a/block/blk-settings.c b/block/blk-settings.c
index b21dcdb64151..41392fbe19ff 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -141,8 +141,6 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
         if (q->unplug_delay == 0)
                 q->unplug_delay = 1;
 
-        INIT_WORK(&q->unplug_work, blk_unplug_work);
-
         q->unplug_timer.function = blk_unplug_timeout;
         q->unplug_timer.data = (unsigned long)q;
 
diff --git a/block/blk.h b/block/blk.h
index e5c579769963..d2e49af90db5 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -20,6 +20,7 @@ void blk_unplug_timeout(unsigned long data);
 void blk_rq_timed_out_timer(unsigned long data);
 void blk_delete_timer(struct request *);
 void blk_add_timer(struct request *);
+void __generic_unplug_device(struct request_queue *);
 
 /*
  * Internal atomic flags for request handling
diff --git a/block/elevator.c b/block/elevator.c
index 04518921db31..59173a69ebdf 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -612,7 +612,7 @@ void elv_insert(struct request_queue *q, struct request *rq, int where)
                  *   processing.
                  */
                 blk_remove_plug(q);
-                q->request_fn(q);
+                blk_start_queueing(q);
                 break;
 
         case ELEVATOR_INSERT_SORT:
@@ -950,7 +950,7 @@ void elv_completed_request(struct request_queue *q, struct request *rq)
                     blk_ordered_cur_seq(q) == QUEUE_ORDSEQ_DRAIN &&
                     blk_ordered_req_seq(first_rq) > QUEUE_ORDSEQ_DRAIN) {
                         blk_ordered_complete_seq(q, QUEUE_ORDSEQ_DRAIN, 0);
-                        q->request_fn(q);
+                        blk_start_queueing(q);
                 }
         }
 }
@@ -1109,8 +1109,7 @@ static int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
         elv_drain_elevator(q);
 
         while (q->rq.elvpriv) {
-                blk_remove_plug(q);
-                q->request_fn(q);
+                blk_start_queueing(q);
                 spin_unlock_irq(q->queue_lock);
                 msleep(10);
                 spin_lock_irq(q->queue_lock);
@@ -1166,15 +1165,10 @@ ssize_t elv_iosched_store(struct request_queue *q, const char *name,
                           size_t count)
 {
         char elevator_name[ELV_NAME_MAX];
-        size_t len;
         struct elevator_type *e;
 
-        elevator_name[sizeof(elevator_name) - 1] = '\0';
-        strncpy(elevator_name, name, sizeof(elevator_name) - 1);
-        len = strlen(elevator_name);
-
-        if (len && elevator_name[len - 1] == '\n')
-                elevator_name[len - 1] = '\0';
+        strlcpy(elevator_name, name, sizeof(elevator_name));
+        strstrip(elevator_name);
 
         e = elevator_get(elevator_name);
         if (!e) {
diff --git a/block/genhd.c b/block/genhd.c
index 4cd3433c99ac..646e1d2507c7 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -358,7 +358,6 @@ static int blk_mangle_minor(int minor)
 /**
  * blk_alloc_devt - allocate a dev_t for a partition
  * @part: partition to allocate dev_t for
- * @gfp_mask: memory allocation flag
  * @devt: out parameter for resulting dev_t
  *
  * Allocate a dev_t for block device.
@@ -535,7 +534,7 @@ void unlink_gendisk(struct gendisk *disk)
 /**
  * get_gendisk - get partitioning information for a given device
  * @devt: device to get partitioning information for
- * @part: returned partition index
+ * @partno: returned partition index
  *
  * This function gets the structure containing partitioning
  * information for the given device @devt.