/*
* replica_get_pool_size -- find the effective size (mapped) of a pool based
* on metadata from given replica
*/
size_t
replica_get_pool_size(struct pool_set *set, unsigned repn)
{
LOG(3, "set %p, repn %u", set, repn);
struct pool_set_part *part = &PART(REP(set, repn), 0);
int should_close_part = 0;
int should_unmap_part = 0;
if (part->fd == -1) {
if (util_part_open(part, 0, 0))
return set->poolsize;
should_close_part = 1;
}
if (part->addr == NULL) {
if (util_map_part(part, NULL,
MMAP_ALIGN_UP(sizeof(PMEMobjpool)), 0,
MAP_SHARED, 1)) {
util_part_fdclose(part);
return set->poolsize;
}
should_unmap_part = 1;
}
PMEMobjpool *pop = (PMEMobjpool *)part->addr;
size_t ret = pop->heap_offset + pop->heap_size;
if (should_unmap_part)
util_unmap_part(part);
if (should_close_part)
util_part_fdclose(part);
return ret;
}
/*
* recreate_broken_parts -- (internal) create parts in place of the broken ones
*/
static int
recreate_broken_parts(struct pool_set *set,
struct poolset_health_status *set_hs, unsigned flags)
{
for (unsigned r = 0; r < set_hs->nreplicas; ++r) {
struct pool_replica *broken_r = set->replica[r];
for (unsigned p = 0; p < set_hs->replica[r]->nparts; ++p) {
/* skip unbroken parts */
if (!replica_is_part_broken(r, p, set_hs))
continue;
/* remove parts from broken replica */
if (!is_dry_run(flags)) {
if (replica_remove_part(set, r, p)) {
ERR("Cannot remove part");
errno = EINVAL;
return -1;
}
}
/* create removed part and open it */
if (util_part_open(&broken_r->part[p], 0,
!is_dry_run(flags))) {
ERR("Cannot open/create parts");
errno = EINVAL;
return -1;
}
}
}
return 0;
}
/*
* replica_get_pool_size -- find the effective size (mapped) of a pool based
* on metadata from given replica
*/
size_t
replica_get_pool_size(struct pool_set *set, unsigned repn)
{
struct pool_set_part *part = &PART(REP(set, repn), 0);
int should_close_part = 0;
if (part->fd == -1) {
if (util_part_open(part, 0, 0))
return set->poolsize;
if (util_map_part(part, NULL, sizeof(PMEMobjpool), 0,
MAP_PRIVATE|MAP_NORESERVE)) {
util_part_fdclose(part);
return set->poolsize;
}
should_close_part = 1;
}
PMEMobjpool *pop = (PMEMobjpool *)part->addr;
size_t ret = pop->heap_offset + pop->heap_size;
if (should_close_part) {
util_unmap_part(part);
util_part_fdclose(part);
}
return ret;
}
/*
* check_and_open_poolset_part_files -- (internal) for each part in a poolset
* check if the part files are accessible, and if not, mark it as broken
* in a helping structure; then open the part file
*/
static int
check_and_open_poolset_part_files(struct pool_set *set,
struct poolset_health_status *set_hs, unsigned flags)
{
LOG(3, "set %p, set_hs %p, flags %u", set, set_hs, flags);
for (unsigned r = 0; r < set->nreplicas; ++r) {
struct pool_replica *rep = set->replica[r];
struct replica_health_status *rep_hs = set_hs->replica[r];
if (rep->remote) {
if (util_replica_open_remote(set, r, 0)) {
LOG(1, "cannot open remote replica no %u", r);
return -1;
}
unsigned nlanes = REMOTE_NLANES;
int ret = util_poolset_remote_open(rep, r,
rep->repsize, 0,
rep->part[0].addr,
rep->part[0].size, &nlanes);
if (ret)
rep_hs->flags |= IS_BROKEN;
continue;
}
for (unsigned p = 0; p < rep->nparts; ++p) {
if (access(rep->part[p].path, R_OK|W_OK) != 0) {
LOG(1, "part file %s is not accessible",
rep->part[p].path);
errno = 0;
rep_hs->part[p] |= IS_BROKEN;
if (is_dry_run(flags))
continue;
}
if (util_part_open(&rep->part[p], 0, 0)) {
LOG(1, "opening part %s failed",
rep->part[p].path);
errno = 0;
rep_hs->part[p] |= IS_BROKEN;
}
}
}
return 0;
}
/*
* replica_open_replica_part_files -- open all part files for a replica
*/
int
replica_open_replica_part_files(struct pool_set *set, unsigned repn)
{
struct pool_replica *rep = set->replica[repn];
for (unsigned p = 0; p < rep->nparts; ++p) {
/* skip already opened files */
if (rep->part[p].fd != -1)
continue;
if (util_part_open(&rep->part[p], 0, 0)) {
LOG(1, "part files open failed for replica %u, part %u",
repn, p);
errno = EINVAL;
goto err;
}
}
return 0;
err:
util_replica_fdclose(set->replica[repn]);
return -1;
}
