1/*
2   linear.c : Multiple Devices driver for Linux
3	      Copyright (C) 1994-96 Marc ZYNGIER
4	      <zyngier@ufr-info-p7.ibp.fr> or
5	      <maz@gloups.fdn.fr>
6
7   Linear mode management functions.
8
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)
12   any later version.
13
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.
17*/
18
19#include <linux/blkdev.h>
20#include <linux/raid/md_u.h>
21#include <linux/seq_file.h>
22#include <linux/module.h>
23#include <linux/slab.h>
24#include "md.h"
25#include "linear.h"
26
27/*
28 * find which device holds a particular offset
29 */
30static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector)
31{
32	int lo, mid, hi;
33	struct linear_conf *conf;
34
35	lo = 0;
36	hi = mddev->raid_disks - 1;
37	conf = rcu_dereference(mddev->private);
38
39	/*
40	 * Binary Search
41	 */
42
43	while (hi > lo) {
44
45		mid = (hi + lo) / 2;
46		if (sector < conf->disks[mid].end_sector)
47			hi = mid;
48		else
49			lo = mid + 1;
50	}
51
52	return conf->disks + lo;
53}
54
55/**
56 *	linear_mergeable_bvec -- tell bio layer if two requests can be merged
57 *	@q: request queue
58 *	@bvm: properties of new bio
59 *	@biovec: the request that could be merged to it.
60 *
61 *	Return amount of bytes we can take at this offset
62 */
63static int linear_mergeable_bvec(struct request_queue *q,
64				 struct bvec_merge_data *bvm,
65				 struct bio_vec *biovec)
66{
67	struct mddev *mddev = q->queuedata;
68	struct dev_info *dev0;
69	unsigned long maxsectors, bio_sectors = bvm->bi_size >> 9;
70	sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
71
72	rcu_read_lock();
73	dev0 = which_dev(mddev, sector);
74	maxsectors = dev0->end_sector - sector;
75	rcu_read_unlock();
76
77	if (maxsectors < bio_sectors)
78		maxsectors = 0;
79	else
80		maxsectors -= bio_sectors;
81
82	if (maxsectors <= (PAGE_SIZE >> 9 ) && bio_sectors == 0)
83		return biovec->bv_len;
84	/* The bytes available at this offset could be really big,
85	 * so we cap at 2^31 to avoid overflow */
86	if (maxsectors > (1 << (31-9)))
87		return 1<<31;
88	return maxsectors << 9;
89}
90
91static int linear_congested(void *data, int bits)
92{
93	struct mddev *mddev = data;
94	struct linear_conf *conf;
95	int i, ret = 0;
96
97	if (mddev_congested(mddev, bits))
98		return 1;
99
100	rcu_read_lock();
101	conf = rcu_dereference(mddev->private);
102
103	for (i = 0; i < mddev->raid_disks && !ret ; i++) {
104		struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev);
105		ret |= bdi_congested(&q->backing_dev_info, bits);
106	}
107
108	rcu_read_unlock();
109	return ret;
110}
111
112static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks)
113{
114	struct linear_conf *conf;
115	sector_t array_sectors;
116
117	rcu_read_lock();
118	conf = rcu_dereference(mddev->private);
119	WARN_ONCE(sectors || raid_disks,
120		  "%s does not support generic reshape\n", __func__);
121	array_sectors = conf->array_sectors;
122	rcu_read_unlock();
123
124	return array_sectors;
125}
126
127static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)
128{
129	struct linear_conf *conf;
130	struct md_rdev *rdev;
131	int i, cnt;
132
133	conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(struct dev_info),
134			GFP_KERNEL);
135	if (!conf)
136		return NULL;
137
138	cnt = 0;
139	conf->array_sectors = 0;
140
141	list_for_each_entry(rdev, &mddev->disks, same_set) {
142		int j = rdev->raid_disk;
143		struct dev_info *disk = conf->disks + j;
144		sector_t sectors;
145
146		if (j < 0 || j >= raid_disks || disk->rdev) {
147			printk(KERN_ERR "md/linear:%s: disk numbering problem. Aborting!\n",
148			       mdname(mddev));
149			goto out;
150		}
151
152		disk->rdev = rdev;
153		if (mddev->chunk_sectors) {
154			sectors = rdev->sectors;
155			sector_div(sectors, mddev->chunk_sectors);
156			rdev->sectors = sectors * mddev->chunk_sectors;
157		}
158
159		disk_stack_limits(mddev->gendisk, rdev->bdev,
160				  rdev->data_offset << 9);
161		/* as we don't honour merge_bvec_fn, we must never risk
162		 * violating it, so limit max_segments to 1 lying within
163		 * a single page.
164		 */
165		if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
166			blk_queue_max_segments(mddev->queue, 1);
167			blk_queue_segment_boundary(mddev->queue,
168						   PAGE_CACHE_SIZE - 1);
169		}
170
171		conf->array_sectors += rdev->sectors;
172		cnt++;
173
174	}
175	if (cnt != raid_disks) {
176		printk(KERN_ERR "md/linear:%s: not enough drives present. Aborting!\n",
177		       mdname(mddev));
178		goto out;
179	}
180
181	/*
182	 * Here we calculate the device offsets.
183	 */
184	conf->disks[0].end_sector = conf->disks[0].rdev->sectors;
185
186	for (i = 1; i < raid_disks; i++)
187		conf->disks[i].end_sector =
188			conf->disks[i-1].end_sector +
189			conf->disks[i].rdev->sectors;
190
191	return conf;
192
193out:
194	kfree(conf);
195	return NULL;
196}
197
198static int linear_run (struct mddev *mddev)
199{
200	struct linear_conf *conf;
201
202	if (md_check_no_bitmap(mddev))
203		return -EINVAL;
204	conf = linear_conf(mddev, mddev->raid_disks);
205
206	if (!conf)
207		return 1;
208	mddev->private = conf;
209	md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
210
211	blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec);
212	mddev->queue->backing_dev_info.congested_fn = linear_congested;
213	mddev->queue->backing_dev_info.congested_data = mddev;
214	return md_integrity_register(mddev);
215}
216
217static int linear_add(struct mddev *mddev, struct md_rdev *rdev)
218{
219	/* Adding a drive to a linear array allows the array to grow.
220	 * It is permitted if the new drive has a matching superblock
221	 * already on it, with raid_disk equal to raid_disks.
222	 * It is achieved by creating a new linear_private_data structure
223	 * and swapping it in in-place of the current one.
224	 * The current one is never freed until the array is stopped.
225	 * This avoids races.
226	 */
227	struct linear_conf *newconf, *oldconf;
228
229	if (rdev->saved_raid_disk != mddev->raid_disks)
230		return -EINVAL;
231
232	rdev->raid_disk = rdev->saved_raid_disk;
233	rdev->saved_raid_disk = -1;
234
235	newconf = linear_conf(mddev,mddev->raid_disks+1);
236
237	if (!newconf)
238		return -ENOMEM;
239
240	oldconf = rcu_dereference(mddev->private);
241	mddev->raid_disks++;
242	rcu_assign_pointer(mddev->private, newconf);
243	md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
244	set_capacity(mddev->gendisk, mddev->array_sectors);
245	revalidate_disk(mddev->gendisk);
246	kfree_rcu(oldconf, rcu);
247	return 0;
248}
249
250static int linear_stop (struct mddev *mddev)
251{
252	struct linear_conf *conf = mddev->private;
253
254	/*
255	 * We do not require rcu protection here since
256	 * we hold reconfig_mutex for both linear_add and
257	 * linear_stop, so they cannot race.
258	 * We should make sure any old 'conf's are properly
259	 * freed though.
260	 */
261	rcu_barrier();
262	blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
263	kfree(conf);
264	mddev->private = NULL;
265
266	return 0;
267}
268
269static void linear_make_request(struct mddev *mddev, struct bio *bio)
270{
271	struct dev_info *tmp_dev;
272	sector_t start_sector;
273
274	if (unlikely(bio->bi_rw & REQ_FLUSH)) {
275		md_flush_request(mddev, bio);
276		return;
277	}
278
279	rcu_read_lock();
280	tmp_dev = which_dev(mddev, bio->bi_sector);
281	start_sector = tmp_dev->end_sector - tmp_dev->rdev->sectors;
282
283
284	if (unlikely(bio->bi_sector >= (tmp_dev->end_sector)
285		     || (bio->bi_sector < start_sector))) {
286		char b[BDEVNAME_SIZE];
287
288		printk(KERN_ERR
289		       "md/linear:%s: make_request: Sector %llu out of bounds on "
290		       "dev %s: %llu sectors, offset %llu\n",
291		       mdname(mddev),
292		       (unsigned long long)bio->bi_sector,
293		       bdevname(tmp_dev->rdev->bdev, b),
294		       (unsigned long long)tmp_dev->rdev->sectors,
295		       (unsigned long long)start_sector);
296		rcu_read_unlock();
297		bio_io_error(bio);
298		return;
299	}
300	if (unlikely(bio->bi_sector + (bio->bi_size >> 9) >
301		     tmp_dev->end_sector)) {
302		/* This bio crosses a device boundary, so we have to
303		 * split it.
304		 */
305		struct bio_pair *bp;
306		sector_t end_sector = tmp_dev->end_sector;
307
308		rcu_read_unlock();
309
310		bp = bio_split(bio, end_sector - bio->bi_sector);
311
312		linear_make_request(mddev, &bp->bio1);
313		linear_make_request(mddev, &bp->bio2);
314		bio_pair_release(bp);
315		return;
316	}
317
318	bio->bi_bdev = tmp_dev->rdev->bdev;
319	bio->bi_sector = bio->bi_sector - start_sector
320		+ tmp_dev->rdev->data_offset;
321	rcu_read_unlock();
322	generic_make_request(bio);
323}
324
325static void linear_status (struct seq_file *seq, struct mddev *mddev)
326{
327
328	seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2);
329}
330
331
332static struct md_personality linear_personality =
333{
334	.name		= "linear",
335	.level		= LEVEL_LINEAR,
336	.owner		= THIS_MODULE,
337	.make_request	= linear_make_request,
338	.run		= linear_run,
339	.stop		= linear_stop,
340	.status		= linear_status,
341	.hot_add_disk	= linear_add,
342	.size		= linear_size,
343};
344
345static int __init linear_init (void)
346{
347	return register_md_personality (&linear_personality);
348}
349
350static void linear_exit (void)
351{
352	unregister_md_personality (&linear_personality);
353}
354
355
356module_init(linear_init);
357module_exit(linear_exit);
358MODULE_LICENSE("GPL");
359MODULE_DESCRIPTION("Linear device concatenation personality for MD");
360MODULE_ALIAS("md-personality-1"); /* LINEAR - deprecated*/
361MODULE_ALIAS("md-linear");
362MODULE_ALIAS("md-level--1");
363