ret_val = 0;
dprintf("Array size changed");
}
- dprintf(" from %llu to %llu.\n",
- current_size, new_size);
+ dprintf_cont(" from %llu to %llu.\n",
+ current_size, new_size);
}
sysfs_free(info);
} else
int err;
err = remove_disks_for_takeover(st, sra, array.layout);
if (err) {
- dprintf("%s: Array cannot be reshaped\n", Name);
+ dprintf("Array cannot be reshaped\n");
if (cfd > -1)
close(cfd);
rv = 1;
char *ep;
unsigned long long position = strtoull(buf, &ep, 0);
- dprintf("%s: Read sync_max sysfs entry is: %s\n", Name, buf);
+ dprintf("Read sync_max sysfs entry is: %s\n", buf);
if (!(ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))) {
position *= get_data_disks(level,
info->new_layout,
fd = open_dev(mdstat->devnm);
if (fd < 0) {
- printf("%s: Device %s cannot be opened for reshape.",
- Name, adev);
+ pr_err("Device %s cannot be opened for reshape.\n", adev);
break;
}
* reshape_array is resolved().
*/
printf("%s: Multiple reshape execution detected for "
- "device %s.", Name, adev);
+ "device %s.\n", Name, adev);
close(fd);
break;
}
dprintf("Grow continue is run for ");
if (st->ss->external == 0) {
int d;
- dprintf("native array (%s)\n", devname);
+ dprintf_cont("native array (%s)\n", devname);
if (ioctl(fd, GET_ARRAY_INFO, &array.array) < 0) {
pr_err("%s is not an active md array -"
" aborting\n", devname);
char *container;
if (subarray) {
- dprintf("subarray (%s)\n", subarray);
+ dprintf_cont("subarray (%s)\n", subarray);
container = st->container_devnm;
cfd = open_dev_excl(st->container_devnm);
} else {
container = st->devnm;
close(fd);
cfd = open_dev_excl(st->devnm);
- dprintf("container (%s)\n", container);
+ dprintf_cont("container (%s)\n", container);
fd = cfd;
}
if (cfd < 0) {
char buf[32];
if (!id_path)
- dprintf("%s: incremental removal without --path <id_path> "
+ dprintf("incremental removal without --path <id_path> "
"lacks the possibility to re-add new device in this "
- "port\n", Name);
+ "port\n");
if (strchr(devname, '/')) {
pr_err("incremental removal requires a "
/* Note that this doesn't close fds if they are being used
* by a clone. ->container will be set for a clone
*/
- dprintf("%s: sys_name: %s\n", __func__, aa->info.sys_name);
+ dprintf("sys_name: %s\n", aa->info.sys_name);
if (!aa->container)
close_aa(aa);
while (aa->info.devs) {
.state = 0,
};
- dprintf("%s: add %d:%d to container\n",
- __func__, sd->disk.major, sd->disk.minor);
+ dprintf("add %d:%d to container\n", sd->disk.major, sd->disk.minor);
sd->next = st->devs;
st->devs = sd;
.raid_disk = -1,
.state = 0,
};
- dprintf("%s: remove %d:%d from container\n",
- __func__, sd->disk.major, sd->disk.minor);
+ dprintf("remove %d:%d from container\n",
+ sd->disk.major, sd->disk.minor);
st->update_tail = &update;
st->ss->remove_from_super(st, &dk);
/* prevent the kernel from activating the disk(s) before we
* finish adding them
*/
- dprintf("%s: freezing %s\n", __func__, a->info.sys_name);
+ dprintf("freezing %s\n", a->info.sys_name);
sysfs_set_str(&a->info, NULL, "sync_action", "frozen");
/* Add device to array and set offset/size/slot.
if (sysfs_set_str(&a->info, NULL, "sync_action", "recover")
== 0)
newa->prev_action = recover;
- dprintf("%s: recovery started on %s\n", __func__,
- a->info.sys_name);
+ dprintf("recovery started on %s\n", a->info.sys_name);
out:
while (newdev) {
d = newdev->next;
new->metadata_fd = sysfs_open2(new->info.sys_name, NULL, "metadata_version");
new->sync_completed_fd = sysfs_open2(new->info.sys_name, NULL, "sync_completed");
- dprintf("%s: inst: %s action: %d state: %d\n", __func__, inst,
+ dprintf("inst: %s action: %d state: %d\n", inst,
new->action_fd, new->info.state_fd);
if (sigterm)
a->autof = c->autof;
}
if (map_lock(&map))
- pr_err("%s: failed to get "
- "exclusive lock on mapfile\n",
- __func__);
+ pr_err("failed to get exclusive lock on mapfile\n");
do {
failures = 0;
successes = 0;
#ifdef DEBUG
#define dprintf(fmt, arg...) \
+ fprintf(stderr, "%s: %s: "fmt, Name, __func__, ##arg)
+#define dprintf_cont(fmt, arg...) \
fprintf(stderr, fmt, ##arg)
#else
#define dprintf(fmt, arg...) \
+ ({ if (0) fprintf(stderr, "%s: %s: " fmt, Name, __func__, ##arg); 0; })
+#define dprintf_cont(fmt, arg...) \
({ if (0) fprintf(stderr, fmt, ##arg); 0; })
#endif
#include <assert.h>
return ret;
}
+#ifdef DEBUG
+#define pr_err(fmt, args...) fprintf(stderr, "%s: %s: "fmt, Name, __func__, ##args)
+#else
#define pr_err(fmt, args...) fprintf(stderr, "%s: "fmt, Name, ##args)
+#endif
#define cont_err(fmt ...) fprintf(stderr, " " fmt)
void *xmalloc(size_t len);
if (fd < 0)
return;
if (fstat(fd, &st) == -1) {
- dprintf("%s: Invalid fd %d\n", __func__, fd);
+ dprintf("Invalid fd %d\n", fd);
return;
}
if (st.st_nlink == 0) {
- dprintf("%s: fd %d was deleted\n", __func__, fd);
+ dprintf("fd %d was deleted\n", fd);
return;
}
if (fd > *maxfd)
n = read_attr(buf, 30, fd);
if (n <= 0) {
- dprintf("%s: Failed to read resync_start (%d)\n",
- __func__, fd);
+ dprintf("Failed to read resync_start (%d)\n", fd);
return;
}
if (strncmp(buf, "none", 4) == 0)
}
gettimeofday(&tv, NULL);
- dprintf("%s(%d): %ld.%06ld state:%s prev:%s action:%s prev: %s start:%llu\n",
- __func__, a->info.container_member,
+ dprintf("(%d): %ld.%06ld state:%s prev:%s action:%s prev: %s start:%llu\n",
+ a->info.container_member,
tv.tv_sec, tv.tv_usec,
array_states[a->curr_state],
array_states[a->prev_state],
a->last_checkpoint = sync_completed;
a->container->ss->sync_metadata(a->container);
- dprintf("%s(%d): state:%s action:%s next(", __func__, a->info.container_member,
+ dprintf("(%d): state:%s action:%s next(", a->info.container_member,
array_states[a->curr_state], sync_actions[a->curr_action]);
/* Effect state changes in the array */
if (a->next_state != bad_word) {
- dprintf(" state:%s", array_states[a->next_state]);
+ dprintf_cont(" state:%s", array_states[a->next_state]);
write_attr(array_states[a->next_state], a->info.state_fd);
}
if (a->next_action != bad_action) {
write_attr(sync_actions[a->next_action], a->action_fd);
- dprintf(" action:%s", sync_actions[a->next_action]);
+ dprintf_cont(" action:%s", sync_actions[a->next_action]);
}
for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
if (mdi->next_state & DS_UNBLOCK) {
- dprintf(" %d:-blocked", mdi->disk.raid_disk);
+ dprintf_cont(" %d:-blocked", mdi->disk.raid_disk);
write_attr("-blocked", mdi->state_fd);
}
*/
remove_result = write_attr("remove", mdi->state_fd);
if (remove_result > 0) {
- dprintf(" %d:removed", mdi->disk.raid_disk);
+ dprintf_cont(" %d:removed", mdi->disk.raid_disk);
close(mdi->state_fd);
close(mdi->recovery_fd);
mdi->state_fd = -1;
}
if (mdi->next_state & DS_INSYNC) {
write_attr("+in_sync", mdi->state_fd);
- dprintf(" %d:+in_sync", mdi->disk.raid_disk);
+ dprintf_cont(" %d:+in_sync", mdi->disk.raid_disk);
}
}
- dprintf(" )\n");
+ dprintf_cont(" )\n");
/* move curr_ to prev_ */
a->prev_state = a->curr_state;
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) {}
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 ||
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;
}
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;
}
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;
}
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;
};
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;
}
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);
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
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));
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;
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;
/* 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;
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;
}
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);
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,
- (unsigned long long)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,
+ 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));
}
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);
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)
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;
*/
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;
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);
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;
}
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;
}
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;
}
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));
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);
}
}
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));
}
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)
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");
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;
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;
}
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;
}
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) &&
dl->pdnum >= 0) {
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)
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;
}
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) {
+ 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);
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));
}
} 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),
+ dprintf("VD %s exists already in slot %d\n",
+ guid_str(vd->entries[0].guid),
ent);
return;
}
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,
+ 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);
}
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,
+ 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("%s: conf update for %s (%s)\n", __func__,
+ 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
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)
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:
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)
&& 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;
}
free_gpt(st);
if (posix_memalign((void**)&super, 4096, 32*512) != 0) {
- pr_err("%s could not allocate superblock\n",
- __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
}
if (not_supported)
- dprintf("%s (IMSM): Unknown attributes : %x\n", Name, not_supported);
+ dprintf("(IMSM): Unknown attributes : %x\n", not_supported);
ret_val = 0;
}
case 5:
return map->num_members - 1;
default:
- dprintf("%s: unsupported raid level\n", __func__);
+ dprintf("unsupported raid level\n");
return 0;
}
}
int update_memory_size = 0;
- dprintf("imsm_create_metadata_checkpoint_update(enter)\n");
+ dprintf("(enter)\n");
if (u == NULL)
return 0;
*u = xcalloc(1, update_memory_size);
if (*u == NULL) {
- dprintf("error: cannot get memory for "
- "imsm_create_metadata_checkpoint_update update\n");
+ dprintf("error: cannot get memory\n");
return 0;
}
(*u)->type = update_general_migration_checkpoint;
(*u)->curr_migr_unit = __le32_to_cpu(super->migr_rec->curr_migr_unit);
- dprintf("imsm_create_metadata_checkpoint_update: prepared for %u\n",
- (*u)->curr_migr_unit);
+ dprintf("prepared for %u\n", (*u)->curr_migr_unit);
return update_memory_size;
}
*/
component_size_alligment = component_size % (chunk_size/512);
- dprintf("imsm_component_size_aligment_check(Level: %i, "
- "chunk_size = %i, component_size = %llu), "
- "component_size_alligment = %u\n",
+ dprintf("(Level: %i, chunk_size = %i, component_size = %llu), component_size_alligment = %u\n",
level, chunk_size, component_size,
component_size_alligment);
dprintf("imsm: reported component size alligned from %llu ",
component_size);
component_size -= component_size_alligment;
- dprintf("to %llu (%i).\n",
+ dprintf_cont("to %llu (%i).\n",
component_size, component_size_alligment);
}
*/
max_enough = max(max_enough, enough);
}
- dprintf("%s: enough: %d\n", __func__, max_enough);
+ dprintf("enough: %d\n", max_enough);
info->container_enough = max_enough;
if (super->disks) {
free(anchor);
if (posix_memalign(&super->migr_rec_buf, 512, MIGR_REC_BUF_SIZE) != 0) {
- pr_err("%s could not allocate migr_rec buffer\n", __func__);
+ pr_err("could not allocate migr_rec buffer\n");
free(super->buf);
return 2;
}
if (tbl_mpb->family_num == mpb->family_num) {
if (tbl_mpb->check_sum == mpb->check_sum) {
- dprintf("%s: mpb from %d:%d matches %d:%d\n",
- __func__, super->disks->major,
+ dprintf("mpb from %d:%d matches %d:%d\n",
+ super->disks->major,
super->disks->minor,
table[i]->disks->major,
table[i]->disks->minor);
*/
struct intel_disk *idisk;
- dprintf("%s: mpb from %d:%d replaces %d:%d\n",
- __func__, super->disks->major,
+ dprintf("mpb from %d:%d replaces %d:%d\n",
+ super->disks->major,
super->disks->minor,
table[i]->disks->major,
table[i]->disks->minor);
idisk->disk.status |= CONFIGURED_DISK;
}
- dprintf("%s: mpb from %d:%d prefer %d:%d\n",
- __func__, super->disks->major,
+ dprintf("mpb from %d:%d prefer %d:%d\n",
+ super->disks->major,
super->disks->minor,
table[i]->disks->major,
table[i]->disks->minor);
idisk->owner == IMSM_UNKNOWN_OWNER)
ok_count++;
else
- dprintf("%s: '%.16s' owner %d != %d\n",
- __func__, disk->serial, idisk->owner,
+ dprintf("'%.16s' owner %d != %d\n",
+ disk->serial, idisk->owner,
owner);
} else {
- dprintf("%s: unknown disk %x [%d]: %.16s\n",
- __func__, __le32_to_cpu(mpb->family_num), i,
+ dprintf("unknown disk %x [%d]: %.16s\n",
+ __le32_to_cpu(mpb->family_num), i,
disk->serial);
break;
}
s = NULL;
if (!s)
- dprintf("%s: marking family: %#x from %d:%d offline\n",
- __func__, mpb->family_num,
+ dprintf("marking family: %#x from %d:%d offline\n",
+ mpb->family_num,
super_table[i]->disks->major,
super_table[i]->disks->minor);
super_table[i] = s;
}
if (posix_memalign(&super->migr_rec_buf, 512,
MIGR_REC_BUF_SIZE) != 0) {
- pr_err("%s could not allocate migr_rec buffer\n",
- __func__);
+ pr_err("could not allocate migr_rec buffer\n");
free(super->buf);
free(super);
free(mpb_new);
super = NULL;
}
if (!super) {
- pr_err("%s could not allocate superblock\n", __func__);
+ pr_err("could not allocate superblock\n");
return 0;
}
if (posix_memalign(&super->migr_rec_buf, 512, MIGR_REC_BUF_SIZE) != 0) {
- pr_err("%s could not allocate migr_rec buffer\n", __func__);
+ pr_err("could not allocate migr_rec buffer\n");
free(super->buf);
free(super);
return 0;
* is prepared.
*/
if (!st->update_tail) {
- pr_err("%s shall be used in mdmon context only"
- "(line %d).\n", __func__, __LINE__);
+ pr_err("shall be used in mdmon context only\n");
return 1;
}
dd = xcalloc(1, sizeof(*dd));
spare->check_sum = __cpu_to_le32(sum);
if (store_imsm_mpb(d->fd, spare)) {
- pr_err("%s: failed for device %d:%d %s\n",
- __func__, d->major, d->minor, strerror(errno));
+ pr_err("failed for device %d:%d %s\n",
+ d->major, d->minor, strerror(errno));
return 1;
}
if (doclose) {
if (store_imsm_mpb(d->fd, mpb))
fprintf(stderr,
- "%s: failed for device %d:%d (fd: %d)%s\n",
- __func__, d->major, d->minor,
+ "failed for device %d:%d (fd: %d)%s\n",
+ d->major, d->minor,
d->fd, strerror(errno));
if (doclose) {
#if DEBUG
char str[256];
fd2devname(fd, str);
- dprintf("validate_geometry_imsm_container: fd: %d %s orom: %p rv: %d raiddisk: %d\n",
+ dprintf("fd: %d %s orom: %p rv: %d raiddisk: %d\n",
fd, str, super->orom, rv, raiddisks);
#endif
/* no orom/efi or non-intel hba of the disk */
tmpdev->container = 0;
dfd = dev_open(devname, O_RDONLY|O_EXCL);
if (dfd < 0) {
- dprintf(": cannot open device %s: %s\n",
+ dprintf("cannot open device %s: %s\n",
devname, strerror(errno));
tmpdev->used = 2;
} else if (fstat(dfd, &stb)< 0) {
/* Impossible! */
- dprintf(": fstat failed for %s: %s\n",
+ dprintf("fstat failed for %s: %s\n",
devname, strerror(errno));
tmpdev->used = 2;
} else if ((stb.st_mode & S_IFMT) != S_IFBLK) {
- dprintf(": %s is not a block device.\n",
+ dprintf("%s is not a block device.\n",
devname);
tmpdev->used = 2;
} else if (must_be_container(dfd)) {
struct supertype *cst;
cst = super_by_fd(dfd, NULL);
if (cst == NULL) {
- dprintf(": cannot recognize container type %s\n",
+ dprintf("cannot recognize container type %s\n",
devname);
tmpdev->used = 2;
} else if (tst->ss != st->ss) {
- dprintf(": non-imsm container - ignore it: %s\n",
+ dprintf("non-imsm container - ignore it: %s\n",
devname);
tmpdev->used = 2;
} else if (!tst->ss->load_container ||
} else {
tmpdev->st_rdev = stb.st_rdev;
if (tst->ss->load_super(tst,dfd, NULL)) {
- dprintf(": no RAID superblock on %s\n",
+ dprintf("no RAID superblock on %s\n",
devname);
tmpdev->used = 2;
} else if (tst->ss->compare_super == NULL) {
- dprintf(": Cannot assemble %s metadata on %s\n",
+ dprintf("Cannot assemble %s metadata on %s\n",
tst->ss->name, devname);
tmpdev->used = 2;
}
* Or, if we are auto assembling, we just ignore the second
* for now.
*/
- dprintf(": superblock on %s doesn't match others - assembly aborted\n",
+ dprintf("superblock on %s doesn't match others - assembly aborted\n",
devname);
goto loop;
}
if (iter->array.state & (1<<MD_SB_BLOCK_VOLUME)) {
/* do not assemble arrays with unsupported
configurations */
- dprintf(": Cannot activate member %s.\n",
+ dprintf("Cannot activate member %s.\n",
iter->text_version);
} else
count++;
sysfs_free(head);
} else {
- dprintf(" no valid super block on device list: err: %d %p\n",
+ dprintf("No valid super block on device list: err: %d %p\n",
err, st->sb);
}
} else {
- dprintf(" no more devices to examin\n");
+ dprintf("no more devices to examine\n");
}
for (tmpdev = devlist; tmpdev; tmpdev = tmpdev->next) {
return 0;
count = active_arrays_by_format("imsm", hba, &devlist, dpa, verbose);
- dprintf(" path: %s active arrays: %d\n", hba, count);
+ dprintf("path: %s active arrays: %d\n", hba, count);
if (devlist == NULL)
return 0;
do {
* IMSM_ORD_REBUILD, so assume they are missing and the
* disk_ord_tbl was not correctly updated
*/
- dprintf("%s: failed to locate out-of-sync disk\n", __func__);
+ dprintf("failed to locate out-of-sync disk\n");
return;
}
struct imsm_super *mpb = super->anchor;
if (atoi(inst) >= mpb->num_raid_devs) {
- pr_err("%s: subarry index %d, out of range\n",
- __func__, atoi(inst));
+ pr_err("subarry index %d, out of range\n", atoi(inst));
return -ENODEV;
}
case IMSM_T_STATE_NORMAL: /* transition to normal state */
dprintf("normal: ");
if (is_rebuilding(dev)) {
- dprintf("while rebuilding");
+ dprintf_cont("while rebuilding");
/* check if recovery is really finished */
for (mdi = a->info.devs; mdi ; mdi = mdi->next)
if (mdi->recovery_start != MaxSector) {
break;
}
if (recovery_not_finished) {
- dprintf("\nimsm: Rebuild has not finished yet, "
- "state not changed");
+ dprintf_cont("\n");
+ dprintf("Rebuild has not finished yet, state not changed");
if (a->last_checkpoint < mdi->recovery_start) {
a->last_checkpoint = mdi->recovery_start;
super->updates_pending++;
break;
}
if (is_gen_migration(dev)) {
- dprintf("while general migration");
+ dprintf_cont("while general migration");
if (a->last_checkpoint >= a->info.component_size)
end_migration(dev, super, map_state);
else
}
break;
case IMSM_T_STATE_DEGRADED: /* transition to degraded state */
- dprintf("degraded: ");
+ dprintf_cont("degraded: ");
if ((map->map_state != map_state) &&
!dev->vol.migr_state) {
- dprintf("mark degraded");
+ dprintf_cont("mark degraded");
map->map_state = map_state;
super->updates_pending++;
a->last_checkpoint = 0;
break;
}
if (is_rebuilding(dev)) {
- dprintf("while rebuilding.");
+ dprintf_cont("while rebuilding.");
if (map->map_state != map_state) {
- dprintf(" Map state change");
+ dprintf_cont(" Map state change");
end_migration(dev, super, map_state);
super->updates_pending++;
}
break;
}
if (is_gen_migration(dev)) {
- dprintf("while general migration");
+ dprintf_cont("while general migration");
if (a->last_checkpoint >= a->info.component_size)
end_migration(dev, super, map_state);
else {
break;
}
if (is_initializing(dev)) {
- dprintf("while initialization.");
+ dprintf_cont("while initialization.");
map->map_state = map_state;
super->updates_pending++;
break;
}
break;
case IMSM_T_STATE_FAILED: /* transition to failed state */
- dprintf("failed: ");
+ dprintf_cont("failed: ");
if (is_gen_migration(dev)) {
- dprintf("while general migration");
+ dprintf_cont("while general migration");
map->map_state = map_state;
super->updates_pending++;
break;
}
if (map->map_state != map_state) {
- dprintf("mark failed");
+ dprintf_cont("mark failed");
end_migration(dev, super, map_state);
super->updates_pending++;
a->last_checkpoint = 0;
}
break;
default:
- dprintf("state %i\n", map_state);
+ dprintf_cont("state %i\n", map_state);
}
- dprintf("\n");
-
+ dprintf_cont("\n");
}
static int store_imsm_mpb(int fd, struct imsm_super *mpb)
dl = NULL;
if (dl)
- dprintf("%s: found %x:%x\n", __func__, dl->major, dl->minor);
+ dprintf("found %x:%x\n", dl->major, dl->minor);
return dl;
}
super->disks = dl->next;
dl->next = NULL;
__free_imsm_disk(dl);
- dprintf("%s: removed %x:%x\n",
- __func__, major, minor);
+ dprintf("removed %x:%x\n", major, minor);
break;
}
prev = dl;
disk_cfg->next = super->disks;
super->disks = disk_cfg;
check_degraded = 1;
- dprintf("%s: added %x:%x\n",
- __func__, disk_cfg->major,
- disk_cfg->minor);
+ dprintf("added %x:%x\n",
+ disk_cfg->major, disk_cfg->minor);
} else if (disk_cfg->action == DISK_REMOVE) {
dprintf("Disk remove action processed: %x.%x\n",
disk_cfg->major, disk_cfg->minor);
void **tofree = NULL;
int ret_val = 0;
- dprintf("apply_reshape_migration_update()\n");
+ dprintf("(enter)\n");
if ((u->subdev < 0) ||
(u->subdev > 1)) {
dprintf("imsm: Error: Wrong subdev: %i\n", u->subdev);
struct intel_dev *id;
int ret_val = 0;
- dprintf("apply_size_change_update()\n");
+ dprintf("(enter)\n");
if ((u->subdev < 0) ||
(u->subdev > 1)) {
dprintf("imsm: Error: Wrong subdev: %i\n", u->subdev);
/* calculate new size
*/
blocks_per_member = u->new_size / used_disks;
- dprintf("imsm: apply_size_change_update(size: %llu, "
- "blocks per member: %llu)\n",
+ dprintf("(size: %llu, blocks per member: %llu)\n",
u->new_size, blocks_per_member);
set_blocks_per_member(map, blocks_per_member);
imsm_set_array_size(dev, u->new_size);
int ret_val = 0;
unsigned int dev_id;
- dprintf("imsm: apply_reshape_container_disks_update()\n");
+ dprintf("(enter)\n");
/* enable spares to use in array */
for (i = 0; i < delta_disks; i++) {
struct imsm_update_general_migration_checkpoint *u =
(void *)update->buf;
- dprintf("imsm: process_update() "
- "for update_general_migration_checkpoint called\n");
+ dprintf("called for update_general_migration_checkpoint\n");
/* find device under general migration */
for (id = super->devlist ; id; id = id->next) {
/* handle racing creates: first come first serve */
if (u->dev_idx < mpb->num_raid_devs) {
- dprintf("%s: subarray %d already defined\n",
- __func__, u->dev_idx);
+ dprintf("subarray %d already defined\n", u->dev_idx);
goto create_error;
}
/* check update is next in sequence */
if (u->dev_idx != mpb->num_raid_devs) {
- dprintf("%s: can not create array %d expected index %d\n",
- __func__, u->dev_idx, mpb->num_raid_devs);
+ dprintf("can not create array %d expected index %d\n",
+ u->dev_idx, mpb->num_raid_devs);
goto create_error;
}
continue;
if (disks_overlap(super, i, u)) {
- dprintf("%s: arrays overlap\n", __func__);
+ dprintf("arrays overlap\n");
goto create_error;
}
}
/* check that prepare update was successful */
if (!update->space) {
- dprintf("%s: prepare update failed\n", __func__);
+ dprintf("prepare update failed\n");
goto create_error;
}
for (i = 0; i < new_map->num_members; i++) {
dl = serial_to_dl(inf[i].serial, super);
if (!dl) {
- dprintf("%s: disk disappeared\n", __func__);
+ dprintf("disk disappeared\n");
goto create_error;
}
}
case update_general_migration_checkpoint:
if (update->len < (int)sizeof(struct imsm_update_general_migration_checkpoint))
return 0;
- dprintf("imsm: prepare_update() "
- "for update_general_migration_checkpoint called\n");
+ dprintf("called for update_general_migration_checkpoint\n");
break;
case update_takeover: {
struct imsm_update_takeover *u = (void *)update->buf;
if (update->len < (int)sizeof(*u))
return 0;
- dprintf("imsm: imsm_prepare_update() for update_reshape\n");
+ dprintf("for update_reshape\n");
for (dl = super->devlist; dl; dl = dl->next) {
int size = sizeof_imsm_dev(dl->dev, 1);
if (update->len < (int)sizeof(*u))
return 0;
- dprintf("imsm: imsm_prepare_update() for update_reshape\n");
+ dprintf("for update_reshape\n");
/* add space for bigger array in update
*/
int i, j, num_members;
__u32 ord;
- dprintf("%s: deleting device[%d] from imsm_super\n",
- __func__, index);
+ dprintf("deleting device[%d] from imsm_super\n", index);
/* shift all indexes down one */
for (iter = super->disks; iter; iter = iter->next)
ret_val = 1;
if (ret_val)
- dprintf("\tContainer operation allowed\n");
+ dprintf("Container operation allowed\n");
else
- dprintf("\tError: %i\n", ret_val);
+ dprintf("Error: %i\n", ret_val);
return ret_val;
}
int delta_disks = 0;
struct mdinfo *dev;
- dprintf("imsm_update_metadata_for_reshape(enter) raid_disks = %i\n",
- geo->raid_disks);
+ dprintf("(enter) raid_disks = %i\n", geo->raid_disks);
delta_disks = geo->raid_disks - old_raid_disks;
dprintf("imsm: reshape update preparation :");
if (i == delta_disks) {
- dprintf(" OK\n");
+ dprintf_cont(" OK\n");
*updatep = u;
return update_memory_size;
}
free(u);
- dprintf(" Error\n");
+ dprintf_cont(" Error\n");
return 0;
}
int update_memory_size = 0;
struct imsm_update_size_change *u = NULL;
- dprintf("imsm_create_metadata_update_for_size_change(enter)"
- " New size = %llu\n", geo->size);
+ dprintf("(enter) New size = %llu\n", geo->size);
/* size of all update data without anchor */
update_memory_size = sizeof(struct imsm_update_size_change);
struct imsm_dev *dev;
int previous_level = -1;
- dprintf("imsm_create_metadata_update_for_migration(enter)"
- " New Level = %i\n", geo->level);
+ dprintf("(enter) New Level = %i\n", geo->level);
/* size of all update data without anchor */
update_memory_size = sizeof(struct imsm_update_reshape_migration);
int ret_val = 1;
struct geo_params geo;
- dprintf("imsm: reshape_super called.\n");
+ dprintf("(enter)\n");
memset(&geo, 0, sizeof(struct geo_params));
if (delta_disks != UnSet)
geo.raid_disks += delta_disks;
- dprintf("\tfor level : %i\n", geo.level);
- dprintf("\tfor raid_disks : %i\n", geo.raid_disks);
+ dprintf("for level : %i\n", geo.level);
+ dprintf("for raid_disks : %i\n", geo.raid_disks);
if (experimental() == 0)
return ret_val;
unsigned long long position_to_set = to_complete / ndata;
if (fd < 0) {
- dprintf("imsm: wait_for_reshape_imsm() "
- "cannot open reshape_position\n");
+ dprintf("cannot open reshape_position\n");
return 1;
}
if (sysfs_fd_get_ll(fd, &completed) < 0) {
- dprintf("imsm: wait_for_reshape_imsm() "
- "cannot read reshape_position (no reshape in progres)\n");
+ dprintf("cannot read reshape_position (no reshape in progres)\n");
close(fd);
return 0;
}
if (completed > position_to_set) {
- dprintf("imsm: wait_for_reshape_imsm() "
- "wrong next position to set %llu (%llu)\n",
+ dprintf("wrong next position to set %llu (%llu)\n",
to_complete, position_to_set);
close(fd);
return -1;
dprintf("Position set: %llu\n", position_to_set);
if (sysfs_set_num(sra, NULL, "sync_max",
position_to_set) != 0) {
- dprintf("imsm: wait_for_reshape_imsm() "
- "cannot set reshape position to %llu\n",
+ dprintf("cannot set reshape position to %llu\n",
position_to_set);
close(fd);
return -1;
strncmp(action, "reshape", 7) != 0)
break;
if (sysfs_fd_get_ll(fd, &completed) < 0) {
- dprintf("imsm: wait_for_reshape_imsm() "
- "cannot read reshape_position (in loop)\n");
+ dprintf("cannot read reshape_position (in loop)\n");
close(fd);
return 1;
}
free_mbr(st);
if (posix_memalign((void**)&super, 512, 512) != 0) {
- pr_err("%s could not allocate superblock\n",
- __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
struct MBR *old, *super;
if (posix_memalign((void**)&old, 512, 512) != 0) {
- pr_err("%s could not allocate superblock\n",
- __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
if (posix_memalign((void**)&sb, 4096,
MD_SB_BYTES + ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
- pr_err("%s could not allocate superblock\n", __func__);
+ pr_err("could not allocate superblock\n");
return 0;
}
memset(sb, 0, MD_SB_BYTES + sizeof(bitmap_super_t));
if (posix_memalign((void**)&first, 4096,
MD_SB_BYTES +
ROUND_UP(sizeof(struct bitmap_super_s), 4096)) != 0) {
- pr_err("%s could not allocate superblock\n", __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
memcpy(first, second, MD_SB_BYTES + sizeof(struct bitmap_super_s));
if (posix_memalign((void**)&super, 4096,
MD_SB_BYTES +
ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
- pr_err("%s could not allocate superblock\n", __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
size = __le32_to_cpu(sb->bblog_size)* 512;
if (posix_memalign((void**)&bbl, 4096, size) != 0) {
- pr_err("%s could not allocate badblocks list\n", __func__);
+ pr_err("could not allocate badblocks list\n");
return 0;
}
offset = __le64_to_cpu(sb->super_offset) +
int sbsize;
if (posix_memalign((void**)&sb, 4096, SUPER1_SIZE) != 0) {
- pr_err("%s could not allocate superblock\n", __func__);
+ pr_err("could not allocate superblock\n");
return 0;
}
memset(sb, 0, SUPER1_SIZE);
if (!first) {
if (posix_memalign((void**)&first, 4096, SUPER1_SIZE) != 0) {
- pr_err("%s could not allocate superblock\n", __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
memcpy(first, second, SUPER1_SIZE);
}
if (posix_memalign((void**)&super, 4096, SUPER1_SIZE) != 0) {
- pr_err("%s could not allocate superblock\n",
- __func__);
+ pr_err("could not allocate superblock\n");
return 1;
}
n = write(fd, val, strlen(val));
close(fd);
if (n != strlen(val)) {
- dprintf("%s: failed to write '%s' to '%s' (%s)\n",
- Name, val, fname, strerror(errno));
+ dprintf("failed to write '%s' to '%s' (%s)\n",
+ val, fname, strerror(errno));
return -1;
}
return 0;
n = write(fd, event, strlen(event));
close(fd);
if (n != (int)strlen(event)) {
- dprintf("%s: failed to write '%s' to '%s' (%s)\n",
- Name, event, fname, strerror(errno));
+ dprintf("failed to write '%s' to '%s' (%s)\n",
+ event, fname, strerror(errno));
return -1;
}
return 0;
delay *= 2;
}
if (i == 25)
- dprintf("%s: timeout waiting for %s\n", __func__, dev);
+ dprintf("timeout waiting for %s\n", dev);
}
struct superswitch *superlist[] =
projects / thirdparty / mdadm.git / commitdiff
