Merge branches 'tracing/ftrace' and 'linus' into tracing/core

2 files changed, 69 insertions, 41 deletions

diff --git a/block/blk-merge.c b/block/blk-merge.c
index b92f5b0866b0..a104593e70c3 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -38,72 +38,84 @@ void blk_recalc_rq_sectors(struct request *rq, int nsect)
         }
 }
 
-void blk_recalc_rq_segments(struct request *rq)
+static unsigned int __blk_recalc_rq_segments(struct request_queue *q,
+                                             struct bio *bio,
+                                             unsigned int *seg_size_ptr)
 {
-        int nr_phys_segs;
         unsigned int phys_size;
         struct bio_vec *bv, *bvprv = NULL;
-        int seg_size;
-        int cluster;
-        struct req_iterator iter;
-        int high, highprv = 1;
-        struct request_queue *q = rq->q;
+        int cluster, i, high, highprv = 1;
+        unsigned int seg_size, nr_phys_segs;
+        struct bio *fbio;
 
-        if (!rq->bio)
-                return;
+        if (!bio)
+                return 0;
 
+        fbio = bio;
         cluster = test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
         seg_size = 0;
         phys_size = nr_phys_segs = 0;
-        rq_for_each_segment(bv, rq, iter) {
-                /*
-                 * the trick here is making sure that a high page is never
-                 * considered part of another segment, since that might
-                 * change with the bounce page.
-                 */
-                high = page_to_pfn(bv->bv_page) > q->bounce_pfn;
-                if (high || highprv)
-                        goto new_segment;
-                if (cluster) {
-                        if (seg_size + bv->bv_len > q->max_segment_size)
-                                goto new_segment;
-                        if (!BIOVEC_PHYS_MERGEABLE(bvprv, bv))
-                                goto new_segment;
-                        if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bv))
+        for_each_bio(bio) {
+                bio_for_each_segment(bv, bio, i) {
+                        /*
+                         * the trick here is making sure that a high page is
+                         * never considered part of another segment, since that
+                         * might change with the bounce page.
+                         */
+                        high = page_to_pfn(bv->bv_page) > q->bounce_pfn;
+                        if (high || highprv)
                                 goto new_segment;
+                        if (cluster) {
+                                if (seg_size + bv->bv_len > q->max_segment_size)
+                                        goto new_segment;
+                                if (!BIOVEC_PHYS_MERGEABLE(bvprv, bv))
+                                        goto new_segment;
+                                if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bv))
+                                        goto new_segment;
+
+                                seg_size += bv->bv_len;
+                                bvprv = bv;
+                                continue;
+                        }
+new_segment:
+                        if (nr_phys_segs == 1 && seg_size >
+                            fbio->bi_seg_front_size)
+                                fbio->bi_seg_front_size = seg_size;
 
-                        seg_size += bv->bv_len;
+                        nr_phys_segs++;
                         bvprv = bv;
-                        continue;
+                        seg_size = bv->bv_len;
+                        highprv = high;
                 }
-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)
+        if (seg_size_ptr)
+                *seg_size_ptr = seg_size;
+
+        return nr_phys_segs;
+}
+
+void blk_recalc_rq_segments(struct request *rq)
+{
+        unsigned int seg_size = 0, phys_segs;
+
+        phys_segs = __blk_recalc_rq_segments(rq->q, rq->bio, &seg_size);
+
+        if (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;
+        rq->nr_phys_segments = phys_segs;
 }
 
 void blk_recount_segments(struct request_queue *q, struct bio *bio)
 {
-        struct request rq;
         struct bio *nxt = bio->bi_next;
-        rq.q = q;
-        rq.bio = rq.biotail = bio;
+
         bio->bi_next = NULL;
-        blk_recalc_rq_segments(&rq);
+        bio->bi_phys_segments = __blk_recalc_rq_segments(q, bio, NULL);
         bio->bi_next = nxt;
-        bio->bi_phys_segments = rq.nr_phys_segments;
         bio->bi_flags |= (1 << BIO_SEG_VALID);
 }
 EXPORT_SYMBOL(blk_recount_segments);
diff --git a/block/genhd.c b/block/genhd.c
index e1eadcc9546a..a9ec910974c1 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -256,6 +256,22 @@ void blkdev_show(struct seq_file *seqf, off_t offset)
 }
 #endif /* CONFIG_PROC_FS */
 
+/**
+ * register_blkdev - register a new block device
+ *
+ * @major: the requested major device number [1..255]. If @major=0, try to
+ *         allocate any unused major number.
+ * @name: the name of the new block device as a zero terminated string
+ *
+ * The @name must be unique within the system.
+ *
+ * The return value depends on the @major input parameter.
+ *  - if a major device number was requested in range [1..255] then the
+ *    function returns zero on success, or a negative error code
+ *  - if any unused major number was requested with @major=0 parameter
+ *    then the return value is the allocated major number in range
+ *    [1..255] or a negative error code otherwise
+ */
 int register_blkdev(unsigned int major, const char *name)
 {
         struct blk_major_name **n, *p;