Commit c472273f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://neil.brown.name/md 

* 'for-linus' of git://neil.brown.name/md:
  md: fix input truncation in safe_delay_store()
  md: check for memory allocation failure in faulty personality
  md: build failure due to missing delay.h
  md: Relax minimum size restrictions on chunk_size.
  md: remove space after function name in declaration and call.
  md: Remove unnecessary #includes, #defines, and function declarations.
  md: Convert remaining 1k representations in linear.c to sectors.
  md: linear.c: Make two local variables sector-based.
  md: linear: Represent dev_info->size and dev_info->offset in sectors.
  md: linear.c: Remove broken debug code.
  md: linear.c: Remove pointless initialization of curr_offset.
  md: linear.c: Fix typo in comment.
  md: Don't try to set an array to 'read-auto' if it is already in that state.
  md: Allow metadata_version to be updated for externally managed metadata.
  md: Fix rdev_size_store with size == 0
parents 36ac1d2f 97ce0a7f

drivers/md/faulty.c

+2 −0
Original line number Diff line number Diff line
@@ -287,6 +287,8 @@ static int run(mddev_t *mddev) 
	int i;



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

	if (!conf)

		return -ENOMEM;



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

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

drivers/md/linear.c

+52 −81
Original line number Diff line number Diff line
@@ -16,16 +16,8 @@ 
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  

*/



#include <linux/module.h>



#include <linux/raid/md.h>

#include <linux/slab.h>

#include <linux/raid/linear.h>



#define MAJOR_NR MD_MAJOR

#define MD_DRIVER

#define MD_PERSONALITY



/*

 * find which device holds a particular offset 

 */
@@ -33,16 +25,15 @@ static inline dev_info_t *which_dev(mddev_t *mddev, sector_t sector) 
{

	dev_info_t *hash;

	linear_conf_t *conf = mddev_to_conf(mddev);

	sector_t block = sector >> 1;



	/*

	 * sector_div(a,b) returns the remainer and sets a to a/b

	 */

	block >>= conf->preshift;

	(void)sector_div(block, conf->hash_spacing);

	hash = conf->hash_table[block];

	sector >>= conf->sector_shift;

	(void)sector_div(sector, conf->spacing);

	hash = conf->hash_table[sector];



	while ((sector>>1) >= (hash->size + hash->offset))

	while (sector >= hash->num_sectors + hash->start_sector)

		hash++;

	return hash;

}
@@ -65,7 +56,7 @@ static int linear_mergeable_bvec(struct request_queue *q, 
	sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);



	dev0 = which_dev(mddev, sector);

	maxsectors = (dev0->size << 1) - (sector - (dev0->offset<<1));

	maxsectors = dev0->num_sectors - (sector - dev0->start_sector);



	if (maxsectors < bio_sectors)

		maxsectors = 0;
@@ -112,8 +103,8 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 
	dev_info_t **table;

	mdk_rdev_t *rdev;

	int i, nb_zone, cnt;

	sector_t min_spacing;

	sector_t curr_offset;

	sector_t min_sectors;

	sector_t curr_sector;

	struct list_head *tmp;



	conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(dev_info_t),
@@ -145,7 +136,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 
		    mddev->queue->max_sectors > (PAGE_SIZE>>9))

			blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);



		disk->size = rdev->size;

		disk->num_sectors = rdev->size * 2;

		conf->array_sectors += rdev->size * 2;



		cnt++;
@@ -155,34 +146,34 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 
		goto out;

	}



	min_spacing = conf->array_sectors / 2;

	sector_div(min_spacing, PAGE_SIZE/sizeof(struct dev_info *));

	min_sectors = conf->array_sectors;

	sector_div(min_sectors, PAGE_SIZE/sizeof(struct dev_info *));



	/* min_spacing is the minimum spacing that will fit the hash

	/* min_sectors is the minimum spacing that will fit the hash

	 * table in one PAGE.  This may be much smaller than needed.

	 * We find the smallest non-terminal set of consecutive devices

	 * that is larger than min_spacing as use the size of that as

	 * that is larger than min_sectors and use the size of that as

	 * the actual spacing

	 */

	conf->hash_spacing = conf->array_sectors / 2;

	conf->spacing = conf->array_sectors;

	for (i=0; i < cnt-1 ; i++) {

		sector_t sz = 0;

		sector_t tmp = 0;

		int j;

		for (j = i; j < cnt - 1 && sz < min_spacing; j++)

			sz += conf->disks[j].size;

		if (sz >= min_spacing && sz < conf->hash_spacing)

			conf->hash_spacing = sz;

		for (j = i; j < cnt - 1 && tmp < min_sectors; j++)

			tmp += conf->disks[j].num_sectors;

		if (tmp >= min_sectors && tmp < conf->spacing)

			conf->spacing = tmp;

	}



	/* hash_spacing may be too large for sector_div to work with,

	/* spacing may be too large for sector_div to work with,

	 * so we might need to pre-shift

	 */

	conf->preshift = 0;

	conf->sector_shift = 0;

	if (sizeof(sector_t) > sizeof(u32)) {

		sector_t space = conf->hash_spacing;

		sector_t space = conf->spacing;

		while (space > (sector_t)(~(u32)0)) {

			space >>= 1;

			conf->preshift++;

			conf->sector_shift++;

		}

	}

	/*
@@ -194,9 +185,9 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 
		unsigned round;

		unsigned long base;



		sz = conf->array_sectors >> (conf->preshift + 1);

		sz = conf->array_sectors >> conf->sector_shift;

		sz += 1; /* force round-up */

		base = conf->hash_spacing >> conf->preshift;

		base = conf->spacing >> conf->sector_shift;

		round = sector_div(sz, base);

		nb_zone = sz + (round ? 1 : 0);

	}
@@ -211,32 +202,31 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 
	 * Here we generate the linear hash table

	 * First calculate the device offsets.

	 */

	conf->disks[0].offset = 0;

	conf->disks[0].start_sector = 0;

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

		conf->disks[i].offset =

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

			conf->disks[i-1].size;

		conf->disks[i].start_sector =

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

			conf->disks[i-1].num_sectors;



	table = conf->hash_table;

	curr_offset = 0;

	i = 0;

	for (curr_offset = 0;

	     curr_offset < conf->array_sectors / 2;

	     curr_offset += conf->hash_spacing) {

	for (curr_sector = 0;

	     curr_sector < conf->array_sectors;

	     curr_sector += conf->spacing) {



		while (i < raid_disks-1 &&

		       curr_offset >= conf->disks[i+1].offset)

		       curr_sector >= conf->disks[i+1].start_sector)

			i++;



		*table ++ = conf->disks + i;

	}



	if (conf->preshift) {

		conf->hash_spacing >>= conf->preshift;

		/* round hash_spacing up so that when we divide by it,

	if (conf->sector_shift) {

		conf->spacing >>= conf->sector_shift;

		/* round spacing up so that when we divide by it,

		 * we err on the side of "too-low", which is safest.

		 */

		conf->hash_spacing++;

		conf->spacing++;

	}



	BUG_ON(table - conf->hash_table > nb_zone);
@@ -317,7 +307,6 @@ static int linear_make_request (struct request_queue *q, struct bio *bio) 
	const int rw = bio_data_dir(bio);

	mddev_t *mddev = q->queuedata;

	dev_info_t *tmp_dev;

	sector_t block;

	int cpu;



	if (unlikely(bio_barrier(bio))) {
@@ -332,29 +321,33 @@ static int linear_make_request (struct request_queue *q, struct bio *bio) 
	part_stat_unlock();



	tmp_dev = which_dev(mddev, bio->bi_sector);

	block = bio->bi_sector >> 1;

    

	if (unlikely(block >= (tmp_dev->size + tmp_dev->offset)

		     || block < tmp_dev->offset)) {

	if (unlikely(bio->bi_sector >= (tmp_dev->num_sectors +

					tmp_dev->start_sector)

		     || (bio->bi_sector <

			 tmp_dev->start_sector))) {

		char b[BDEVNAME_SIZE];



		printk("linear_make_request: Block %llu out of bounds on "

			"dev %s size %llu offset %llu\n",

			(unsigned long long)block,

		printk("linear_make_request: Sector %llu out of bounds on "

			"dev %s: %llu sectors, offset %llu\n",

			(unsigned long long)bio->bi_sector,

			bdevname(tmp_dev->rdev->bdev, b),

			(unsigned long long)tmp_dev->size,

		        (unsigned long long)tmp_dev->offset);

			(unsigned long long)tmp_dev->num_sectors,

			(unsigned long long)tmp_dev->start_sector);

		bio_io_error(bio);

		return 0;

	}

	if (unlikely(bio->bi_sector + (bio->bi_size >> 9) >

		     (tmp_dev->offset + tmp_dev->size)<<1)) {

		     tmp_dev->start_sector + tmp_dev->num_sectors)) {

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

		 * split it.

		 */

		struct bio_pair *bp;



		bp = bio_split(bio,

			       ((tmp_dev->offset + tmp_dev->size)<<1) - bio->bi_sector);

			       tmp_dev->start_sector + tmp_dev->num_sectors

			       - bio->bi_sector);



		if (linear_make_request(q, &bp->bio1))

			generic_make_request(&bp->bio1);

		if (linear_make_request(q, &bp->bio2))
@@ -364,7 +357,8 @@ static int linear_make_request (struct request_queue *q, struct bio *bio) 
	}

		    

	bio->bi_bdev = tmp_dev->rdev->bdev;

	bio->bi_sector = bio->bi_sector - (tmp_dev->offset << 1) + tmp_dev->rdev->data_offset;

	bio->bi_sector = bio->bi_sector - tmp_dev->start_sector

		+ tmp_dev->rdev->data_offset;



	return 1;

}
@@ -372,29 +366,6 @@ static int linear_make_request (struct request_queue *q, struct bio *bio) 
static void linear_status (struct seq_file *seq, mddev_t *mddev)

{



#undef MD_DEBUG

#ifdef MD_DEBUG

	int j;

	linear_conf_t *conf = mddev_to_conf(mddev);

	sector_t s = 0;

  

	seq_printf(seq, "      ");

	for (j = 0; j < mddev->raid_disks; j++)

	{

		char b[BDEVNAME_SIZE];

		s += conf->smallest_size;

		seq_printf(seq, "[%s",

			   bdevname(conf->hash_table[j][0].rdev->bdev,b));



		while (s > conf->hash_table[j][0].offset +

		           conf->hash_table[j][0].size)

			seq_printf(seq, "/%s] ",

				   bdevname(conf->hash_table[j][1].rdev->bdev,b));

		else

			seq_printf(seq, "] ");

	}

	seq_printf(seq, "\n");

#endif

	seq_printf(seq, " %dk rounding", mddev->chunk_size/1024);

}

drivers/md/md.c

+33 −48
Original line number Diff line number Diff line
@@ -32,31 +32,21 @@ 
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/kthread.h>

#include <linux/linkage.h>

#include <linux/raid/md.h>

#include <linux/raid/bitmap.h>

#include <linux/sysctl.h>

#include <linux/buffer_head.h> /* for invalidate_bdev */

#include <linux/poll.h>

#include <linux/mutex.h>

#include <linux/ctype.h>

#include <linux/freezer.h>



#include <linux/init.h>



#include <linux/hdreg.h>

#include <linux/proc_fs.h>

#include <linux/random.h>

#include <linux/reboot.h>

#include <linux/file.h>



#ifdef CONFIG_KMOD

#include <linux/kmod.h>

#endif



#include <asm/unaligned.h>

#include <linux/delay.h>



#define MAJOR_NR MD_MAJOR

#define MD_DRIVER



/* 63 partitions with the alternate major number (mdp) */

#define MdpMinorShift 6
@@ -2106,8 +2096,6 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len) 


	if (strict_strtoull(buf, 10, &size) < 0)

		return -EINVAL;

	if (size < my_mddev->size)

		return -EINVAL;

	if (my_mddev->pers && rdev->raid_disk >= 0) {

		if (my_mddev->persistent) {

			size = super_types[my_mddev->major_version].
@@ -2118,9 +2106,9 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len) 
			size = (rdev->bdev->bd_inode->i_size >> 10);

			size -= rdev->data_offset/2;

		}

	}

	if (size < my_mddev->size)

		return -EINVAL; /* component must fit device */

	}



	rdev->size = size;

	if (size > oldsize && my_mddev->external) {
@@ -2406,12 +2394,11 @@ safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len) 
	int i;

	unsigned long msec;

	char buf[30];

	char *e;



	/* remove a period, and count digits after it */

	if (len >= sizeof(buf))

		return -EINVAL;

	strlcpy(buf, cbuf, len);

	buf[len] = 0;

	strlcpy(buf, cbuf, sizeof(buf));

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

		if (dot) {

			if (isdigit(buf[i])) {
@@ -2424,8 +2411,7 @@ safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len) 
			buf[i] = 0;

		}

	}

	msec = simple_strtoul(buf, &e, 10);

	if (e == buf || (*e && *e != '\n'))

	if (strict_strtoul(buf, 10, &msec) < 0)

		return -EINVAL;

	msec = (msec * 1000) / scale;

	if (msec == 0)
@@ -2727,9 +2713,9 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len) 
		break;

	case read_auto:

		if (mddev->pers) {

			if (mddev->ro != 1)

			if (mddev->ro == 0)

				err = do_md_stop(mddev, 1, 0);

			else

			else if (mddev->ro == 1)

				err = restart_array(mddev);

			if (err == 0) {

				mddev->ro = 2;
@@ -2945,7 +2931,13 @@ metadata_store(mddev_t *mddev, const char *buf, size_t len) 
{

	int major, minor;

	char *e;

	if (!list_empty(&mddev->disks))

	/* Changing the details of 'external' metadata is

	 * always permitted.  Otherwise there must be

	 * no devices attached to the array.

	 */

	if (mddev->external && strncmp(buf, "external:", 9) == 0)

		;

	else if (!list_empty(&mddev->disks))

		return -EBUSY;



	if (cmd_match(buf, "none")) {
@@ -3527,17 +3519,12 @@ static int do_md_run(mddev_t * mddev) 
			return -EINVAL;

		}

		/*

		 * chunk-size has to be a power of 2 and multiples of PAGE_SIZE

		 * chunk-size has to be a power of 2

		 */

		if ( (1 << ffz(~chunk_size)) != chunk_size) {

			printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);

			return -EINVAL;

		}

		if (chunk_size < PAGE_SIZE) {

			printk(KERN_ERR "too small chunk_size: %d < %ld\n",

				chunk_size, PAGE_SIZE);

			return -EINVAL;

		}



		/* devices must have minimum size of one chunk */

		rdev_for_each(rdev, tmp, mddev) {
@@ -3555,12 +3542,10 @@ static int do_md_run(mddev_t * mddev) 
		}

	}



#ifdef CONFIG_KMOD

	if (mddev->level != LEVEL_NONE)

		request_module("md-level-%d", mddev->level);

	else if (mddev->clevel[0])

		request_module("md-%s", mddev->clevel);

#endif



	/*

	 * Drop all container device buffers, from now on
@@ -6304,7 +6289,7 @@ static int __init md_init(void) 
	raid_table_header = register_sysctl_table(raid_root_table);



	md_geninit();

	return (0);

	return 0;

}

drivers/md/multipath.c

+0 −9
Original line number Diff line number Diff line
@@ -19,16 +19,7 @@ 
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */



#include <linux/module.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/raid/multipath.h>

#include <linux/buffer_head.h>

#include <asm/atomic.h>



#define MAJOR_NR MD_MAJOR

#define MD_DRIVER

#define MD_PERSONALITY



#define MAX_WORK_PER_DISK 128

drivers/md/raid0.c

+0 −5
Original line number Diff line number Diff line
@@ -18,13 +18,8 @@ 
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  

*/



#include <linux/module.h>

#include <linux/raid/raid0.h>



#define MAJOR_NR MD_MAJOR

#define MD_DRIVER

#define MD_PERSONALITY



static void raid0_unplug(struct request_queue *q)

{

	mddev_t *mddev = q->queuedata;

CRA Git | Maintained and supported by SUSTech CRA and CCSE