int
as_record_write_from_pickle(as_storage_rd* rd)
{
cf_assert(as_bin_inuse_has(rd), AS_RECORD, "unexpected binless pickle");
return as_storage_record_write(rd);
}
/*
* Function: Close storage record if it open and also set flags
*
* Parameters:
* urec : UDF record
*
* Return value : 0 in case storage was open
* 1 in case storage was not open
*
* Callers:
* udf_record_close
*
* Side effect:
* flag will be reset
* bins will be closed
*/
int
udf_storage_record_close(udf_record *urecord)
{
if (urecord->flag & UDF_RECORD_FLAG_STORAGE_OPEN) {
as_index_ref *r_ref = urecord->r_ref;
as_storage_rd *rd = urecord->rd;
// In case allow update is not set .. the record has been opened for
// the aggregation. Do not do any rec property update.
// Pick info from index and put it in storage record.
size_t rec_props_data_size = as_storage_record_rec_props_size(rd);
uint8_t rec_props_data[rec_props_data_size];
if (urecord->flag & UDF_RECORD_FLAG_ALLOW_UPDATES) {
if (rec_props_data_size > 0) {
cf_detail(AS_LDT, "LDT_INDEXBITS Setting Property at close time parent=%d, esr=%d, sub=%d",
as_ldt_record_is_parent(rd->r),
as_ldt_record_is_esr(rd->r),
as_ldt_record_is_subrec(rd->r));
as_storage_record_set_rec_props(rd, rec_props_data);
}
}
if (!(urecord->flag & UDF_RECORD_FLAG_IS_SUBRECORD)) {
if (as_ldt_record_is_parent(rd->r)) {
cf_detail_digest(AS_LDT, &rd->keyd, "LDT_INDEXBIT Parent @ write: Digest:");
}
} else {
as_ldt_subrec_storage_validate(rd, "Writing");
}
if (r_ref) {
if (urecord->flag & UDF_RECORD_FLAG_HAS_UPDATES) {
as_storage_record_write(r_ref->r, rd);
urecord->flag &= ~UDF_RECORD_FLAG_HAS_UPDATES; // TODO - necessary?
}
as_storage_record_close(r_ref->r, rd);
} else {
// Should never happen.
cf_warning(AS_UDF, "Unexpected Internal Error (null r_ref)");
}
urecord->flag &= ~UDF_RECORD_FLAG_STORAGE_OPEN;
cf_detail_digest(AS_UDF, &urecord->tr->keyd, "Storage Close:: Rec(%p) Flag(%x) Digest:",
urecord, urecord->flag );
return 0;
} else {
return 1;
}
}
int
write_replica(as_partition_reservation* rsv, cf_digest* keyd,
uint8_t* pickled_buf, size_t pickled_sz,
const as_rec_props* p_rec_props, as_generation generation,
uint32_t void_time, uint64_t last_update_time, cf_node master,
uint32_t info, ldt_prole_info* linfo)
{
as_namespace* ns = rsv->ns;
if (! as_storage_has_space(rsv->ns)) {
cf_warning(AS_RW, "{%s} write_replica: drives full", ns->name);
return AS_PROTO_RESULT_FAIL_PARTITION_OUT_OF_SPACE;
}
as_index_tree* tree = rsv->tree;
bool is_subrec = false;
bool is_ldt_parent = false;
if (ns->ldt_enabled) {
if ((info & RW_INFO_LDT_SUBREC) != 0 || (info & RW_INFO_LDT_ESR) != 0) {
tree = rsv->sub_tree;
is_subrec = true;
}
else if ((info & RW_INFO_LDT_PARENTREC) != 0) {
is_ldt_parent = true;
}
}
as_index_ref r_ref;
r_ref.skip_lock = false;
int rv = as_record_get_create(tree, keyd, &r_ref, ns, is_subrec);
if (rv < 0) {
cf_warning_digest(AS_RW, keyd, "{%s} write_replica: fail as_record_get_create() ", ns->name);
return AS_PROTO_RESULT_FAIL_UNKNOWN;
}
as_record* r = r_ref.r;
as_storage_rd rd;
bool is_create = false;
if (rv == 1) {
as_storage_record_create(ns, r, &rd, keyd);
is_create = true;
}
else {
as_storage_record_open(ns, r, &rd, keyd);
}
bool has_sindex = (info & RW_INFO_SINDEX_TOUCHED) != 0;
rd.ignore_record_on_device = ! has_sindex && ! is_ldt_parent;
rd.n_bins = as_bin_get_n_bins(r, &rd);
// TODO - we really need an inline utility for this!
uint16_t newbins = ntohs(*(uint16_t*)pickled_buf);
if (! rd.ns->storage_data_in_memory && ! rd.ns->single_bin &&
newbins > rd.n_bins) {
rd.n_bins = newbins;
}
as_bin stack_bins[rd.ns->storage_data_in_memory ? 0 : rd.n_bins];
rd.bins = as_bin_get_all(r, &rd, stack_bins);
uint32_t stack_particles_sz = rd.ns->storage_data_in_memory ?
0 : as_record_buf_get_stack_particles_sz(pickled_buf);
uint8_t stack_particles[stack_particles_sz + 256];
uint8_t* p_stack_particles = stack_particles;
// + 256 for LDT control bin, to hold version.
if (! ldt_get_prole_version(rsv, keyd, linfo, info, &rd, is_create)) {
if (is_create) {
as_index_delete(tree, keyd);
}
as_storage_record_close(r, &rd);
as_record_done(&r_ref, ns);
return AS_PROTO_RESULT_FAIL_UNKNOWN;
}
uint64_t memory_bytes = 0;
if (! is_create) {
memory_bytes = as_storage_record_get_n_bytes_memory(&rd);
}
as_record_set_properties(&rd, p_rec_props);
if (as_record_unpickle_replace(r, &rd, pickled_buf, pickled_sz,
&p_stack_particles, has_sindex) != 0) {
if (is_create) {
as_index_delete(tree, keyd);
}
as_storage_record_close(r, &rd);
as_record_done(&r_ref, ns);
return AS_PROTO_RESULT_FAIL_UNKNOWN; // TODO - better granularity?
}
r->generation = generation;
r->void_time = void_time;
r->last_update_time = last_update_time;
as_storage_record_adjust_mem_stats(&rd, memory_bytes);
uint64_t version_to_set = 0;
bool set_version = false;
if (is_ldt_parent) {
if (linfo->replication_partition_version_match &&
linfo->ldt_prole_version_set) {
version_to_set = linfo->ldt_prole_version;
set_version = true;
}
else if (! linfo->replication_partition_version_match) {
version_to_set = linfo->ldt_source_version;
set_version = true;
}
}
if (set_version) {
int ldt_rv = as_ldt_parent_storage_set_version(&rd, version_to_set,
p_stack_particles, __FILE__, __LINE__);
if (ldt_rv < 0) {
cf_warning(AS_LDT, "write_replica: LDT parent storage version set failed %d", ldt_rv);
// TODO - roll back.
}
}
bool is_delete = false;
if (! as_bin_inuse_has(&rd)) {
// A master write that deletes a record by deleting (all) bins sends a
// binless pickle that ends up here.
is_delete = true;
as_index_delete(tree, keyd);
}
as_storage_record_write(r, &rd);
as_storage_record_close(r, &rd);
uint16_t set_id = as_index_get_set_id(r);
as_record_done(&r_ref, ns);
// Don't send an XDR delete if it's disallowed.
if (is_delete && ! is_xdr_delete_shipping_enabled()) {
// TODO - should we also not ship if there was no record here before?
return AS_PROTO_RESULT_OK;
}
// Do XDR write if the write is a non-XDR write or forwarding is enabled.
if ((info & RW_INFO_XDR) == 0 ||
is_xdr_forwarding_enabled() || ns->ns_forward_xdr_writes) {
xdr_write(ns, *keyd, generation, master, is_delete, set_id, NULL);
}
return AS_PROTO_RESULT_OK;
}
