X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super-ddf.c;h=faaf0a7ca9e0ba5eed7e8fdd961fcb43d158ee7d;hb=50d72ed4298618c679efd43647dd055527e59b10;hp=58d00fdda064393d2d8a18552779f49e52139e33;hpb=476066a3d54d9ff258586115c987d20da7eb2c53;p=thirdparty%2Fmdadm.git diff --git a/super-ddf.c b/super-ddf.c index 58d00fdd..faaf0a7c 100644 --- a/super-ddf.c +++ b/super-ddf.c @@ -30,6 +30,7 @@ #include "mdmon.h" #include "sha1.h" #include +#include /* a non-official T10 name for creation GUIDs */ static char T10[] = "Linux-MD"; @@ -536,23 +537,19 @@ static int init_super_ddf_bvd(struct supertype *st, char *name, char *homehost, int *uuid, unsigned long long data_offset); -#ifndef offsetof -#define offsetof(t,f) ((size_t)&(((t*)0)->f)) -#endif - #if DEBUG static void pr_state(struct ddf_super *ddf, const char *msg) { unsigned int i; - dprintf("%s/%s: ", __func__, msg); + dprintf("%s: ", msg); for (i = 0; i < be16_to_cpu(ddf->active->max_vd_entries); i++) { if (all_ff(ddf->virt->entries[i].guid)) continue; - dprintf("%u(s=%02x i=%02x) ", i, + dprintf_cont("%u(s=%02x i=%02x) ", i, ddf->virt->entries[i].state, ddf->virt->entries[i].init_state); } - dprintf("\n"); + dprintf_cont("\n"); } #else static void pr_state(const struct ddf_super *ddf, const char *msg) {} @@ -828,11 +825,11 @@ static int load_ddf_header(int fd, unsigned long long lba, return 0; if (!be32_eq(hdr->magic, DDF_HEADER_MAGIC)) { - pr_err("%s: bad header magic\n", __func__); + pr_err("bad header magic\n"); return 0; } if (!be32_eq(calc_crc(hdr, 512), hdr->crc)) { - pr_err("%s: bad CRC\n", __func__); + pr_err("bad CRC\n"); return 0; } if (memcmp(anchor->guid, hdr->guid, DDF_GUID_LEN) != 0 || @@ -842,7 +839,7 @@ static int load_ddf_header(int fd, unsigned long long lba, hdr->type != type || memcmp(anchor->pad2, hdr->pad2, 512 - offsetof(struct ddf_header, pad2)) != 0) { - pr_err("%s: header mismatch\n", __func__); + pr_err("header mismatch\n"); return 0; } @@ -921,8 +918,7 @@ static int load_ddf_headers(int fd, struct ddf_super *super, char *devname) if (memcmp(super->anchor.revision, DDF_REVISION_0, 8) != 0 && memcmp(super->anchor.revision, DDF_REVISION_2, 8) != 0) { if (devname) - pr_err("can only support super revision" - " %.8s and earlier, not %.8s on %s\n", + pr_err("can only support super revision %.8s and earlier, not %.8s on %s\n", DDF_REVISION_2, super->anchor.revision,devname); return 2; } @@ -931,8 +927,7 @@ static int load_ddf_headers(int fd, struct ddf_super *super, char *devname) dsize >> 9, 1, &super->primary, &super->anchor) == 0) { if (devname) - pr_err("Failed to load primary DDF header " - "on %s\n", devname); + pr_err("Failed to load primary DDF header on %s\n", devname); } else super->active = &super->primary; @@ -1058,8 +1053,7 @@ static int load_ddf_local(int fd, struct ddf_super *super, if (posix_memalign((void**)&dl, 512, sizeof(*dl) + (super->max_part) * sizeof(dl->vlist[0])) != 0) { - pr_err("%s could not allocate disk info buffer\n", - __func__); + pr_err("could not allocate disk info buffer\n"); return 1; } @@ -1119,8 +1113,7 @@ static int load_ddf_local(int fd, struct ddf_super *super, continue; if (posix_memalign((void**)&dl->spare, 512, super->conf_rec_len*512) != 0) { - pr_err("%s could not allocate spare info buf\n", - __func__); + pr_err("could not allocate spare info buf\n"); return 1; } @@ -1151,16 +1144,14 @@ static int load_ddf_local(int fd, struct ddf_super *super, if (posix_memalign((void**)&vcl, 512, (super->conf_rec_len*512 + offsetof(struct vcl, conf))) != 0) { - pr_err("%s could not allocate vcl buf\n", - __func__); + pr_err("could not allocate vcl buf\n"); return 1; } vcl->next = super->conflist; vcl->block_sizes = NULL; /* FIXME not for CONCAT */ vcl->conf.sec_elmnt_count = vd->sec_elmnt_count; if (alloc_other_bvds(super, vcl) != 0) { - pr_err("%s could not allocate other bvds\n", - __func__); + pr_err("could not allocate other bvds\n"); free(vcl); return 1; }; @@ -1196,15 +1187,13 @@ static int load_super_ddf(struct supertype *st, int fd, /* 32M is a lower bound */ if (dsize <= 32*1024*1024) { if (devname) - pr_err("%s is too small for ddf: " - "size is %llu sectors.\n", + pr_err("%s is too small for ddf: size is %llu sectors.\n", devname, dsize>>9); return 1; } if (dsize & 511) { if (devname) - pr_err("%s is an odd size for ddf: " - "size is %llu bytes.\n", + pr_err("%s is an odd size for ddf: size is %llu bytes.\n", devname, dsize); return 1; } @@ -1230,8 +1219,7 @@ static int load_super_ddf(struct supertype *st, int fd, if (rv) { if (devname) - pr_err("Failed to load all information " - "sections on %s\n", devname); + pr_err("Failed to load all information sections on %s\n", devname); free(super); return rv; } @@ -1240,8 +1228,7 @@ static int load_super_ddf(struct supertype *st, int fd, if (rv) { if (devname) - pr_err("Failed to load all information " - "sections on %s\n", devname); + pr_err("Failed to load all information sections on %s\n", devname); free(super); return rv; } @@ -1461,6 +1448,7 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid) printf("%d", j); else printf("--"); + printf("@%lluK", (unsigned long long) be64_to_cpu(LBA_OFFSET(sb, vc)[i])/2); } printf(")\n"); if (vc->chunk_shift != 255) @@ -1760,6 +1748,7 @@ static void detail_super_ddf(struct supertype *st, char *homehost) printf(" Virtual Disks : %d\n", cnt); printf("\n"); } +#endif static const char *vendors_with_variable_volume_UUID[] = { "LSI ", @@ -1806,6 +1795,7 @@ static void uuid_of_ddf_subarray(const struct ddf_super *ddf, memcpy(uuid, sha, 4*4); } +#ifndef MDASSEMBLE static void brief_detail_super_ddf(struct supertype *st) { struct mdinfo info; @@ -1865,8 +1855,8 @@ static int find_index_in_bvd(const struct ddf_super *ddf, j++; } } - dprintf("%s: couldn't find BVD member %u (total %u)\n", - __func__, n, be16_to_cpu(conf->prim_elmnt_count)); + dprintf("couldn't find BVD member %u (total %u)\n", + n, be16_to_cpu(conf->prim_elmnt_count)); return 0; } @@ -1897,8 +1887,8 @@ static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst, goto bad; } if (v->other_bvds == NULL) { - pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n", - __func__, conf->sec_elmnt_count); + pr_err("BUG: other_bvds is NULL, nsec=%u\n", + conf->sec_elmnt_count); goto bad; } nsec = n / be16_to_cpu(conf->prim_elmnt_count); @@ -1915,13 +1905,13 @@ static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst, if (!find_index_in_bvd(ddf, conf, n - nsec*conf->sec_elmnt_count, n_bvd)) goto bad; - dprintf("%s: found disk %u as member %u in bvd %d of array %u\n" - , __func__, n, *n_bvd, ibvd, inst); + dprintf("found disk %u as member %u in bvd %d of array %u\n", + n, *n_bvd, ibvd, inst); *vcl = v; return conf; } bad: - pr_err("%s: Could't find disk %d in array %u\n", __func__, n, inst); + pr_err("Could't find disk %d in array %u\n", n, inst); return NULL; } #endif @@ -2076,7 +2066,7 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha int cd = ddf->currentdev; int n_prim; int j; - struct dl *dl; + struct dl *dl = NULL; int map_disks = info->array.raid_disks; __u32 *cptr; struct vd_config *conf; @@ -2342,7 +2332,7 @@ static int init_super_ddf(struct supertype *st, data_offset); if (posix_memalign((void**)&ddf, 512, sizeof(*ddf)) != 0) { - pr_err("%s could not allocate superblock\n", __func__); + pr_err("could not allocate superblock\n"); return 0; } memset(ddf, 0, sizeof(*ddf)); @@ -2477,7 +2467,7 @@ static int init_super_ddf(struct supertype *st, strcpy((char*)ddf->controller.vendor_data, homehost); if (posix_memalign((void**)&pd, 512, pdsize) != 0) { - pr_err("%s could not allocate pd\n", __func__); + pr_err("could not allocate pd\n"); return 0; } ddf->phys = pd; @@ -2493,7 +2483,7 @@ static int init_super_ddf(struct supertype *st, memset(pd->entries[i].guid, 0xff, DDF_GUID_LEN); if (posix_memalign((void**)&vd, 512, vdsize) != 0) { - pr_err("%s could not allocate vd\n", __func__); + pr_err("could not allocate vd\n"); return 0; } ddf->virt = vd; @@ -2672,7 +2662,7 @@ static int init_super_ddf_bvd(struct supertype *st, /* Now create a new vd_config */ if (posix_memalign((void**)&vcl, 512, (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512)) != 0) { - pr_err("%s could not allocate vd_config\n", __func__); + pr_err("could not allocate vd_config\n"); return 0; } vcl->vcnum = venum; @@ -2687,15 +2677,14 @@ static int init_super_ddf_bvd(struct supertype *st, vc->chunk_shift = chunk_to_shift(info->chunk_size); if (layout_md2ddf(info, vc) == -1 || be16_to_cpu(vc->prim_elmnt_count) > ddf->mppe) { - pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n", - __func__, info->level, info->layout, info->raid_disks); + pr_err("unsupported RAID level/layout %d/%d with %d disks\n", + info->level, info->layout, info->raid_disks); free(vcl); return 0; } vc->sec_elmnt_seq = 0; if (alloc_other_bvds(ddf, vcl) != 0) { - pr_err("%s could not allocate other bvds\n", - __func__); + pr_err("could not allocate other bvds\n"); free(vcl); return 0; } @@ -2814,8 +2803,8 @@ static void add_to_super_ddf_bvd(struct supertype *st, cpu_to_be16(DDF_Global_Spare)); be16_set(ddf->phys->entries[dl->pdnum].type, cpu_to_be16(DDF_Active_in_VD)); - dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n", - __func__, dl->pdnum, be32_to_cpu(dl->disk.refnum), + dprintf("added disk %d/%08x to VD %d/%s as disk %d\n", + dl->pdnum, be32_to_cpu(dl->disk.refnum), ddf->currentconf->vcnum, guid_str(vc->guid), dk->raid_disk); ddf_set_updates_pending(ddf, vc); @@ -2846,14 +2835,15 @@ static void _set_config_size(struct phys_disk_entry *pde, const struct dl *dl) if (t < cfs) { __u64 wsp = cfs - t; if (wsp > 1024*1024*2ULL && wsp > dl->size / 16) { - pr_err("%s: %x:%x: workspace size 0x%llx too big, ignoring\n", - __func__, dl->major, dl->minor, wsp); + pr_err("%x:%x: workspace size 0x%llx too big, ignoring\n", + dl->major, dl->minor, (unsigned long long)wsp); } else cfs = t; } pde->config_size = cpu_to_be64(cfs); - dprintf("%s: %x:%x config_size %llx, DDF structure is %llx blocks\n", - __func__, dl->major, dl->minor, cfs, dl->size-cfs); + dprintf("%x:%x config_size %llx, DDF structure is %llx blocks\n", + dl->major, dl->minor, + (unsigned long long)cfs, (unsigned long long)(dl->size-cfs)); } /* Add a device to a container, either while creating it or while @@ -2884,23 +2874,20 @@ static int add_to_super_ddf(struct supertype *st, fstat(fd, &stb); n = find_unused_pde(ddf); if (n == DDF_NOTFOUND) { - pr_err("%s: No free slot in array, cannot add disk\n", - __func__); + pr_err("No free slot in array, cannot add disk\n"); return 1; } pde = &ddf->phys->entries[n]; get_dev_size(fd, NULL, &size); if (size <= 32*1024*1024) { - pr_err("%s: device size must be at least 32MB\n", - __func__); + pr_err("device size must be at least 32MB\n"); return 1; } size >>= 9; if (posix_memalign((void**)&dd, 512, sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part) != 0) { - pr_err("%s could allocate buffer for new disk, aborting\n", - __func__); + pr_err("could allocate buffer for new disk, aborting\n"); return 1; } dd->major = major(stb.st_rdev); @@ -3171,6 +3158,7 @@ static int _write_super_to_disk(struct ddf_super *ddf, struct dl *d) memcpy(&ddf->primary, &ddf->anchor, 512); memcpy(&ddf->secondary, &ddf->anchor, 512); + ddf->anchor.type = DDF_HEADER_ANCHOR; ddf->anchor.openflag = 0xFF; /* 'open' means nothing */ ddf->anchor.seq = cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */ ddf->anchor.crc = calc_crc(&ddf->anchor, 512); @@ -3258,13 +3246,15 @@ static int write_init_super_ddf(struct supertype *st) len); append_metadata_update(st, vc, tlen); - /* FIXME I need to close the fds! */ return 0; } else { struct dl *d; if (!currentconf) for (d = ddf->dlist; d; d=d->next) while (Kill(d->devname, NULL, 0, -1, 1) == 0); + /* Note: we don't close the fd's now, but a subsequent + * ->free_super() will + */ return __write_init_super_ddf(st); } } @@ -3432,19 +3422,10 @@ static int validate_geometry_ddf(struct supertype *st, */ fd = open(dev, O_RDONLY|O_EXCL, 0); if (fd >= 0) { - sra = sysfs_read(fd, NULL, GET_VERSION); close(fd); - if (sra && sra->array.major_version == -1 && - strcmp(sra->text_version, "ddf") == 0) { - /* load super */ - /* find space for 'n' devices. */ - /* remember the devices */ - /* Somehow return the fact that we have enough */ - } - + /* Just a bare device, no good to us */ if (verbose) - pr_err("ddf: Cannot create this array " - "on device %s - a container is required.\n", + pr_err("ddf: Cannot create this array on device %s - a container is required.\n", dev); return 0; } @@ -3560,8 +3541,7 @@ static int validate_geometry_ddf_bvd(struct supertype *st, } if (dcnt < raiddisks) { if (verbose) - pr_err("ddf: Not enough devices with " - "space for this array (%d < %d)\n", + pr_err("ddf: Not enough devices with space for this array (%d < %d)\n", dcnt, raiddisks); return 0; } @@ -3579,15 +3559,13 @@ static int validate_geometry_ddf_bvd(struct supertype *st, } if (!dl) { if (verbose) - pr_err("ddf: %s is not in the " - "same DDF set\n", + pr_err("ddf: %s is not in the same DDF set\n", dev); return 0; } maxsize = ULLONG_MAX; find_space(ddf, dl, data_offset, &maxsize); *freesize = maxsize; - // FIXME here I am return 1; } @@ -3736,7 +3714,7 @@ static int check_secondary(const struct vcl *vc) } for (i = 0; i < conf->sec_elmnt_count; i++) { if (!__was_sec_seen(i)) { - pr_err("BVD %d is missing\n", i); + /* pr_err("BVD %d is missing\n", i); */ return -1; } } @@ -3930,8 +3908,7 @@ static int store_super_ddf(struct supertype *st, int fd) int ofd, ret; if (fstat(fd, &sta) == -1 || !S_ISBLK(sta.st_mode)) { - pr_err("%s: file descriptor for invalid device\n", - __func__); + pr_err("file descriptor for invalid device\n"); return 1; } for (dl = ddf->dlist; dl; dl = dl->next) @@ -3939,7 +3916,7 @@ static int store_super_ddf(struct supertype *st, int fd) dl->minor == (int)minor(sta.st_rdev)) break; if (!dl) { - pr_err("%s: couldn't find disk %d/%d\n", __func__, + pr_err("couldn't find disk %d/%d\n", (int)major(sta.st_rdev), (int)minor(sta.st_rdev)); return 1; @@ -3993,7 +3970,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) */ if (!be32_eq(first->active->seq, second->active->seq)) { - dprintf("%s: sequence number mismatch %u<->%u\n", __func__, + dprintf("sequence number mismatch %u<->%u\n", be32_to_cpu(first->active->seq), be32_to_cpu(second->active->seq)); return 0; @@ -4015,7 +3992,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) if (vl1->other_bvds != NULL && vl1->conf.sec_elmnt_seq != vl2->conf.sec_elmnt_seq) { - dprintf("%s: adding BVD %u\n", __func__, + dprintf("adding BVD %u\n", vl2->conf.sec_elmnt_seq); add_other_bvd(vl1, &vl2->conf, first->conf_rec_len*512); @@ -4026,8 +4003,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) if (posix_memalign((void **)&vl1, 512, (first->conf_rec_len*512 + offsetof(struct vcl, conf))) != 0) { - pr_err("%s could not allocate vcl buf\n", - __func__); + pr_err("could not allocate vcl buf\n"); return 3; } @@ -4035,8 +4011,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) vl1->block_sizes = NULL; memcpy(&vl1->conf, &vl2->conf, first->conf_rec_len*512); if (alloc_other_bvds(first, vl1) != 0) { - pr_err("%s could not allocate other bvds\n", - __func__); + pr_err("could not allocate other bvds\n"); free(vl1); return 3; } @@ -4045,7 +4020,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) vl1->conf.guid, DDF_GUID_LEN)) break; vl1->vcnum = vd; - dprintf("%s: added config for VD %u\n", __func__, vl1->vcnum); + dprintf("added config for VD %u\n", vl1->vcnum); first->conflist = vl1; } @@ -4059,8 +4034,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) if (posix_memalign((void **)&dl1, 512, sizeof(*dl1) + (first->max_part) * sizeof(dl1->vlist[0])) != 0) { - pr_err("%s could not allocate disk info buffer\n", - __func__); + pr_err("could not allocate disk info buffer\n"); return 3; } memcpy(dl1, dl2, sizeof(*dl1)); @@ -4075,8 +4049,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) if (dl2->spare) { if (posix_memalign((void **)&dl1->spare, 512, first->conf_rec_len*512) != 0) { - pr_err("%s could not allocate spare info buf\n", - __func__); + pr_err("could not allocate spare info buf\n"); return 3; } memcpy(dl1->spare, dl2->spare, first->conf_rec_len*512); @@ -4095,7 +4068,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) } } first->dlist = dl1; - dprintf("%s: added disk %d: %08x\n", __func__, dl1->pdnum, + dprintf("added disk %d: %08x\n", dl1->pdnum, be32_to_cpu(dl1->disk.refnum)); } @@ -4118,10 +4091,10 @@ static int ddf_open_new(struct supertype *c, struct active_array *a, char *inst) static const char faulty[] = "faulty"; if (all_ff(ddf->virt->entries[n].guid)) { - pr_err("%s: subarray %d doesn't exist\n", __func__, n); + pr_err("subarray %d doesn't exist\n", n); return -ENODEV; } - dprintf("%s: new subarray %d, GUID: %s\n", __func__, n, + dprintf("new subarray %d, GUID: %s\n", n, guid_str(ddf->virt->entries[n].guid)); for (dev = a->info.devs; dev; dev = dev->next) { for (dl = ddf->dlist; dl; dl = dl->next) @@ -4129,16 +4102,15 @@ static int ddf_open_new(struct supertype *c, struct active_array *a, char *inst) dl->minor == dev->disk.minor) break; if (!dl || dl->pdnum < 0) { - pr_err("%s: device %d/%d of subarray %d not found in meta data\n", - __func__, dev->disk.major, dev->disk.minor, n); + pr_err("device %d/%d of subarray %d not found in meta data\n", + dev->disk.major, dev->disk.minor, n); return -1; } if ((be16_to_cpu(ddf->phys->entries[dl->pdnum].state) & (DDF_Online|DDF_Missing|DDF_Failed)) != DDF_Online) { - pr_err("%s: new subarray %d contains broken device %d/%d (%02x)\n", - __func__, n, dl->major, dl->minor, - be16_to_cpu( - ddf->phys->entries[dl->pdnum].state)); + pr_err("new subarray %d contains broken device %d/%d (%02x)\n", + n, dl->major, dl->minor, + be16_to_cpu(ddf->phys->entries[dl->pdnum].state)); if (write(dev->state_fd, faulty, sizeof(faulty)-1) != sizeof(faulty) - 1) pr_err("Write to state_fd failed\n"); @@ -4215,7 +4187,6 @@ static int ddf_set_array_state(struct active_array *a, int consistent) int old = ddf->virt->entries[inst].state; if (consistent == 2) { handle_missing(ddf, a, inst); - /* Should check if a recovery should be started FIXME */ consistent = 1; if (!is_resync_complete(&a->info)) consistent = 0; @@ -4363,7 +4334,7 @@ static void ddf_set_disk(struct active_array *a, int n, int state) struct dl *dl; int update = 0; - dprintf("%s: %d to %x\n", __func__, n, state); + dprintf("%d to %x\n", n, state); if (vc == NULL) { dprintf("ddf: cannot find instance %d!!\n", inst); return; @@ -4373,8 +4344,7 @@ static void ddf_set_disk(struct active_array *a, int n, int state) if (mdi->disk.raid_disk == n) break; if (!mdi) { - pr_err("%s: cannot find raid disk %d\n", - __func__, n); + pr_err("cannot find raid disk %d\n", n); return; } @@ -4385,9 +4355,8 @@ static void ddf_set_disk(struct active_array *a, int n, int state) mdi->disk.minor == dl->minor) break; if (!dl) { - pr_err("%s: cannot find raid disk %d (%d/%d)\n", - __func__, n, - mdi->disk.major, mdi->disk.minor); + pr_err("cannot find raid disk %d (%d/%d)\n", + n, mdi->disk.major, mdi->disk.minor); return; } @@ -4395,14 +4364,15 @@ static void ddf_set_disk(struct active_array *a, int n, int state) if (pd < 0 || pd != dl->pdnum) { /* disk doesn't currently exist or has changed. * If it is now in_sync, insert it. */ - dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n", - __func__, dl->pdnum, dl->major, dl->minor, + dprintf("phys disk not found for %d: %d/%d ref %08x\n", + dl->pdnum, dl->major, dl->minor, be32_to_cpu(dl->disk.refnum)); - dprintf("%s: array %u disk %u ref %08x pd %d\n", - __func__, inst, n_bvd, + dprintf("array %u disk %u ref %08x pd %d\n", + inst, n_bvd, be32_to_cpu(vc->phys_refnum[n_bvd]), pd); - if ((state & DS_INSYNC) && ! (state & DS_FAULTY)) { - pd = dl->pdnum; /* FIXME: is this really correct ? */ + if ((state & DS_INSYNC) && ! (state & DS_FAULTY) && + dl->pdnum >= 0) { + pd = dl->pdnum; vc->phys_refnum[n_bvd] = dl->disk.refnum; LBA_OFFSET(ddf, vc)[n_bvd] = cpu_to_be64(mdi->data_offset); @@ -4485,13 +4455,11 @@ static int _kill_subarray_ddf(struct ddf_super *ddf, const char *guid) unsigned int vdnum, i; vdnum = find_vde_by_guid(ddf, guid); if (vdnum == DDF_NOTFOUND) { - pr_err("%s: could not find VD %s\n", __func__, - guid_str(guid)); + pr_err("could not find VD %s\n", guid_str(guid)); return -1; } if (del_from_conflist(&ddf->conflist, guid) == 0) { - pr_err("%s: could not find conf %s\n", __func__, - guid_str(guid)); + pr_err("could not find conf %s\n", guid_str(guid)); return -1; } for (dl = ddf->dlist; dl; dl = dl->next) @@ -4501,7 +4469,7 @@ static int _kill_subarray_ddf(struct ddf_super *ddf, const char *guid) DDF_GUID_LEN)) dl->vlist[i] = NULL; memset(ddf->virt->entries[vdnum].guid, 0xff, DDF_GUID_LEN); - dprintf("%s: deleted %s\n", __func__, guid_str(guid)); + dprintf("deleted %s\n", guid_str(guid)); return 0; } @@ -4518,14 +4486,13 @@ static int kill_subarray_ddf(struct supertype *st) ddf->currentconf = NULL; if (!victim) { - pr_err("%s: nothing to kill\n", __func__); + pr_err("nothing to kill\n"); return -1; } conf = &victim->conf; vdnum = find_vde_by_guid(ddf, conf->guid); if (vdnum == DDF_NOTFOUND) { - pr_err("%s: could not find VD %s\n", __func__, - guid_str(conf->guid)); + pr_err("could not find VD %s\n", guid_str(conf->guid)); return -1; } if (st->update_tail) { @@ -4534,8 +4501,7 @@ static int kill_subarray_ddf(struct supertype *st) + sizeof(struct virtual_entry); vd = xmalloc(len); if (vd == NULL) { - pr_err("%s: failed to allocate %d bytes\n", __func__, - len); + pr_err("failed to allocate %d bytes\n", len); return -1; } memset(vd, 0 , len); @@ -4570,10 +4536,301 @@ static void copy_matching_bvd(struct ddf_super *ddf, return; } } - pr_err("%s: no match for BVD %d of %s in update\n", __func__, + pr_err("no match for BVD %d of %s in update\n", conf->sec_elmnt_seq, guid_str(conf->guid)); } +static void ddf_process_phys_update(struct supertype *st, + struct metadata_update *update) +{ + struct ddf_super *ddf = st->sb; + struct phys_disk *pd; + unsigned int ent; + + pd = (struct phys_disk*)update->buf; + ent = be16_to_cpu(pd->used_pdes); + if (ent >= be16_to_cpu(ddf->phys->max_pdes)) + return; + if (be16_and(pd->entries[0].state, cpu_to_be16(DDF_Missing))) { + struct dl **dlp; + /* removing this disk. */ + be16_set(ddf->phys->entries[ent].state, + cpu_to_be16(DDF_Missing)); + for (dlp = &ddf->dlist; *dlp; dlp = &(*dlp)->next) { + struct dl *dl = *dlp; + if (dl->pdnum == (signed)ent) { + close(dl->fd); + dl->fd = -1; + *dlp = dl->next; + update->space = dl->devname; + *(void**)dl = update->space_list; + update->space_list = (void**)dl; + break; + } + } + ddf_set_updates_pending(ddf, NULL); + return; + } + if (!all_ff(ddf->phys->entries[ent].guid)) + return; + ddf->phys->entries[ent] = pd->entries[0]; + ddf->phys->used_pdes = cpu_to_be16 + (1 + be16_to_cpu(ddf->phys->used_pdes)); + ddf_set_updates_pending(ddf, NULL); + if (ddf->add_list) { + struct active_array *a; + struct dl *al = ddf->add_list; + ddf->add_list = al->next; + + al->next = ddf->dlist; + ddf->dlist = al; + + /* As a device has been added, we should check + * for any degraded devices that might make + * use of this spare */ + for (a = st->arrays ; a; a=a->next) + a->check_degraded = 1; + } +} + +static void ddf_process_virt_update(struct supertype *st, + struct metadata_update *update) +{ + struct ddf_super *ddf = st->sb; + struct virtual_disk *vd; + unsigned int ent; + + vd = (struct virtual_disk*)update->buf; + + if (vd->entries[0].state == DDF_state_deleted) { + if (_kill_subarray_ddf(ddf, vd->entries[0].guid)) + return; + } else { + ent = find_vde_by_guid(ddf, vd->entries[0].guid); + if (ent != DDF_NOTFOUND) { + dprintf("VD %s exists already in slot %d\n", + guid_str(vd->entries[0].guid), + ent); + return; + } + ent = find_unused_vde(ddf); + if (ent == DDF_NOTFOUND) + return; + ddf->virt->entries[ent] = vd->entries[0]; + ddf->virt->populated_vdes = + cpu_to_be16( + 1 + be16_to_cpu( + ddf->virt->populated_vdes)); + dprintf("added VD %s in slot %d(s=%02x i=%02x)\n", + guid_str(vd->entries[0].guid), ent, + ddf->virt->entries[ent].state, + ddf->virt->entries[ent].init_state); + } + ddf_set_updates_pending(ddf, NULL); +} + +static void ddf_remove_failed(struct ddf_super *ddf) +{ + /* Now remove any 'Failed' devices that are not part + * of any VD. They will have the Transition flag set. + * Once done, we need to update all dl->pdnum numbers. + */ + unsigned int pdnum; + unsigned int pd2 = 0; + struct dl *dl; + + for (pdnum = 0; pdnum < be16_to_cpu(ddf->phys->max_pdes); + pdnum++) { + if (be32_to_cpu(ddf->phys->entries[pdnum].refnum) == + 0xFFFFFFFF) + continue; + if (be16_and(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Failed)) + && be16_and(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Transition))) { + /* skip this one unless in dlist*/ + for (dl = ddf->dlist; dl; dl = dl->next) + if (dl->pdnum == (int)pdnum) + break; + if (!dl) + continue; + } + if (pdnum == pd2) + pd2++; + else { + ddf->phys->entries[pd2] = + ddf->phys->entries[pdnum]; + for (dl = ddf->dlist; dl; dl = dl->next) + if (dl->pdnum == (int)pdnum) + dl->pdnum = pd2; + pd2++; + } + } + ddf->phys->used_pdes = cpu_to_be16(pd2); + while (pd2 < pdnum) { + memset(ddf->phys->entries[pd2].guid, 0xff, + DDF_GUID_LEN); + pd2++; + } +} + +static void ddf_update_vlist(struct ddf_super *ddf, struct dl *dl) +{ + struct vcl *vcl; + unsigned int vn = 0; + int in_degraded = 0; + + if (dl->pdnum < 0) + return; + for (vcl = ddf->conflist; vcl ; vcl = vcl->next) { + unsigned int dn, ibvd; + const struct vd_config *conf; + int vstate; + dn = get_pd_index_from_refnum(vcl, + dl->disk.refnum, + ddf->mppe, + &conf, &ibvd); + if (dn == DDF_NOTFOUND) + continue; + dprintf("dev %d/%08x has %s (sec=%u) at %d\n", + dl->pdnum, + be32_to_cpu(dl->disk.refnum), + guid_str(conf->guid), + conf->sec_elmnt_seq, vn); + /* Clear the Transition flag */ + if (be16_and + (ddf->phys->entries[dl->pdnum].state, + cpu_to_be16(DDF_Failed))) + be16_clear(ddf->phys + ->entries[dl->pdnum].state, + cpu_to_be16(DDF_Transition)); + dl->vlist[vn++] = vcl; + vstate = ddf->virt->entries[vcl->vcnum].state + & DDF_state_mask; + if (vstate == DDF_state_degraded || + vstate == DDF_state_part_optimal) + in_degraded = 1; + } + while (vn < ddf->max_part) + dl->vlist[vn++] = NULL; + if (dl->vlist[0]) { + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + if (!be16_and(ddf->phys + ->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD))) { + be16_set(ddf->phys + ->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD)); + if (in_degraded) + be16_set(ddf->phys + ->entries[dl->pdnum] + .state, + cpu_to_be16 + (DDF_Rebuilding)); + } + } + if (dl->spare) { + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + be16_set(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Spare)); + } + if (!dl->vlist[0] && !dl->spare) { + be16_set(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Spare)); + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD)); + } +} + +static void ddf_process_conf_update(struct supertype *st, + struct metadata_update *update) +{ + struct ddf_super *ddf = st->sb; + struct vd_config *vc; + struct vcl *vcl; + struct dl *dl; + unsigned int ent; + unsigned int pdnum, len; + + vc = (struct vd_config*)update->buf; + len = ddf->conf_rec_len * 512; + if ((unsigned int)update->len != len * vc->sec_elmnt_count) { + pr_err("%s: insufficient data (%d) for %u BVDs\n", + guid_str(vc->guid), update->len, + vc->sec_elmnt_count); + return; + } + for (vcl = ddf->conflist; vcl ; vcl = vcl->next) + if (memcmp(vcl->conf.guid, vc->guid, DDF_GUID_LEN) == 0) + break; + dprintf("conf update for %s (%s)\n", + guid_str(vc->guid), (vcl ? "old" : "new")); + if (vcl) { + /* An update, just copy the phys_refnum and lba_offset + * fields + */ + unsigned int i; + unsigned int k; + copy_matching_bvd(ddf, &vcl->conf, update); + for (k = 0; k < be16_to_cpu(vc->prim_elmnt_count); k++) + dprintf("BVD %u has %08x at %llu\n", 0, + be32_to_cpu(vcl->conf.phys_refnum[k]), + be64_to_cpu(LBA_OFFSET(ddf, + &vcl->conf)[k])); + for (i = 1; i < vc->sec_elmnt_count; i++) { + copy_matching_bvd(ddf, vcl->other_bvds[i-1], + update); + for (k = 0; k < be16_to_cpu( + vc->prim_elmnt_count); k++) + dprintf("BVD %u has %08x at %llu\n", i, + be32_to_cpu + (vcl->other_bvds[i-1]-> + phys_refnum[k]), + be64_to_cpu + (LBA_OFFSET + (ddf, + vcl->other_bvds[i-1])[k])); + } + } else { + /* A new VD_CONF */ + unsigned int i; + if (!update->space) + return; + vcl = update->space; + update->space = NULL; + vcl->next = ddf->conflist; + memcpy(&vcl->conf, vc, len); + ent = find_vde_by_guid(ddf, vc->guid); + if (ent == DDF_NOTFOUND) + return; + vcl->vcnum = ent; + ddf->conflist = vcl; + for (i = 1; i < vc->sec_elmnt_count; i++) + memcpy(vcl->other_bvds[i-1], + update->buf + len * i, len); + } + /* Set DDF_Transition on all Failed devices - to help + * us detect those that are no longer in use + */ + for (pdnum = 0; pdnum < be16_to_cpu(ddf->phys->max_pdes); + pdnum++) + if (be16_and(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Failed))) + be16_set(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Transition)); + + /* Now make sure vlist is correct for each dl. */ + for (dl = ddf->dlist; dl; dl = dl->next) + ddf_update_vlist(ddf, dl); + ddf_remove_failed(ddf); + + ddf_set_updates_pending(ddf, vc); +} + static void ddf_process_update(struct supertype *st, struct metadata_update *update) { @@ -4604,307 +4861,57 @@ static void ddf_process_update(struct supertype *st, * and offset. This will also mark the spare as active with * a spare-assignment record. */ - struct ddf_super *ddf = st->sb; be32 *magic = (be32 *)update->buf; - struct phys_disk *pd; - struct virtual_disk *vd; - struct vd_config *vc; - struct vcl *vcl; - struct dl *dl; - unsigned int ent; - unsigned int pdnum, pd2, len; dprintf("Process update %x\n", be32_to_cpu(*magic)); if (be32_eq(*magic, DDF_PHYS_RECORDS_MAGIC)) { - if (update->len != (sizeof(struct phys_disk) + + if (update->len == (sizeof(struct phys_disk) + sizeof(struct phys_disk_entry))) - return; - pd = (struct phys_disk*)update->buf; - - ent = be16_to_cpu(pd->used_pdes); - if (ent >= be16_to_cpu(ddf->phys->max_pdes)) - return; - if (be16_and(pd->entries[0].state, cpu_to_be16(DDF_Missing))) { - struct dl **dlp; - /* removing this disk. */ - be16_set(ddf->phys->entries[ent].state, - cpu_to_be16(DDF_Missing)); - for (dlp = &ddf->dlist; *dlp; dlp = &(*dlp)->next) { - struct dl *dl = *dlp; - if (dl->pdnum == (signed)ent) { - close(dl->fd); - dl->fd = -1; - /* FIXME this doesn't free - * dl->devname */ - update->space = dl; - *dlp = dl->next; - break; - } - } - ddf_set_updates_pending(ddf, NULL); - return; - } - if (!all_ff(ddf->phys->entries[ent].guid)) - return; - ddf->phys->entries[ent] = pd->entries[0]; - ddf->phys->used_pdes = cpu_to_be16 - (1 + be16_to_cpu(ddf->phys->used_pdes)); - ddf_set_updates_pending(ddf, NULL); - if (ddf->add_list) { - struct active_array *a; - struct dl *al = ddf->add_list; - ddf->add_list = al->next; - - al->next = ddf->dlist; - ddf->dlist = al; - - /* As a device has been added, we should check - * for any degraded devices that might make - * use of this spare */ - for (a = st->arrays ; a; a=a->next) - a->check_degraded = 1; - } + ddf_process_phys_update(st, update); } else if (be32_eq(*magic, DDF_VIRT_RECORDS_MAGIC)) { - if (update->len != (sizeof(struct virtual_disk) + + if (update->len == (sizeof(struct virtual_disk) + sizeof(struct virtual_entry))) - return; - vd = (struct virtual_disk*)update->buf; - - if (vd->entries[0].state == DDF_state_deleted) { - if (_kill_subarray_ddf(ddf, vd->entries[0].guid)) - return; - } else { - ent = find_vde_by_guid(ddf, vd->entries[0].guid); - if (ent != DDF_NOTFOUND) { - dprintf("%s: VD %s exists already in slot %d\n", - __func__, guid_str(vd->entries[0].guid), - ent); - return; - } - ent = find_unused_vde(ddf); - if (ent == DDF_NOTFOUND) - return; - ddf->virt->entries[ent] = vd->entries[0]; - ddf->virt->populated_vdes = - cpu_to_be16( - 1 + be16_to_cpu( - ddf->virt->populated_vdes)); - dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n", - __func__, guid_str(vd->entries[0].guid), ent, - ddf->virt->entries[ent].state, - ddf->virt->entries[ent].init_state); - } - ddf_set_updates_pending(ddf, NULL); - } - - else if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { - vc = (struct vd_config*)update->buf; - len = ddf->conf_rec_len * 512; - if ((unsigned int)update->len != len * vc->sec_elmnt_count) { - pr_err("%s: %s: insufficient data (%d) for %u BVDs\n", - __func__, guid_str(vc->guid), update->len, - vc->sec_elmnt_count); - return; - } - for (vcl = ddf->conflist; vcl ; vcl = vcl->next) - if (memcmp(vcl->conf.guid, vc->guid, DDF_GUID_LEN) == 0) - break; - dprintf("%s: conf update for %s (%s)\n", __func__, - guid_str(vc->guid), (vcl ? "old" : "new")); - if (vcl) { - /* An update, just copy the phys_refnum and lba_offset - * fields - */ - unsigned int i; - unsigned int k; - copy_matching_bvd(ddf, &vcl->conf, update); - for (k = 0; k < be16_to_cpu(vc->prim_elmnt_count); k++) - dprintf("BVD %u has %08x at %llu\n", 0, - be32_to_cpu(vcl->conf.phys_refnum[k]), - be64_to_cpu(LBA_OFFSET(ddf, - &vcl->conf)[k])); - for (i = 1; i < vc->sec_elmnt_count; i++) { - copy_matching_bvd(ddf, vcl->other_bvds[i-1], - update); - for (k = 0; k < be16_to_cpu( - vc->prim_elmnt_count); k++) - dprintf("BVD %u has %08x at %llu\n", i, - be32_to_cpu - (vcl->other_bvds[i-1]-> - phys_refnum[k]), - be64_to_cpu - (LBA_OFFSET - (ddf, - vcl->other_bvds[i-1])[k])); - } - } else { - /* A new VD_CONF */ - unsigned int i; - if (!update->space) - return; - vcl = update->space; - update->space = NULL; - vcl->next = ddf->conflist; - memcpy(&vcl->conf, vc, len); - ent = find_vde_by_guid(ddf, vc->guid); - if (ent == DDF_NOTFOUND) - return; - vcl->vcnum = ent; - ddf->conflist = vcl; - for (i = 1; i < vc->sec_elmnt_count; i++) - memcpy(vcl->other_bvds[i-1], - update->buf + len * i, len); - } - /* Set DDF_Transition on all Failed devices - to help - * us detect those that are no longer in use - */ - for (pdnum = 0; pdnum < be16_to_cpu(ddf->phys->max_pdes); - pdnum++) - if (be16_and(ddf->phys->entries[pdnum].state, - cpu_to_be16(DDF_Failed))) - be16_set(ddf->phys->entries[pdnum].state, - cpu_to_be16(DDF_Transition)); - /* Now make sure vlist is correct for each dl. */ - for (dl = ddf->dlist; dl; dl = dl->next) { - unsigned int vn = 0; - int in_degraded = 0; - - if (dl->pdnum < 0) - continue; - for (vcl = ddf->conflist; vcl ; vcl = vcl->next) { - unsigned int dn, ibvd; - const struct vd_config *conf; - int vstate; - dn = get_pd_index_from_refnum(vcl, - dl->disk.refnum, - ddf->mppe, - &conf, &ibvd); - if (dn == DDF_NOTFOUND) - continue; - dprintf("dev %d/%08x has %s (sec=%u) at %d\n", - dl->pdnum, - be32_to_cpu(dl->disk.refnum), - guid_str(conf->guid), - conf->sec_elmnt_seq, vn); - /* Clear the Transition flag */ - if (be16_and - (ddf->phys->entries[dl->pdnum].state, - cpu_to_be16(DDF_Failed))) - be16_clear(ddf->phys - ->entries[dl->pdnum].state, - cpu_to_be16(DDF_Transition)); - dl->vlist[vn++] = vcl; - vstate = ddf->virt->entries[vcl->vcnum].state - & DDF_state_mask; - if (vstate == DDF_state_degraded || - vstate == DDF_state_part_optimal) - in_degraded = 1; - } - while (vn < ddf->max_part) - dl->vlist[vn++] = NULL; - if (dl->vlist[0]) { - be16_clear(ddf->phys->entries[dl->pdnum].type, - cpu_to_be16(DDF_Global_Spare)); - if (!be16_and(ddf->phys - ->entries[dl->pdnum].type, - cpu_to_be16(DDF_Active_in_VD))) { - be16_set(ddf->phys - ->entries[dl->pdnum].type, - cpu_to_be16(DDF_Active_in_VD)); - if (in_degraded) - be16_set(ddf->phys - ->entries[dl->pdnum] - .state, - cpu_to_be16 - (DDF_Rebuilding)); - } - } - if (dl->spare) { - be16_clear(ddf->phys->entries[dl->pdnum].type, - cpu_to_be16(DDF_Global_Spare)); - be16_set(ddf->phys->entries[dl->pdnum].type, - cpu_to_be16(DDF_Spare)); - } - if (!dl->vlist[0] && !dl->spare) { - be16_set(ddf->phys->entries[dl->pdnum].type, - cpu_to_be16(DDF_Global_Spare)); - be16_clear(ddf->phys->entries[dl->pdnum].type, - cpu_to_be16(DDF_Spare)); - be16_clear(ddf->phys->entries[dl->pdnum].type, - cpu_to_be16(DDF_Active_in_VD)); - } - } - - /* Now remove any 'Failed' devices that are not part - * of any VD. They will have the Transition flag set. - * Once done, we need to update all dl->pdnum numbers. - */ - pd2 = 0; - for (pdnum = 0; pdnum < be16_to_cpu(ddf->phys->max_pdes); - pdnum++) { - if (be32_to_cpu(ddf->phys->entries[pdnum].refnum) == - 0xFFFFFFFF) - continue; - if (be16_and(ddf->phys->entries[pdnum].state, - cpu_to_be16(DDF_Failed)) - && be16_and(ddf->phys->entries[pdnum].state, - cpu_to_be16(DDF_Transition))) { - /* skip this one unless in dlist*/ - for (dl = ddf->dlist; dl; dl = dl->next) - if (dl->pdnum == (int)pdnum) - break; - if (!dl) - continue; - } - if (pdnum == pd2) - pd2++; - else { - ddf->phys->entries[pd2] = - ddf->phys->entries[pdnum]; - for (dl = ddf->dlist; dl; dl = dl->next) - if (dl->pdnum == (int)pdnum) - dl->pdnum = pd2; - pd2++; - } - } - ddf->phys->used_pdes = cpu_to_be16(pd2); - while (pd2 < pdnum) { - memset(ddf->phys->entries[pd2].guid, 0xff, - DDF_GUID_LEN); - pd2++; - } - - ddf_set_updates_pending(ddf, vc); + ddf_process_virt_update(st, update); + } else if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { + ddf_process_conf_update(st, update); } /* case DDF_SPARE_ASSIGN_MAGIC */ } -static void ddf_prepare_update(struct supertype *st, - struct metadata_update *update) +static int ddf_prepare_update(struct supertype *st, + struct metadata_update *update) { /* This update arrived at managemon. * We are about to pass it to monitor. * If a malloc is needed, do it here. */ struct ddf_super *ddf = st->sb; - be32 *magic = (be32 *)update->buf; + be32 *magic; + if (update->len < 4) + return 0; + magic = (be32 *)update->buf; if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { struct vcl *vcl; - struct vd_config *conf = (struct vd_config *) update->buf; + struct vd_config *conf; + if (update->len < (int)sizeof(*conf)) + return 0; + conf = (struct vd_config *) update->buf; if (posix_memalign(&update->space, 512, offsetof(struct vcl, conf) + ddf->conf_rec_len * 512) != 0) { update->space = NULL; - return; + return 0; } vcl = update->space; vcl->conf.sec_elmnt_count = conf->sec_elmnt_count; if (alloc_other_bvds(ddf, vcl) != 0) { free(update->space); update->space = NULL; + return 0; } } + return 1; } /* @@ -4928,7 +4935,7 @@ static int raid10_degraded(struct mdinfo *info) for (d = info->devs; d; d = d->next) { i = d->disk.raid_disk / n_prim; if (i >= n_bvds) { - pr_err("%s: BUG: invalid raid disk\n", __func__); + pr_err("BUG: invalid raid disk\n"); goto out; } if (d->state_fd > 0) @@ -4937,12 +4944,11 @@ static int raid10_degraded(struct mdinfo *info) ret = 2; for (i = 0; i < n_bvds; i++) if (!found[i]) { - dprintf("%s: BVD %d/%d failed\n", __func__, i, n_bvds); + dprintf("BVD %d/%d failed\n", i, n_bvds); ret = 0; goto out; } else if (found[i] < n_prim) { - dprintf("%s: BVD %d/%d degraded\n", __func__, i, - n_bvds); + dprintf("BVD %d/%d degraded\n", i, n_bvds); ret = 1; } out: @@ -4991,7 +4997,7 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, working ++; } - dprintf("%s: working=%d (%d) level=%d\n", __func__, working, + dprintf("working=%d (%d) level=%d\n", working, a->info.array.raid_disks, a->info.array.level); if (working == a->info.array.raid_disks) @@ -5176,8 +5182,8 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, && dl->minor == di->disk.minor) break; if (!dl || dl->pdnum < 0) { - pr_err("%s: BUG: can't find disk %d (%d/%d)\n", - __func__, di->disk.raid_disk, + pr_err("BUG: can't find disk %d (%d/%d)\n", + di->disk.raid_disk, di->disk.major, di->disk.minor); return NULL; }