bool librados::RadosClient::pool_requires_alignment(int64_t pool_id)
{
- bool requires;
- int r = pool_requires_alignment2(pool_id, &requires);
+ bool required;
+ int r = pool_requires_alignment2(pool_id, &required);
if (r < 0) {
// Cast answer to false, this is a little bit problematic
// since we really don't know the answer yet, say.
return false;
}
- return requires;
+ return required;
}
// a safer version of pool_requires_alignment
int librados::RadosClient::pool_requires_alignment2(int64_t pool_id,
- bool *requires)
+ bool *req)
{
- if (!requires)
+ if (!req)
return -EINVAL;
int r = wait_for_osdmap();
return r;
}
- return objecter->with_osdmap([requires, pool_id](const OSDMap& o) {
+ return objecter->with_osdmap([req, pool_id](const OSDMap& o) {
if (!o.have_pg_pool(pool_id)) {
return -ENOENT;
}
- *requires = o.get_pg_pool(pool_id)->requires_aligned_append();
+ *req = o.get_pg_pool(pool_id)->requires_aligned_append();
return 0;
});
}
int get_fsid(std::string *s);
int64_t lookup_pool(const char *name);
bool pool_requires_alignment(int64_t pool_id);
- int pool_requires_alignment2(int64_t pool_id, bool *requires);
+ int pool_requires_alignment2(int64_t pool_id, bool *req);
uint64_t pool_required_alignment(int64_t pool_id);
int pool_required_alignment2(int64_t pool_id, uint64_t *alignment);
int pool_get_name(uint64_t pool_id, std::string *name,
extern "C" int LIBRADOS_C_API_DEFAULT_F(rados_ioctx_pool_requires_alignment2)(
rados_ioctx_t io,
- int *requires)
+ int *req)
{
tracepoint(librados, rados_ioctx_pool_requires_alignment_enter2, io);
librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io;
&requires_alignment);
tracepoint(librados, rados_ioctx_pool_requires_alignment_exit2, retval,
requires_alignment);
- if (requires)
- *requires = requires_alignment;
+ if (req)
+ *req = requires_alignment;
return retval;
}
LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_requires_alignment2);
return io_ctx_impl->client->pool_requires_alignment(get_id());
}
-int librados::IoCtx::pool_requires_alignment2(bool *requires)
+int librados::IoCtx::pool_requires_alignment2(bool *req)
{
- return io_ctx_impl->client->pool_requires_alignment2(get_id(), requires);
+ return io_ctx_impl->client->pool_requires_alignment2(get_id(), req);
}
uint64_t librados::IoCtx::pool_required_alignment()
{
cluster = RadosTestNS::s_cluster;
ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
- int requires;
- ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &requires));
- ASSERT_FALSE(requires);
+ int req;
+ ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &req));
+ ASSERT_FALSE(req);
}
void RadosTestNS::TearDown()
{
cluster = RadosTestECNS::s_cluster;
ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
- int requires;
- ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &requires));
- ASSERT_TRUE(requires);
+ int req;
+ ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &req));
+ ASSERT_TRUE(req);
ASSERT_EQ(0, rados_ioctx_pool_required_alignment2(ioctx, &alignment));
ASSERT_NE(0U, alignment);
}
ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
nspace = get_temp_pool_name();
rados_ioctx_set_namespace(ioctx, nspace.c_str());
- int requires;
- ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &requires));
- ASSERT_FALSE(requires);
+ int req;
+ ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &req));
+ ASSERT_FALSE(req);
}
void RadosTest::TearDown()
ASSERT_EQ(0, rados_ioctx_create(cluster, pool_name.c_str(), &ioctx));
nspace = get_temp_pool_name();
rados_ioctx_set_namespace(ioctx, nspace.c_str());
- int requires;
- ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &requires));
- ASSERT_TRUE(requires);
+ int req;
+ ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(ioctx, &req));
+ ASSERT_TRUE(req);
ASSERT_EQ(0, rados_ioctx_pool_required_alignment2(ioctx, &alignment));
ASSERT_NE(0U, alignment);
}
ASSERT_EQ("", test_data.init());
ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
nullptr, &my_completion));
- int requires;
- ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(test_data.m_ioctx, &requires));
- ASSERT_NE(0, requires);
+ int req;
+ ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(test_data.m_ioctx, &req));
+ ASSERT_NE(0, req);
uint64_t alignment;
ASSERT_EQ(0, rados_ioctx_pool_required_alignment2(test_data.m_ioctx, &alignment));
ASSERT_NE(0U, alignment);
ASSERT_EQ("", test_data.init());
auto my_completion = std::unique_ptr<AioCompletion>{Rados::aio_create_completion()};
ASSERT_TRUE(my_completion);
- bool requires;
- ASSERT_EQ(0, test_data.m_ioctx.pool_requires_alignment2(&requires));
- ASSERT_TRUE(requires);
+ bool req;
+ ASSERT_EQ(0, test_data.m_ioctx.pool_requires_alignment2(&req));
+ ASSERT_TRUE(req);
uint64_t alignment;
ASSERT_EQ(0, test_data.m_ioctx.pool_required_alignment2(&alignment));
ASSERT_NE((unsigned)0, alignment);
void RadosTestPPNS::SetUp()
{
ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
- bool requires;
- ASSERT_EQ(0, ioctx.pool_requires_alignment2(&requires));
- ASSERT_FALSE(requires);
+ bool req;
+ ASSERT_EQ(0, ioctx.pool_requires_alignment2(&req));
+ ASSERT_FALSE(req);
}
void RadosTestPPNS::TearDown()
}
ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
- bool requires;
- ASSERT_EQ(0, ioctx.pool_requires_alignment2(&requires));
- ASSERT_FALSE(requires);
+ bool req;
+ ASSERT_EQ(0, ioctx.pool_requires_alignment2(&req));
+ ASSERT_FALSE(req);
}
void RadosTestParamPPNS::TearDown()
void RadosTestECPPNS::SetUp()
{
ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
- bool requires;
- ASSERT_EQ(0, ioctx.pool_requires_alignment2(&requires));
- ASSERT_TRUE(requires);
+ bool req;
+ ASSERT_EQ(0, ioctx.pool_requires_alignment2(&req));
+ ASSERT_TRUE(req);
ASSERT_EQ(0, ioctx.pool_required_alignment2(&alignment));
ASSERT_NE(0U, alignment);
}
ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
nspace = get_temp_pool_name();
ioctx.set_namespace(nspace);
- bool requires;
- ASSERT_EQ(0, ioctx.pool_requires_alignment2(&requires));
- ASSERT_FALSE(requires);
+ bool req;
+ ASSERT_EQ(0, ioctx.pool_requires_alignment2(&req));
+ ASSERT_FALSE(req);
}
void RadosTestPP::TearDown()
ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
nspace = get_temp_pool_name();
ioctx.set_namespace(nspace);
- bool requires;
- ASSERT_EQ(0, ioctx.pool_requires_alignment2(&requires));
- ASSERT_FALSE(requires);
+ bool req;
+ ASSERT_EQ(0, ioctx.pool_requires_alignment2(&req));
+ ASSERT_FALSE(req);
}
void RadosTestParamPP::TearDown()
ASSERT_EQ(0, cluster.ioctx_create(pool_name.c_str(), ioctx));
nspace = get_temp_pool_name();
ioctx.set_namespace(nspace);
- bool requires;
- ASSERT_EQ(0, ioctx.pool_requires_alignment2(&requires));
- ASSERT_TRUE(requires);
+ bool req;
+ ASSERT_EQ(0, ioctx.pool_requires_alignment2(&req));
+ ASSERT_TRUE(req);
ASSERT_EQ(0, ioctx.pool_required_alignment2(&alignment));
ASSERT_NE(0U, alignment);
}
// align op_size
{
- bool requires;
- ret = io_ctx.pool_requires_alignment2(&requires);
+ bool req;
+ ret = io_ctx.pool_requires_alignment2(&req);
if (ret < 0) {
cerr << "error checking pool alignment requirement"
<< cpp_strerror(ret) << std::endl;
return 1;
}
- if (requires) {
+ if (req) {
uint64_t align = 0;
ret = io_ctx.pool_required_alignment2(&align);
if (ret < 0) {
TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_exit2,
TP_ARGS(
int, retval,
- int, requires),
+ int, req),
TP_FIELDS(
ctf_integer(int, retval, retval)
- ctf_integer(int, requires, requires)
+ ctf_integer(int, requires, req)
)
)