GitHub-Mirror/linux-bl808
2
0
Fork 0
mirror of https://github.com/Fishwaldo/linux-bl808.git synced 2025-06-17 20:25:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

md: Turn rdev->sb_offset into a sector-based quantity.

Browse source 
Rename it to sb_start to make sure all users have been converted.

Signed-off-by: Andre Noll <maan@systemlinux.org>
Signed-off-by: Neil Brown <neilb@suse.de>
This commit is contained in:
Andre Noll 2008-07-11 22:02:23 +10:00 • committed by Neil Brown
parent b73df2d3d6
commit 0f420358e3
3 changed files with 44 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

10
drivers/md/bitmap.c
View file

@ -225,7 +225,7 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
|| test_bit(Faulty, &rdev->flags)) || test_bit(Faulty, &rdev->flags))
continue; continue;
target = (rdev->sb_offset << 1) + offset + index * (PAGE_SIZE/512); target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
if (sync_page_io(rdev->bdev, target, PAGE_SIZE, page, READ)) { if (sync_page_io(rdev->bdev, target, PAGE_SIZE, page, READ)) {
page->index = index; page->index = index;
@ -262,12 +262,12 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
/* bitmap runs in to metadata */ /* bitmap runs in to metadata */
return -EINVAL; return -EINVAL;
if (rdev->data_offset + mddev->size*2 if (rdev->data_offset + mddev->size*2
> rdev->sb_offset*2 + bitmap->offset) > rdev->sb_start + bitmap->offset)
/* data runs in to bitmap */ /* data runs in to bitmap */
return -EINVAL; return -EINVAL;
} else if (rdev->sb_offset*2 < rdev->data_offset) { } else if (rdev->sb_start < rdev->data_offset) {
/* METADATA BITMAP DATA */ /* METADATA BITMAP DATA */
if (rdev->sb_offset*2 if (rdev->sb_start
+ bitmap->offset + bitmap->offset
+ page->index*(PAGE_SIZE/512) + size/512 + page->index*(PAGE_SIZE/512) + size/512
> rdev->data_offset) > rdev->data_offset)
@ -277,7 +277,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
/* DATA METADATA BITMAP - no problems */ /* DATA METADATA BITMAP - no problems */
} }
md_super_write(mddev, rdev, md_super_write(mddev, rdev,
(rdev->sb_offset<<1) + bitmap->offset rdev->sb_start + bitmap->offset
+ page->index * (PAGE_SIZE/512), + page->index * (PAGE_SIZE/512),
size, size,
page); page);

81
drivers/md/md.c
View file

@ -356,7 +356,7 @@ static inline sector_t calc_dev_sboffset(struct block_device *bdev)
static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size) static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size)
{ {
sector_t num_sectors = rdev->sb_offset * 2; sector_t num_sectors = rdev->sb_start;
if (chunk_size) if (chunk_size)
num_sectors &= ~((sector_t)chunk_size/512 - 1); num_sectors &= ~((sector_t)chunk_size/512 - 1);
@ -383,7 +383,7 @@ static void free_disk_sb(mdk_rdev_t * rdev)
put_page(rdev->sb_page); put_page(rdev->sb_page);
rdev->sb_loaded = 0; rdev->sb_loaded = 0;
rdev->sb_page = NULL; rdev->sb_page = NULL;
rdev->sb_offset = 0; rdev->sb_start = 0;
rdev->size = 0; rdev->size = 0;
} }
} }
@ -529,7 +529,7 @@ static int read_disk_sb(mdk_rdev_t * rdev, int size)
return 0; return 0;
if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ)) if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ))
goto fail; goto fail;
rdev->sb_loaded = 1; rdev->sb_loaded = 1;
return 0; return 0;
@ -666,16 +666,14 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
mdp_super_t *sb; mdp_super_t *sb;
int ret; int ret;
sector_t sb_offset;
/* /*
* Calculate the position of the superblock, * Calculate the position of the superblock (512byte sectors),
* it's at the end of the disk. * it's at the end of the disk.
* *
* It also happens to be a multiple of 4Kb. * It also happens to be a multiple of 4Kb.
*/ */
sb_offset = calc_dev_sboffset(rdev->bdev) / 2; rdev->sb_start = calc_dev_sboffset(rdev->bdev);
rdev->sb_offset = sb_offset;
ret = read_disk_sb(rdev, MD_SB_BYTES); ret = read_disk_sb(rdev, MD_SB_BYTES);
if (ret) return ret; if (ret) return ret;
@ -1007,10 +1005,10 @@ super_90_rdev_size_change(mdk_rdev_t *rdev, unsigned long long size)
size *= 2; /* convert to sectors */ size *= 2; /* convert to sectors */
if (rdev->mddev->bitmap_offset) if (rdev->mddev->bitmap_offset)
return 0; /* can't move bitmap */ return 0; /* can't move bitmap */
rdev->sb_offset = calc_dev_sboffset(rdev->bdev) / 2; rdev->sb_start = calc_dev_sboffset(rdev->bdev);
if (!size || size > rdev->sb_offset*2) if (!size || size > rdev->sb_start)
size = rdev->sb_offset*2; size = rdev->sb_start;
md_super_write(rdev->mddev, rdev, rdev->sb_offset << 1, rdev->sb_size, md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
rdev->sb_page); rdev->sb_page);
md_super_wait(rdev->mddev); md_super_wait(rdev->mddev);
return size/2; /* kB for sysfs */ return size/2; /* kB for sysfs */
@ -1048,12 +1046,12 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
{ {
struct mdp_superblock_1 *sb; struct mdp_superblock_1 *sb;
int ret; int ret;
sector_t sb_offset; sector_t sb_start;
char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
int bmask; int bmask;
/* /*
* Calculate the position of the superblock. * Calculate the position of the superblock in 512byte sectors.
* It is always aligned to a 4K boundary and * It is always aligned to a 4K boundary and
* depeding on minor_version, it can be: * depeding on minor_version, it can be:
* 0: At least 8K, but less than 12K, from end of device * 0: At least 8K, but less than 12K, from end of device
@ -1062,22 +1060,20 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
*/ */
switch(minor_version) { switch(minor_version) {
case 0: case 0:
sb_offset = rdev->bdev->bd_inode->i_size >> 9; sb_start = rdev->bdev->bd_inode->i_size >> 9;
sb_offset -= 8*2; sb_start -= 8*2;
sb_offset &= ~(sector_t)(4*2-1); sb_start &= ~(sector_t)(4*2-1);
/* convert from sectors to K */
sb_offset /= 2;
break; break;
case 1: case 1:
sb_offset = 0; sb_start = 0;
break; break;
case 2: case 2:
sb_offset = 4; sb_start = 8;
break; break;
default: default:
return -EINVAL; return -EINVAL;
} }
rdev->sb_offset = sb_offset; rdev->sb_start = sb_start;
/* superblock is rarely larger than 1K, but it can be larger, /* superblock is rarely larger than 1K, but it can be larger,
* and it is safe to read 4k, so we do that * and it is safe to read 4k, so we do that
@ -1091,7 +1087,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
if (sb->magic != cpu_to_le32(MD_SB_MAGIC) || if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
sb->major_version != cpu_to_le32(1) || sb->major_version != cpu_to_le32(1) ||
le32_to_cpu(sb->max_dev) > (4096-256)/2 || le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) || le64_to_cpu(sb->super_offset) != rdev->sb_start ||
(le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0) (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
return -EINVAL; return -EINVAL;
@ -1127,7 +1123,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
rdev->sb_size = (rdev->sb_size | bmask) + 1; rdev->sb_size = (rdev->sb_size | bmask) + 1;
if (minor_version if (minor_version
&& rdev->data_offset < sb_offset + (rdev->sb_size/512)) && rdev->data_offset < sb_start + (rdev->sb_size/512))
return -EINVAL; return -EINVAL;
if (sb->level == cpu_to_le32(LEVEL_MULTIPATH)) if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
@ -1163,7 +1159,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
if (minor_version) if (minor_version)
rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2; rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
else else
rdev->size = rdev->sb_offset; rdev->size = rdev->sb_start / 2;
if (rdev->size < le64_to_cpu(sb->data_size)/2) if (rdev->size < le64_to_cpu(sb->data_size)/2)
return -EINVAL; return -EINVAL;
rdev->size = le64_to_cpu(sb->data_size)/2; rdev->size = le64_to_cpu(sb->data_size)/2;
@ -1350,7 +1346,7 @@ super_1_rdev_size_change(mdk_rdev_t *rdev, unsigned long long size)
if (size && size < rdev->mddev->size) if (size && size < rdev->mddev->size)
return 0; /* component must fit device */ return 0; /* component must fit device */
size *= 2; /* convert to sectors */ size *= 2; /* convert to sectors */
if (rdev->sb_offset < rdev->data_offset/2) { if (rdev->sb_start < rdev->data_offset) {
/* minor versions 1 and 2; superblock before data */ /* minor versions 1 and 2; superblock before data */
max_size = (rdev->bdev->bd_inode->i_size >> 9); max_size = (rdev->bdev->bd_inode->i_size >> 9);
max_size -= rdev->data_offset; max_size -= rdev->data_offset;
@ -1361,19 +1357,19 @@ super_1_rdev_size_change(mdk_rdev_t *rdev, unsigned long long size)
return 0; return 0;
} else { } else {
/* minor version 0; superblock after data */ /* minor version 0; superblock after data */
sector_t sb_offset; sector_t sb_start;
sb_offset = (rdev->bdev->bd_inode->i_size >> 9) - 8*2; sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
sb_offset &= ~(sector_t)(4*2 - 1); sb_start &= ~(sector_t)(4*2 - 1);
max_size = rdev->size*2 + sb_offset - rdev->sb_offset*2; max_size = rdev->size*2 + sb_start - rdev->sb_start;
if (!size || size > max_size) if (!size || size > max_size)
size = max_size; size = max_size;
rdev->sb_offset = sb_offset/2; rdev->sb_start = sb_start;
} }
sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page); sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
sb->data_size = cpu_to_le64(size); sb->data_size = cpu_to_le64(size);
sb->super_offset = rdev->sb_offset*2; sb->super_offset = rdev->sb_start;
sb->sb_csum = calc_sb_1_csum(sb); sb->sb_csum = calc_sb_1_csum(sb);
md_super_write(rdev->mddev, rdev, rdev->sb_offset << 1, rdev->sb_size, md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
rdev->sb_page); rdev->sb_page);
md_super_wait(rdev->mddev); md_super_wait(rdev->mddev);
return size/2; /* kB for sysfs */ return size/2; /* kB for sysfs */
@ -1810,11 +1806,11 @@ repeat:
dprintk("%s ", bdevname(rdev->bdev,b)); dprintk("%s ", bdevname(rdev->bdev,b));
if (!test_bit(Faulty, &rdev->flags)) { if (!test_bit(Faulty, &rdev->flags)) {
md_super_write(mddev,rdev, md_super_write(mddev,rdev,
rdev->sb_offset<<1, rdev->sb_size, rdev->sb_start, rdev->sb_size,
rdev->sb_page); rdev->sb_page);
dprintk(KERN_INFO "(write) %s's sb offset: %llu\n", dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
bdevname(rdev->bdev,b), bdevname(rdev->bdev,b),
(unsigned long long)rdev->sb_offset); (unsigned long long)rdev->sb_start);
rdev->sb_events = mddev->events; rdev->sb_events = mddev->events;
} else } else
@ -3577,16 +3573,16 @@ static int do_md_run(mddev_t * mddev)
* We don't want the data to overlap the metadata, * We don't want the data to overlap the metadata,
* Internal Bitmap issues has handled elsewhere. * Internal Bitmap issues has handled elsewhere.
*/ */
if (rdev->data_offset < rdev->sb_offset) { if (rdev->data_offset < rdev->sb_start) {
if (mddev->size && if (mddev->size &&
rdev->data_offset + mddev->size*2 rdev->data_offset + mddev->size*2
> rdev->sb_offset*2) { > rdev->sb_start) {
printk("md: %s: data overlaps metadata\n", printk("md: %s: data overlaps metadata\n",
mdname(mddev)); mdname(mddev));
return -EINVAL; return -EINVAL;
} }
} else { } else {
if (rdev->sb_offset*2 + rdev->sb_size/512 if (rdev->sb_start + rdev->sb_size/512
> rdev->data_offset) { > rdev->data_offset) {
printk("md: %s: metadata overlaps data\n", printk("md: %s: metadata overlaps data\n",
mdname(mddev)); mdname(mddev));
@ -4355,9 +4351,9 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
if (!mddev->persistent) { if (!mddev->persistent) {
printk(KERN_INFO "md: nonpersistent superblock ...\n"); printk(KERN_INFO "md: nonpersistent superblock ...\n");
rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS; rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
} else } else
rdev->sb_offset = calc_dev_sboffset(rdev->bdev) / 2; rdev->sb_start = calc_dev_sboffset(rdev->bdev);
rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2; rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
err = bind_rdev_to_array(rdev, mddev); err = bind_rdev_to_array(rdev, mddev);
@ -4424,10 +4420,9 @@ static int hot_add_disk(mddev_t * mddev, dev_t dev)
} }
if (mddev->persistent) if (mddev->persistent)
rdev->sb_offset = calc_dev_sboffset(rdev->bdev) / 2; rdev->sb_start = calc_dev_sboffset(rdev->bdev);
else else
rdev->sb_offset = rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2; rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
@ -4628,7 +4623,7 @@ static int update_size(mddev_t *mddev, sector_t num_sectors)
* linear and raid0 always use whatever space is available. We can only * linear and raid0 always use whatever space is available. We can only
* consider changing this number if no resync or reconstruction is * consider changing this number if no resync or reconstruction is
* happening, and if the new size is acceptable. It must fit before the * happening, and if the new size is acceptable. It must fit before the
* sb_offset or, if that is <data_offset, it must fit before the size * sb_start or, if that is <data_offset, it must fit before the size
* of each device. If num_sectors is zero, we find the largest size * of each device. If num_sectors is zero, we find the largest size
* that fits. * that fits.

2
include/linux/raid/md_k.h
View file

@ -59,7 +59,7 @@ struct mdk_rdev_s
int sb_loaded; int sb_loaded;
__u64 sb_events; __u64 sb_events;
sector_t data_offset; /* start of data in array */ sector_t data_offset; /* start of data in array */
sector_t sb_offset; sector_t sb_start; /* offset of the super block (in 512byte sectors) */
int sb_size; /* bytes in the superblock */ int sb_size; /* bytes in the superblock */
int preferred_minor; /* autorun support */ int preferred_minor; /* autorun support */