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; }