block: Move queue limits to an embedded struct

[pandora-kernel.git] / block / blk-settings.c

diff --git a/block/blk-settings.c b/block/blk-settings.c
index 57af728..b0f547c 100644 (file)
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -134,7 +134,7 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
        q->backing_dev_info.state = 0;
        q->backing_dev_info.capabilities = BDI_CAP_MAP_COPY;
        blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
-       blk_queue_hardsect_size(q, 512);
+       blk_queue_logical_block_size(q, 512);
        blk_queue_dma_alignment(q, 511);
        blk_queue_congestion_threshold(q);
        q->nr_batching = BLK_BATCH_REQ;
@@ -179,16 +179,16 @@ void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask)
         */
        if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
                dma = 1;
-       q->bounce_pfn = max_low_pfn;
+       q->limits.bounce_pfn = max_low_pfn;
 #else
        if (b_pfn < blk_max_low_pfn)
                dma = 1;
-       q->bounce_pfn = b_pfn;
+       q->limits.bounce_pfn = b_pfn;
 #endif
        if (dma) {
                init_emergency_isa_pool();
                q->bounce_gfp = GFP_NOIO | GFP_DMA;
-               q->bounce_pfn = b_pfn;
+               q->limits.bounce_pfn = b_pfn;
        }
 }
 EXPORT_SYMBOL(blk_queue_bounce_limit);
@@ -211,14 +211,23 @@ void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
        }
 
        if (BLK_DEF_MAX_SECTORS > max_sectors)
-               q->max_hw_sectors = q->max_sectors = max_sectors;
+               q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors;
        else {
-               q->max_sectors = BLK_DEF_MAX_SECTORS;
-               q->max_hw_sectors = max_sectors;
+               q->limits.max_sectors = BLK_DEF_MAX_SECTORS;
+               q->limits.max_hw_sectors = max_sectors;
        }
 }
 EXPORT_SYMBOL(blk_queue_max_sectors);
 
+void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors)
+{
+       if (BLK_DEF_MAX_SECTORS > max_sectors)
+               q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS;
+       else
+               q->limits.max_hw_sectors = max_sectors;
+}
+EXPORT_SYMBOL(blk_queue_max_hw_sectors);
+
 /**
  * blk_queue_max_phys_segments - set max phys segments for a request for this queue
  * @q:  the request queue for the device
@@ -238,7 +247,7 @@ void blk_queue_max_phys_segments(struct request_queue *q,
                       __func__, max_segments);
        }
 
-       q->max_phys_segments = max_segments;
+       q->limits.max_phys_segments = max_segments;
 }
 EXPORT_SYMBOL(blk_queue_max_phys_segments);
 
@@ -262,7 +271,7 @@ void blk_queue_max_hw_segments(struct request_queue *q,
                       __func__, max_segments);
        }
 
-       q->max_hw_segments = max_segments;
+       q->limits.max_hw_segments = max_segments;
 }
 EXPORT_SYMBOL(blk_queue_max_hw_segments);
 
@@ -283,26 +292,25 @@ void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
                       __func__, max_size);
        }
 
-       q->max_segment_size = max_size;
+       q->limits.max_segment_size = max_size;
 }
 EXPORT_SYMBOL(blk_queue_max_segment_size);
 
 /**
- * blk_queue_hardsect_size - set hardware sector size for the queue
+ * blk_queue_logical_block_size - set logical block size for the queue
  * @q:  the request queue for the device
- * @size:  the hardware sector size, in bytes
+ * @size:  the logical block size, in bytes
  *
  * Description:
- *   This should typically be set to the lowest possible sector size
- *   that the hardware can operate on (possible without reverting to
- *   even internal read-modify-write operations). Usually the default
- *   of 512 covers most hardware.
+ *   This should be set to the lowest possible block size that the
+ *   storage device can address.  The default of 512 covers most
+ *   hardware.
  **/
-void blk_queue_hardsect_size(struct request_queue *q, unsigned short size)
+void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
 {
-       q->hardsect_size = size;
+       q->limits.logical_block_size = size;
 }
-EXPORT_SYMBOL(blk_queue_hardsect_size);
+EXPORT_SYMBOL(blk_queue_logical_block_size);
 
 /*
  * Returns the minimum that is _not_ zero, unless both are zero.
@@ -317,14 +325,27 @@ EXPORT_SYMBOL(blk_queue_hardsect_size);
 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
 {
        /* zero is "infinity" */
-       t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
-       t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
-       t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, b->seg_boundary_mask);
-
-       t->max_phys_segments = min_not_zero(t->max_phys_segments, b->max_phys_segments);
-       t->max_hw_segments = min_not_zero(t->max_hw_segments, b->max_hw_segments);
-       t->max_segment_size = min_not_zero(t->max_segment_size, b->max_segment_size);
-       t->hardsect_size = max(t->hardsect_size, b->hardsect_size);
+       t->limits.max_sectors = min_not_zero(queue_max_sectors(t),
+                                            queue_max_sectors(b));
+
+       t->limits.max_hw_sectors = min_not_zero(queue_max_hw_sectors(t),
+                                               queue_max_hw_sectors(b));
+
+       t->limits.seg_boundary_mask = min_not_zero(queue_segment_boundary(t),
+                                                  queue_segment_boundary(b));
+
+       t->limits.max_phys_segments = min_not_zero(queue_max_phys_segments(t),
+                                                  queue_max_phys_segments(b));
+
+       t->limits.max_hw_segments = min_not_zero(queue_max_hw_segments(t),
+                                                queue_max_hw_segments(b));
+
+       t->limits.max_segment_size = min_not_zero(queue_max_segment_size(t),
+                                                 queue_max_segment_size(b));
+
+       t->limits.logical_block_size = max(queue_logical_block_size(t),
+                                          queue_logical_block_size(b));
+
        if (!t->queue_lock)
                WARN_ON_ONCE(1);
        else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
@@ -396,11 +417,11 @@ int blk_queue_dma_drain(struct request_queue *q,
                               dma_drain_needed_fn *dma_drain_needed,
                               void *buf, unsigned int size)
 {
-       if (q->max_hw_segments < 2 || q->max_phys_segments < 2)
+       if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2)
                return -EINVAL;
        /* make room for appending the drain */
-       --q->max_hw_segments;
-       --q->max_phys_segments;
+       blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1);
+       blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1);
        q->dma_drain_needed = dma_drain_needed;
        q->dma_drain_buffer = buf;
        q->dma_drain_size = size;
@@ -422,7 +443,7 @@ void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
                       __func__, mask);
        }
 
-       q->seg_boundary_mask = mask;
+       q->limits.seg_boundary_mask = mask;
 }
 EXPORT_SYMBOL(blk_queue_segment_boundary);