/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Neil Brown
- * Email: <neilb@cse.unsw.edu.au>
- * Paper: Neil Brown
- * School of Computer Science and Engineering
- * The University of New South Wales
- * Sydney, 2052
- * Australia
+ * Email: <neilb@suse.de>
*/
#define HAVE_STDINT_H 1
mdp_super_t *sb = st->sb;
time_t atime;
int d;
+ int delta_extra = 0;
char *c;
printf(" Magic : %08x\n", sb->md_magic);
printf(" Reshape pos'n : %llu%s\n", (unsigned long long)sb->reshape_position/2, human_size((long long)sb->reshape_position<<9));
if (sb->delta_disks) {
printf(" Delta Devices : %d", sb->delta_disks);
- if (sb->delta_disks)
- printf(" (%d->%d)\n", sb->raid_disks-sb->delta_disks, sb->raid_disks);
- else
- printf(" (%d->%d)\n", sb->raid_disks, sb->raid_disks+sb->delta_disks);
+ printf(" (%d->%d)\n", sb->raid_disks-sb->delta_disks, sb->raid_disks);
+ if (((int)sb->delta_disks) < 0)
+ delta_extra = - sb->delta_disks;
}
if (sb->new_level != sb->level) {
c = map_num(pers, sb->new_level);
c = map_num(r5layout, sb->new_layout);
printf(" New Layout : %s\n", c?c:"-unknown-");
}
+ if (sb->level == 6) {
+ c = map_num(r6layout, sb->new_layout);
+ printf(" New Layout : %s\n", c?c:"-unknown-");
+ }
if (sb->level == 10) {
printf(" New Layout : near=%d, %s=%d\n",
sb->new_layout&255,
c = map_num(r5layout, sb->layout);
printf(" Layout : %s\n", c?c:"-unknown-");
}
+ if (sb->level == 6) {
+ c = map_num(r6layout, sb->layout);
+ printf(" Layout : %s\n", c?c:"-unknown-");
+ }
if (sb->level == 10) {
printf(" Layout :");
print_r10_layout(sb->layout);
}
printf("\n");
printf(" Number Major Minor RaidDevice State\n");
- for (d= -1; d<(signed int)(sb->raid_disks+sb->spare_disks); d++) {
+ for (d= -1; d<(signed int)(sb->raid_disks+delta_extra + sb->spare_disks); d++) {
mdp_disk_t *dp;
char *dv;
char nb[5];
}
}
-static void brief_examine_super0(struct supertype *st)
+static void brief_examine_super0(struct supertype *st, int verbose)
{
mdp_super_t *sb = st->sb;
char *c=map_num(pers, sb->level);
sprintf(devname, "/dev/md%d", sb->md_minor);
- printf("ARRAY %s level=%s num-devices=%d UUID=",
- devname,
- c?c:"-unknown-", sb->raid_disks);
+ if (verbose) {
+ printf("ARRAY %s level=%s num-devices=%d",
+ devname,
+ c?c:"-unknown-", sb->raid_disks);
+ } else
+ printf("ARRAY %s", devname);
+
if (sb->minor_version >= 90)
- printf("%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
+ printf(" UUID=%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
sb->set_uuid2, sb->set_uuid3);
else
- printf("%08x", sb->set_uuid0);
+ printf(" UUID=%08x", sb->set_uuid0);
printf("\n");
}
{
mdp_super_t *sb = st->sb;
char buf[20];
- char *hash = sha1_buffer(homehost,
- strlen(homehost),
- buf);
+ char *hash;
+
+ if (!homehost)
+ return 0;
+ hash = sha1_buffer(homehost,
+ strlen(homehost),
+ buf);
return (memcmp(&sb->set_uuid2, hash, 8)==0);
}
info->delta_disks = sb->delta_disks;
info->new_layout = sb->new_layout;
info->new_chunk = sb->new_chunk;
+ if (info->delta_disks < 0)
+ info->array.raid_disks -= info->delta_disks;
} else
info->reshape_active = 0;
if (strcmp(update, "assemble")==0) {
int d = info->disk.number;
int wonly = sb->disks[d].state & (1<<MD_DISK_WRITEMOSTLY);
- if ((sb->disks[d].state & ~(1<<MD_DISK_WRITEMOSTLY))
+ int mask = (1<<MD_DISK_WRITEMOSTLY);
+ int add = 0;
+ if (sb->minor_version >= 91)
+ /* During reshape we don't insist on everything
+ * being marked 'sync'
+ */
+ add = (1<<MD_DISK_SYNC);
+ if (((sb->disks[d].state & ~mask) | add)
!= info->disk.state) {
sb->disks[d].state = info->disk.state | wonly;
rv = 1;
mdp_super_t *sb;
int spares;
- if (posix_memalign((void**)&sb, 512, MD_SB_BYTES + sizeof(bitmap_super_t)) != 0) {
+ if (posix_memalign((void**)&sb, 4096,
+ MD_SB_BYTES + ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
fprintf(stderr, Name ": %s could not allocate superblock\n", __func__);
return 0;
}
if (super->state & (1<<MD_SB_BITMAP_PRESENT)) {
struct bitmap_super_s * bm = (struct bitmap_super_s*)(super+1);
if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC)
- if (write(fd, bm, ROUND_UP(sizeof(*bm),512)) !=
- ROUND_UP(sizeof(*bm),512))
+ if (write(fd, bm, ROUND_UP(sizeof(*bm),4096)) !=
+ ROUND_UP(sizeof(*bm),4096))
return 5;
}
if (second->md_magic != MD_SB_MAGIC)
return 1;
if (!first) {
- if (posix_memalign((void**)&first, 512,
- MD_SB_BYTES + sizeof(struct bitmap_super_s)) != 0) {
+ if (posix_memalign((void**)&first, 4096,
+ MD_SB_BYTES +
+ ROUND_UP(sizeof(struct bitmap_super_s), 4096)) != 0) {
fprintf(stderr, Name
": %s could not allocate superblock\n", __func__);
return 1;
return 1;
}
- if (posix_memalign((void**)&super, 512,
- MD_SB_BYTES + sizeof(bitmap_super_t)+512) != 0) {
+ if (posix_memalign((void**)&super, 4096,
+ MD_SB_BYTES +
+ ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
fprintf(stderr, Name
": %s could not allocate superblock\n", __func__);
return 1;
* valid. If it doesn't clear the bit. An --assemble --force
* should get that written out.
*/
- if (read(fd, super+1, ROUND_UP(sizeof(struct bitmap_super_s),512))
- != ROUND_UP(sizeof(struct bitmap_super_s),512))
+ if (read(fd, super+1, ROUND_UP(sizeof(struct bitmap_super_s),4096))
+ != ROUND_UP(sizeof(struct bitmap_super_s),4096))
goto no_bitmap;
uuid_from_super0(st, uuid);
int rv = 0;
int towrite, n;
- char abuf[4096+512];
- char *buf = (char*)(((long)(abuf+512))&~511UL);
+ char abuf[4096+4096];
+ char *buf = (char*)(((long)(abuf+4096))&~4095L);
if (!get_dev_size(fd, NULL, &dsize))
return 1;
return 0;
if (raiddisks > MD_SB_DISKS)
return 0;
- if (size > (0x7fffffffULL<<10))
+ if (size > (0x7fffffffULL<<9))
return 0;
if (!subdev)
return 1;
if (ldsize < MD_RESERVED_SECTORS * 512)
return 0;
- if (size > (0x7fffffffULL<<10))
+ if (size > (0x7fffffffULL<<9))
return 0;
*freesize = MD_NEW_SIZE_SECTORS(ldsize >> 9);
return 1;
projects / thirdparty / mdadm.git / blobdiff