← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to block/blk-settings.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
block/blk-settings.c
 
1
/*
 
2
 * Functions related to setting various queue properties from drivers
 
3
 */
 
4
#include <linux/kernel.h>
 
5
#include <linux/module.h>
 
6
#include <linux/init.h>
 
7
#include <linux/bio.h>
 
8
#include <linux/blkdev.h>
 
9
#include <linux/bootmem.h>      /* for max_pfn/max_low_pfn */
 
10
#include <linux/gcd.h>
 
11
#include <linux/lcm.h>
 
12
#include <linux/jiffies.h>
 
13
#include <linux/gfp.h>
 
14
 
 
15
#include "blk.h"
 
16
 
 
17
unsigned long blk_max_low_pfn;
 
18
EXPORT_SYMBOL(blk_max_low_pfn);
 
19
 
 
20
unsigned long blk_max_pfn;
 
21
 
 
22
/**
 
23
 * blk_queue_prep_rq - set a prepare_request function for queue
 
24
 * @q:          queue
 
25
 * @pfn:        prepare_request function
 
26
 *
 
27
 * It's possible for a queue to register a prepare_request callback which
 
28
 * is invoked before the request is handed to the request_fn. The goal of
 
29
 * the function is to prepare a request for I/O, it can be used to build a
 
30
 * cdb from the request data for instance.
 
31
 *
 
32
 */
 
33
void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
 
34
{
 
35
        q->prep_rq_fn = pfn;
 
36
}
 
37
EXPORT_SYMBOL(blk_queue_prep_rq);
 
38
 
 
39
/**
 
40
 * blk_queue_unprep_rq - set an unprepare_request function for queue
 
41
 * @q:          queue
 
42
 * @ufn:        unprepare_request function
 
43
 *
 
44
 * It's possible for a queue to register an unprepare_request callback
 
45
 * which is invoked before the request is finally completed. The goal
 
46
 * of the function is to deallocate any data that was allocated in the
 
47
 * prepare_request callback.
 
48
 *
 
49
 */
 
50
void blk_queue_unprep_rq(struct request_queue *q, unprep_rq_fn *ufn)
 
51
{
 
52
        q->unprep_rq_fn = ufn;
 
53
}
 
54
EXPORT_SYMBOL(blk_queue_unprep_rq);
 
55
 
 
56
/**
 
57
 * blk_queue_merge_bvec - set a merge_bvec function for queue
 
58
 * @q:          queue
 
59
 * @mbfn:       merge_bvec_fn
 
60
 *
 
61
 * Usually queues have static limitations on the max sectors or segments that
 
62
 * we can put in a request. Stacking drivers may have some settings that
 
63
 * are dynamic, and thus we have to query the queue whether it is ok to
 
64
 * add a new bio_vec to a bio at a given offset or not. If the block device
 
65
 * has such limitations, it needs to register a merge_bvec_fn to control
 
66
 * the size of bio's sent to it. Note that a block device *must* allow a
 
67
 * single page to be added to an empty bio. The block device driver may want
 
68
 * to use the bio_split() function to deal with these bio's. By default
 
69
 * no merge_bvec_fn is defined for a queue, and only the fixed limits are
 
70
 * honored.
 
71
 */
 
72
void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn)
 
73
{
 
74
        q->merge_bvec_fn = mbfn;
 
75
}
 
76
EXPORT_SYMBOL(blk_queue_merge_bvec);
 
77
 
 
78
void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn)
 
79
{
 
80
        q->softirq_done_fn = fn;
 
81
}
 
82
EXPORT_SYMBOL(blk_queue_softirq_done);
 
83
 
 
84
void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout)
 
85
{
 
86
        q->rq_timeout = timeout;
 
87
}
 
88
EXPORT_SYMBOL_GPL(blk_queue_rq_timeout);
 
89
 
 
90
void blk_queue_rq_timed_out(struct request_queue *q, rq_timed_out_fn *fn)
 
91
{
 
92
        q->rq_timed_out_fn = fn;
 
93
}
 
94
EXPORT_SYMBOL_GPL(blk_queue_rq_timed_out);
 
95
 
 
96
void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn)
 
97
{
 
98
        q->lld_busy_fn = fn;
 
99
}
 
100
EXPORT_SYMBOL_GPL(blk_queue_lld_busy);
 
101
 
 
102
/**
 
103
 * blk_set_default_limits - reset limits to default values
 
104
 * @lim:  the queue_limits structure to reset
 
105
 *
 
106
 * Description:
 
107
 *   Returns a queue_limit struct to its default state.  Can be used by
 
108
 *   stacking drivers like DM that stage table swaps and reuse an
 
109
 *   existing device queue.
 
110
 */
 
111
void blk_set_default_limits(struct queue_limits *lim)
 
112
{
 
113
        lim->max_segments = BLK_MAX_SEGMENTS;
 
114
        lim->max_integrity_segments = 0;
 
115
        lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
 
116
        lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
 
117
        lim->max_sectors = BLK_DEF_MAX_SECTORS;
 
118
        lim->max_hw_sectors = INT_MAX;
 
119
        lim->max_discard_sectors = 0;
 
120
        lim->discard_granularity = 0;
 
121
        lim->discard_alignment = 0;
 
122
        lim->discard_misaligned = 0;
 
123
        lim->discard_zeroes_data = 1;
 
124
        lim->logical_block_size = lim->physical_block_size = lim->io_min = 512;
 
125
        lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT);
 
126
        lim->alignment_offset = 0;
 
127
        lim->io_opt = 0;
 
128
        lim->misaligned = 0;
 
129
        lim->cluster = 1;
 
130
}
 
131
EXPORT_SYMBOL(blk_set_default_limits);
 
132
 
 
133
/**
 
134
 * blk_queue_make_request - define an alternate make_request function for a device
 
135
 * @q:  the request queue for the device to be affected
 
136
 * @mfn: the alternate make_request function
 
137
 *
 
138
 * Description:
 
139
 *    The normal way for &struct bios to be passed to a device
 
140
 *    driver is for them to be collected into requests on a request
 
141
 *    queue, and then to allow the device driver to select requests
 
142
 *    off that queue when it is ready.  This works well for many block
 
143
 *    devices. However some block devices (typically virtual devices
 
144
 *    such as md or lvm) do not benefit from the processing on the
 
145
 *    request queue, and are served best by having the requests passed
 
146
 *    directly to them.  This can be achieved by providing a function
 
147
 *    to blk_queue_make_request().
 
148
 *
 
149
 * Caveat:
 
150
 *    The driver that does this *must* be able to deal appropriately
 
151
 *    with buffers in "highmemory". This can be accomplished by either calling
 
152
 *    __bio_kmap_atomic() to get a temporary kernel mapping, or by calling
 
153
 *    blk_queue_bounce() to create a buffer in normal memory.
 
154
 **/
 
155
void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
 
156
{
 
157
        /*
 
158
         * set defaults
 
159
         */
 
160
        q->nr_requests = BLKDEV_MAX_RQ;
 
161
 
 
162
        q->make_request_fn = mfn;
 
163
        blk_queue_dma_alignment(q, 511);
 
164
        blk_queue_congestion_threshold(q);
 
165
        q->nr_batching = BLK_BATCH_REQ;
 
166
 
 
167
        blk_set_default_limits(&q->limits);
 
168
        blk_queue_max_hw_sectors(q, BLK_SAFE_MAX_SECTORS);
 
169
        q->limits.discard_zeroes_data = 0;
 
170
 
 
171
        /*
 
172
         * by default assume old behaviour and bounce for any highmem page
 
173
         */
 
174
        blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
 
175
}
 
176
EXPORT_SYMBOL(blk_queue_make_request);
 
177
 
 
178
/**
 
179
 * blk_queue_bounce_limit - set bounce buffer limit for queue
 
180
 * @q: the request queue for the device
 
181
 * @dma_mask: the maximum address the device can handle
 
182
 *
 
183
 * Description:
 
184
 *    Different hardware can have different requirements as to what pages
 
185
 *    it can do I/O directly to. A low level driver can call
 
186
 *    blk_queue_bounce_limit to have lower memory pages allocated as bounce
 
187
 *    buffers for doing I/O to pages residing above @dma_mask.
 
188
 **/
 
189
void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask)
 
190
{
 
191
        unsigned long b_pfn = dma_mask >> PAGE_SHIFT;
 
192
        int dma = 0;
 
193
 
 
194
        q->bounce_gfp = GFP_NOIO;
 
195
#if BITS_PER_LONG == 64
 
196
        /*
 
197
         * Assume anything <= 4GB can be handled by IOMMU.  Actually
 
198
         * some IOMMUs can handle everything, but I don't know of a
 
199
         * way to test this here.
 
200
         */
 
201
        if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
 
202
                dma = 1;
 
203
        q->limits.bounce_pfn = max(max_low_pfn, b_pfn);
 
204
#else
 
205
        if (b_pfn < blk_max_low_pfn)
 
206
                dma = 1;
 
207
        q->limits.bounce_pfn = b_pfn;
 
208
#endif
 
209
        if (dma) {
 
210
                init_emergency_isa_pool();
 
211
                q->bounce_gfp = GFP_NOIO | GFP_DMA;
 
212
                q->limits.bounce_pfn = b_pfn;
 
213
        }
 
214
}
 
215
EXPORT_SYMBOL(blk_queue_bounce_limit);
 
216
 
 
217
/**
 
218
 * blk_limits_max_hw_sectors - set hard and soft limit of max sectors for request
 
219
 * @limits: the queue limits
 
220
 * @max_hw_sectors:  max hardware sectors in the usual 512b unit
 
221
 *
 
222
 * Description:
 
223
 *    Enables a low level driver to set a hard upper limit,
 
224
 *    max_hw_sectors, on the size of requests.  max_hw_sectors is set by
 
225
 *    the device driver based upon the combined capabilities of I/O
 
226
 *    controller and storage device.
 
227
 *
 
228
 *    max_sectors is a soft limit imposed by the block layer for
 
229
 *    filesystem type requests.  This value can be overridden on a
 
230
 *    per-device basis in /sys/block/<device>/queue/max_sectors_kb.
 
231
 *    The soft limit can not exceed max_hw_sectors.
 
232
 **/
 
233
void blk_limits_max_hw_sectors(struct queue_limits *limits, unsigned int max_hw_sectors)
 
234
{
 
235
        if ((max_hw_sectors << 9) < PAGE_CACHE_SIZE) {
 
236
                max_hw_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
 
237
                printk(KERN_INFO "%s: set to minimum %d\n",
 
238
                       __func__, max_hw_sectors);
 
239
        }
 
240
 
 
241
        limits->max_hw_sectors = max_hw_sectors;
 
242
        limits->max_sectors = min_t(unsigned int, max_hw_sectors,
 
243
                                    BLK_DEF_MAX_SECTORS);
 
244
}
 
245
EXPORT_SYMBOL(blk_limits_max_hw_sectors);
 
246
 
 
247
/**
 
248
 * blk_queue_max_hw_sectors - set max sectors for a request for this queue
 
249
 * @q:  the request queue for the device
 
250
 * @max_hw_sectors:  max hardware sectors in the usual 512b unit
 
251
 *
 
252
 * Description:
 
253
 *    See description for blk_limits_max_hw_sectors().
 
254
 **/
 
255
void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors)
 
256
{
 
257
        blk_limits_max_hw_sectors(&q->limits, max_hw_sectors);
 
258
}
 
259
EXPORT_SYMBOL(blk_queue_max_hw_sectors);
 
260
 
 
261
/**
 
262
 * blk_queue_max_discard_sectors - set max sectors for a single discard
 
263
 * @q:  the request queue for the device
 
264
 * @max_discard_sectors: maximum number of sectors to discard
 
265
 **/
 
266
void blk_queue_max_discard_sectors(struct request_queue *q,
 
267
                unsigned int max_discard_sectors)
 
268
{
 
269
        q->limits.max_discard_sectors = max_discard_sectors;
 
270
}
 
271
EXPORT_SYMBOL(blk_queue_max_discard_sectors);
 
272
 
 
273
/**
 
274
 * blk_queue_max_segments - set max hw segments for a request for this queue
 
275
 * @q:  the request queue for the device
 
276
 * @max_segments:  max number of segments
 
277
 *
 
278
 * Description:
 
279
 *    Enables a low level driver to set an upper limit on the number of
 
280
 *    hw data segments in a request.
 
281
 **/
 
282
void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
 
283
{
 
284
        if (!max_segments) {
 
285
                max_segments = 1;
 
286
                printk(KERN_INFO "%s: set to minimum %d\n",
 
287
                       __func__, max_segments);
 
288
        }
 
289
 
 
290
        q->limits.max_segments = max_segments;
 
291
}
 
292
EXPORT_SYMBOL(blk_queue_max_segments);
 
293
 
 
294
/**
 
295
 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
 
296
 * @q:  the request queue for the device
 
297
 * @max_size:  max size of segment in bytes
 
298
 *
 
299
 * Description:
 
300
 *    Enables a low level driver to set an upper limit on the size of a
 
301
 *    coalesced segment
 
302
 **/
 
303
void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
 
304
{
 
305
        if (max_size < PAGE_CACHE_SIZE) {
 
306
                max_size = PAGE_CACHE_SIZE;
 
307
                printk(KERN_INFO "%s: set to minimum %d\n",
 
308
                       __func__, max_size);
 
309
        }
 
310
 
 
311
        q->limits.max_segment_size = max_size;
 
312
}
 
313
EXPORT_SYMBOL(blk_queue_max_segment_size);
 
314
 
 
315
/**
 
316
 * blk_queue_logical_block_size - set logical block size for the queue
 
317
 * @q:  the request queue for the device
 
318
 * @size:  the logical block size, in bytes
 
319
 *
 
320
 * Description:
 
321
 *   This should be set to the lowest possible block size that the
 
322
 *   storage device can address.  The default of 512 covers most
 
323
 *   hardware.
 
324
 **/
 
325
void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
 
326
{
 
327
        q->limits.logical_block_size = size;
 
328
 
 
329
        if (q->limits.physical_block_size < size)
 
330
                q->limits.physical_block_size = size;
 
331
 
 
332
        if (q->limits.io_min < q->limits.physical_block_size)
 
333
                q->limits.io_min = q->limits.physical_block_size;
 
334
}
 
335
EXPORT_SYMBOL(blk_queue_logical_block_size);
 
336
 
 
337
/**
 
338
 * blk_queue_physical_block_size - set physical block size for the queue
 
339
 * @q:  the request queue for the device
 
340
 * @size:  the physical block size, in bytes
 
341
 *
 
342
 * Description:
 
343
 *   This should be set to the lowest possible sector size that the
 
344
 *   hardware can operate on without reverting to read-modify-write
 
345
 *   operations.
 
346
 */
 
347
void blk_queue_physical_block_size(struct request_queue *q, unsigned int size)
 
348
{
 
349
        q->limits.physical_block_size = size;
 
350
 
 
351
        if (q->limits.physical_block_size < q->limits.logical_block_size)
 
352
                q->limits.physical_block_size = q->limits.logical_block_size;
 
353
 
 
354
        if (q->limits.io_min < q->limits.physical_block_size)
 
355
                q->limits.io_min = q->limits.physical_block_size;
 
356
}
 
357
EXPORT_SYMBOL(blk_queue_physical_block_size);
 
358
 
 
359
/**
 
360
 * blk_queue_alignment_offset - set physical block alignment offset
 
361
 * @q:  the request queue for the device
 
362
 * @offset: alignment offset in bytes
 
363
 *
 
364
 * Description:
 
365
 *   Some devices are naturally misaligned to compensate for things like
 
366
 *   the legacy DOS partition table 63-sector offset.  Low-level drivers
 
367
 *   should call this function for devices whose first sector is not
 
368
 *   naturally aligned.
 
369
 */
 
370
void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset)
 
371
{
 
372
        q->limits.alignment_offset =
 
373
                offset & (q->limits.physical_block_size - 1);
 
374
        q->limits.misaligned = 0;
 
375
}
 
376
EXPORT_SYMBOL(blk_queue_alignment_offset);
 
377
 
 
378
/**
 
379
 * blk_limits_io_min - set minimum request size for a device
 
380
 * @limits: the queue limits
 
381
 * @min:  smallest I/O size in bytes
 
382
 *
 
383
 * Description:
 
384
 *   Some devices have an internal block size bigger than the reported
 
385
 *   hardware sector size.  This function can be used to signal the
 
386
 *   smallest I/O the device can perform without incurring a performance
 
387
 *   penalty.
 
388
 */
 
389
void blk_limits_io_min(struct queue_limits *limits, unsigned int min)
 
390
{
 
391
        limits->io_min = min;
 
392
 
 
393
        if (limits->io_min < limits->logical_block_size)
 
394
                limits->io_min = limits->logical_block_size;
 
395
 
 
396
        if (limits->io_min < limits->physical_block_size)
 
397
                limits->io_min = limits->physical_block_size;
 
398
}
 
399
EXPORT_SYMBOL(blk_limits_io_min);
 
400
 
 
401
/**
 
402
 * blk_queue_io_min - set minimum request size for the queue
 
403
 * @q:  the request queue for the device
 
404
 * @min:  smallest I/O size in bytes
 
405
 *
 
406
 * Description:
 
407
 *   Storage devices may report a granularity or preferred minimum I/O
 
408
 *   size which is the smallest request the device can perform without
 
409
 *   incurring a performance penalty.  For disk drives this is often the
 
410
 *   physical block size.  For RAID arrays it is often the stripe chunk
 
411
 *   size.  A properly aligned multiple of minimum_io_size is the
 
412
 *   preferred request size for workloads where a high number of I/O
 
413
 *   operations is desired.
 
414
 */
 
415
void blk_queue_io_min(struct request_queue *q, unsigned int min)
 
416
{
 
417
        blk_limits_io_min(&q->limits, min);
 
418
}
 
419
EXPORT_SYMBOL(blk_queue_io_min);
 
420
 
 
421
/**
 
422
 * blk_limits_io_opt - set optimal request size for a device
 
423
 * @limits: the queue limits
 
424
 * @opt:  smallest I/O size in bytes
 
425
 *
 
426
 * Description:
 
427
 *   Storage devices may report an optimal I/O size, which is the
 
428
 *   device's preferred unit for sustained I/O.  This is rarely reported
 
429
 *   for disk drives.  For RAID arrays it is usually the stripe width or
 
430
 *   the internal track size.  A properly aligned multiple of
 
431
 *   optimal_io_size is the preferred request size for workloads where
 
432
 *   sustained throughput is desired.
 
433
 */
 
434
void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt)
 
435
{
 
436
        limits->io_opt = opt;
 
437
}
 
438
EXPORT_SYMBOL(blk_limits_io_opt);
 
439
 
 
440
/**
 
441
 * blk_queue_io_opt - set optimal request size for the queue
 
442
 * @q:  the request queue for the device
 
443
 * @opt:  optimal request size in bytes
 
444
 *
 
445
 * Description:
 
446
 *   Storage devices may report an optimal I/O size, which is the
 
447
 *   device's preferred unit for sustained I/O.  This is rarely reported
 
448
 *   for disk drives.  For RAID arrays it is usually the stripe width or
 
449
 *   the internal track size.  A properly aligned multiple of
 
450
 *   optimal_io_size is the preferred request size for workloads where
 
451
 *   sustained throughput is desired.
 
452
 */
 
453
void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
 
454
{
 
455
        blk_limits_io_opt(&q->limits, opt);
 
456
}
 
457
EXPORT_SYMBOL(blk_queue_io_opt);
 
458
 
 
459
/**
 
460
 * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
 
461
 * @t:  the stacking driver (top)
 
462
 * @b:  the underlying device (bottom)
 
463
 **/
 
464
void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
 
465
{
 
466
        blk_stack_limits(&t->limits, &b->limits, 0);
 
467
}
 
468
EXPORT_SYMBOL(blk_queue_stack_limits);
 
469
 
 
470
/**
 
471
 * blk_stack_limits - adjust queue_limits for stacked devices
 
472
 * @t:  the stacking driver limits (top device)
 
473
 * @b:  the underlying queue limits (bottom, component device)
 
474
 * @start:  first data sector within component device
 
475
 *
 
476
 * Description:
 
477
 *    This function is used by stacking drivers like MD and DM to ensure
 
478
 *    that all component devices have compatible block sizes and
 
479
 *    alignments.  The stacking driver must provide a queue_limits
 
480
 *    struct (top) and then iteratively call the stacking function for
 
481
 *    all component (bottom) devices.  The stacking function will
 
482
 *    attempt to combine the values and ensure proper alignment.
 
483
 *
 
484
 *    Returns 0 if the top and bottom queue_limits are compatible.  The
 
485
 *    top device's block sizes and alignment offsets may be adjusted to
 
486
 *    ensure alignment with the bottom device. If no compatible sizes
 
487
 *    and alignments exist, -1 is returned and the resulting top
 
488
 *    queue_limits will have the misaligned flag set to indicate that
 
489
 *    the alignment_offset is undefined.
 
490
 */
 
491
int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
 
492
                     sector_t start)
 
493
{
 
494
        unsigned int top, bottom, alignment, ret = 0;
 
495
 
 
496
        t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
 
497
        t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
 
498
        t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
 
499
 
 
500
        t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
 
501
                                            b->seg_boundary_mask);
 
502
 
 
503
        t->max_segments = min_not_zero(t->max_segments, b->max_segments);
 
504
        t->max_integrity_segments = min_not_zero(t->max_integrity_segments,
 
505
                                                 b->max_integrity_segments);
 
506
 
 
507
        t->max_segment_size = min_not_zero(t->max_segment_size,
 
508
                                           b->max_segment_size);
 
509
 
 
510
        t->misaligned |= b->misaligned;
 
511
 
 
512
        alignment = queue_limit_alignment_offset(b, start);
 
513
 
 
514
        /* Bottom device has different alignment.  Check that it is
 
515
         * compatible with the current top alignment.
 
516
         */
 
517
        if (t->alignment_offset != alignment) {
 
518
 
 
519
                top = max(t->physical_block_size, t->io_min)
 
520
                        + t->alignment_offset;
 
521
                bottom = max(b->physical_block_size, b->io_min) + alignment;
 
522
 
 
523
                /* Verify that top and bottom intervals line up */
 
524
                if (max(top, bottom) & (min(top, bottom) - 1)) {
 
525
                        t->misaligned = 1;
 
526
                        ret = -1;
 
527
                }
 
528
        }
 
529
 
 
530
        t->logical_block_size = max(t->logical_block_size,
 
531
                                    b->logical_block_size);
 
532
 
 
533
        t->physical_block_size = max(t->physical_block_size,
 
534
                                     b->physical_block_size);
 
535
 
 
536
        t->io_min = max(t->io_min, b->io_min);
 
537
        t->io_opt = lcm(t->io_opt, b->io_opt);
 
538
 
 
539
        t->cluster &= b->cluster;
 
540
        t->discard_zeroes_data &= b->discard_zeroes_data;
 
541
 
 
542
        /* Physical block size a multiple of the logical block size? */
 
543
        if (t->physical_block_size & (t->logical_block_size - 1)) {
 
544
                t->physical_block_size = t->logical_block_size;
 
545
                t->misaligned = 1;
 
546
                ret = -1;
 
547
        }
 
548
 
 
549
        /* Minimum I/O a multiple of the physical block size? */
 
550
        if (t->io_min & (t->physical_block_size - 1)) {
 
551
                t->io_min = t->physical_block_size;
 
552
                t->misaligned = 1;
 
553
                ret = -1;
 
554
        }
 
555
 
 
556
        /* Optimal I/O a multiple of the physical block size? */
 
557
        if (t->io_opt & (t->physical_block_size - 1)) {
 
558
                t->io_opt = 0;
 
559
                t->misaligned = 1;
 
560
                ret = -1;
 
561
        }
 
562
 
 
563
        /* Find lowest common alignment_offset */
 
564
        t->alignment_offset = lcm(t->alignment_offset, alignment)
 
565
                & (max(t->physical_block_size, t->io_min) - 1);
 
566
 
 
567
        /* Verify that new alignment_offset is on a logical block boundary */
 
568
        if (t->alignment_offset & (t->logical_block_size - 1)) {
 
569
                t->misaligned = 1;
 
570
                ret = -1;
 
571
        }
 
572
 
 
573
        /* Discard alignment and granularity */
 
574
        if (b->discard_granularity) {
 
575
                alignment = queue_limit_discard_alignment(b, start);
 
576
 
 
577
                if (t->discard_granularity != 0 &&
 
578
                    t->discard_alignment != alignment) {
 
579
                        top = t->discard_granularity + t->discard_alignment;
 
580
                        bottom = b->discard_granularity + alignment;
 
581
 
 
582
                        /* Verify that top and bottom intervals line up */
 
583
                        if (max(top, bottom) & (min(top, bottom) - 1))
 
584
                                t->discard_misaligned = 1;
 
585
                }
 
586
 
 
587
                t->max_discard_sectors = min_not_zero(t->max_discard_sectors,
 
588
                                                      b->max_discard_sectors);
 
589
                t->discard_granularity = max(t->discard_granularity,
 
590
                                             b->discard_granularity);
 
591
                t->discard_alignment = lcm(t->discard_alignment, alignment) &
 
592
                        (t->discard_granularity - 1);
 
593
        }
 
594
 
 
595
        return ret;
 
596
}
 
597
EXPORT_SYMBOL(blk_stack_limits);
 
598
 
 
599
/**
 
600
 * bdev_stack_limits - adjust queue limits for stacked drivers
 
601
 * @t:  the stacking driver limits (top device)
 
602
 * @bdev:  the component block_device (bottom)
 
603
 * @start:  first data sector within component device
 
604
 *
 
605
 * Description:
 
606
 *    Merges queue limits for a top device and a block_device.  Returns
 
607
 *    0 if alignment didn't change.  Returns -1 if adding the bottom
 
608
 *    device caused misalignment.
 
609
 */
 
610
int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
 
611
                      sector_t start)
 
612
{
 
613
        struct request_queue *bq = bdev_get_queue(bdev);
 
614
 
 
615
        start += get_start_sect(bdev);
 
616
 
 
617
        return blk_stack_limits(t, &bq->limits, start);
 
618
}
 
619
EXPORT_SYMBOL(bdev_stack_limits);
 
620
 
 
621
/**
 
622
 * disk_stack_limits - adjust queue limits for stacked drivers
 
623
 * @disk:  MD/DM gendisk (top)
 
624
 * @bdev:  the underlying block device (bottom)
 
625
 * @offset:  offset to beginning of data within component device
 
626
 *
 
627
 * Description:
 
628
 *    Merges the limits for a top level gendisk and a bottom level
 
629
 *    block_device.
 
630
 */
 
631
void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
 
632
                       sector_t offset)
 
633
{
 
634
        struct request_queue *t = disk->queue;
 
635
 
 
636
        if (bdev_stack_limits(&t->limits, bdev, offset >> 9) < 0) {
 
637
                char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE];
 
638
 
 
639
                disk_name(disk, 0, top);
 
640
                bdevname(bdev, bottom);
 
641
 
 
642
                printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n",
 
643
                       top, bottom);
 
644
        }
 
645
}
 
646
EXPORT_SYMBOL(disk_stack_limits);
 
647
 
 
648
/**
 
649
 * blk_queue_dma_pad - set pad mask
 
650
 * @q:     the request queue for the device
 
651
 * @mask:  pad mask
 
652
 *
 
653
 * Set dma pad mask.
 
654
 *
 
655
 * Appending pad buffer to a request modifies the last entry of a
 
656
 * scatter list such that it includes the pad buffer.
 
657
 **/
 
658
void blk_queue_dma_pad(struct request_queue *q, unsigned int mask)
 
659
{
 
660
        q->dma_pad_mask = mask;
 
661
}
 
662
EXPORT_SYMBOL(blk_queue_dma_pad);
 
663
 
 
664
/**
 
665
 * blk_queue_update_dma_pad - update pad mask
 
666
 * @q:     the request queue for the device
 
667
 * @mask:  pad mask
 
668
 *
 
669
 * Update dma pad mask.
 
670
 *
 
671
 * Appending pad buffer to a request modifies the last entry of a
 
672
 * scatter list such that it includes the pad buffer.
 
673
 **/
 
674
void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask)
 
675
{
 
676
        if (mask > q->dma_pad_mask)
 
677
                q->dma_pad_mask = mask;
 
678
}
 
679
EXPORT_SYMBOL(blk_queue_update_dma_pad);
 
680
 
 
681
/**
 
682
 * blk_queue_dma_drain - Set up a drain buffer for excess dma.
 
683
 * @q:  the request queue for the device
 
684
 * @dma_drain_needed: fn which returns non-zero if drain is necessary
 
685
 * @buf:        physically contiguous buffer
 
686
 * @size:       size of the buffer in bytes
 
687
 *
 
688
 * Some devices have excess DMA problems and can't simply discard (or
 
689
 * zero fill) the unwanted piece of the transfer.  They have to have a
 
690
 * real area of memory to transfer it into.  The use case for this is
 
691
 * ATAPI devices in DMA mode.  If the packet command causes a transfer
 
692
 * bigger than the transfer size some HBAs will lock up if there
 
693
 * aren't DMA elements to contain the excess transfer.  What this API
 
694
 * does is adjust the queue so that the buf is always appended
 
695
 * silently to the scatterlist.
 
696
 *
 
697
 * Note: This routine adjusts max_hw_segments to make room for appending
 
698
 * the drain buffer.  If you call blk_queue_max_segments() after calling
 
699
 * this routine, you must set the limit to one fewer than your device
 
700
 * can support otherwise there won't be room for the drain buffer.
 
701
 */
 
702
int blk_queue_dma_drain(struct request_queue *q,
 
703
                               dma_drain_needed_fn *dma_drain_needed,
 
704
                               void *buf, unsigned int size)
 
705
{
 
706
        if (queue_max_segments(q) < 2)
 
707
                return -EINVAL;
 
708
        /* make room for appending the drain */
 
709
        blk_queue_max_segments(q, queue_max_segments(q) - 1);
 
710
        q->dma_drain_needed = dma_drain_needed;
 
711
        q->dma_drain_buffer = buf;
 
712
        q->dma_drain_size = size;
 
713
 
 
714
        return 0;
 
715
}
 
716
EXPORT_SYMBOL_GPL(blk_queue_dma_drain);
 
717
 
 
718
/**
 
719
 * blk_queue_segment_boundary - set boundary rules for segment merging
 
720
 * @q:  the request queue for the device
 
721
 * @mask:  the memory boundary mask
 
722
 **/
 
723
void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
 
724
{
 
725
        if (mask < PAGE_CACHE_SIZE - 1) {
 
726
                mask = PAGE_CACHE_SIZE - 1;
 
727
                printk(KERN_INFO "%s: set to minimum %lx\n",
 
728
                       __func__, mask);
 
729
        }
 
730
 
 
731
        q->limits.seg_boundary_mask = mask;
 
732
}
 
733
EXPORT_SYMBOL(blk_queue_segment_boundary);
 
734
 
 
735
/**
 
736
 * blk_queue_dma_alignment - set dma length and memory alignment
 
737
 * @q:     the request queue for the device
 
738
 * @mask:  alignment mask
 
739
 *
 
740
 * description:
 
741
 *    set required memory and length alignment for direct dma transactions.
 
742
 *    this is used when building direct io requests for the queue.
 
743
 *
 
744
 **/
 
745
void blk_queue_dma_alignment(struct request_queue *q, int mask)
 
746
{
 
747
        q->dma_alignment = mask;
 
748
}
 
749
EXPORT_SYMBOL(blk_queue_dma_alignment);
 
750
 
 
751
/**
 
752
 * blk_queue_update_dma_alignment - update dma length and memory alignment
 
753
 * @q:     the request queue for the device
 
754
 * @mask:  alignment mask
 
755
 *
 
756
 * description:
 
757
 *    update required memory and length alignment for direct dma transactions.
 
758
 *    If the requested alignment is larger than the current alignment, then
 
759
 *    the current queue alignment is updated to the new value, otherwise it
 
760
 *    is left alone.  The design of this is to allow multiple objects
 
761
 *    (driver, device, transport etc) to set their respective
 
762
 *    alignments without having them interfere.
 
763
 *
 
764
 **/
 
765
void blk_queue_update_dma_alignment(struct request_queue *q, int mask)
 
766
{
 
767
        BUG_ON(mask > PAGE_SIZE);
 
768
 
 
769
        if (mask > q->dma_alignment)
 
770
                q->dma_alignment = mask;
 
771
}
 
772
EXPORT_SYMBOL(blk_queue_update_dma_alignment);
 
773
 
 
774
/**
 
775
 * blk_queue_flush - configure queue's cache flush capability
 
776
 * @q:          the request queue for the device
 
777
 * @flush:      0, REQ_FLUSH or REQ_FLUSH | REQ_FUA
 
778
 *
 
779
 * Tell block layer cache flush capability of @q.  If it supports
 
780
 * flushing, REQ_FLUSH should be set.  If it supports bypassing
 
781
 * write cache for individual writes, REQ_FUA should be set.
 
782
 */
 
783
void blk_queue_flush(struct request_queue *q, unsigned int flush)
 
784
{
 
785
        WARN_ON_ONCE(flush & ~(REQ_FLUSH | REQ_FUA));
 
786
 
 
787
        if (WARN_ON_ONCE(!(flush & REQ_FLUSH) && (flush & REQ_FUA)))
 
788
                flush &= ~REQ_FUA;
 
789
 
 
790
        q->flush_flags = flush & (REQ_FLUSH | REQ_FUA);
 
791
}
 
792
EXPORT_SYMBOL_GPL(blk_queue_flush);
 
793
 
 
794
void blk_queue_flush_queueable(struct request_queue *q, bool queueable)
 
795
{
 
796
        q->flush_not_queueable = !queueable;
 
797
}
 
798
EXPORT_SYMBOL_GPL(blk_queue_flush_queueable);
 
799
 
 
800
static int __init blk_settings_init(void)
 
801
{
 
802
        blk_max_low_pfn = max_low_pfn - 1;
 
803
        blk_max_pfn = max_pfn - 1;
 
804
        return 0;
 
805
}
 
806
subsys_initcall(blk_settings_init);