2 linear.c : Multiple Devices driver for Linux
3 Copyright (C) 1994-96 Marc ZYNGIER
4 <zyngier@ufr-info-p7.ibp.fr> or
7 Linear mode management functions.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 You should have received a copy of the GNU General Public License
15 (for example /usr/src/linux/COPYING); if not, write to the Free
16 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 #include <linux/blkdev.h>
20 #include <linux/raid/md_u.h>
21 #include <linux/seq_file.h>
26 * find which device holds a particular offset
28 static inline dev_info_t
*which_dev(mddev_t
*mddev
, sector_t sector
)
31 linear_conf_t
*conf
= mddev
->private;
35 while (sector
>= hash
->end_sector
)
41 * linear_mergeable_bvec -- tell bio layer if two requests can be merged
43 * @bvm: properties of new bio
44 * @biovec: the request that could be merged to it.
46 * Return amount of bytes we can take at this offset
48 static int linear_mergeable_bvec(struct request_queue
*q
,
49 struct bvec_merge_data
*bvm
,
50 struct bio_vec
*biovec
)
52 mddev_t
*mddev
= q
->queuedata
;
54 unsigned long maxsectors
, bio_sectors
= bvm
->bi_size
>> 9;
55 sector_t sector
= bvm
->bi_sector
+ get_start_sect(bvm
->bi_bdev
);
57 dev0
= which_dev(mddev
, sector
);
58 maxsectors
= dev0
->end_sector
- sector
;
60 if (maxsectors
< bio_sectors
)
63 maxsectors
-= bio_sectors
;
65 if (maxsectors
<= (PAGE_SIZE
>> 9 ) && bio_sectors
== 0)
66 return biovec
->bv_len
;
67 /* The bytes available at this offset could be really big,
68 * so we cap at 2^31 to avoid overflow */
69 if (maxsectors
> (1 << (31-9)))
71 return maxsectors
<< 9;
74 static void linear_unplug(struct request_queue
*q
)
76 mddev_t
*mddev
= q
->queuedata
;
77 linear_conf_t
*conf
= mddev
->private;
80 for (i
=0; i
< mddev
->raid_disks
; i
++) {
81 struct request_queue
*r_queue
= bdev_get_queue(conf
->disks
[i
].rdev
->bdev
);
86 static int linear_congested(void *data
, int bits
)
88 mddev_t
*mddev
= data
;
89 linear_conf_t
*conf
= mddev
->private;
92 for (i
= 0; i
< mddev
->raid_disks
&& !ret
; i
++) {
93 struct request_queue
*q
= bdev_get_queue(conf
->disks
[i
].rdev
->bdev
);
94 ret
|= bdi_congested(&q
->backing_dev_info
, bits
);
99 static sector_t
linear_size(mddev_t
*mddev
, sector_t sectors
, int raid_disks
)
101 linear_conf_t
*conf
= mddev
->private;
103 WARN_ONCE(sectors
|| raid_disks
,
104 "%s does not support generic reshape\n", __func__
);
106 return conf
->array_sectors
;
109 static linear_conf_t
*linear_conf(mddev_t
*mddev
, int raid_disks
)
115 conf
= kzalloc (sizeof (*conf
) + raid_disks
*sizeof(dev_info_t
),
121 conf
->array_sectors
= 0;
123 list_for_each_entry(rdev
, &mddev
->disks
, same_set
) {
124 int j
= rdev
->raid_disk
;
125 dev_info_t
*disk
= conf
->disks
+ j
;
127 if (j
< 0 || j
>= raid_disks
|| disk
->rdev
) {
128 printk("linear: disk numbering problem. Aborting!\n");
134 blk_queue_stack_limits(mddev
->queue
,
135 rdev
->bdev
->bd_disk
->queue
);
136 /* as we don't honour merge_bvec_fn, we must never risk
137 * violating it, so limit ->max_sector to one PAGE, as
138 * a one page request is never in violation.
140 if (rdev
->bdev
->bd_disk
->queue
->merge_bvec_fn
&&
141 queue_max_sectors(mddev
->queue
) > (PAGE_SIZE
>>9))
142 blk_queue_max_sectors(mddev
->queue
, PAGE_SIZE
>>9);
144 conf
->array_sectors
+= rdev
->sectors
;
148 if (cnt
!= raid_disks
) {
149 printk("linear: not enough drives present. Aborting!\n");
154 * Here we calculate the device offsets.
156 conf
->disks
[0].end_sector
= conf
->disks
[0].rdev
->sectors
;
158 for (i
= 1; i
< raid_disks
; i
++)
159 conf
->disks
[i
].end_sector
=
160 conf
->disks
[i
-1].end_sector
+
161 conf
->disks
[i
].rdev
->sectors
;
170 static int linear_run (mddev_t
*mddev
)
174 mddev
->queue
->queue_lock
= &mddev
->queue
->__queue_lock
;
175 conf
= linear_conf(mddev
, mddev
->raid_disks
);
179 mddev
->private = conf
;
180 md_set_array_sectors(mddev
, linear_size(mddev
, 0, 0));
182 blk_queue_merge_bvec(mddev
->queue
, linear_mergeable_bvec
);
183 mddev
->queue
->unplug_fn
= linear_unplug
;
184 mddev
->queue
->backing_dev_info
.congested_fn
= linear_congested
;
185 mddev
->queue
->backing_dev_info
.congested_data
= mddev
;
189 static int linear_add(mddev_t
*mddev
, mdk_rdev_t
*rdev
)
191 /* Adding a drive to a linear array allows the array to grow.
192 * It is permitted if the new drive has a matching superblock
193 * already on it, with raid_disk equal to raid_disks.
194 * It is achieved by creating a new linear_private_data structure
195 * and swapping it in in-place of the current one.
196 * The current one is never freed until the array is stopped.
199 linear_conf_t
*newconf
;
201 if (rdev
->saved_raid_disk
!= mddev
->raid_disks
)
204 rdev
->raid_disk
= rdev
->saved_raid_disk
;
206 newconf
= linear_conf(mddev
,mddev
->raid_disks
+1);
211 newconf
->prev
= mddev
->private;
212 mddev
->private = newconf
;
214 md_set_array_sectors(mddev
, linear_size(mddev
, 0, 0));
215 set_capacity(mddev
->gendisk
, mddev
->array_sectors
);
219 static int linear_stop (mddev_t
*mddev
)
221 linear_conf_t
*conf
= mddev
->private;
223 blk_sync_queue(mddev
->queue
); /* the unplug fn references 'conf'*/
225 linear_conf_t
*t
= conf
->prev
;
233 static int linear_make_request (struct request_queue
*q
, struct bio
*bio
)
235 const int rw
= bio_data_dir(bio
);
236 mddev_t
*mddev
= q
->queuedata
;
238 sector_t start_sector
;
241 if (unlikely(bio_barrier(bio
))) {
242 bio_endio(bio
, -EOPNOTSUPP
);
246 cpu
= part_stat_lock();
247 part_stat_inc(cpu
, &mddev
->gendisk
->part0
, ios
[rw
]);
248 part_stat_add(cpu
, &mddev
->gendisk
->part0
, sectors
[rw
],
252 tmp_dev
= which_dev(mddev
, bio
->bi_sector
);
253 start_sector
= tmp_dev
->end_sector
- tmp_dev
->rdev
->sectors
;
255 if (unlikely(bio
->bi_sector
>= (tmp_dev
->end_sector
)
256 || (bio
->bi_sector
< start_sector
))) {
257 char b
[BDEVNAME_SIZE
];
259 printk("linear_make_request: Sector %llu out of bounds on "
260 "dev %s: %llu sectors, offset %llu\n",
261 (unsigned long long)bio
->bi_sector
,
262 bdevname(tmp_dev
->rdev
->bdev
, b
),
263 (unsigned long long)tmp_dev
->rdev
->sectors
,
264 (unsigned long long)start_sector
);
268 if (unlikely(bio
->bi_sector
+ (bio
->bi_size
>> 9) >
269 tmp_dev
->end_sector
)) {
270 /* This bio crosses a device boundary, so we have to
276 tmp_dev
->end_sector
- bio
->bi_sector
);
278 if (linear_make_request(q
, &bp
->bio1
))
279 generic_make_request(&bp
->bio1
);
280 if (linear_make_request(q
, &bp
->bio2
))
281 generic_make_request(&bp
->bio2
);
282 bio_pair_release(bp
);
286 bio
->bi_bdev
= tmp_dev
->rdev
->bdev
;
287 bio
->bi_sector
= bio
->bi_sector
- start_sector
288 + tmp_dev
->rdev
->data_offset
;
293 static void linear_status (struct seq_file
*seq
, mddev_t
*mddev
)
296 seq_printf(seq
, " %dk rounding", mddev
->chunk_size
/1024);
300 static struct mdk_personality linear_personality
=
303 .level
= LEVEL_LINEAR
,
304 .owner
= THIS_MODULE
,
305 .make_request
= linear_make_request
,
308 .status
= linear_status
,
309 .hot_add_disk
= linear_add
,
313 static int __init
linear_init (void)
315 return register_md_personality (&linear_personality
);
318 static void linear_exit (void)
320 unregister_md_personality (&linear_personality
);
324 module_init(linear_init
);
325 module_exit(linear_exit
);
326 MODULE_LICENSE("GPL");
327 MODULE_ALIAS("md-personality-1"); /* LINEAR - deprecated*/
328 MODULE_ALIAS("md-linear");
329 MODULE_ALIAS("md-level--1");