/*
* convert_v2_v3 -- (internal) informs the user of the unfortunate fate of their
* pools.
*
* The change introduced in the third major layout version impacts the internal
* alignment of user structures and as such, a generic conversion is not
* possible.
*/
static int
convert_v2_v3(void *poolset, void *addr)
{
printf("The conversion can only be made automatically if the\n"
"PMEMmutex, PMEMrwlock and PMEMcond types are not used in the\n"
"pool or all of the variables of those three types are aligned "
"to 8 bytes.\nProceed only if you are sure that the above is "
"true for this pool.\n");
if (ask_Yn('?', "convert the pool ?") == 'y') {
return 0;
}
return -1;
}
/*
* rm_file -- remove single file
*/
static void
rm_file(const char *file)
{
int write_protected = access(file, W_OK) != 0;
char cask = 'y';
switch (ask_mode) {
case ASK_ALWAYS:
cask = '?';
break;
case ASK_NEVER:
cask = 'y';
break;
case ASK_SOMETIMES:
cask = write_protected ? '?' : 'y';
break;
}
const char *pre_msg = write_protected ? "write-protected " : "";
if (ask_Yn(cask, "remove %sfile '%s' ?", pre_msg, file) == 'y') {
if (util_unlink(file))
err(1, "cannot remove file '%s'", file);
outv(1, "removed '%s'\n", file);
}
}
/*
* pmempool_convert_func -- main function for convert command
*/
int
pmempool_convert_func(char *appname, int argc, char *argv[])
{
if (argc != 2) {
print_usage(appname);
return -1;
}
int ret = 0;
const char *f = argv[1];
struct pmem_pool_params params;
if (pmem_pool_parse_params(f, ¶ms, 1)) {
fprintf(stderr, "Cannot determine type of pool.\n");
return -1;
}
if (params.is_part) {
fprintf(stderr, "Conversion cannot be performed on "
"a poolset part.\n");
return -1;
}
if (params.type != PMEM_POOL_TYPE_OBJ) {
fprintf(stderr, "Conversion is currently supported only for "
"pmemobj pools.\n");
return -1;
}
struct pool_set_file *psf = pool_set_file_open(f, 0, 1);
if (psf == NULL) {
perror(f);
return -1;
}
if (psf->poolset->remote) {
fprintf(stderr, "Conversion of remotely replicated pools is "
"currently not supported. Remove the replica first\n");
pool_set_file_close(psf);
return -1;
}
void *addr = pool_set_file_map(psf, 0);
if (addr == NULL) {
perror(f);
ret = -1;
goto out;
}
struct pool_hdr *phdr = addr;
uint32_t m = le32toh(phdr->major);
if (m >= COUNT_OF(version_convert) || !version_convert[m]) {
fprintf(stderr, "There's no conversion method for the pool.\n"
"Please make sure the pmempool utility "
"is up-to-date.\n");
ret = -1;
goto out;
}
printf("This tool will update the pool to the latest available "
"layout version.\nThis process is NOT fail-safe.\n"
"Proceed only if the pool has been backed up or\n"
"the risks are fully understood and acceptable.\n");
if (ask_Yn('?', "convert the pool '%s' ?", f) != 'y') {
ret = 0;
goto out;
}
PMEMobjpool *pop = addr;
for (unsigned r = 0; r < psf->poolset->nreplicas; ++r) {
struct pool_replica *rep = psf->poolset->replica[r];
for (unsigned p = 0; p < rep->nparts; ++p) {
struct pool_set_part *part = &rep->part[p];
if (util_map_hdr(part, MAP_SHARED, 0) != 0) {
fprintf(stderr, "Failed to map headers.\n"
"Conversion did not start.\n");
ret = -1;
goto out;
}
}
}
uint32_t i;
for (i = m; i < COUNT_OF(version_convert); ++i) {
if (version_convert[i](psf, pop) != 0) {
fprintf(stderr, "Failed to convert the pool\n");
break;
} else {
/* need to update every header of every part */
uint32_t target_m = i + 1;
for (unsigned r = 0; r < psf->poolset->nreplicas; ++r) {
struct pool_replica *rep =
psf->poolset->replica[r];
for (unsigned p = 0; p < rep->nparts; ++p) {
struct pool_set_part *part =
&rep->part[p];
struct pool_hdr *hdr = part->hdr;
hdr->major = htole32(target_m);
util_checksum(hdr, sizeof(*hdr),
&hdr->checksum, 1);
PERSIST_GENERIC_AUTO(hdr,
sizeof(struct pool_hdr));
}
}
}
}
if (i != m) /* at least one step has been performed */
printf("The pool has been converted to version %d\n.", i);
PERSIST_GENERIC_AUTO(pop, psf->size);
out:
for (unsigned r = 0; r < psf->poolset->nreplicas; ++r) {
struct pool_replica *rep = psf->poolset->replica[r];
for (unsigned p = 0; p < rep->nparts; ++p) {
struct pool_set_part *part = &rep->part[p];
if (part->hdr != NULL)
util_unmap_hdr(part);
}
}
pool_set_file_close(psf);
return ret;
}
/*
* remove_remote -- (internal) remove remote pool
*/
static int
remove_remote(const char *target, const char *pool_set)
{
#ifdef USE_RPMEM
char cask = 'y';
switch (ask_mode) {
case ASK_ALWAYS:
cask = '?';
break;
case ASK_NEVER:
case ASK_SOMETIMES:
cask = 'y';
break;
}
if (ask_Yn(cask, "remove remote pool '%s' on '%s'?",
pool_set, target) != 'y')
return 0;
struct rpmem_target_info *info = rpmem_target_parse(target);
if (!info)
goto err_parse;
struct rpmem_ssh *ssh;
if (force) {
ssh = rpmem_ssh_exec(info, "--remove",
pool_set, "--force", NULL);
} else {
ssh = rpmem_ssh_exec(info, "--remove",
pool_set, NULL);
}
if (!ssh)
goto err_ssh_exec;
int ret = 0;
if (rpmem_ssh_monitor(ssh, 0))
ret = 1;
if (rpmem_ssh_close(ssh))
ret = 1;
if (ret)
goto err_ssh_exec;
rpmem_target_free(info);
outv(1, "removed '%s' on '%s'\n",
pool_set, target);
return ret;
err_ssh_exec:
rpmem_target_free(info);
err_parse:
if (!force)
outv_err("cannot remove '%s' on '%s'", pool_set, target);
return 1;
#else
outv_err("remote replication not supported");
return 1;
#endif
}
