X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fceph%2Fsrc%2Fosd%2FECUtil.cc;fp=src%2Fceph%2Fsrc%2Fosd%2FECUtil.cc;h=9c3c7981ea32b6d9dc0e6884aa2666ec063de3ea;hb=812ff6ca9fcd3e629e49d4328905f33eee8ca3f5;hp=0000000000000000000000000000000000000000;hpb=15280273faafb77777eab341909a3f495cf248d9;p=stor4nfv.git diff --git a/src/ceph/src/osd/ECUtil.cc b/src/ceph/src/osd/ECUtil.cc new file mode 100644 index 0000000..9c3c798 --- /dev/null +++ b/src/ceph/src/osd/ECUtil.cc @@ -0,0 +1,215 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- + +#include +#include "include/encoding.h" +#include "ECUtil.h" +using namespace std; + +int ECUtil::decode( + const stripe_info_t &sinfo, + ErasureCodeInterfaceRef &ec_impl, + map &to_decode, + bufferlist *out) { + assert(to_decode.size()); + + uint64_t total_data_size = to_decode.begin()->second.length(); + assert(total_data_size % sinfo.get_chunk_size() == 0); + + assert(out); + assert(out->length() == 0); + + for (map::iterator i = to_decode.begin(); + i != to_decode.end(); + ++i) { + assert(i->second.length() == total_data_size); + } + + if (total_data_size == 0) + return 0; + + for (uint64_t i = 0; i < total_data_size; i += sinfo.get_chunk_size()) { + map chunks; + for (map::iterator j = to_decode.begin(); + j != to_decode.end(); + ++j) { + chunks[j->first].substr_of(j->second, i, sinfo.get_chunk_size()); + } + bufferlist bl; + int r = ec_impl->decode_concat(chunks, &bl); + assert(bl.length() == sinfo.get_stripe_width()); + assert(r == 0); + out->claim_append(bl); + } + return 0; +} + +int ECUtil::decode( + const stripe_info_t &sinfo, + ErasureCodeInterfaceRef &ec_impl, + map &to_decode, + map &out) { + assert(to_decode.size()); + + uint64_t total_data_size = to_decode.begin()->second.length(); + assert(total_data_size % sinfo.get_chunk_size() == 0); + + for (map::iterator i = to_decode.begin(); + i != to_decode.end(); + ++i) { + assert(i->second.length() == total_data_size); + } + + if (total_data_size == 0) + return 0; + + set need; + for (map::iterator i = out.begin(); + i != out.end(); + ++i) { + assert(i->second); + assert(i->second->length() == 0); + need.insert(i->first); + } + + for (uint64_t i = 0; i < total_data_size; i += sinfo.get_chunk_size()) { + map chunks; + for (map::iterator j = to_decode.begin(); + j != to_decode.end(); + ++j) { + chunks[j->first].substr_of(j->second, i, sinfo.get_chunk_size()); + } + map out_bls; + int r = ec_impl->decode(need, chunks, &out_bls); + assert(r == 0); + for (map::iterator j = out.begin(); + j != out.end(); + ++j) { + assert(out_bls.count(j->first)); + assert(out_bls[j->first].length() == sinfo.get_chunk_size()); + j->second->claim_append(out_bls[j->first]); + } + } + for (map::iterator i = out.begin(); + i != out.end(); + ++i) { + assert(i->second->length() == total_data_size); + } + return 0; +} + +int ECUtil::encode( + const stripe_info_t &sinfo, + ErasureCodeInterfaceRef &ec_impl, + bufferlist &in, + const set &want, + map *out) { + + uint64_t logical_size = in.length(); + + assert(logical_size % sinfo.get_stripe_width() == 0); + assert(out); + assert(out->empty()); + + if (logical_size == 0) + return 0; + + for (uint64_t i = 0; i < logical_size; i += sinfo.get_stripe_width()) { + map encoded; + bufferlist buf; + buf.substr_of(in, i, sinfo.get_stripe_width()); + int r = ec_impl->encode(want, buf, &encoded); + assert(r == 0); + for (map::iterator i = encoded.begin(); + i != encoded.end(); + ++i) { + assert(i->second.length() == sinfo.get_chunk_size()); + (*out)[i->first].claim_append(i->second); + } + } + + for (map::iterator i = out->begin(); + i != out->end(); + ++i) { + assert(i->second.length() % sinfo.get_chunk_size() == 0); + assert( + sinfo.aligned_chunk_offset_to_logical_offset(i->second.length()) == + logical_size); + } + return 0; +} + +void ECUtil::HashInfo::append(uint64_t old_size, + map &to_append) { + assert(old_size == total_chunk_size); + uint64_t size_to_append = to_append.begin()->second.length(); + if (has_chunk_hash()) { + assert(to_append.size() == cumulative_shard_hashes.size()); + for (map::iterator i = to_append.begin(); + i != to_append.end(); + ++i) { + assert(size_to_append == i->second.length()); + assert((unsigned)i->first < cumulative_shard_hashes.size()); + uint32_t new_hash = i->second.crc32c(cumulative_shard_hashes[i->first]); + cumulative_shard_hashes[i->first] = new_hash; + } + } + total_chunk_size += size_to_append; +} + +void ECUtil::HashInfo::encode(bufferlist &bl) const +{ + ENCODE_START(1, 1, bl); + ::encode(total_chunk_size, bl); + ::encode(cumulative_shard_hashes, bl); + ENCODE_FINISH(bl); +} + +void ECUtil::HashInfo::decode(bufferlist::iterator &bl) +{ + DECODE_START(1, bl); + ::decode(total_chunk_size, bl); + ::decode(cumulative_shard_hashes, bl); + projected_total_chunk_size = total_chunk_size; + DECODE_FINISH(bl); +} + +void ECUtil::HashInfo::dump(Formatter *f) const +{ + f->dump_unsigned("total_chunk_size", total_chunk_size); + f->open_object_section("cumulative_shard_hashes"); + for (unsigned i = 0; i != cumulative_shard_hashes.size(); ++i) { + f->open_object_section("hash"); + f->dump_unsigned("shard", i); + f->dump_unsigned("hash", cumulative_shard_hashes[i]); + f->close_section(); + } + f->close_section(); +} + +void ECUtil::HashInfo::generate_test_instances(list& o) +{ + o.push_back(new HashInfo(3)); + { + bufferlist bl; + bl.append_zero(20); + map buffers; + buffers[0] = bl; + buffers[1] = bl; + buffers[2] = bl; + o.back()->append(0, buffers); + o.back()->append(20, buffers); + } + o.push_back(new HashInfo(4)); +} + +const string HINFO_KEY = "hinfo_key"; + +bool ECUtil::is_hinfo_key_string(const string &key) +{ + return key == HINFO_KEY; +} + +const string &ECUtil::get_hinfo_key() +{ + return HINFO_KEY; +}