X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super1.c;h=b04945f51f3efbfff203e502f05ec9ebf94dfca5;hb=ba728be72f4b3f0b5cf56d19670a5cf117b0e373;hp=a18952a71e93e45199f6ac1d0a0dc3dc96aa3e42;hpb=d669228f295e4c695475f0c1f7dc52f514a177c4;p=thirdparty%2Fmdadm.git diff --git a/super1.c b/super1.c index a18952a7..b04945f5 100644 --- a/super1.c +++ b/super1.c @@ -89,6 +89,13 @@ struct mdp_superblock_1 { __u16 dev_roles[0]; /* role in array, or 0xffff for a spare, or 0xfffe for faulty */ }; +#define MAX_SB_SIZE 4096 +/* bitmap super size is 256, but we round up to a sector for alignment */ +#define BM_SUPER_SIZE 512 +#define MAX_DEVS ((int)(MAX_SB_SIZE - sizeof(struct mdp_superblock_1)) / 2) +#define SUPER1_SIZE (MAX_SB_SIZE + BM_SUPER_SIZE \ + + sizeof(struct misc_dev_info)) + struct misc_dev_info { __u64 device_size; }; @@ -135,8 +142,25 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb) return __cpu_to_le32(csum); } +/* + * Information related to file descriptor used for aligned reads/writes. + * Cache the block size. + */ +struct align_fd { + int fd; + int blk_sz; +}; + +static void init_afd(struct align_fd *afd, int fd) +{ + afd->fd = fd; + + if (ioctl(afd->fd, BLKSSZGET, &afd->blk_sz) != 0) + afd->blk_sz = 512; +} + static char abuf[4096+4096]; -static int aread(int fd, void *buf, int len) +static int aread(struct align_fd *afd, void *buf, int len) { /* aligned read. * On devices with a 4K sector size, we need to read @@ -146,26 +170,30 @@ static int aread(int fd, void *buf, int len) int bsize, iosize; char *b; int n; - if (ioctl(fd, BLKSSZGET, &bsize) != 0) - bsize = 512; - if (bsize > 4096 || len > 4096) + bsize = afd->blk_sz; + + if (!bsize || bsize > 4096 || len > 4096) { + if (!bsize) + fprintf(stderr, "WARNING - aread() called with " + "invalid block size\n"); return -1; - b = (char*)(((long)(abuf+4096))&~4095UL); + } + b = ROUND_UP_PTR((char *)abuf, 4096); for (iosize = 0; iosize < len; iosize += bsize) ; - n = read(fd, b, iosize); + n = read(afd->fd, b, iosize); if (n <= 0) return n; - lseek(fd, len - n, 1); + lseek(afd->fd, len - n, 1); if (n > len) n = len; memcpy(buf, b, n); return n; } -static int awrite(int fd, void *buf, int len) +static int awrite(struct align_fd *afd, void *buf, int len) { /* aligned write. * On devices with a 4K sector size, we need to write @@ -176,27 +204,31 @@ static int awrite(int fd, void *buf, int len) int bsize, iosize; char *b; int n; - if (ioctl(fd, BLKSSZGET, &bsize) != 0) - bsize = 512; - if (bsize > 4096 || len > 4096) + + bsize = afd->blk_sz; + if (!bsize || bsize > 4096 || len > 4096) { + if (!bsize) + fprintf(stderr, "WARNING - awrite() called with " + "invalid block size\n"); return -1; - b = (char*)(((long)(abuf+4096))&~4095UL); + } + b = ROUND_UP_PTR((char *)abuf, 4096); for (iosize = 0; iosize < len ; iosize += bsize) ; if (len != iosize) { - n = read(fd, b, iosize); + n = read(afd->fd, b, iosize); if (n <= 0) return n; - lseek(fd, -n, 1); + lseek(afd->fd, -n, 1); } memcpy(b, buf, len); - n = write(fd, b, iosize); + n = write(afd->fd, b, iosize); if (n <= 0) return n; - lseek(fd, len - n, 1); + lseek(afd->fd, len - n, 1); return len; } @@ -246,7 +278,7 @@ static void examine_super1(struct supertype *st, char *homehost) (unsigned long long)__le64_to_cpu(sb->data_size), human_size(__le64_to_cpu(sb->data_size)<<9)); if (__le32_to_cpu(sb->level) > 0) { - int ddsks=0; + int ddsks = 0, ddsks_denom = 1; switch(__le32_to_cpu(sb->level)) { case 1: ddsks=1;break; case 4: @@ -254,13 +286,15 @@ static void examine_super1(struct supertype *st, char *homehost) case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break; case 10: layout = __le32_to_cpu(sb->layout); - ddsks = __le32_to_cpu(sb->raid_disks) - / (layout&255) / ((layout>>8)&255); + ddsks = __le32_to_cpu(sb->raid_disks); + ddsks_denom = (layout&255) * ((layout>>8)&255); } - if (ddsks) + if (ddsks) { + long long asize = __le64_to_cpu(sb->size); + asize = (asize << 9) * ddsks / ddsks_denom; printf(" Array Size : %llu%s\n", - ddsks*(unsigned long long)__le64_to_cpu(sb->size), - human_size(ddsks*__le64_to_cpu(sb->size)<<9)); + asize >> 10, human_size(asize)); + } if (sb->size != sb->data_size) printf(" Used Dev Size : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->size), @@ -586,13 +620,13 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) info->data_offset = __le64_to_cpu(sb->data_offset); info->component_size = __le64_to_cpu(sb->size); if (sb->feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET)) - info->bitmap_offset = __le32_to_cpu(sb->bitmap_offset); + info->bitmap_offset = (int32_t)__le32_to_cpu(sb->bitmap_offset); info->disk.major = 0; info->disk.minor = 0; info->disk.number = __le32_to_cpu(sb->dev_number); if (__le32_to_cpu(sb->dev_number) >= __le32_to_cpu(sb->max_dev) || - __le32_to_cpu(sb->max_dev) > 512) + __le32_to_cpu(sb->dev_number) >= MAX_DEVS) role = 0xfffe; else role = __le16_to_cpu(sb->dev_roles[__le32_to_cpu(sb->dev_number)]); @@ -661,7 +695,7 @@ static struct mdinfo *container_content1(struct supertype *st, char *subarray) if (subarray) return NULL; - info = malloc(sizeof(*info)); + info = xmalloc(sizeof(*info)); getinfo_super1(st, info, NULL); return info; } @@ -775,7 +809,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info, if (__le32_to_cpu(sb->feature_map)&MD_FEATURE_BITMAP_OFFSET) { struct bitmap_super_s *bm; - bm = (struct bitmap_super_s*)(st->sb+1024); + bm = (struct bitmap_super_s*)(st->sb+MAX_SB_SIZE); memcpy(bm->uuid, sb->set_uuid, 16); } } else if (strcmp(update, "no-bitmap") == 0) { @@ -807,7 +841,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info, __le64_to_cpu(sb->data_offset)) { /* set data_size to device size less data_offset */ struct misc_dev_info *misc = (struct misc_dev_info*) - (st->sb + 1024 + 512); + (st->sb + MAX_SB_SIZE + BM_SUPER_SIZE); printf("Size was %llu\n", (unsigned long long) __le64_to_cpu(sb->data_size)); sb->data_size = __cpu_to_le64( @@ -834,14 +868,13 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, int spares; int rfd; char defname[10]; + int sbsize; - if (posix_memalign((void**)&sb, 512, (1024 + 512 + - sizeof(struct misc_dev_info))) != 0) { - fprintf(stderr, Name - ": %s could not allocate superblock\n", __func__); + if (posix_memalign((void**)&sb, 4096, SUPER1_SIZE) != 0) { + pr_err("%s could not allocate superblock\n", __func__); return 0; } - memset(sb, 0, 1024); + memset(sb, 0, SUPER1_SIZE); st->sb = sb; if (info == NULL) { @@ -850,9 +883,9 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, } spares = info->working_disks - info->active_disks; - if (info->raid_disks + spares > 384) { - fprintf(stderr, Name ": too many devices requested: %d+%d > %d\n", - info->raid_disks , spares, 384); + if (info->raid_disks + spares > MAX_DEVS) { + pr_err("too many devices requested: %d+%d > %d\n", + info->raid_disks , spares, MAX_DEVS); return 0; } @@ -876,7 +909,6 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, sprintf(defname, "%d", info->md_minor); name = defname; } - memset(sb->set_name, 0, 32); if (homehost && strchr(name, ':')== NULL && strlen(homehost)+1+strlen(name) < 32) { @@ -904,11 +936,11 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, sb->resync_offset = MaxSector; else sb->resync_offset = 0; - sb->max_dev = __cpu_to_le32((1024- sizeof(struct mdp_superblock_1))/ - sizeof(sb->dev_roles[0])); - memset(sb->pad3, 0, sizeof(sb->pad3)); + sbsize = sizeof(struct mdp_superblock_1) + 2 * (info->raid_disks + spares); + sbsize = ROUND_UP(sbsize, 512); + sb->max_dev = __cpu_to_le32((sbsize - sizeof(struct mdp_superblock_1)) / 2); - memset(sb->dev_roles, 0xff, 1024 - sizeof(struct mdp_superblock_1)); + memset(sb->dev_roles, 0xff, MAX_SB_SIZE - sizeof(struct mdp_superblock_1)); return 1; } @@ -936,7 +968,7 @@ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk, *rp = 0xfffe; if (dk->number >= (int)__le32_to_cpu(sb->max_dev) && - __le32_to_cpu(sb->max_dev) < 384) + __le32_to_cpu(sb->max_dev) < MAX_DEVS) sb->max_dev = __cpu_to_le32(dk->number+1); sb->dev_number = __cpu_to_le32(dk->number); @@ -946,7 +978,7 @@ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk, 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 = *dk; @@ -963,6 +995,7 @@ static int store_super1(struct supertype *st, int fd) { struct mdp_superblock_1 *sb = st->sb; unsigned long long sb_offset; + struct align_fd afd; int sbsize; unsigned long long dsize; @@ -974,6 +1007,8 @@ static int store_super1(struct supertype *st, int fd) if (dsize < 24) return 2; + init_afd(&afd, fd); + /* * Calculate the position of the superblock. * It is always aligned to a 4K boundary and @@ -1003,27 +1038,25 @@ static int store_super1(struct supertype *st, int fd) if (sb_offset != __le64_to_cpu(sb->super_offset) && 0 != __le64_to_cpu(sb->super_offset) ) { - fprintf(stderr, Name ": internal error - sb_offset is wrong\n"); + pr_err("internal error - sb_offset is wrong\n"); abort(); } if (lseek64(fd, sb_offset << 9, 0)< 0LL) return 3; - sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev); - sbsize = (sbsize+511)&(~511UL); + sbsize = ROUND_UP(sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev), 512); - if (awrite(fd, sb, sbsize) != sbsize) + if (awrite(&afd, sb, sbsize) != sbsize) return 4; if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) { struct bitmap_super_s *bm = (struct bitmap_super_s*) - (((char*)sb)+1024); + (((char*)sb)+MAX_SB_SIZE); if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) { locate_bitmap1(st, fd); - if (awrite(fd, bm, sizeof(*bm)) != - sizeof(*bm)) - return 5; + if (awrite(&afd, bm, sizeof(*bm)) != sizeof(*bm)) + return 5; } } fsync(fd); @@ -1060,15 +1093,15 @@ static int write_init_super1(struct supertype *st) unsigned long long reserved; struct devinfo *di; unsigned long long dsize, array_size; - unsigned long long sb_offset; + unsigned long long sb_offset, headroom; - for (di = st->info; di && ! rv ; di = di->next) { + for (di = st->info; di; di = di->next) { if (di->disk.state == 1) continue; if (di->fd < 0) continue; - while (Kill(di->devname, NULL, 0, 1, 1) == 0) + while (Kill(di->devname, NULL, 0, -1, 1) == 0) ; sb->dev_number = __cpu_to_le32(di->disk.number); @@ -1106,13 +1139,16 @@ static int write_init_super1(struct supertype *st) } free(refst); - if (!get_dev_size(di->fd, NULL, &dsize)) - return 1; + if (!get_dev_size(di->fd, NULL, &dsize)) { + rv = 1; + goto error_out; + } dsize >>= 9; if (dsize < 24) { close(di->fd); - return 2; + rv = 2; + goto error_out; } @@ -1130,6 +1166,14 @@ static int write_init_super1(struct supertype *st) /* work out how much space we left for a bitmap */ bm_space = choose_bm_space(array_size); + /* We try to leave 0.1% at the start for reshape + * operations, but limit this to 128Meg (0.1% of 10Gig) + * which is plenty for efficient reshapes + */ + headroom = 128 * 1024 * 2; + while (headroom << 10 > array_size) + headroom >>= 1; + switch(st->minor_version) { case 0: sb_offset = dsize; @@ -1144,11 +1188,15 @@ static int write_init_super1(struct supertype *st) case 1: sb->super_offset = __cpu_to_le64(0); reserved = bm_space + 4*2; + if (reserved < headroom) + reserved = headroom; + if (reserved + array_size > dsize) + reserved = dsize - array_size; /* Try for multiple of 1Meg so it is nicely aligned */ #define ONE_MEG (2*1024) - reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG; - if (reserved + __le64_to_cpu(sb->size) > dsize) - reserved = dsize - __le64_to_cpu(sb->size); + if (reserved > ONE_MEG) + reserved = (reserved/ONE_MEG) * ONE_MEG; + /* force 4K alignment */ reserved &= ~7ULL; @@ -1158,17 +1206,21 @@ static int write_init_super1(struct supertype *st) case 2: sb_offset = 4*2; sb->super_offset = __cpu_to_le64(4*2); - if (4*2 + 4*2 + bm_space + __le64_to_cpu(sb->size) + if (4*2 + 4*2 + bm_space + array_size > dsize) - bm_space = dsize - __le64_to_cpu(sb->size) + bm_space = dsize - array_size - 4*2 - 4*2; reserved = bm_space + 4*2 + 4*2; + if (reserved < headroom) + reserved = headroom; + if (reserved + array_size > dsize) + reserved = dsize - array_size; /* Try for multiple of 1Meg so it is nicely aligned */ #define ONE_MEG (2*1024) - reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG; - if (reserved + __le64_to_cpu(sb->size) > dsize) - reserved = dsize - __le64_to_cpu(sb->size); + if (reserved > ONE_MEG) + reserved = (reserved/ONE_MEG) * ONE_MEG; + /* force 4K alignment */ reserved &= ~7ULL; @@ -1176,22 +1228,27 @@ static int write_init_super1(struct supertype *st) sb->data_size = __cpu_to_le64(dsize - reserved); break; default: - return -EINVAL; + pr_err("Failed to write invalid " + "metadata format 1.%i to %s\n", + st->minor_version, di->devname); + rv = -EINVAL; + goto out; } - sb->sb_csum = calc_sb_1_csum(sb); rv = store_super1(st, di->fd); - if (rv) - fprintf(stderr, - Name ": failed to write superblock to %s\n", - di->devname); - if (rv == 0 && (__le32_to_cpu(sb->feature_map) & 1)) rv = st->ss->write_bitmap(st, di->fd); close(di->fd); di->fd = -1; + if (rv) + goto error_out; } +error_out: + if (rv) + pr_err("Failed to write metadata to %s\n", + di->devname); +out: return rv; } #endif @@ -1214,15 +1271,11 @@ static int compare_super1(struct supertype *st, struct supertype *tst) return 1; if (!first) { - if (posix_memalign((void**)&first, 512, - 1024 + 512 + - sizeof(struct misc_dev_info)) != 0) { - fprintf(stderr, Name - ": %s could not allocate superblock\n", __func__); + if (posix_memalign((void**)&first, 4096, SUPER1_SIZE) != 0) { + pr_err("%s could not allocate superblock\n", __func__); return 1; } - memcpy(first, second, 1024 + 512 + - sizeof(struct misc_dev_info)); + memcpy(first, second, SUPER1_SIZE); st->sb = first; return 0; } @@ -1247,9 +1300,12 @@ static int load_super1(struct supertype *st, int fd, char *devname) int uuid[4]; struct bitmap_super_s *bsb; struct misc_dev_info *misc; + struct align_fd afd; free_super1(st); + init_afd(&afd, fd); + if (st->ss == NULL || st->minor_version == -1) { int bestvers = -1; struct supertype tst; @@ -1276,7 +1332,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) int rv; tst.minor_version = bestvers; tst.ss = &super1; - tst.max_devs = 384; + tst.max_devs = MAX_DEVS; rv = load_super1(&tst, fd, devname); if (rv == 0) *st = tst; @@ -1290,7 +1346,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (dsize < 24) { if (devname) - fprintf(stderr, Name ": %s is too small for md: size is %llu sectors.\n", + pr_err("%s is too small for md: size is %llu sectors.\n", devname, dsize); return 1; } @@ -1324,22 +1380,20 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (lseek64(fd, sb_offset << 9, 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, 512, - 1024 + 512 + - sizeof(struct misc_dev_info)) != 0) { - fprintf(stderr, Name ": %s could not allocate superblock\n", + if (posix_memalign((void**)&super, 4096, SUPER1_SIZE) != 0) { + pr_err("%s could not allocate superblock\n", __func__); return 1; } - if (aread(fd, super, 1024) != 1024) { + if (aread(&afd, super, MAX_SB_SIZE) != MAX_SB_SIZE) { if (devname) - fprintf(stderr, Name ": Cannot read superblock on %s\n", + pr_err("Cannot read superblock on %s\n", devname); free(super); return 1; @@ -1347,7 +1401,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (__le32_to_cpu(super->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, __le32_to_cpu(super->magic)); free(super); return 2; @@ -1355,23 +1409,23 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (__le32_to_cpu(super->major_version) != 1) { 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, __le32_to_cpu(super->major_version)); free(super); return 2; } if (__le64_to_cpu(super->super_offset) != sb_offset) { if (devname) - fprintf(stderr, Name ": No superblock found on %s (super_offset is wrong)\n", + pr_err("No superblock found on %s (super_offset is wrong)\n", devname); free(super); return 2; } st->sb = super; - bsb = (struct bitmap_super_s *)(((char*)super)+1024); + bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE); - misc = (struct misc_dev_info*) (((char*)super)+1024+512); + misc = (struct misc_dev_info*) (((char*)super)+MAX_SB_SIZE+BM_SUPER_SIZE); misc->device_size = dsize; /* Now check on the bitmap superblock */ @@ -1382,8 +1436,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) * should get that written out. */ locate_bitmap1(st, fd); - if (aread(fd, ((char*)super)+1024, 512) - != 512) + if (aread(&afd, bsb, 512) != 512) goto no_bitmap; uuid_from_super1(st, uuid); @@ -1401,13 +1454,11 @@ static int load_super1(struct supertype *st, int fd, char *devname) static struct supertype *match_metadata_desc1(char *arg) { - struct supertype *st = malloc(sizeof(*st)); - if (!st) return st; + struct supertype *st = xcalloc(1, sizeof(*st)); - memset(st, 0, sizeof(*st)); st->container_dev = NoMdDev; st->ss = &super1; - st->max_devs = 384; + st->max_devs = MAX_DEVS; st->sb = NULL; /* leading zeros can be safely ignored. --detail generates them. */ while (*arg == '0') @@ -1458,7 +1509,7 @@ static __u64 avail_size1(struct supertype *st, __u64 devsize) else if (__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) { /* hot-add. allow for actual size of bitmap */ struct bitmap_super_s *bsb; - bsb = (struct bitmap_super_s *)(((char*)super)+1024); + bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE); devsize -= bitmap_sectors(bsb); } #endif @@ -1468,12 +1519,13 @@ static __u64 avail_size1(struct supertype *st, __u64 devsize) st->minor_version = 2; if (super == NULL && st->minor_version > 0) { /* haven't committed to a size yet, so allow some - * slack for alignment of data_offset. - * We haven't access to device details so allow - * 1 Meg if bigger than 1Gig + * slack for space for reshape. + * Limit slack to 128M, but aim for about 0.1% */ - if (devsize > 1024*1024*2) - devsize -= 1024*2; + unsigned long long headroom = 128*1024*2; + while ((headroom << 10) > devsize) + headroom >>= 1; + devsize -= headroom; } switch(st->minor_version) { case 0: @@ -1512,7 +1564,7 @@ add_internal_bitmap1(struct supertype *st, int room = 0; int creating = 0; struct mdp_superblock_1 *sb = st->sb; - bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + 1024); + bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MAX_SB_SIZE); int uuid[4]; if (__le64_to_cpu(sb->data_size) == 0) @@ -1598,7 +1650,7 @@ add_internal_bitmap1(struct supertype *st, offset = -room; } - sb->bitmap_offset = __cpu_to_le32(offset); + sb->bitmap_offset = (int32_t)__cpu_to_le32(offset); sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | MD_FEATURE_BITMAP_OFFSET); @@ -1639,10 +1691,13 @@ static void locate_bitmap1(struct supertype *st, int fd) static int write_bitmap1(struct supertype *st, int fd) { struct mdp_superblock_1 *sb = st->sb; - bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+1024); + bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+MAX_SB_SIZE); int rv = 0; void *buf; int towrite, n; + struct align_fd afd; + + init_afd(&afd, fd); locate_bitmap1(st, fd); @@ -1650,7 +1705,7 @@ static int write_bitmap1(struct supertype *st, int fd) return -ENOMEM; memset(buf, 0xff, 4096); - memcpy(buf, ((char*)sb)+1024, sizeof(bitmap_super_t)); + memcpy(buf, (char *)bms, sizeof(bitmap_super_t)); towrite = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9); towrite = (towrite+7) >> 3; /* bits to bytes */ @@ -1660,7 +1715,7 @@ static int write_bitmap1(struct supertype *st, int fd) n = towrite; if (n > 4096) n = 4096; - n = awrite(fd, buf, n); + n = awrite(&afd, buf, n); if (n > 0) towrite -= n; else @@ -1701,7 +1756,7 @@ static int validate_geometry1(struct supertype *st, int level, if (level == LEVEL_CONTAINER) { if (verbose) - fprintf(stderr, Name ": 1.x metadata does not support containers\n"); + pr_err("1.x metadata does not support containers\n"); return 0; } if (chunk && *chunk == UnSet) @@ -1713,7 +1768,7 @@ static int validate_geometry1(struct supertype *st, int level, fd = open(subdev, O_RDONLY|O_EXCL, 0); if (fd < 0) { if (verbose) - fprintf(stderr, Name ": super1.x cannot open %s: %s\n", + pr_err("super1.x cannot open %s: %s\n", subdev, strerror(errno)); return 0; }