Commit 0bd7c5d8 authored by Jens Axboe's avatar Jens Axboe
Browse files

Merge tag 'md-next-20231219' of... 

Merge tag 'md-next-20231219' of https://git.kernel.org/pub/scm/linux/kernel/git/song/md into for-6.8/block

Pull MD updates from Song:

"1. Remove deprecated flavors, by Song Liu;
 2. raid1 read error check support, by Li Nan;
 3. Better handle events off-by-1 case, by Alex Lyakas."

* tag 'md-next-20231219' of https://git.kernel.org/pub/scm/linux/kernel/git/song/md:
  md: Remove deprecated CONFIG_MD_FAULTY
  md: Remove deprecated CONFIG_MD_MULTIPATH
  md: Remove deprecated CONFIG_MD_LINEAR
  md/raid1: support read error check
  md: factor out a helper exceed_read_errors() to check read_errors
  md: Whenassemble the array, consult the superblock of the freshest device
  md/raid1: remove unnecessary null checking
parents 4c434392 415c7451

drivers/md/Kconfig

+0 −34
Original line number Diff line number Diff line
@@ -61,19 +61,6 @@ config MD_BITMAP_FILE 
	  various kernel APIs and can only work with files on a file system not

	  actually sitting on the MD device.



config MD_LINEAR

	tristate "Linear (append) mode (deprecated)"

	depends on BLK_DEV_MD

	help

	  If you say Y here, then your multiple devices driver will be able to

	  use the so-called linear mode, i.e. it will combine the hard disk

	  partitions by simply appending one to the other.



	  To compile this as a module, choose M here: the module

	  will be called linear.



	  If unsure, say Y.



config MD_RAID0

	tristate "RAID-0 (striping) mode"

	depends on BLK_DEV_MD
@@ -172,27 +159,6 @@ config MD_RAID456 


	  If unsure, say Y.



config MD_MULTIPATH

	tristate "Multipath I/O support (deprecated)"

	depends on BLK_DEV_MD

	help

	  MD_MULTIPATH provides a simple multi-path personality for use

	  the MD framework.  It is not under active development.  New

	  projects should consider using DM_MULTIPATH which has more

	  features and more testing.



	  If unsure, say N.



config MD_FAULTY

	tristate "Faulty test module for MD (deprecated)"

	depends on BLK_DEV_MD

	help

	  The "faulty" module allows for a block device that occasionally returns

	  read or write errors.  It is useful for testing.



	  In unsure, say N.





config MD_CLUSTER

	tristate "Cluster Support for MD"

	depends on BLK_DEV_MD

drivers/md/Makefile

+2 −8
Original line number Diff line number Diff line
@@ -29,22 +29,16 @@ dm-zoned-y += dm-zoned-target.o dm-zoned-metadata.o dm-zoned-reclaim.o 


md-mod-y	+= md.o md-bitmap.o

raid456-y	+= raid5.o raid5-cache.o raid5-ppl.o

linear-y	+= md-linear.o

multipath-y	+= md-multipath.o

faulty-y	+= md-faulty.o



# Note: link order is important.  All raid personalities

# and must come before md.o, as they each initialise

# themselves, and md.o may use the personalities when it

# auto-initialised.



obj-$(CONFIG_MD_LINEAR)		+= linear.o

obj-$(CONFIG_MD_RAID0)		+= raid0.o

obj-$(CONFIG_MD_RAID1)		+= raid1.o

obj-$(CONFIG_MD_RAID10)		+= raid10.o

obj-$(CONFIG_MD_RAID456)	+= raid456.o

obj-$(CONFIG_MD_MULTIPATH)	+= multipath.o

obj-$(CONFIG_MD_FAULTY)		+= faulty.o

obj-$(CONFIG_MD_CLUSTER)	+= md-cluster.o

obj-$(CONFIG_BCACHE)		+= bcache/

obj-$(CONFIG_BLK_DEV_MD)	+= md-mod.o

drivers/md/md-autodetect.c

+2 −6
Original line number Diff line number Diff line
@@ -49,7 +49,6 @@ static int md_setup_ents __initdata; 
 *             instead of just one.  -- KTK

 * 18May2000: Added support for persistent-superblock arrays:

 *             md=n,0,factor,fault,device-list   uses RAID0 for device n

 *             md=n,-1,factor,fault,device-list  uses LINEAR for device n

 *             md=n,device-list      reads a RAID superblock from the devices

 *             elements in device-list are read by name_to_kdev_t so can be

 *             a hex number or something like /dev/hda1 /dev/sdb
@@ -88,7 +87,7 @@ static int __init md_setup(char *str) 
		md_setup_ents++;

	switch (get_option(&str, &level)) {	/* RAID level */

	case 2: /* could be 0 or -1.. */

		if (level == 0 || level == LEVEL_LINEAR) {

		if (level == 0) {

			if (get_option(&str, &factor) != 2 ||	/* Chunk Size */

					get_option(&str, &fault) != 2) {

				printk(KERN_WARNING "md: Too few arguments supplied to md=.\n");
@@ -96,9 +95,6 @@ static int __init md_setup(char *str) 
			}

			md_setup_args[ent].level = level;

			md_setup_args[ent].chunk = 1 << (factor+12);

			if (level ==  LEVEL_LINEAR)

				pername = "linear";

			else

			pername = "raid0";

			break;

		}

drivers/md/md-faulty.c

deleted100644 → 0
+0 −365
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * faulty.c : Multiple Devices driver for Linux

 *

 * Copyright (C) 2004 Neil Brown

 *

 * fautly-device-simulator personality for md

 */





/*

 * The "faulty" personality causes some requests to fail.

 *

 * Possible failure modes are:

 *   reads fail "randomly" but succeed on retry

 *   writes fail "randomly" but succeed on retry

 *   reads for some address fail and then persist until a write

 *   reads for some address fail and then persist irrespective of write

 *   writes for some address fail and persist

 *   all writes fail

 *

 * Different modes can be active at a time, but only

 * one can be set at array creation.  Others can be added later.

 * A mode can be one-shot or recurrent with the recurrence being

 * once in every N requests.

 * The bottom 5 bits of the "layout" indicate the mode.  The

 * remainder indicate a period, or 0 for one-shot.

 *

 * There is an implementation limit on the number of concurrently

 * persisting-faulty blocks. When a new fault is requested that would

 * exceed the limit, it is ignored.

 * All current faults can be clear using a layout of "0".

 *

 * Requests are always sent to the device.  If they are to fail,

 * we clone the bio and insert a new b_end_io into the chain.

 */



#define	WriteTransient	0

#define	ReadTransient	1

#define	WritePersistent	2

#define	ReadPersistent	3

#define	WriteAll	4 /* doesn't go to device */

#define	ReadFixable	5

#define	Modes	6



#define	ClearErrors	31

#define	ClearFaults	30



#define AllPersist	100 /* internal use only */

#define	NoPersist	101



#define	ModeMask	0x1f

#define	ModeShift	5



#define MaxFault	50

#include <linux/blkdev.h>

#include <linux/module.h>

#include <linux/raid/md_u.h>

#include <linux/slab.h>

#include "md.h"

#include <linux/seq_file.h>





static void faulty_fail(struct bio *bio)

{

	struct bio *b = bio->bi_private;



	b->bi_iter.bi_size = bio->bi_iter.bi_size;

	b->bi_iter.bi_sector = bio->bi_iter.bi_sector;



	bio_put(bio);



	bio_io_error(b);

}



struct faulty_conf {

	int period[Modes];

	atomic_t counters[Modes];

	sector_t faults[MaxFault];

	int	modes[MaxFault];

	int nfaults;

	struct md_rdev *rdev;

};



static int check_mode(struct faulty_conf *conf, int mode)

{

	if (conf->period[mode] == 0 &&

	    atomic_read(&conf->counters[mode]) <= 0)

		return 0; /* no failure, no decrement */





	if (atomic_dec_and_test(&conf->counters[mode])) {

		if (conf->period[mode])

			atomic_set(&conf->counters[mode], conf->period[mode]);

		return 1;

	}

	return 0;

}



static int check_sector(struct faulty_conf *conf, sector_t start, sector_t end, int dir)

{

	/* If we find a ReadFixable sector, we fix it ... */

	int i;

	for (i=0; i<conf->nfaults; i++)

		if (conf->faults[i] >= start &&

		    conf->faults[i] < end) {

			/* found it ... */

			switch (conf->modes[i] * 2 + dir) {

			case WritePersistent*2+WRITE: return 1;

			case ReadPersistent*2+READ: return 1;

			case ReadFixable*2+READ: return 1;

			case ReadFixable*2+WRITE:

				conf->modes[i] = NoPersist;

				return 0;

			case AllPersist*2+READ:

			case AllPersist*2+WRITE: return 1;

			default:

				return 0;

			}

		}

	return 0;

}



static void add_sector(struct faulty_conf *conf, sector_t start, int mode)

{

	int i;

	int n = conf->nfaults;

	for (i=0; i<conf->nfaults; i++)

		if (conf->faults[i] == start) {

			switch(mode) {

			case NoPersist: conf->modes[i] = mode; return;

			case WritePersistent:

				if (conf->modes[i] == ReadPersistent ||

				    conf->modes[i] == ReadFixable)

					conf->modes[i] = AllPersist;

				else

					conf->modes[i] = WritePersistent;

				return;

			case ReadPersistent:

				if (conf->modes[i] == WritePersistent)

					conf->modes[i] = AllPersist;

				else

					conf->modes[i] = ReadPersistent;

				return;

			case ReadFixable:

				if (conf->modes[i] == WritePersistent ||

				    conf->modes[i] == ReadPersistent)

					conf->modes[i] = AllPersist;

				else

					conf->modes[i] = ReadFixable;

				return;

			}

		} else if (conf->modes[i] == NoPersist)

			n = i;



	if (n >= MaxFault)

		return;

	conf->faults[n] = start;

	conf->modes[n] = mode;

	if (conf->nfaults == n)

		conf->nfaults = n+1;

}



static bool faulty_make_request(struct mddev *mddev, struct bio *bio)

{

	struct faulty_conf *conf = mddev->private;

	int failit = 0;



	if (bio_data_dir(bio) == WRITE) {

		/* write request */

		if (atomic_read(&conf->counters[WriteAll])) {

			/* special case - don't decrement, don't submit_bio_noacct,

			 * just fail immediately

			 */

			bio_io_error(bio);

			return true;

		}



		if (check_sector(conf, bio->bi_iter.bi_sector,

				 bio_end_sector(bio), WRITE))

			failit = 1;

		if (check_mode(conf, WritePersistent)) {

			add_sector(conf, bio->bi_iter.bi_sector,

				   WritePersistent);

			failit = 1;

		}

		if (check_mode(conf, WriteTransient))

			failit = 1;

	} else {

		/* read request */

		if (check_sector(conf, bio->bi_iter.bi_sector,

				 bio_end_sector(bio), READ))

			failit = 1;

		if (check_mode(conf, ReadTransient))

			failit = 1;

		if (check_mode(conf, ReadPersistent)) {

			add_sector(conf, bio->bi_iter.bi_sector,

				   ReadPersistent);

			failit = 1;

		}

		if (check_mode(conf, ReadFixable)) {

			add_sector(conf, bio->bi_iter.bi_sector,

				   ReadFixable);

			failit = 1;

		}

	}



	md_account_bio(mddev, &bio);

	if (failit) {

		struct bio *b = bio_alloc_clone(conf->rdev->bdev, bio, GFP_NOIO,

						&mddev->bio_set);



		b->bi_private = bio;

		b->bi_end_io = faulty_fail;

		bio = b;

	} else

		bio_set_dev(bio, conf->rdev->bdev);



	submit_bio_noacct(bio);

	return true;

}



static void faulty_status(struct seq_file *seq, struct mddev *mddev)

{

	struct faulty_conf *conf = mddev->private;

	int n;



	if ((n=atomic_read(&conf->counters[WriteTransient])) != 0)

		seq_printf(seq, " WriteTransient=%d(%d)",

			   n, conf->period[WriteTransient]);



	if ((n=atomic_read(&conf->counters[ReadTransient])) != 0)

		seq_printf(seq, " ReadTransient=%d(%d)",

			   n, conf->period[ReadTransient]);



	if ((n=atomic_read(&conf->counters[WritePersistent])) != 0)

		seq_printf(seq, " WritePersistent=%d(%d)",

			   n, conf->period[WritePersistent]);



	if ((n=atomic_read(&conf->counters[ReadPersistent])) != 0)

		seq_printf(seq, " ReadPersistent=%d(%d)",

			   n, conf->period[ReadPersistent]);





	if ((n=atomic_read(&conf->counters[ReadFixable])) != 0)

		seq_printf(seq, " ReadFixable=%d(%d)",

			   n, conf->period[ReadFixable]);



	if ((n=atomic_read(&conf->counters[WriteAll])) != 0)

		seq_printf(seq, " WriteAll");



	seq_printf(seq, " nfaults=%d", conf->nfaults);

}





static int faulty_reshape(struct mddev *mddev)

{

	int mode = mddev->new_layout & ModeMask;

	int count = mddev->new_layout >> ModeShift;

	struct faulty_conf *conf = mddev->private;



	if (mddev->new_layout < 0)

		return 0;



	/* new layout */

	if (mode == ClearFaults)

		conf->nfaults = 0;

	else if (mode == ClearErrors) {

		int i;

		for (i=0 ; i < Modes ; i++) {

			conf->period[i] = 0;

			atomic_set(&conf->counters[i], 0);

		}

	} else if (mode < Modes) {

		conf->period[mode] = count;

		if (!count) count++;

		atomic_set(&conf->counters[mode], count);

	} else

		return -EINVAL;

	mddev->new_layout = -1;

	mddev->layout = -1; /* makes sure further changes come through */

	return 0;

}



static sector_t faulty_size(struct mddev *mddev, sector_t sectors, int raid_disks)

{

	WARN_ONCE(raid_disks,

		  "%s does not support generic reshape\n", __func__);



	if (sectors == 0)

		return mddev->dev_sectors;



	return sectors;

}



static int faulty_run(struct mddev *mddev)

{

	struct md_rdev *rdev;

	int i;

	struct faulty_conf *conf;



	if (md_check_no_bitmap(mddev))

		return -EINVAL;



	conf = kmalloc(sizeof(*conf), GFP_KERNEL);

	if (!conf)

		return -ENOMEM;



	for (i=0; i<Modes; i++) {

		atomic_set(&conf->counters[i], 0);

		conf->period[i] = 0;

	}

	conf->nfaults = 0;



	rdev_for_each(rdev, mddev) {

		conf->rdev = rdev;

		disk_stack_limits(mddev->gendisk, rdev->bdev,

				  rdev->data_offset << 9);

	}



	md_set_array_sectors(mddev, faulty_size(mddev, 0, 0));

	mddev->private = conf;



	faulty_reshape(mddev);



	return 0;

}



static void faulty_free(struct mddev *mddev, void *priv)

{

	struct faulty_conf *conf = priv;



	kfree(conf);

}



static struct md_personality faulty_personality =

{

	.name		= "faulty",

	.level		= LEVEL_FAULTY,

	.owner		= THIS_MODULE,

	.make_request	= faulty_make_request,

	.run		= faulty_run,

	.free		= faulty_free,

	.status		= faulty_status,

	.check_reshape	= faulty_reshape,

	.size		= faulty_size,

};



static int __init raid_init(void)

{

	return register_md_personality(&faulty_personality);

}



static void raid_exit(void)

{

	unregister_md_personality(&faulty_personality);

}



module_init(raid_init);

module_exit(raid_exit);

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Fault injection personality for MD (deprecated)");

MODULE_ALIAS("md-personality-10"); /* faulty */

MODULE_ALIAS("md-faulty");

MODULE_ALIAS("md-level--5");

drivers/md/md-linear.c

deleted100644 → 0
+0 −318
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

   linear.c : Multiple Devices driver for Linux

	      Copyright (C) 1994-96 Marc ZYNGIER

	      <zyngier@ufr-info-p7.ibp.fr> or

	      <maz@gloups.fdn.fr>



   Linear mode management functions.



*/



#include <linux/blkdev.h>

#include <linux/raid/md_u.h>

#include <linux/seq_file.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <trace/events/block.h>

#include "md.h"

#include "md-linear.h"



/*

 * find which device holds a particular offset

 */

static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector)

{

	int lo, mid, hi;

	struct linear_conf *conf;



	lo = 0;

	hi = mddev->raid_disks - 1;

	conf = mddev->private;



	/*

	 * Binary Search

	 */



	while (hi > lo) {



		mid = (hi + lo) / 2;

		if (sector < conf->disks[mid].end_sector)

			hi = mid;

		else

			lo = mid + 1;

	}



	return conf->disks + lo;

}



static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks)

{

	struct linear_conf *conf;

	sector_t array_sectors;



	conf = mddev->private;

	WARN_ONCE(sectors || raid_disks,

		  "%s does not support generic reshape\n", __func__);

	array_sectors = conf->array_sectors;



	return array_sectors;

}



static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)

{

	struct linear_conf *conf;

	struct md_rdev *rdev;

	int i, cnt;



	conf = kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL);

	if (!conf)

		return NULL;



	/*

	 * conf->raid_disks is copy of mddev->raid_disks. The reason to

	 * keep a copy of mddev->raid_disks in struct linear_conf is,

	 * mddev->raid_disks may not be consistent with pointers number of

	 * conf->disks[] when it is updated in linear_add() and used to

	 * iterate old conf->disks[] earray in linear_congested().

	 * Here conf->raid_disks is always consitent with number of

	 * pointers in conf->disks[] array, and mddev->private is updated

	 * with rcu_assign_pointer() in linear_addr(), such race can be

	 * avoided.

	 */

	conf->raid_disks = raid_disks;



	cnt = 0;

	conf->array_sectors = 0;



	rdev_for_each(rdev, mddev) {

		int j = rdev->raid_disk;

		struct dev_info *disk = conf->disks + j;

		sector_t sectors;



		if (j < 0 || j >= raid_disks || disk->rdev) {

			pr_warn("md/linear:%s: disk numbering problem. Aborting!\n",

				mdname(mddev));

			goto out;

		}



		disk->rdev = rdev;

		if (mddev->chunk_sectors) {

			sectors = rdev->sectors;

			sector_div(sectors, mddev->chunk_sectors);

			rdev->sectors = sectors * mddev->chunk_sectors;

		}



		disk_stack_limits(mddev->gendisk, rdev->bdev,

				  rdev->data_offset << 9);



		conf->array_sectors += rdev->sectors;

		cnt++;

	}

	if (cnt != raid_disks) {

		pr_warn("md/linear:%s: not enough drives present. Aborting!\n",

			mdname(mddev));

		goto out;

	}



	/*

	 * Here we calculate the device offsets.

	 */

	conf->disks[0].end_sector = conf->disks[0].rdev->sectors;



	for (i = 1; i < raid_disks; i++)

		conf->disks[i].end_sector =

			conf->disks[i-1].end_sector +

			conf->disks[i].rdev->sectors;



	return conf;



out:

	kfree(conf);

	return NULL;

}



static int linear_run (struct mddev *mddev)

{

	struct linear_conf *conf;

	int ret;



	if (md_check_no_bitmap(mddev))

		return -EINVAL;

	conf = linear_conf(mddev, mddev->raid_disks);



	if (!conf)

		return 1;

	mddev->private = conf;

	md_set_array_sectors(mddev, linear_size(mddev, 0, 0));



	ret =  md_integrity_register(mddev);

	if (ret) {

		kfree(conf);

		mddev->private = NULL;

	}

	return ret;

}



static int linear_add(struct mddev *mddev, struct md_rdev *rdev)

{

	/* Adding a drive to a linear array allows the array to grow.

	 * It is permitted if the new drive has a matching superblock

	 * already on it, with raid_disk equal to raid_disks.

	 * It is achieved by creating a new linear_private_data structure

	 * and swapping it in in-place of the current one.

	 * The current one is never freed until the array is stopped.

	 * This avoids races.

	 */

	struct linear_conf *newconf, *oldconf;



	if (rdev->saved_raid_disk != mddev->raid_disks)

		return -EINVAL;



	rdev->raid_disk = rdev->saved_raid_disk;

	rdev->saved_raid_disk = -1;



	newconf = linear_conf(mddev,mddev->raid_disks+1);



	if (!newconf)

		return -ENOMEM;



	/* newconf->raid_disks already keeps a copy of * the increased

	 * value of mddev->raid_disks, WARN_ONCE() is just used to make

	 * sure of this. It is possible that oldconf is still referenced

	 * in linear_congested(), therefore kfree_rcu() is used to free

	 * oldconf until no one uses it anymore.

	 */

	oldconf = rcu_dereference_protected(mddev->private,

			lockdep_is_held(&mddev->reconfig_mutex));

	mddev->raid_disks++;

	WARN_ONCE(mddev->raid_disks != newconf->raid_disks,

		"copied raid_disks doesn't match mddev->raid_disks");

	rcu_assign_pointer(mddev->private, newconf);

	md_set_array_sectors(mddev, linear_size(mddev, 0, 0));

	set_capacity_and_notify(mddev->gendisk, mddev->array_sectors);

	kfree_rcu(oldconf, rcu);

	return 0;

}



static void linear_free(struct mddev *mddev, void *priv)

{

	struct linear_conf *conf = priv;



	kfree(conf);

}



static bool linear_make_request(struct mddev *mddev, struct bio *bio)

{

	struct dev_info *tmp_dev;

	sector_t start_sector, end_sector, data_offset;

	sector_t bio_sector = bio->bi_iter.bi_sector;



	if (unlikely(bio->bi_opf & REQ_PREFLUSH)

	    && md_flush_request(mddev, bio))

		return true;



	tmp_dev = which_dev(mddev, bio_sector);

	start_sector = tmp_dev->end_sector - tmp_dev->rdev->sectors;

	end_sector = tmp_dev->end_sector;

	data_offset = tmp_dev->rdev->data_offset;



	if (unlikely(bio_sector >= end_sector ||

		     bio_sector < start_sector))

		goto out_of_bounds;



	if (unlikely(is_rdev_broken(tmp_dev->rdev))) {

		md_error(mddev, tmp_dev->rdev);

		bio_io_error(bio);

		return true;

	}



	if (unlikely(bio_end_sector(bio) > end_sector)) {

		/* This bio crosses a device boundary, so we have to split it */

		struct bio *split = bio_split(bio, end_sector - bio_sector,

					      GFP_NOIO, &mddev->bio_set);

		bio_chain(split, bio);

		submit_bio_noacct(bio);

		bio = split;

	}



	md_account_bio(mddev, &bio);

	bio_set_dev(bio, tmp_dev->rdev->bdev);

	bio->bi_iter.bi_sector = bio->bi_iter.bi_sector -

		start_sector + data_offset;



	if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&

		     !bdev_max_discard_sectors(bio->bi_bdev))) {

		/* Just ignore it */

		bio_endio(bio);

	} else {

		if (mddev->gendisk)

			trace_block_bio_remap(bio, disk_devt(mddev->gendisk),

					      bio_sector);

		mddev_check_write_zeroes(mddev, bio);

		submit_bio_noacct(bio);

	}

	return true;



out_of_bounds:

	pr_err("md/linear:%s: make_request: Sector %llu out of bounds on dev %pg: %llu sectors, offset %llu\n",

	       mdname(mddev),

	       (unsigned long long)bio->bi_iter.bi_sector,

	       tmp_dev->rdev->bdev,

	       (unsigned long long)tmp_dev->rdev->sectors,

	       (unsigned long long)start_sector);

	bio_io_error(bio);

	return true;

}



static void linear_status (struct seq_file *seq, struct mddev *mddev)

{

	seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2);

}



static void linear_error(struct mddev *mddev, struct md_rdev *rdev)

{

	if (!test_and_set_bit(MD_BROKEN, &mddev->flags)) {

		char *md_name = mdname(mddev);



		pr_crit("md/linear%s: Disk failure on %pg detected, failing array.\n",

			md_name, rdev->bdev);

	}

}



static void linear_quiesce(struct mddev *mddev, int state)

{

}



static struct md_personality linear_personality =

{

	.name		= "linear",

	.level		= LEVEL_LINEAR,

	.owner		= THIS_MODULE,

	.make_request	= linear_make_request,

	.run		= linear_run,

	.free		= linear_free,

	.status		= linear_status,

	.hot_add_disk	= linear_add,

	.size		= linear_size,

	.quiesce	= linear_quiesce,

	.error_handler	= linear_error,

};



static int __init linear_init (void)

{

	return register_md_personality (&linear_personality);

}



static void linear_exit (void)

{

	unregister_md_personality (&linear_personality);

}



module_init(linear_init);

module_exit(linear_exit);

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Linear device concatenation personality for MD (deprecated)");

MODULE_ALIAS("md-personality-1"); /* LINEAR - deprecated*/

MODULE_ALIAS("md-linear");

MODULE_ALIAS("md-level--1");