size_t get_store_objsize(uint64_t oid)
{
if (is_erasure_oid(oid)) {
uint8_t policy = get_vdi_copy_policy(oid_to_vid(oid));
int d;
ec_policy_to_dp(policy, &d, NULL);
return SD_DATA_OBJ_SIZE / d;
}
return get_objsize(oid);
}
int default_create_and_write(uint64_t oid, const struct siocb *iocb)
{
char path[PATH_MAX], tmp_path[PATH_MAX];
int flags = prepare_iocb(oid, iocb, true);
int ret, fd;
uint32_t len = iocb->length;
bool ec = is_erasure_obj(oid, iocb->copy_policy);
size_t obj_size;
sd_debug("%"PRIx64, oid);
get_obj_path(oid, path, sizeof(path));
get_tmp_obj_path(oid, tmp_path, sizeof(tmp_path));
if (uatomic_is_true(&sys->use_journal) &&
journal_write_store(oid, iocb->buf, iocb->length,
iocb->offset, true)
!= SD_RES_SUCCESS) {
sd_err("turn off journaling");
uatomic_set_false(&sys->use_journal);
flags |= O_DSYNC;
sync();
}
fd = open(tmp_path, flags, sd_def_fmode);
if (fd < 0) {
if (errno == EEXIST) {
/*
* This happens if node membership changes during object
* creation; while gateway retries a CREATE request,
* recovery process could also recover the object at the
* same time. They should try to write the same date,
* so it is okay to simply return success here.
*/
sd_debug("%s exists", tmp_path);
return SD_RES_SUCCESS;
}
sd_err("failed to open %s: %m", tmp_path);
return err_to_sderr(path, oid, errno);
}
if (ec) {
uint8_t policy = iocb->copy_policy ?:
get_vdi_copy_policy(oid_to_vid(oid));
int d;
ec_policy_to_dp(policy, &d, NULL);
obj_size = SD_DATA_OBJ_SIZE / d;
} else
static void finish_requests(struct request *req, struct req_iter *reqs,
int nr_to_send)
{
uint64_t oid = req->rq.obj.oid;
uint32_t len = req->rq.data_length;
uint64_t off = req->rq.obj.offset;
int opcode = req->rq.opcode;
int start = off / SD_EC_DATA_STRIPE_SIZE;
int end = DIV_ROUND_UP(off + len, SD_EC_DATA_STRIPE_SIZE), i, j;
int nr_stripe = end - start;
if (!is_erasure_oid(oid))
goto out;
sd_debug("start %d, end %d, send %d, off %"PRIu64 ", len %"PRIu32,
start, end, nr_to_send, off, len);
/* We need to assemble the data strips into the req buffer for read */
if (opcode == SD_OP_READ_OBJ) {
char *p, *buf;
uint8_t policy = req->rq.obj.copy_policy ?:
get_vdi_copy_policy(oid_to_vid(req->rq.obj.oid));
int ed = 0, strip_size;
buf = malloc(SD_EC_DATA_STRIPE_SIZE * nr_stripe);
if(unlikely(!buf)) {
goto out;
}
ec_policy_to_dp(policy, &ed, NULL);
strip_size = SD_EC_DATA_STRIPE_SIZE / ed;
p = buf;
for (i = 0; i < nr_stripe; i++) {
for (j = 0; j < nr_to_send; j++) {
memcpy(p, reqs[j].buf + strip_size * i,
strip_size);
p += strip_size;
}
}
memcpy(req->data, buf + off % SD_EC_DATA_STRIPE_SIZE, len);
req->rp.data_length = req->rq.data_length;
free(buf);
}
bool is_erasure_oid(uint64_t oid)
{
return !is_vdi_obj(oid) && !is_vdi_btree_obj(oid) &&
!is_ledger_object(oid) &&
get_vdi_copy_policy(oid_to_vid(oid)) > 0;
}
/*
* We spread data strips of req along with its parity strips onto replica for
* write operation. For read we only need to prepare data strip buffers.
*/
static struct req_iter *prepare_erasure_requests(struct request *req, int *nr)
{
uint32_t len = req->rq.data_length;
uint64_t off = req->rq.obj.offset;
int opcode = req->rq.opcode;
int start = off / SD_EC_DATA_STRIPE_SIZE;
int end = DIV_ROUND_UP(off + len, SD_EC_DATA_STRIPE_SIZE), i, j;
int nr_stripe = end - start;
struct fec *ctx;
int strip_size, nr_to_send;
struct req_iter *reqs;
char *p, *buf = NULL;
uint8_t policy = req->rq.obj.copy_policy ?:
get_vdi_copy_policy(oid_to_vid(req->rq.obj.oid));
int ed = 0, ep = 0, edp;
edp = ec_policy_to_dp(policy, &ed, &ep);
ctx = ec_init(ed, edp);
*nr = nr_to_send = (opcode == SD_OP_READ_OBJ) ? ed : edp;
strip_size = SD_EC_DATA_STRIPE_SIZE / ed;
reqs = xzalloc(sizeof(*reqs) * nr_to_send);
sd_debug("start %d, end %d, send %d, off %"PRIu64 ", len %"PRIu32,
start, end, nr_to_send, off, len);
for (i = 0; i < nr_to_send; i++) {
int l = strip_size * nr_stripe;
reqs[i].buf = xmalloc(l);
reqs[i].dlen = l;
reqs[i].off = start * strip_size;
switch (opcode) {
case SD_OP_CREATE_AND_WRITE_OBJ:
case SD_OP_WRITE_OBJ:
reqs[i].wlen = l;
break;
default:
break;
}
}
if (opcode != SD_OP_WRITE_OBJ && opcode != SD_OP_CREATE_AND_WRITE_OBJ)
goto out; /* Read and remove operation */
p = buf = init_erasure_buffer(req, SD_EC_DATA_STRIPE_SIZE * nr_stripe);
if (!buf) {
sd_err("failed to init erasure buffer %"PRIx64,
req->rq.obj.oid);
for (i = 0; i < nr_to_send; i++)
free(reqs[i].buf);
free(reqs);
reqs = NULL;
goto out;
}
for (i = 0; i < nr_stripe; i++) {
const uint8_t *ds[ed];
uint8_t *ps[ep];
for (j = 0; j < ed; j++)
ds[j] = reqs[j].buf + strip_size * i;
for (j = 0; j < ep; j++)
ps[j] = reqs[ed + j].buf + strip_size * i;
for (j = 0; j < ed; j++)
memcpy((uint8_t *)ds[j], p + j * strip_size,
strip_size);
ec_encode(ctx, ds, ps);
p += SD_EC_DATA_STRIPE_SIZE;
}
out:
ec_destroy(ctx);
free(buf);
return reqs;
}