forked from vitalif/vitastor
Rename osd_op_t.op to req
parent
72a89be912
commit
4a52a15564
24
osd.cpp
24
osd.cpp
|
@ -99,7 +99,7 @@ osd_op_t::~osd_op_t()
|
||||||
// Note: reusing osd_op_t WILL currently lead to memory leaks
|
// Note: reusing osd_op_t WILL currently lead to memory leaks
|
||||||
// So we don't reuse it, but free it every time
|
// So we don't reuse it, but free it every time
|
||||||
if (op_type == OSD_OP_IN &&
|
if (op_type == OSD_OP_IN &&
|
||||||
op.hdr.opcode == OSD_OP_SHOW_CONFIG)
|
req.hdr.opcode == OSD_OP_SHOW_CONFIG)
|
||||||
{
|
{
|
||||||
std::string *str = (std::string*)buf;
|
std::string *str = (std::string*)buf;
|
||||||
delete str;
|
delete str;
|
||||||
|
@ -245,8 +245,8 @@ void osd_t::cancel_osd_ops(osd_client_t & cl)
|
||||||
void osd_t::cancel_op(osd_op_t *op)
|
void osd_t::cancel_op(osd_op_t *op)
|
||||||
{
|
{
|
||||||
op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
||||||
op->reply.hdr.id = op->op.hdr.id;
|
op->reply.hdr.id = op->req.hdr.id;
|
||||||
op->reply.hdr.opcode = op->op.hdr.opcode;
|
op->reply.hdr.opcode = op->req.hdr.opcode;
|
||||||
op->reply.hdr.retval = -EPIPE;
|
op->reply.hdr.retval = -EPIPE;
|
||||||
op->callback(op);
|
op->callback(op);
|
||||||
}
|
}
|
||||||
|
@ -304,30 +304,30 @@ void osd_t::exec_op(osd_op_t *cur_op)
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
inflight_ops++;
|
inflight_ops++;
|
||||||
if (cur_op->op.hdr.magic != SECONDARY_OSD_OP_MAGIC ||
|
if (cur_op->req.hdr.magic != SECONDARY_OSD_OP_MAGIC ||
|
||||||
cur_op->op.hdr.opcode < OSD_OP_MIN || cur_op->op.hdr.opcode > OSD_OP_MAX ||
|
cur_op->req.hdr.opcode < OSD_OP_MIN || cur_op->req.hdr.opcode > OSD_OP_MAX ||
|
||||||
(cur_op->op.hdr.opcode == OSD_OP_SECONDARY_READ || cur_op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE ||
|
(cur_op->req.hdr.opcode == OSD_OP_SECONDARY_READ || cur_op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_READ || cur_op->op.hdr.opcode == OSD_OP_WRITE) &&
|
cur_op->req.hdr.opcode == OSD_OP_READ || cur_op->req.hdr.opcode == OSD_OP_WRITE) &&
|
||||||
(cur_op->op.sec_rw.len > OSD_RW_MAX || cur_op->op.sec_rw.len % OSD_RW_ALIGN || cur_op->op.sec_rw.offset % OSD_RW_ALIGN))
|
(cur_op->req.sec_rw.len > OSD_RW_MAX || cur_op->req.sec_rw.len % OSD_RW_ALIGN || cur_op->req.sec_rw.offset % OSD_RW_ALIGN))
|
||||||
{
|
{
|
||||||
// Bad command
|
// Bad command
|
||||||
cur_op->bs_op.retval = -EINVAL;
|
cur_op->bs_op.retval = -EINVAL;
|
||||||
secondary_op_callback(cur_op);
|
secondary_op_callback(cur_op);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (cur_op->op.hdr.opcode == OSD_OP_TEST_SYNC_STAB_ALL)
|
if (cur_op->req.hdr.opcode == OSD_OP_TEST_SYNC_STAB_ALL)
|
||||||
{
|
{
|
||||||
exec_sync_stab_all(cur_op);
|
exec_sync_stab_all(cur_op);
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_SHOW_CONFIG)
|
else if (cur_op->req.hdr.opcode == OSD_OP_SHOW_CONFIG)
|
||||||
{
|
{
|
||||||
exec_show_config(cur_op);
|
exec_show_config(cur_op);
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_READ)
|
else if (cur_op->req.hdr.opcode == OSD_OP_READ)
|
||||||
{
|
{
|
||||||
exec_primary_read(cur_op);
|
exec_primary_read(cur_op);
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_WRITE)
|
else if (cur_op->req.hdr.opcode == OSD_OP_WRITE)
|
||||||
{
|
{
|
||||||
exec_primary_write(cur_op);
|
exec_primary_write(cur_op);
|
||||||
}
|
}
|
||||||
|
|
2
osd.h
2
osd.h
|
@ -98,7 +98,7 @@ struct osd_op_t
|
||||||
{
|
{
|
||||||
int op_type;
|
int op_type;
|
||||||
int peer_fd;
|
int peer_fd;
|
||||||
osd_any_op_t op;
|
osd_any_op_t req;
|
||||||
osd_any_reply_t reply;
|
osd_any_reply_t reply;
|
||||||
blockstore_op_t bs_op;
|
blockstore_op_t bs_op;
|
||||||
void *buf = NULL;
|
void *buf = NULL;
|
||||||
|
|
|
@ -4,18 +4,18 @@ void slice()
|
||||||
// Primary OSD still operates individual stripes, except they're twice the size of the blockstore's stripe.
|
// Primary OSD still operates individual stripes, except they're twice the size of the blockstore's stripe.
|
||||||
std::vector read_parts;
|
std::vector read_parts;
|
||||||
int block = bs->get_block_size();
|
int block = bs->get_block_size();
|
||||||
uint64_t stripe1 = cur_op->op.rw.offset / block / 2;
|
uint64_t stripe1 = cur_op->req.rw.offset / block / 2;
|
||||||
uint64_t stripe2 = (cur_op->op.rw.offset + cur_op->op.rw.len + block*2 - 1) / block / 2 - 1;
|
uint64_t stripe2 = (cur_op->req.rw.offset + cur_op->req.rw.len + block*2 - 1) / block / 2 - 1;
|
||||||
for (uint64_t s = stripe1; s <= stripe2; s++)
|
for (uint64_t s = stripe1; s <= stripe2; s++)
|
||||||
{
|
{
|
||||||
uint64_t start = s == stripe1 ? cur_op->op.rw.offset - stripe1*block*2 : 0;
|
uint64_t start = s == stripe1 ? cur_op->req.rw.offset - stripe1*block*2 : 0;
|
||||||
uint64_t end = s == stripe2 ? cur_op->op.rw.offset + cur_op->op.rw.len - stripe2*block*2 : block*2;
|
uint64_t end = s == stripe2 ? cur_op->req.rw.offset + cur_op->req.rw.len - stripe2*block*2 : block*2;
|
||||||
if (start < block)
|
if (start < block)
|
||||||
{
|
{
|
||||||
read_parts.push_back({
|
read_parts.push_back({
|
||||||
.role = 1,
|
.role = 1,
|
||||||
.oid = {
|
.oid = {
|
||||||
.inode = cur_op->op.rw.inode,
|
.inode = cur_op->req.rw.inode,
|
||||||
.stripe = (s << STRIPE_ROLE_BITS) | 1,
|
.stripe = (s << STRIPE_ROLE_BITS) | 1,
|
||||||
},
|
},
|
||||||
.version = UINT64_MAX,
|
.version = UINT64_MAX,
|
||||||
|
@ -28,7 +28,7 @@ void slice()
|
||||||
read_parts.push_back({
|
read_parts.push_back({
|
||||||
.role = 2,
|
.role = 2,
|
||||||
.oid = {
|
.oid = {
|
||||||
.inode = cur_op->op.rw.inode,
|
.inode = cur_op->req.rw.inode,
|
||||||
.stripe = (s << STRIPE_ROLE_BITS) | 2,
|
.stripe = (s << STRIPE_ROLE_BITS) | 2,
|
||||||
},
|
},
|
||||||
.version = UINT64_MAX,
|
.version = UINT64_MAX,
|
||||||
|
|
|
@ -21,46 +21,46 @@ void osd_t::secondary_op_callback(osd_op_t *cur_op)
|
||||||
void osd_t::exec_secondary(osd_op_t *cur_op)
|
void osd_t::exec_secondary(osd_op_t *cur_op)
|
||||||
{
|
{
|
||||||
cur_op->bs_op.callback = [this, cur_op](blockstore_op_t* bs_op) { secondary_op_callback(cur_op); };
|
cur_op->bs_op.callback = [this, cur_op](blockstore_op_t* bs_op) { secondary_op_callback(cur_op); };
|
||||||
cur_op->bs_op.opcode = (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_READ ? BS_OP_READ
|
cur_op->bs_op.opcode = (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_READ ? BS_OP_READ
|
||||||
: (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE ? BS_OP_WRITE
|
: (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE ? BS_OP_WRITE
|
||||||
: (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_SYNC ? BS_OP_SYNC
|
: (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_SYNC ? BS_OP_SYNC
|
||||||
: (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ? BS_OP_STABLE
|
: (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ? BS_OP_STABLE
|
||||||
: (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK ? BS_OP_ROLLBACK
|
: (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK ? BS_OP_ROLLBACK
|
||||||
: (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_DELETE ? BS_OP_DELETE
|
: (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_DELETE ? BS_OP_DELETE
|
||||||
: (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_LIST ? BS_OP_LIST
|
: (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_LIST ? BS_OP_LIST
|
||||||
: -1)))))));
|
: -1)))))));
|
||||||
if (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_READ ||
|
if (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_READ ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE)
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE)
|
||||||
{
|
{
|
||||||
cur_op->bs_op.oid = cur_op->op.sec_rw.oid;
|
cur_op->bs_op.oid = cur_op->req.sec_rw.oid;
|
||||||
cur_op->bs_op.version = cur_op->op.sec_rw.version;
|
cur_op->bs_op.version = cur_op->req.sec_rw.version;
|
||||||
cur_op->bs_op.offset = cur_op->op.sec_rw.offset;
|
cur_op->bs_op.offset = cur_op->req.sec_rw.offset;
|
||||||
cur_op->bs_op.len = cur_op->op.sec_rw.len;
|
cur_op->bs_op.len = cur_op->req.sec_rw.len;
|
||||||
cur_op->bs_op.buf = cur_op->buf;
|
cur_op->bs_op.buf = cur_op->buf;
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_DELETE)
|
else if (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_DELETE)
|
||||||
{
|
{
|
||||||
cur_op->bs_op.oid = cur_op->op.sec_del.oid;
|
cur_op->bs_op.oid = cur_op->req.sec_del.oid;
|
||||||
cur_op->bs_op.version = cur_op->op.sec_del.version;
|
cur_op->bs_op.version = cur_op->req.sec_del.version;
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ||
|
else if (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK)
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK)
|
||||||
{
|
{
|
||||||
cur_op->bs_op.len = cur_op->op.sec_stab.len/sizeof(obj_ver_id);
|
cur_op->bs_op.len = cur_op->req.sec_stab.len/sizeof(obj_ver_id);
|
||||||
cur_op->bs_op.buf = cur_op->buf;
|
cur_op->bs_op.buf = cur_op->buf;
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_LIST)
|
else if (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_LIST)
|
||||||
{
|
{
|
||||||
if (cur_op->op.sec_list.pg_count < cur_op->op.sec_list.list_pg)
|
if (cur_op->req.sec_list.pg_count < cur_op->req.sec_list.list_pg)
|
||||||
{
|
{
|
||||||
// requested pg number is greater than total pg count
|
// requested pg number is greater than total pg count
|
||||||
cur_op->bs_op.retval = -EINVAL;
|
cur_op->bs_op.retval = -EINVAL;
|
||||||
secondary_op_callback(cur_op);
|
secondary_op_callback(cur_op);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
cur_op->bs_op.oid.stripe = cur_op->op.sec_list.parity_block_size;
|
cur_op->bs_op.oid.stripe = cur_op->req.sec_list.parity_block_size;
|
||||||
cur_op->bs_op.len = cur_op->op.sec_list.pg_count;
|
cur_op->bs_op.len = cur_op->req.sec_list.pg_count;
|
||||||
cur_op->bs_op.offset = cur_op->op.sec_list.list_pg - 1;
|
cur_op->bs_op.offset = cur_op->req.sec_list.list_pg - 1;
|
||||||
}
|
}
|
||||||
#ifdef OSD_STUB
|
#ifdef OSD_STUB
|
||||||
cur_op->bs_op.retval = cur_op->bs_op.len;
|
cur_op->bs_op.retval = cur_op->bs_op.len;
|
||||||
|
@ -92,15 +92,15 @@ void osd_t::exec_sync_stab_all(osd_op_t *cur_op)
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
cur_op->bs_op.opcode = BS_OP_SYNC;
|
cur_op->bs_op.opcode = BS_OP_SYNC;
|
||||||
cur_op->bs_op.callback = [this, cur_op](blockstore_op_t *op)
|
cur_op->bs_op.callback = [this, cur_op](blockstore_op_t *bs_op)
|
||||||
{
|
{
|
||||||
auto & unstable_writes = bs->get_unstable_writes();
|
auto & unstable_writes = bs->get_unstable_writes();
|
||||||
if (op->retval >= 0 && unstable_writes.size() > 0)
|
if (bs_op->retval >= 0 && unstable_writes.size() > 0)
|
||||||
{
|
{
|
||||||
op->opcode = BS_OP_STABLE;
|
bs_op->opcode = BS_OP_STABLE;
|
||||||
op->len = unstable_writes.size();
|
bs_op->len = unstable_writes.size();
|
||||||
obj_ver_id *vers = new obj_ver_id[op->len];
|
obj_ver_id *vers = new obj_ver_id[bs_op->len];
|
||||||
op->buf = vers;
|
bs_op->buf = vers;
|
||||||
int i = 0;
|
int i = 0;
|
||||||
for (auto it = unstable_writes.begin(); it != unstable_writes.end(); it++, i++)
|
for (auto it = unstable_writes.begin(); it != unstable_writes.end(); it++, i++)
|
||||||
{
|
{
|
||||||
|
@ -110,13 +110,13 @@ void osd_t::exec_sync_stab_all(osd_op_t *cur_op)
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
unstable_writes.clear();
|
unstable_writes.clear();
|
||||||
op->callback = [this, cur_op](blockstore_op_t *op)
|
bs_op->callback = [this, cur_op](blockstore_op_t *bs_op)
|
||||||
{
|
{
|
||||||
secondary_op_callback(cur_op);
|
secondary_op_callback(cur_op);
|
||||||
obj_ver_id *vers = (obj_ver_id*)op->buf;
|
obj_ver_id *vers = (obj_ver_id*)bs_op->buf;
|
||||||
delete[] vers;
|
delete[] vers;
|
||||||
};
|
};
|
||||||
bs->enqueue_op(op);
|
bs->enqueue_op(bs_op);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -134,9 +134,9 @@ void osd_t::exec_sync_stab_all(osd_op_t *cur_op)
|
||||||
void osd_t::make_reply(osd_op_t *op)
|
void osd_t::make_reply(osd_op_t *op)
|
||||||
{
|
{
|
||||||
op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
||||||
op->reply.hdr.id = op->op.hdr.id;
|
op->reply.hdr.id = op->req.hdr.id;
|
||||||
op->reply.hdr.opcode = op->op.hdr.opcode;
|
op->reply.hdr.opcode = op->req.hdr.opcode;
|
||||||
if (op->op.hdr.opcode == OSD_OP_SHOW_CONFIG)
|
if (op->req.hdr.opcode == OSD_OP_SHOW_CONFIG)
|
||||||
{
|
{
|
||||||
std::string *str = (std::string*)op->buf;
|
std::string *str = (std::string*)op->buf;
|
||||||
op->reply.hdr.retval = str->size()+1;
|
op->reply.hdr.retval = str->size()+1;
|
||||||
|
@ -145,20 +145,20 @@ void osd_t::make_reply(osd_op_t *op)
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
op->reply.hdr.retval = op->bs_op.retval;
|
op->reply.hdr.retval = op->bs_op.retval;
|
||||||
if (op->op.hdr.opcode == OSD_OP_SECONDARY_LIST)
|
if (op->req.hdr.opcode == OSD_OP_SECONDARY_LIST)
|
||||||
op->reply.sec_list.stable_count = op->bs_op.version;
|
op->reply.sec_list.stable_count = op->bs_op.version;
|
||||||
else if (op->op.hdr.opcode == OSD_OP_SECONDARY_READ ||
|
else if (op->req.hdr.opcode == OSD_OP_SECONDARY_READ ||
|
||||||
op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE)
|
op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE)
|
||||||
op->reply.sec_rw.version = op->bs_op.version;
|
op->reply.sec_rw.version = op->bs_op.version;
|
||||||
else if (op->op.hdr.opcode == OSD_OP_SECONDARY_DELETE)
|
else if (op->req.hdr.opcode == OSD_OP_SECONDARY_DELETE)
|
||||||
op->reply.sec_del.version = op->bs_op.version;
|
op->reply.sec_del.version = op->bs_op.version;
|
||||||
}
|
}
|
||||||
if (op->op.hdr.opcode == OSD_OP_SECONDARY_READ &&
|
if (op->req.hdr.opcode == OSD_OP_SECONDARY_READ &&
|
||||||
op->reply.hdr.retval > 0)
|
op->reply.hdr.retval > 0)
|
||||||
{
|
{
|
||||||
op->send_list.push_back(op->buf, op->reply.hdr.retval);
|
op->send_list.push_back(op->buf, op->reply.hdr.retval);
|
||||||
}
|
}
|
||||||
else if (op->op.hdr.opcode == OSD_OP_SECONDARY_LIST &&
|
else if (op->req.hdr.opcode == OSD_OP_SECONDARY_LIST &&
|
||||||
op->reply.hdr.retval > 0)
|
op->reply.hdr.retval > 0)
|
||||||
{
|
{
|
||||||
op->buf = op->bs_op.buf; // allocated by blockstore
|
op->buf = op->bs_op.buf; // allocated by blockstore
|
||||||
|
|
|
@ -348,7 +348,7 @@ void osd_t::start_pg_peering(int pg_idx)
|
||||||
osd_op_t *op = new osd_op_t();
|
osd_op_t *op = new osd_op_t();
|
||||||
op->op_type = OSD_OP_OUT;
|
op->op_type = OSD_OP_OUT;
|
||||||
op->peer_fd = cl.peer_fd;
|
op->peer_fd = cl.peer_fd;
|
||||||
op->op = {
|
op->req = {
|
||||||
.sec_list = {
|
.sec_list = {
|
||||||
.header = {
|
.header = {
|
||||||
.magic = SECONDARY_OSD_OP_MAGIC,
|
.magic = SECONDARY_OSD_OP_MAGIC,
|
||||||
|
|
|
@ -28,8 +28,8 @@ void osd_t::finish_primary_op(osd_op_t *cur_op, int retval)
|
||||||
{
|
{
|
||||||
// FIXME add separate magics
|
// FIXME add separate magics
|
||||||
cur_op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
cur_op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
|
||||||
cur_op->reply.hdr.id = cur_op->op.hdr.id;
|
cur_op->reply.hdr.id = cur_op->req.hdr.id;
|
||||||
cur_op->reply.hdr.opcode = cur_op->op.hdr.opcode;
|
cur_op->reply.hdr.opcode = cur_op->req.hdr.opcode;
|
||||||
cur_op->reply.hdr.retval = retval;
|
cur_op->reply.hdr.retval = retval;
|
||||||
outbox_push(this->clients[cur_op->peer_fd], cur_op);
|
outbox_push(this->clients[cur_op->peer_fd], cur_op);
|
||||||
}
|
}
|
||||||
|
@ -41,7 +41,7 @@ bool osd_t::prepare_primary_rw(osd_op_t *cur_op)
|
||||||
// But we must not use K in the process of calculating the PG number
|
// But we must not use K in the process of calculating the PG number
|
||||||
// So we calculate the PG number using a separate setting which should be per-inode (FIXME)
|
// So we calculate the PG number using a separate setting which should be per-inode (FIXME)
|
||||||
// FIXME Real pg_num should equal the below expression + 1
|
// FIXME Real pg_num should equal the below expression + 1
|
||||||
pg_num_t pg_num = (cur_op->op.rw.inode + cur_op->op.rw.offset / parity_block_size) % pg_count;
|
pg_num_t pg_num = (cur_op->req.rw.inode + cur_op->req.rw.offset / parity_block_size) % pg_count;
|
||||||
// FIXME: Postpone operations in inactive PGs
|
// FIXME: Postpone operations in inactive PGs
|
||||||
if (pg_num > pgs.size() || !(pgs[pg_num].state & PG_ACTIVE))
|
if (pg_num > pgs.size() || !(pgs[pg_num].state & PG_ACTIVE))
|
||||||
{
|
{
|
||||||
|
@ -50,14 +50,14 @@ bool osd_t::prepare_primary_rw(osd_op_t *cur_op)
|
||||||
}
|
}
|
||||||
uint64_t pg_parity_size = bs_block_size * pgs[pg_num].pg_minsize;
|
uint64_t pg_parity_size = bs_block_size * pgs[pg_num].pg_minsize;
|
||||||
object_id oid = {
|
object_id oid = {
|
||||||
.inode = cur_op->op.rw.inode,
|
.inode = cur_op->req.rw.inode,
|
||||||
// oid.stripe = starting offset of the parity stripe, so it can be mapped back to the PG
|
// oid.stripe = starting offset of the parity stripe, so it can be mapped back to the PG
|
||||||
.stripe = (cur_op->op.rw.offset / parity_block_size) * parity_block_size +
|
.stripe = (cur_op->req.rw.offset / parity_block_size) * parity_block_size +
|
||||||
((cur_op->op.rw.offset % parity_block_size) / pg_parity_size) * pg_parity_size
|
((cur_op->req.rw.offset % parity_block_size) / pg_parity_size) * pg_parity_size
|
||||||
};
|
};
|
||||||
if ((cur_op->op.rw.offset + cur_op->op.rw.len) > (oid.stripe + pg_parity_size) ||
|
if ((cur_op->req.rw.offset + cur_op->req.rw.len) > (oid.stripe + pg_parity_size) ||
|
||||||
(cur_op->op.rw.offset % bs_disk_alignment) != 0 ||
|
(cur_op->req.rw.offset % bs_disk_alignment) != 0 ||
|
||||||
(cur_op->op.rw.len % bs_disk_alignment) != 0)
|
(cur_op->req.rw.len % bs_disk_alignment) != 0)
|
||||||
{
|
{
|
||||||
finish_primary_op(cur_op, -EINVAL);
|
finish_primary_op(cur_op, -EINVAL);
|
||||||
return false;
|
return false;
|
||||||
|
@ -69,7 +69,7 @@ bool osd_t::prepare_primary_rw(osd_op_t *cur_op)
|
||||||
op_data->oid = oid;
|
op_data->oid = oid;
|
||||||
op_data->stripes = ((osd_read_stripe_t*)(op_data+1));
|
op_data->stripes = ((osd_read_stripe_t*)(op_data+1));
|
||||||
cur_op->op_data = op_data;
|
cur_op->op_data = op_data;
|
||||||
split_stripes(pgs[pg_num].pg_minsize, bs_block_size, (uint32_t)(cur_op->op.rw.offset - oid.stripe), cur_op->op.rw.len, op_data->stripes);
|
split_stripes(pgs[pg_num].pg_minsize, bs_block_size, (uint32_t)(cur_op->req.rw.offset - oid.stripe), cur_op->req.rw.len, op_data->stripes);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -94,7 +94,7 @@ void osd_t::exec_primary_read(osd_op_t *cur_op)
|
||||||
// Fast happy-path
|
// Fast happy-path
|
||||||
cur_op->buf = alloc_read_buffer(op_data->stripes, pg.pg_minsize, 0);
|
cur_op->buf = alloc_read_buffer(op_data->stripes, pg.pg_minsize, 0);
|
||||||
submit_read_subops(pg.pg_minsize, pg.cur_set.data(), cur_op);
|
submit_read_subops(pg.pg_minsize, pg.cur_set.data(), cur_op);
|
||||||
cur_op->send_list.push_back(cur_op->buf, cur_op->op.rw.len);
|
cur_op->send_list.push_back(cur_op->buf, cur_op->req.rw.len);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -158,7 +158,7 @@ void osd_t::handle_primary_read_subop(osd_op_t *cur_op, int ok)
|
||||||
}
|
}
|
||||||
free(op_data);
|
free(op_data);
|
||||||
cur_op->op_data = NULL;
|
cur_op->op_data = NULL;
|
||||||
finish_primary_op(cur_op, cur_op->op.rw.len);
|
finish_primary_op(cur_op, cur_op->req.rw.len);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -223,7 +223,7 @@ void osd_t::submit_read_subops(int read_pg_size, const uint64_t* osd_set, osd_op
|
||||||
{
|
{
|
||||||
subops[subop].op_type = OSD_OP_OUT;
|
subops[subop].op_type = OSD_OP_OUT;
|
||||||
subops[subop].peer_fd = this->osd_peer_fds.at(role_osd_num);
|
subops[subop].peer_fd = this->osd_peer_fds.at(role_osd_num);
|
||||||
subops[subop].op.sec_rw = {
|
subops[subop].req.sec_rw = {
|
||||||
.header = {
|
.header = {
|
||||||
.magic = SECONDARY_OSD_OP_MAGIC,
|
.magic = SECONDARY_OSD_OP_MAGIC,
|
||||||
.id = this->next_subop_id++,
|
.id = this->next_subop_id++,
|
||||||
|
@ -242,7 +242,7 @@ void osd_t::submit_read_subops(int read_pg_size, const uint64_t* osd_set, osd_op
|
||||||
{
|
{
|
||||||
// so it doesn't get freed. FIXME: do it better
|
// so it doesn't get freed. FIXME: do it better
|
||||||
subop->buf = NULL;
|
subop->buf = NULL;
|
||||||
handle_primary_read_subop(cur_op, subop->reply.hdr.retval == subop->op.sec_rw.len);
|
handle_primary_read_subop(cur_op, subop->reply.hdr.retval == subop->req.sec_rw.len);
|
||||||
};
|
};
|
||||||
outbox_push(clients[subops[subop].peer_fd], &subops[subop]);
|
outbox_push(clients[subops[subop].peer_fd], &subops[subop]);
|
||||||
}
|
}
|
||||||
|
|
|
@ -23,7 +23,7 @@ void osd_t::read_requests()
|
||||||
cl.read_op->peer_fd = peer_fd;
|
cl.read_op->peer_fd = peer_fd;
|
||||||
}
|
}
|
||||||
cl.read_op->op_type = OSD_OP_IN;
|
cl.read_op->op_type = OSD_OP_IN;
|
||||||
cl.read_buf = &cl.read_op->op.buf;
|
cl.read_buf = &cl.read_op->req.buf;
|
||||||
cl.read_remaining = OSD_PACKET_SIZE;
|
cl.read_remaining = OSD_PACKET_SIZE;
|
||||||
cl.read_state = CL_READ_OP;
|
cl.read_state = CL_READ_OP;
|
||||||
}
|
}
|
||||||
|
@ -66,7 +66,7 @@ void osd_t::handle_read(ring_data_t *data, int peer_fd)
|
||||||
cl.read_buf = NULL;
|
cl.read_buf = NULL;
|
||||||
if (cl.read_state == CL_READ_OP)
|
if (cl.read_state == CL_READ_OP)
|
||||||
{
|
{
|
||||||
if (cl.read_op->op.hdr.magic == SECONDARY_OSD_REPLY_MAGIC)
|
if (cl.read_op->req.hdr.magic == SECONDARY_OSD_REPLY_MAGIC)
|
||||||
{
|
{
|
||||||
handle_read_reply(&cl);
|
handle_read_reply(&cl);
|
||||||
}
|
}
|
||||||
|
@ -100,29 +100,29 @@ void osd_t::handle_read(ring_data_t *data, int peer_fd)
|
||||||
void osd_t::handle_read_op(osd_client_t *cl)
|
void osd_t::handle_read_op(osd_client_t *cl)
|
||||||
{
|
{
|
||||||
osd_op_t *cur_op = cl->read_op;
|
osd_op_t *cur_op = cl->read_op;
|
||||||
if (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_READ ||
|
if (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_READ ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE ||
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ||
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK)
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK)
|
||||||
{
|
{
|
||||||
// Allocate a buffer
|
// Allocate a buffer
|
||||||
cur_op->buf = memalign(512, cur_op->op.sec_rw.len);
|
cur_op->buf = memalign(512, cur_op->req.sec_rw.len);
|
||||||
}
|
}
|
||||||
else if (cur_op->op.hdr.opcode == OSD_OP_READ ||
|
else if (cur_op->req.hdr.opcode == OSD_OP_READ ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_WRITE)
|
cur_op->req.hdr.opcode == OSD_OP_WRITE)
|
||||||
{
|
{
|
||||||
cur_op->buf = memalign(512, cur_op->op.rw.len);
|
cur_op->buf = memalign(512, cur_op->req.rw.len);
|
||||||
}
|
}
|
||||||
if (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE ||
|
if (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ||
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_STABILIZE ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK ||
|
cur_op->req.hdr.opcode == OSD_OP_SECONDARY_ROLLBACK ||
|
||||||
cur_op->op.hdr.opcode == OSD_OP_WRITE)
|
cur_op->req.hdr.opcode == OSD_OP_WRITE)
|
||||||
{
|
{
|
||||||
// Read data
|
// Read data
|
||||||
cl->read_buf = cur_op->buf;
|
cl->read_buf = cur_op->buf;
|
||||||
cl->read_remaining = (cur_op->op.hdr.opcode == OSD_OP_SECONDARY_WRITE
|
cl->read_remaining = (cur_op->req.hdr.opcode == OSD_OP_SECONDARY_WRITE
|
||||||
? cur_op->op.sec_rw.len
|
? cur_op->req.sec_rw.len
|
||||||
: cur_op->op.rw.len);
|
: cur_op->req.rw.len);
|
||||||
cl->read_state = CL_READ_DATA;
|
cl->read_state = CL_READ_DATA;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
|
@ -137,38 +137,38 @@ void osd_t::handle_read_op(osd_client_t *cl)
|
||||||
void osd_t::handle_read_reply(osd_client_t *cl)
|
void osd_t::handle_read_reply(osd_client_t *cl)
|
||||||
{
|
{
|
||||||
osd_op_t *cur_op = cl->read_op;
|
osd_op_t *cur_op = cl->read_op;
|
||||||
auto req_it = cl->sent_ops.find(cur_op->op.hdr.id);
|
auto req_it = cl->sent_ops.find(cur_op->req.hdr.id);
|
||||||
if (req_it == cl->sent_ops.end())
|
if (req_it == cl->sent_ops.end())
|
||||||
{
|
{
|
||||||
// Command out of sync. Drop connection
|
// Command out of sync. Drop connection
|
||||||
stop_client(cl->peer_fd);
|
stop_client(cl->peer_fd);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
osd_op_t *request = req_it->second;
|
osd_op_t *op = req_it->second;
|
||||||
memcpy(request->reply.buf, cur_op->op.buf, OSD_PACKET_SIZE);
|
memcpy(op->reply.buf, cur_op->req.buf, OSD_PACKET_SIZE);
|
||||||
if (request->reply.hdr.opcode == OSD_OP_SECONDARY_READ &&
|
if (op->reply.hdr.opcode == OSD_OP_SECONDARY_READ &&
|
||||||
request->reply.hdr.retval > 0)
|
op->reply.hdr.retval > 0)
|
||||||
{
|
{
|
||||||
// Read data
|
// Read data
|
||||||
// FIXME: request->buf must be allocated
|
// FIXME: op->buf must be allocated
|
||||||
cl->read_state = CL_READ_REPLY_DATA;
|
cl->read_state = CL_READ_REPLY_DATA;
|
||||||
cl->read_reply_id = request->op.hdr.id;
|
cl->read_reply_id = op->req.hdr.id;
|
||||||
cl->read_buf = request->buf;
|
cl->read_buf = op->buf;
|
||||||
cl->read_remaining = request->reply.hdr.retval;
|
cl->read_remaining = op->reply.hdr.retval;
|
||||||
}
|
}
|
||||||
else if (request->reply.hdr.opcode == OSD_OP_SECONDARY_LIST &&
|
else if (op->reply.hdr.opcode == OSD_OP_SECONDARY_LIST &&
|
||||||
request->reply.hdr.retval > 0)
|
op->reply.hdr.retval > 0)
|
||||||
{
|
{
|
||||||
request->buf = memalign(512, sizeof(obj_ver_id) * request->reply.hdr.retval);
|
op->buf = memalign(512, sizeof(obj_ver_id) * op->reply.hdr.retval);
|
||||||
cl->read_state = CL_READ_REPLY_DATA;
|
cl->read_state = CL_READ_REPLY_DATA;
|
||||||
cl->read_reply_id = request->op.hdr.id;
|
cl->read_reply_id = op->req.hdr.id;
|
||||||
cl->read_buf = request->buf;
|
cl->read_buf = op->buf;
|
||||||
cl->read_remaining = sizeof(obj_ver_id) * request->reply.hdr.retval;
|
cl->read_remaining = sizeof(obj_ver_id) * op->reply.hdr.retval;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
cl->read_state = 0;
|
cl->read_state = 0;
|
||||||
cl->sent_ops.erase(req_it);
|
cl->sent_ops.erase(req_it);
|
||||||
request->callback(request);
|
op->callback(op);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -32,7 +32,7 @@ void osd_t::send_replies()
|
||||||
cl.outbox.pop_front();
|
cl.outbox.pop_front();
|
||||||
if (cl.write_op->op_type == OSD_OP_OUT)
|
if (cl.write_op->op_type == OSD_OP_OUT)
|
||||||
{
|
{
|
||||||
cl.write_buf = &cl.write_op->op.buf;
|
cl.write_buf = &cl.write_op->req.buf;
|
||||||
cl.write_remaining = OSD_PACKET_SIZE;
|
cl.write_remaining = OSD_PACKET_SIZE;
|
||||||
cl.write_state = CL_WRITE_REPLY;
|
cl.write_state = CL_WRITE_REPLY;
|
||||||
}
|
}
|
||||||
|
@ -95,7 +95,7 @@ void osd_t::handle_send(ring_data_t *data, int peer_fd)
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
cl.sent_ops[cl.write_op->op.hdr.id] = cl.write_op;
|
cl.sent_ops[cl.write_op->req.hdr.id] = cl.write_op;
|
||||||
}
|
}
|
||||||
cl.write_op = NULL;
|
cl.write_op = NULL;
|
||||||
cl.write_state = cl.outbox.size() > 0 ? CL_WRITE_READY : 0;
|
cl.write_state = cl.outbox.size() > 0 ? CL_WRITE_READY : 0;
|
||||||
|
|
Loading…
Reference in New Issue