if (subarray)
return NULL;
- info = malloc(sizeof(*info));
+ info = xmalloc(sizeof(*info));
getinfo_super0(st, info, NULL);
return info;
}
sb32+MD_SB_GENERIC_CONSTANT_WORDS+7+1,
(MD_SB_WORDS - (MD_SB_GENERIC_CONSTANT_WORDS+7+1))*4);
if (verbose >= 0)
- fprintf (stderr, Name ": adjusting superblock of %s for 2.2/sparc compatability.\n",
- devname);
+ pr_err("adjusting superblock of %s for 2.2/sparc compatibility.\n",
+ devname);
} else if (strcmp(update, "super-minor") ==0) {
sb->md_minor = info->array.md_minor;
if (verbose > 0)
- fprintf(stderr, Name ": updating superblock of %s with minor number %d\n",
+ pr_err("updating superblock of %s with minor number %d\n",
devname, info->array.md_minor);
} else if (strcmp(update, "summaries") == 0) {
unsigned int i;
static int init_super0(struct supertype *st, mdu_array_info_t *info,
unsigned long long size, char *ignored_name, char *homehost,
- int *uuid)
+ int *uuid, unsigned long long data_offset)
{
mdp_super_t *sb;
int spares;
+ if (data_offset != INVALID_SECTORS) {
+ fprintf(stderr, Name ": data-offset not support for 0.90\n");
+ return 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__);
+ pr_err("%s could not allocate superblock\n", __func__);
return 0;
}
memset(sb, 0, MD_SB_BYTES + sizeof(bitmap_super_t));
spares = info->working_disks - info->active_disks;
if (info->raid_disks + spares > MD_SB_DISKS) {
- fprintf(stderr, Name ": too many devices requested: %d+%d > %d\n",
+ pr_err("too many devices requested: %d+%d > %d\n",
info->raid_disks , spares, MD_SB_DISKS);
return 0;
}
sb->gvalid_words = 0; /* ignored */
sb->ctime = time(0);
sb->level = info->level;
- if (size != (unsigned long long)info->size)
+ sb->size = size;
+ if (size != (unsigned long long)sb->size)
return 0;
- sb->size = info->size;
sb->nr_disks = info->nr_disks;
sb->raid_disks = info->raid_disks;
sb->md_minor = info->md_minor;
if (rfd >= 0)
close(rfd);
}
- if (homehost) {
+ if (homehost && !uuid) {
char buf[20];
char *hash = sha1_buffer(homehost,
strlen(homehost),
#ifndef MDASSEMBLE
/* Add a device to the superblock being created */
static int add_to_super0(struct supertype *st, mdu_disk_info_t *dinfo,
- int fd, char *devname)
+ int fd, char *devname, unsigned long long data_offset)
{
mdp_super_t *sb = st->sb;
mdp_disk_t *dk = &sb->disks[dinfo->number];
dip = (struct devinfo **)&st->info;
while (*dip)
dip = &(*dip)->next;
- di = malloc(sizeof(struct devinfo));
+ di = xmalloc(sizeof(struct devinfo));
di->fd = fd;
di->devname = devname;
di->disk = *dinfo;
continue;
if (di->fd == -1)
continue;
- while (Kill(di->devname, NULL, 0, 1, 1) == 0)
+ while (Kill(di->devname, NULL, 0, -1, 1) == 0)
;
sb->disks[di->disk.number].state &= ~(1<<MD_DISK_FAULTY);
rv = st->ss->write_bitmap(st, di->fd);
if (rv)
- fprintf(stderr,
- Name ": failed to write superblock to %s\n",
- di->devname);
+ pr_err("failed to write superblock to %s\n",
+ di->devname);
}
return rv;
}
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__);
+ pr_err("%s could not allocate superblock\n", __func__);
return 1;
}
memcpy(first, second, MD_SB_BYTES + sizeof(struct bitmap_super_s));
if (dsize < MD_RESERVED_SECTORS*512) {
if (devname)
- fprintf(stderr, Name
- ": %s is too small for md: size is %llu sectors.\n",
- devname, dsize);
+ pr_err("%s is too small for md: size is %llu sectors.\n",
+ devname, dsize);
return 1;
}
if (lseek64(fd, offset, 0)< 0LL) {
if (devname)
- fprintf(stderr, Name ": Cannot seek to superblock on %s: %s\n",
+ pr_err("Cannot seek to superblock on %s: %s\n",
devname, strerror(errno));
return 1;
}
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__);
+ pr_err("%s could not allocate superblock\n", __func__);
return 1;
}
if (read(fd, super, sizeof(*super)) != MD_SB_BYTES) {
if (devname)
- fprintf(stderr, Name ": Cannot read superblock on %s\n",
+ pr_err("Cannot read superblock on %s\n",
devname);
free(super);
return 1;
if (super->md_magic != MD_SB_MAGIC) {
if (devname)
- fprintf(stderr, Name ": No super block found on %s (Expected magic %08x, got %08x)\n",
+ pr_err("No super block found on %s (Expected magic %08x, got %08x)\n",
devname, MD_SB_MAGIC, super->md_magic);
free(super);
return 2;
if (super->major_version != 0) {
if (devname)
- fprintf(stderr, Name ": Cannot interpret superblock on %s - version is %d\n",
+ pr_err("Cannot interpret superblock on %s - version is %d\n",
devname, super->major_version);
free(super);
return 2;
static struct supertype *match_metadata_desc0(char *arg)
{
- struct supertype *st = calloc(1, sizeof(*st));
- if (!st)
- return st;
+ struct supertype *st = xcalloc(1, sizeof(*st));
st->container_dev = NoMdDev;
st->ss = &super0;
return NULL;
}
-static __u64 avail_size0(struct supertype *st, __u64 devsize)
+static __u64 avail_size0(struct supertype *st, __u64 devsize,
+ unsigned long long data_offset)
{
+ if (data_offset != 0 && data_offset != INVALID_SECTORS)
+ return 0ULL;
if (devsize < MD_RESERVED_SECTORS)
return 0ULL;
return MD_NEW_SIZE_SECTORS(devsize);
static int validate_geometry0(struct supertype *st, int level,
int layout, int raiddisks,
int *chunk, unsigned long long size,
+ unsigned long long data_offset,
char *subdev, unsigned long long *freesize,
int verbose)
{
if (level == LEVEL_CONTAINER) {
if (verbose)
- fprintf(stderr, Name ": 0.90 metadata does not support containers\n");
+ pr_err("0.90 metadata does not support containers\n");
return 0;
}
if (raiddisks > MD_SB_DISKS) {
if (verbose)
- fprintf(stderr, Name ": 0.90 metadata supports at most %d devices per array\n",
+ pr_err("0.90 metadata supports at most %d devices per array\n",
MD_SB_DISKS);
return 0;
}
if (size >= tbmax * 2ULL*1024*1024*1024) {
if (verbose)
- fprintf(stderr, Name ": 0.90 metadata supports at most "
- "%d terabytes per device\n", tbmax);
+ pr_err("0.90 metadata supports at most "
+ "%d terabytes per device\n", tbmax);
return 0;
}
if (chunk && *chunk == UnSet)
fd = open(subdev, O_RDONLY|O_EXCL, 0);
if (fd < 0) {
if (verbose)
- fprintf(stderr, Name ": super0.90 cannot open %s: %s\n",
+ pr_err("super0.90 cannot open %s: %s\n",
subdev, strerror(errno));
return 0;
}