mirror of
https://github.com/XTXMarkets/ternfs.git
synced 2026-01-06 02:49:45 -06:00
Continue running GC if servers are down
This was triggered by a server failing hard (fsr13), without any short term resolution (we've already replaced the mobo, we'll probably replace the HBA). In this case GC should still run rather than get stuck.
This commit is contained in:
Francesco Mazzoli
@@ -489,7 +489,7 @@ std::ostream& operator<<(std::ostream& out, const CurrentEdge& x) {
|
||||
return out;
|
||||
}
|
||||
|
||||
void BlockInfo::pack(BincodeBuf& buf) const {
|
||||
void AddSpanInitiateBlockInfo::pack(BincodeBuf& buf) const {
|
||||
buf.packFixedBytes<4>(blockServiceIp1);
|
||||
buf.packScalar<uint16_t>(blockServicePort1);
|
||||
buf.packFixedBytes<4>(blockServiceIp2);
|
||||
@@ -499,7 +499,7 @@ void BlockInfo::pack(BincodeBuf& buf) const {
|
||||
buf.packScalar<uint64_t>(blockId);
|
||||
buf.packFixedBytes<8>(certificate);
|
||||
}
|
||||
void BlockInfo::unpack(BincodeBuf& buf) {
|
||||
void AddSpanInitiateBlockInfo::unpack(BincodeBuf& buf) {
|
||||
buf.unpackFixedBytes<4>(blockServiceIp1);
|
||||
blockServicePort1 = buf.unpackScalar<uint16_t>();
|
||||
buf.unpackFixedBytes<4>(blockServiceIp2);
|
||||
@@ -509,7 +509,7 @@ void BlockInfo::unpack(BincodeBuf& buf) {
|
||||
blockId = buf.unpackScalar<uint64_t>();
|
||||
buf.unpackFixedBytes<8>(certificate);
|
||||
}
|
||||
void BlockInfo::clear() {
|
||||
void AddSpanInitiateBlockInfo::clear() {
|
||||
blockServiceIp1.clear();
|
||||
blockServicePort1 = uint16_t(0);
|
||||
blockServiceIp2.clear();
|
||||
@@ -519,7 +519,7 @@ void BlockInfo::clear() {
|
||||
blockId = uint64_t(0);
|
||||
certificate.clear();
|
||||
}
|
||||
bool BlockInfo::operator==(const BlockInfo& rhs) const {
|
||||
bool AddSpanInitiateBlockInfo::operator==(const AddSpanInitiateBlockInfo& rhs) const {
|
||||
if (blockServiceIp1 != rhs.blockServiceIp1) { return false; };
|
||||
if ((uint16_t)this->blockServicePort1 != (uint16_t)rhs.blockServicePort1) { return false; };
|
||||
if (blockServiceIp2 != rhs.blockServiceIp2) { return false; };
|
||||
@@ -530,8 +530,58 @@ bool BlockInfo::operator==(const BlockInfo& rhs) const {
|
||||
if (certificate != rhs.certificate) { return false; };
|
||||
return true;
|
||||
}
|
||||
std::ostream& operator<<(std::ostream& out, const BlockInfo& x) {
|
||||
out << "BlockInfo(" << "BlockServiceIp1=" << x.blockServiceIp1 << ", " << "BlockServicePort1=" << x.blockServicePort1 << ", " << "BlockServiceIp2=" << x.blockServiceIp2 << ", " << "BlockServicePort2=" << x.blockServicePort2 << ", " << "BlockServiceId=" << x.blockServiceId << ", " << "BlockServiceFailureDomain=" << x.blockServiceFailureDomain << ", " << "BlockId=" << x.blockId << ", " << "Certificate=" << x.certificate << ")";
|
||||
std::ostream& operator<<(std::ostream& out, const AddSpanInitiateBlockInfo& x) {
|
||||
out << "AddSpanInitiateBlockInfo(" << "BlockServiceIp1=" << x.blockServiceIp1 << ", " << "BlockServicePort1=" << x.blockServicePort1 << ", " << "BlockServiceIp2=" << x.blockServiceIp2 << ", " << "BlockServicePort2=" << x.blockServicePort2 << ", " << "BlockServiceId=" << x.blockServiceId << ", " << "BlockServiceFailureDomain=" << x.blockServiceFailureDomain << ", " << "BlockId=" << x.blockId << ", " << "Certificate=" << x.certificate << ")";
|
||||
return out;
|
||||
}
|
||||
|
||||
void RemoveSpanInitiateBlockInfo::pack(BincodeBuf& buf) const {
|
||||
buf.packFixedBytes<4>(blockServiceIp1);
|
||||
buf.packScalar<uint16_t>(blockServicePort1);
|
||||
buf.packFixedBytes<4>(blockServiceIp2);
|
||||
buf.packScalar<uint16_t>(blockServicePort2);
|
||||
blockServiceId.pack(buf);
|
||||
blockServiceFailureDomain.pack(buf);
|
||||
buf.packScalar<uint8_t>(blockServiceFlags);
|
||||
buf.packScalar<uint64_t>(blockId);
|
||||
buf.packFixedBytes<8>(certificate);
|
||||
}
|
||||
void RemoveSpanInitiateBlockInfo::unpack(BincodeBuf& buf) {
|
||||
buf.unpackFixedBytes<4>(blockServiceIp1);
|
||||
blockServicePort1 = buf.unpackScalar<uint16_t>();
|
||||
buf.unpackFixedBytes<4>(blockServiceIp2);
|
||||
blockServicePort2 = buf.unpackScalar<uint16_t>();
|
||||
blockServiceId.unpack(buf);
|
||||
blockServiceFailureDomain.unpack(buf);
|
||||
blockServiceFlags = buf.unpackScalar<uint8_t>();
|
||||
blockId = buf.unpackScalar<uint64_t>();
|
||||
buf.unpackFixedBytes<8>(certificate);
|
||||
}
|
||||
void RemoveSpanInitiateBlockInfo::clear() {
|
||||
blockServiceIp1.clear();
|
||||
blockServicePort1 = uint16_t(0);
|
||||
blockServiceIp2.clear();
|
||||
blockServicePort2 = uint16_t(0);
|
||||
blockServiceId = BlockServiceId(0);
|
||||
blockServiceFailureDomain.clear();
|
||||
blockServiceFlags = uint8_t(0);
|
||||
blockId = uint64_t(0);
|
||||
certificate.clear();
|
||||
}
|
||||
bool RemoveSpanInitiateBlockInfo::operator==(const RemoveSpanInitiateBlockInfo& rhs) const {
|
||||
if (blockServiceIp1 != rhs.blockServiceIp1) { return false; };
|
||||
if ((uint16_t)this->blockServicePort1 != (uint16_t)rhs.blockServicePort1) { return false; };
|
||||
if (blockServiceIp2 != rhs.blockServiceIp2) { return false; };
|
||||
if ((uint16_t)this->blockServicePort2 != (uint16_t)rhs.blockServicePort2) { return false; };
|
||||
if ((BlockServiceId)this->blockServiceId != (BlockServiceId)rhs.blockServiceId) { return false; };
|
||||
if (blockServiceFailureDomain != rhs.blockServiceFailureDomain) { return false; };
|
||||
if ((uint8_t)this->blockServiceFlags != (uint8_t)rhs.blockServiceFlags) { return false; };
|
||||
if ((uint64_t)this->blockId != (uint64_t)rhs.blockId) { return false; };
|
||||
if (certificate != rhs.certificate) { return false; };
|
||||
return true;
|
||||
}
|
||||
std::ostream& operator<<(std::ostream& out, const RemoveSpanInitiateBlockInfo& x) {
|
||||
out << "RemoveSpanInitiateBlockInfo(" << "BlockServiceIp1=" << x.blockServiceIp1 << ", " << "BlockServicePort1=" << x.blockServicePort1 << ", " << "BlockServiceIp2=" << x.blockServiceIp2 << ", " << "BlockServicePort2=" << x.blockServicePort2 << ", " << "BlockServiceId=" << x.blockServiceId << ", " << "BlockServiceFailureDomain=" << x.blockServiceFailureDomain << ", " << "BlockServiceFlags=" << (int)x.blockServiceFlags << ", " << "BlockId=" << x.blockId << ", " << "Certificate=" << x.certificate << ")";
|
||||
return out;
|
||||
}
|
||||
|
||||
@@ -1396,10 +1446,10 @@ std::ostream& operator<<(std::ostream& out, const AddSpanInitiateReq& x) {
|
||||
}
|
||||
|
||||
void AddSpanInitiateResp::pack(BincodeBuf& buf) const {
|
||||
buf.packList<BlockInfo>(blocks);
|
||||
buf.packList<AddSpanInitiateBlockInfo>(blocks);
|
||||
}
|
||||
void AddSpanInitiateResp::unpack(BincodeBuf& buf) {
|
||||
buf.unpackList<BlockInfo>(blocks);
|
||||
buf.unpackList<AddSpanInitiateBlockInfo>(blocks);
|
||||
}
|
||||
void AddSpanInitiateResp::clear() {
|
||||
blocks.clear();
|
||||
@@ -2197,11 +2247,11 @@ std::ostream& operator<<(std::ostream& out, const RemoveSpanInitiateReq& x) {
|
||||
|
||||
void RemoveSpanInitiateResp::pack(BincodeBuf& buf) const {
|
||||
buf.packScalar<uint64_t>(byteOffset);
|
||||
buf.packList<BlockInfo>(blocks);
|
||||
buf.packList<RemoveSpanInitiateBlockInfo>(blocks);
|
||||
}
|
||||
void RemoveSpanInitiateResp::unpack(BincodeBuf& buf) {
|
||||
byteOffset = buf.unpackScalar<uint64_t>();
|
||||
buf.unpackList<BlockInfo>(blocks);
|
||||
buf.unpackList<RemoveSpanInitiateBlockInfo>(blocks);
|
||||
}
|
||||
void RemoveSpanInitiateResp::clear() {
|
||||
byteOffset = uint64_t(0);
|
||||
|
||||
@@ -377,7 +377,7 @@ struct CurrentEdge {
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const CurrentEdge& x);
|
||||
|
||||
struct BlockInfo {
|
||||
struct AddSpanInitiateBlockInfo {
|
||||
BincodeFixedBytes<4> blockServiceIp1;
|
||||
uint16_t blockServicePort1;
|
||||
BincodeFixedBytes<4> blockServiceIp2;
|
||||
@@ -389,7 +389,7 @@ struct BlockInfo {
|
||||
|
||||
static constexpr uint16_t STATIC_SIZE = BincodeFixedBytes<4>::STATIC_SIZE + 2 + BincodeFixedBytes<4>::STATIC_SIZE + 2 + 8 + FailureDomain::STATIC_SIZE + 8 + BincodeFixedBytes<8>::STATIC_SIZE; // blockServiceIp1 + blockServicePort1 + blockServiceIp2 + blockServicePort2 + blockServiceId + blockServiceFailureDomain + blockId + certificate
|
||||
|
||||
BlockInfo() { clear(); }
|
||||
AddSpanInitiateBlockInfo() { clear(); }
|
||||
size_t packedSize() const {
|
||||
size_t _size = 0;
|
||||
_size += BincodeFixedBytes<4>::STATIC_SIZE; // blockServiceIp1
|
||||
@@ -405,10 +405,45 @@ struct BlockInfo {
|
||||
void pack(BincodeBuf& buf) const;
|
||||
void unpack(BincodeBuf& buf);
|
||||
void clear();
|
||||
bool operator==(const BlockInfo&rhs) const;
|
||||
bool operator==(const AddSpanInitiateBlockInfo&rhs) const;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const BlockInfo& x);
|
||||
std::ostream& operator<<(std::ostream& out, const AddSpanInitiateBlockInfo& x);
|
||||
|
||||
struct RemoveSpanInitiateBlockInfo {
|
||||
BincodeFixedBytes<4> blockServiceIp1;
|
||||
uint16_t blockServicePort1;
|
||||
BincodeFixedBytes<4> blockServiceIp2;
|
||||
uint16_t blockServicePort2;
|
||||
BlockServiceId blockServiceId;
|
||||
FailureDomain blockServiceFailureDomain;
|
||||
uint8_t blockServiceFlags;
|
||||
uint64_t blockId;
|
||||
BincodeFixedBytes<8> certificate;
|
||||
|
||||
static constexpr uint16_t STATIC_SIZE = BincodeFixedBytes<4>::STATIC_SIZE + 2 + BincodeFixedBytes<4>::STATIC_SIZE + 2 + 8 + FailureDomain::STATIC_SIZE + 1 + 8 + BincodeFixedBytes<8>::STATIC_SIZE; // blockServiceIp1 + blockServicePort1 + blockServiceIp2 + blockServicePort2 + blockServiceId + blockServiceFailureDomain + blockServiceFlags + blockId + certificate
|
||||
|
||||
RemoveSpanInitiateBlockInfo() { clear(); }
|
||||
size_t packedSize() const {
|
||||
size_t _size = 0;
|
||||
_size += BincodeFixedBytes<4>::STATIC_SIZE; // blockServiceIp1
|
||||
_size += 2; // blockServicePort1
|
||||
_size += BincodeFixedBytes<4>::STATIC_SIZE; // blockServiceIp2
|
||||
_size += 2; // blockServicePort2
|
||||
_size += 8; // blockServiceId
|
||||
_size += blockServiceFailureDomain.packedSize(); // blockServiceFailureDomain
|
||||
_size += 1; // blockServiceFlags
|
||||
_size += 8; // blockId
|
||||
_size += BincodeFixedBytes<8>::STATIC_SIZE; // certificate
|
||||
return _size;
|
||||
}
|
||||
void pack(BincodeBuf& buf) const;
|
||||
void unpack(BincodeBuf& buf);
|
||||
void clear();
|
||||
bool operator==(const RemoveSpanInitiateBlockInfo&rhs) const;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const RemoveSpanInitiateBlockInfo& x);
|
||||
|
||||
struct BlockProof {
|
||||
uint64_t blockId;
|
||||
@@ -1269,9 +1304,9 @@ struct AddSpanInitiateReq {
|
||||
std::ostream& operator<<(std::ostream& out, const AddSpanInitiateReq& x);
|
||||
|
||||
struct AddSpanInitiateResp {
|
||||
BincodeList<BlockInfo> blocks;
|
||||
BincodeList<AddSpanInitiateBlockInfo> blocks;
|
||||
|
||||
static constexpr uint16_t STATIC_SIZE = BincodeList<BlockInfo>::STATIC_SIZE; // blocks
|
||||
static constexpr uint16_t STATIC_SIZE = BincodeList<AddSpanInitiateBlockInfo>::STATIC_SIZE; // blocks
|
||||
|
||||
AddSpanInitiateResp() { clear(); }
|
||||
size_t packedSize() const {
|
||||
@@ -2010,9 +2045,9 @@ std::ostream& operator<<(std::ostream& out, const RemoveSpanInitiateReq& x);
|
||||
|
||||
struct RemoveSpanInitiateResp {
|
||||
uint64_t byteOffset;
|
||||
BincodeList<BlockInfo> blocks;
|
||||
BincodeList<RemoveSpanInitiateBlockInfo> blocks;
|
||||
|
||||
static constexpr uint16_t STATIC_SIZE = 8 + BincodeList<BlockInfo>::STATIC_SIZE; // byteOffset + blocks
|
||||
static constexpr uint16_t STATIC_SIZE = 8 + BincodeList<RemoveSpanInitiateBlockInfo>::STATIC_SIZE; // byteOffset + blocks
|
||||
|
||||
RemoveSpanInitiateResp() { clear(); }
|
||||
size_t packedSize() const {
|
||||
|
||||
@@ -2690,6 +2690,7 @@ struct ShardDBImpl {
|
||||
respBlock.blockServicePort2 = cache.port2;
|
||||
respBlock.blockServiceId = block.blockService();
|
||||
respBlock.blockId = block.blockId();
|
||||
respBlock.blockServiceFlags = cache.flags;
|
||||
respBlock.certificate = _blockEraseCertificate(blocks.cellSize()*blocks.stripes(), block, cache.secretKey);
|
||||
}
|
||||
|
||||
|
||||
@@ -1699,7 +1699,8 @@ func main() {
|
||||
reflect.TypeOf(msgs.DirectoryInfoEntry{}),
|
||||
reflect.TypeOf(msgs.DirectoryInfo{}),
|
||||
reflect.TypeOf(msgs.CurrentEdge{}),
|
||||
reflect.TypeOf(msgs.BlockInfo{}),
|
||||
reflect.TypeOf(msgs.AddSpanInitiateBlockInfo{}),
|
||||
reflect.TypeOf(msgs.RemoveSpanInitiateBlockInfo{}),
|
||||
reflect.TypeOf(msgs.BlockProof{}),
|
||||
reflect.TypeOf(msgs.BlockService{}),
|
||||
reflect.TypeOf(msgs.ShardInfo{}),
|
||||
|
||||
@@ -178,7 +178,7 @@ func WriteBlock(
|
||||
io.Reader
|
||||
io.Writer
|
||||
},
|
||||
block *msgs.BlockInfo,
|
||||
block *msgs.AddSpanInitiateBlockInfo,
|
||||
r io.Reader, // only `size` bytes will be read
|
||||
size uint32,
|
||||
crc msgs.Crc,
|
||||
@@ -249,7 +249,7 @@ func EraseBlock(
|
||||
io.Writer
|
||||
io.Reader
|
||||
},
|
||||
block *msgs.BlockInfo,
|
||||
block *msgs.RemoveSpanInitiateBlockInfo,
|
||||
) ([8]byte, error) {
|
||||
logger.Debug("erasing block %+v", block)
|
||||
var proof [8]byte
|
||||
|
||||
11
go/lib/gc.go
11
go/lib/gc.go
@@ -36,6 +36,7 @@ type DestructionStats struct {
|
||||
VisitedFiles uint64
|
||||
DestructedFiles uint64
|
||||
DestructedSpans uint64
|
||||
SkippedSpans uint64
|
||||
DestructedBlocks uint64
|
||||
FailedFiles uint64
|
||||
}
|
||||
@@ -85,6 +86,13 @@ func DestructFile(
|
||||
defer conn.Close()
|
||||
proof, err = EraseBlock(log, conn, &block)
|
||||
if err != nil {
|
||||
// Check if the block was stale/decommissioned, in which case
|
||||
// there might be nothing we can do here.
|
||||
if block.BlockServiceFlags&(msgs.EGGSFS_BLOCK_SERVICE_STALE|msgs.EGGSFS_BLOCK_SERVICE_DECOMMISSIONED) != 0 {
|
||||
log.Debug("could not destruct file %v which contains references to stale/decommissioned block service", id)
|
||||
stats.SkippedSpans++
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("%v: could not erase block %+v: %w", id, block, err)
|
||||
} else {
|
||||
conn.Put()
|
||||
@@ -216,6 +224,9 @@ func DestructFilesInAllShards(
|
||||
if someErrored {
|
||||
return fmt.Errorf("failed to destruct %v files, see logs", stats.FailedFiles)
|
||||
}
|
||||
if stats.SkippedSpans > 0 {
|
||||
log.RaiseAlert("skipped over %v spans, this is normal if some servers are (or were) down while garbage collecting", stats.SkippedSpans)
|
||||
}
|
||||
log.Info("stats after one destruct files iteration in all shards: %+v", stats)
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -534,7 +534,7 @@ type AddSpanInitiateReq struct {
|
||||
Crcs []Crc
|
||||
}
|
||||
|
||||
type BlockInfo struct {
|
||||
type AddSpanInitiateBlockInfo struct {
|
||||
BlockServiceIp1 [4]byte
|
||||
BlockServicePort1 uint16
|
||||
BlockServiceIp2 [4]byte
|
||||
@@ -548,7 +548,7 @@ type BlockInfo struct {
|
||||
|
||||
type AddSpanInitiateResp struct {
|
||||
// Left empty for inline/zero-filled spans
|
||||
Blocks []BlockInfo
|
||||
Blocks []AddSpanInitiateBlockInfo
|
||||
}
|
||||
|
||||
// The only reason why this isn't the same as AddSpanInitiateReq is
|
||||
@@ -585,10 +585,23 @@ type RemoveSpanInitiateReq struct {
|
||||
Cookie [8]byte
|
||||
}
|
||||
|
||||
type RemoveSpanInitiateBlockInfo struct {
|
||||
BlockServiceIp1 [4]byte
|
||||
BlockServicePort1 uint16
|
||||
BlockServiceIp2 [4]byte
|
||||
BlockServicePort2 uint16
|
||||
BlockServiceId BlockServiceId
|
||||
BlockServiceFailureDomain FailureDomain
|
||||
BlockServiceFlags BlockServiceFlags
|
||||
BlockId BlockId
|
||||
// certificate := MAC(b'w' + block_id + crc + size)[:8] (for creation)
|
||||
Certificate [8]byte
|
||||
}
|
||||
|
||||
type RemoveSpanInitiateResp struct {
|
||||
ByteOffset uint64
|
||||
// If empty, this is a blockless span, and no certification is required
|
||||
Blocks []BlockInfo
|
||||
Blocks []RemoveSpanInitiateBlockInfo
|
||||
}
|
||||
|
||||
type RemoveSpanCertifyReq struct {
|
||||
|
||||
@@ -3149,7 +3149,7 @@ func (v *CurrentEdge) Unpack(r io.Reader) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v *BlockInfo) Pack(w io.Writer) error {
|
||||
func (v *AddSpanInitiateBlockInfo) Pack(w io.Writer) error {
|
||||
if err := bincode.PackFixedBytes(w, 4, v.BlockServiceIp1[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -3177,7 +3177,7 @@ func (v *BlockInfo) Pack(w io.Writer) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v *BlockInfo) Unpack(r io.Reader) error {
|
||||
func (v *AddSpanInitiateBlockInfo) Unpack(r io.Reader) error {
|
||||
if err := bincode.UnpackFixedBytes(r, 4, v.BlockServiceIp1[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -3205,6 +3205,68 @@ func (v *BlockInfo) Unpack(r io.Reader) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v *RemoveSpanInitiateBlockInfo) Pack(w io.Writer) error {
|
||||
if err := bincode.PackFixedBytes(w, 4, v.BlockServiceIp1[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackScalar(w, uint16(v.BlockServicePort1)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackFixedBytes(w, 4, v.BlockServiceIp2[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackScalar(w, uint16(v.BlockServicePort2)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackScalar(w, uint64(v.BlockServiceId)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := v.BlockServiceFailureDomain.Pack(w); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackScalar(w, uint8(v.BlockServiceFlags)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackScalar(w, uint64(v.BlockId)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.PackFixedBytes(w, 8, v.Certificate[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v *RemoveSpanInitiateBlockInfo) Unpack(r io.Reader) error {
|
||||
if err := bincode.UnpackFixedBytes(r, 4, v.BlockServiceIp1[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackScalar(r, (*uint16)(&v.BlockServicePort1)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackFixedBytes(r, 4, v.BlockServiceIp2[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackScalar(r, (*uint16)(&v.BlockServicePort2)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackScalar(r, (*uint64)(&v.BlockServiceId)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := v.BlockServiceFailureDomain.Unpack(r); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackScalar(r, (*uint8)(&v.BlockServiceFlags)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackScalar(r, (*uint64)(&v.BlockId)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := bincode.UnpackFixedBytes(r, 8, v.Certificate[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v *BlockProof) Pack(w io.Writer) error {
|
||||
if err := bincode.PackScalar(w, uint64(v.BlockId)); err != nil {
|
||||
return err
|
||||
|
||||
@@ -360,11 +360,11 @@ static inline void _eggsfs_current_edge_put_creation_time(struct eggsfs_bincode_
|
||||
{ struct eggsfs_current_edge_creation_time* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_current_edge_end* next __attribute__((unused)) = NULL
|
||||
|
||||
struct eggsfs_block_info_start;
|
||||
#define eggsfs_block_info_get_start(ctx, start) struct eggsfs_block_info_start* start = NULL
|
||||
struct eggsfs_add_span_initiate_block_info_start;
|
||||
#define eggsfs_add_span_initiate_block_info_get_start(ctx, start) struct eggsfs_add_span_initiate_block_info_start* start = NULL
|
||||
|
||||
struct eggsfs_block_info_block_service_ip1 { u32 x; };
|
||||
static inline void _eggsfs_block_info_get_block_service_ip1(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_start** prev, struct eggsfs_block_info_block_service_ip1* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_ip1 { u32 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_block_service_ip1(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_start** prev, struct eggsfs_add_span_initiate_block_info_block_service_ip1* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 4)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -374,12 +374,12 @@ static inline void _eggsfs_block_info_get_block_service_ip1(struct eggsfs_bincod
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_block_service_ip1(ctx, prev, next) \
|
||||
struct eggsfs_block_info_block_service_ip1 next; \
|
||||
_eggsfs_block_info_get_block_service_ip1(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_service_ip1(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_ip1 next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_block_service_ip1(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_block_info_block_service_port1 { u16 x; };
|
||||
static inline void _eggsfs_block_info_get_block_service_port1(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_block_service_ip1* prev, struct eggsfs_block_info_block_service_port1* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_port1 { u16 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_block_service_port1(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_ip1* prev, struct eggsfs_add_span_initiate_block_info_block_service_port1* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 2)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -389,12 +389,12 @@ static inline void _eggsfs_block_info_get_block_service_port1(struct eggsfs_binc
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_block_service_port1(ctx, prev, next) \
|
||||
struct eggsfs_block_info_block_service_port1 next; \
|
||||
_eggsfs_block_info_get_block_service_port1(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_service_port1(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_port1 next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_block_service_port1(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_block_info_block_service_ip2 { u32 x; };
|
||||
static inline void _eggsfs_block_info_get_block_service_ip2(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_block_service_port1* prev, struct eggsfs_block_info_block_service_ip2* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_ip2 { u32 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_block_service_ip2(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_port1* prev, struct eggsfs_add_span_initiate_block_info_block_service_ip2* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 4)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -404,12 +404,12 @@ static inline void _eggsfs_block_info_get_block_service_ip2(struct eggsfs_bincod
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_block_service_ip2(ctx, prev, next) \
|
||||
struct eggsfs_block_info_block_service_ip2 next; \
|
||||
_eggsfs_block_info_get_block_service_ip2(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_service_ip2(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_ip2 next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_block_service_ip2(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_block_info_block_service_port2 { u16 x; };
|
||||
static inline void _eggsfs_block_info_get_block_service_port2(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_block_service_ip2* prev, struct eggsfs_block_info_block_service_port2* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_port2 { u16 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_block_service_port2(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_ip2* prev, struct eggsfs_add_span_initiate_block_info_block_service_port2* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 2)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -419,12 +419,12 @@ static inline void _eggsfs_block_info_get_block_service_port2(struct eggsfs_binc
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_block_service_port2(ctx, prev, next) \
|
||||
struct eggsfs_block_info_block_service_port2 next; \
|
||||
_eggsfs_block_info_get_block_service_port2(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_service_port2(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_port2 next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_block_service_port2(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_block_info_block_service_id { u64 x; };
|
||||
static inline void _eggsfs_block_info_get_block_service_id(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_block_service_port2* prev, struct eggsfs_block_info_block_service_id* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_id { u64 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_block_service_id(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_port2* prev, struct eggsfs_add_span_initiate_block_info_block_service_id* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 8)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -434,16 +434,16 @@ static inline void _eggsfs_block_info_get_block_service_id(struct eggsfs_bincode
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_block_service_id(ctx, prev, next) \
|
||||
struct eggsfs_block_info_block_service_id next; \
|
||||
_eggsfs_block_info_get_block_service_id(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_service_id(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_id next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_block_service_id(ctx, &(prev), &(next))
|
||||
|
||||
#define eggsfs_block_info_get_block_service_failure_domain(ctx, prev, next) \
|
||||
{ struct eggsfs_block_info_block_service_id* __dummy __attribute__((unused)) = &(prev); }; \
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_service_failure_domain(ctx, prev, next) \
|
||||
{ struct eggsfs_add_span_initiate_block_info_block_service_id* __dummy __attribute__((unused)) = &(prev); }; \
|
||||
struct eggsfs_failure_domain_start* next = NULL
|
||||
|
||||
struct eggsfs_block_info_block_id { u64 x; };
|
||||
static inline void _eggsfs_block_info_get_block_id(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_failure_domain_end** prev, struct eggsfs_block_info_block_id* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_block_id { u64 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_block_id(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_failure_domain_end** prev, struct eggsfs_add_span_initiate_block_info_block_id* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 8)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -453,12 +453,12 @@ static inline void _eggsfs_block_info_get_block_id(struct eggsfs_bincode_get_ctx
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_block_id(ctx, prev, next) \
|
||||
struct eggsfs_block_info_block_id next; \
|
||||
_eggsfs_block_info_get_block_id(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_block_id(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_id next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_block_id(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_block_info_certificate { u64 x; };
|
||||
static inline void _eggsfs_block_info_get_certificate(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_block_id* prev, struct eggsfs_block_info_certificate* next) {
|
||||
struct eggsfs_add_span_initiate_block_info_certificate { u64 x; };
|
||||
static inline void _eggsfs_add_span_initiate_block_info_get_certificate(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_id* prev, struct eggsfs_add_span_initiate_block_info_certificate* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 8)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
@@ -468,96 +468,320 @@ static inline void _eggsfs_block_info_get_certificate(struct eggsfs_bincode_get_
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_block_info_get_certificate(ctx, prev, next) \
|
||||
struct eggsfs_block_info_certificate next; \
|
||||
_eggsfs_block_info_get_certificate(ctx, &(prev), &(next))
|
||||
#define eggsfs_add_span_initiate_block_info_get_certificate(ctx, prev, next) \
|
||||
struct eggsfs_add_span_initiate_block_info_certificate next; \
|
||||
_eggsfs_add_span_initiate_block_info_get_certificate(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_block_info_end;
|
||||
#define eggsfs_block_info_get_end(ctx, prev, next) \
|
||||
{ struct eggsfs_block_info_certificate* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_block_info_end* next = NULL
|
||||
struct eggsfs_add_span_initiate_block_info_end;
|
||||
#define eggsfs_add_span_initiate_block_info_get_end(ctx, prev, next) \
|
||||
{ struct eggsfs_add_span_initiate_block_info_certificate* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_add_span_initiate_block_info_end* next = NULL
|
||||
|
||||
static inline void eggsfs_block_info_get_finish(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_block_info_end* end) {
|
||||
static inline void eggsfs_add_span_initiate_block_info_get_finish(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_add_span_initiate_block_info_end* end) {
|
||||
if (unlikely(ctx->buf != ctx->end)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
}
|
||||
}
|
||||
|
||||
#define eggsfs_block_info_put_start(ctx, start) struct eggsfs_block_info_start* start = NULL
|
||||
#define eggsfs_add_span_initiate_block_info_put_start(ctx, start) struct eggsfs_add_span_initiate_block_info_start* start = NULL
|
||||
|
||||
static inline void _eggsfs_block_info_put_block_service_ip1(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_start** prev, struct eggsfs_block_info_block_service_ip1* next, u32 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_block_service_ip1(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_start** prev, struct eggsfs_add_span_initiate_block_info_block_service_ip1* next, u32 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 4);
|
||||
put_unaligned_be32(x, ctx->cursor);
|
||||
ctx->cursor += 4;
|
||||
}
|
||||
#define eggsfs_block_info_put_block_service_ip1(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_block_service_ip1 next; \
|
||||
_eggsfs_block_info_put_block_service_ip1(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_block_service_ip1(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_ip1 next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_block_service_ip1(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_block_info_put_block_service_port1(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_block_service_ip1* prev, struct eggsfs_block_info_block_service_port1* next, u16 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_block_service_port1(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_ip1* prev, struct eggsfs_add_span_initiate_block_info_block_service_port1* next, u16 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 2);
|
||||
put_unaligned_le16(x, ctx->cursor);
|
||||
ctx->cursor += 2;
|
||||
}
|
||||
#define eggsfs_block_info_put_block_service_port1(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_block_service_port1 next; \
|
||||
_eggsfs_block_info_put_block_service_port1(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_block_service_port1(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_port1 next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_block_service_port1(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_block_info_put_block_service_ip2(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_block_service_port1* prev, struct eggsfs_block_info_block_service_ip2* next, u32 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_block_service_ip2(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_port1* prev, struct eggsfs_add_span_initiate_block_info_block_service_ip2* next, u32 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 4);
|
||||
put_unaligned_be32(x, ctx->cursor);
|
||||
ctx->cursor += 4;
|
||||
}
|
||||
#define eggsfs_block_info_put_block_service_ip2(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_block_service_ip2 next; \
|
||||
_eggsfs_block_info_put_block_service_ip2(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_block_service_ip2(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_ip2 next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_block_service_ip2(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_block_info_put_block_service_port2(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_block_service_ip2* prev, struct eggsfs_block_info_block_service_port2* next, u16 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_block_service_port2(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_ip2* prev, struct eggsfs_add_span_initiate_block_info_block_service_port2* next, u16 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 2);
|
||||
put_unaligned_le16(x, ctx->cursor);
|
||||
ctx->cursor += 2;
|
||||
}
|
||||
#define eggsfs_block_info_put_block_service_port2(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_block_service_port2 next; \
|
||||
_eggsfs_block_info_put_block_service_port2(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_block_service_port2(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_port2 next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_block_service_port2(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_block_info_put_block_service_id(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_block_service_port2* prev, struct eggsfs_block_info_block_service_id* next, u64 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_block_service_id(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_port2* prev, struct eggsfs_add_span_initiate_block_info_block_service_id* next, u64 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 8);
|
||||
put_unaligned_le64(x, ctx->cursor);
|
||||
ctx->cursor += 8;
|
||||
}
|
||||
#define eggsfs_block_info_put_block_service_id(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_block_service_id next; \
|
||||
_eggsfs_block_info_put_block_service_id(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_block_service_id(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_service_id next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_block_service_id(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_block_info_put_block_id(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_block_service_id* prev, struct eggsfs_block_info_block_id* next, u64 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_block_id(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_service_id* prev, struct eggsfs_add_span_initiate_block_info_block_id* next, u64 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 8);
|
||||
put_unaligned_le64(x, ctx->cursor);
|
||||
ctx->cursor += 8;
|
||||
}
|
||||
#define eggsfs_block_info_put_block_id(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_block_id next; \
|
||||
_eggsfs_block_info_put_block_id(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_block_id(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_block_id next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_block_id(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_block_info_put_certificate(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_block_info_block_id* prev, struct eggsfs_block_info_certificate* next, u64 x) {
|
||||
static inline void _eggsfs_add_span_initiate_block_info_put_certificate(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_add_span_initiate_block_info_block_id* prev, struct eggsfs_add_span_initiate_block_info_certificate* next, u64 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 8);
|
||||
put_unaligned_be64(x, ctx->cursor);
|
||||
ctx->cursor += 8;
|
||||
}
|
||||
#define eggsfs_block_info_put_certificate(ctx, prev, next, x) \
|
||||
struct eggsfs_block_info_certificate next; \
|
||||
_eggsfs_block_info_put_certificate(ctx, &(prev), &(next), x)
|
||||
#define eggsfs_add_span_initiate_block_info_put_certificate(ctx, prev, next, x) \
|
||||
struct eggsfs_add_span_initiate_block_info_certificate next; \
|
||||
_eggsfs_add_span_initiate_block_info_put_certificate(ctx, &(prev), &(next), x)
|
||||
|
||||
#define eggsfs_block_info_put_end(ctx, prev, next) \
|
||||
{ struct eggsfs_block_info_certificate* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_block_info_end* next __attribute__((unused)) = NULL
|
||||
#define eggsfs_add_span_initiate_block_info_put_end(ctx, prev, next) \
|
||||
{ struct eggsfs_add_span_initiate_block_info_certificate* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_add_span_initiate_block_info_end* next __attribute__((unused)) = NULL
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_start;
|
||||
#define eggsfs_remove_span_initiate_block_info_get_start(ctx, start) struct eggsfs_remove_span_initiate_block_info_start* start = NULL
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_ip1 { u32 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_service_ip1(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_start** prev, struct eggsfs_remove_span_initiate_block_info_block_service_ip1* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 4)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_be32(ctx->buf);
|
||||
ctx->buf += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_ip1(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_ip1 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_service_ip1(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_port1 { u16 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_service_port1(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_ip1* prev, struct eggsfs_remove_span_initiate_block_info_block_service_port1* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 2)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_le16(ctx->buf);
|
||||
ctx->buf += 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_port1(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_port1 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_service_port1(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_ip2 { u32 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_service_ip2(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_port1* prev, struct eggsfs_remove_span_initiate_block_info_block_service_ip2* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 4)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_be32(ctx->buf);
|
||||
ctx->buf += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_ip2(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_ip2 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_service_ip2(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_port2 { u16 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_service_port2(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_ip2* prev, struct eggsfs_remove_span_initiate_block_info_block_service_port2* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 2)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_le16(ctx->buf);
|
||||
ctx->buf += 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_port2(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_port2 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_service_port2(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_id { u64 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_service_id(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_port2* prev, struct eggsfs_remove_span_initiate_block_info_block_service_id* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 8)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_le64(ctx->buf);
|
||||
ctx->buf += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_id(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_id next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_service_id(ctx, &(prev), &(next))
|
||||
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_failure_domain(ctx, prev, next) \
|
||||
{ struct eggsfs_remove_span_initiate_block_info_block_service_id* __dummy __attribute__((unused)) = &(prev); }; \
|
||||
struct eggsfs_failure_domain_start* next = NULL
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_flags { u8 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_service_flags(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_failure_domain_end** prev, struct eggsfs_remove_span_initiate_block_info_block_service_flags* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 1)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = *(u8*)(ctx->buf);
|
||||
ctx->buf += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_service_flags(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_flags next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_service_flags(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_block_id { u64 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_block_id(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_flags* prev, struct eggsfs_remove_span_initiate_block_info_block_id* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 8)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_le64(ctx->buf);
|
||||
ctx->buf += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_block_id(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_id next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_block_id(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_certificate { u64 x; };
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_get_certificate(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_id* prev, struct eggsfs_remove_span_initiate_block_info_certificate* next) {
|
||||
if (likely(ctx->err == 0)) {
|
||||
if (unlikely(ctx->end - ctx->buf < 8)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
} else {
|
||||
next->x = get_unaligned_be64(ctx->buf);
|
||||
ctx->buf += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_get_certificate(ctx, prev, next) \
|
||||
struct eggsfs_remove_span_initiate_block_info_certificate next; \
|
||||
_eggsfs_remove_span_initiate_block_info_get_certificate(ctx, &(prev), &(next))
|
||||
|
||||
struct eggsfs_remove_span_initiate_block_info_end;
|
||||
#define eggsfs_remove_span_initiate_block_info_get_end(ctx, prev, next) \
|
||||
{ struct eggsfs_remove_span_initiate_block_info_certificate* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_remove_span_initiate_block_info_end* next = NULL
|
||||
|
||||
static inline void eggsfs_remove_span_initiate_block_info_get_finish(struct eggsfs_bincode_get_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_end* end) {
|
||||
if (unlikely(ctx->buf != ctx->end)) {
|
||||
ctx->err = EGGSFS_ERR_MALFORMED_RESPONSE;
|
||||
}
|
||||
}
|
||||
|
||||
#define eggsfs_remove_span_initiate_block_info_put_start(ctx, start) struct eggsfs_remove_span_initiate_block_info_start* start = NULL
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_service_ip1(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_start** prev, struct eggsfs_remove_span_initiate_block_info_block_service_ip1* next, u32 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 4);
|
||||
put_unaligned_be32(x, ctx->cursor);
|
||||
ctx->cursor += 4;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_service_ip1(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_ip1 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_service_ip1(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_service_port1(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_ip1* prev, struct eggsfs_remove_span_initiate_block_info_block_service_port1* next, u16 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 2);
|
||||
put_unaligned_le16(x, ctx->cursor);
|
||||
ctx->cursor += 2;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_service_port1(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_port1 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_service_port1(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_service_ip2(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_port1* prev, struct eggsfs_remove_span_initiate_block_info_block_service_ip2* next, u32 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 4);
|
||||
put_unaligned_be32(x, ctx->cursor);
|
||||
ctx->cursor += 4;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_service_ip2(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_ip2 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_service_ip2(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_service_port2(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_ip2* prev, struct eggsfs_remove_span_initiate_block_info_block_service_port2* next, u16 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 2);
|
||||
put_unaligned_le16(x, ctx->cursor);
|
||||
ctx->cursor += 2;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_service_port2(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_port2 next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_service_port2(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_service_id(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_port2* prev, struct eggsfs_remove_span_initiate_block_info_block_service_id* next, u64 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 8);
|
||||
put_unaligned_le64(x, ctx->cursor);
|
||||
ctx->cursor += 8;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_service_id(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_id next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_service_id(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_service_flags(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_id* prev, struct eggsfs_remove_span_initiate_block_info_block_service_flags* next, u8 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 1);
|
||||
*(u8*)(ctx->cursor) = x;
|
||||
ctx->cursor += 1;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_service_flags(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_service_flags next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_service_flags(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_block_id(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_service_flags* prev, struct eggsfs_remove_span_initiate_block_info_block_id* next, u64 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 8);
|
||||
put_unaligned_le64(x, ctx->cursor);
|
||||
ctx->cursor += 8;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_block_id(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_block_id next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_block_id(ctx, &(prev), &(next), x)
|
||||
|
||||
static inline void _eggsfs_remove_span_initiate_block_info_put_certificate(struct eggsfs_bincode_put_ctx* ctx, struct eggsfs_remove_span_initiate_block_info_block_id* prev, struct eggsfs_remove_span_initiate_block_info_certificate* next, u64 x) {
|
||||
next = NULL;
|
||||
BUG_ON(ctx->end - ctx->cursor < 8);
|
||||
put_unaligned_be64(x, ctx->cursor);
|
||||
ctx->cursor += 8;
|
||||
}
|
||||
#define eggsfs_remove_span_initiate_block_info_put_certificate(ctx, prev, next, x) \
|
||||
struct eggsfs_remove_span_initiate_block_info_certificate next; \
|
||||
_eggsfs_remove_span_initiate_block_info_put_certificate(ctx, &(prev), &(next), x)
|
||||
|
||||
#define eggsfs_remove_span_initiate_block_info_put_end(ctx, prev, next) \
|
||||
{ struct eggsfs_remove_span_initiate_block_info_certificate* __dummy __attribute__((unused)) = &(prev); }\
|
||||
struct eggsfs_remove_span_initiate_block_info_end* next __attribute__((unused)) = NULL
|
||||
|
||||
#define EGGSFS_BLOCK_PROOF_SIZE 16
|
||||
struct eggsfs_block_proof_start;
|
||||
|
||||
@@ -773,16 +773,16 @@ int eggsfs_shard_add_span_initiate(
|
||||
}
|
||||
int i;
|
||||
for (i = 0; i < B; i++) {
|
||||
eggsfs_block_info_get_start(&ctx, start);
|
||||
eggsfs_block_info_get_block_service_ip1(&ctx, start, bs_ip1);
|
||||
eggsfs_block_info_get_block_service_port1(&ctx, bs_ip1, bs_port1);
|
||||
eggsfs_block_info_get_block_service_ip2(&ctx, bs_port1, bs_ip2);
|
||||
eggsfs_block_info_get_block_service_port2(&ctx, bs_ip2, bs_port2);
|
||||
eggsfs_block_info_get_block_service_id(&ctx, bs_port2, bs_id);
|
||||
eggsfs_block_info_get_block_service_failure_domain(&ctx, bs_id, failure_domain_start);
|
||||
eggsfs_add_span_initiate_block_info_get_start(&ctx, start);
|
||||
eggsfs_add_span_initiate_block_info_get_block_service_ip1(&ctx, start, bs_ip1);
|
||||
eggsfs_add_span_initiate_block_info_get_block_service_port1(&ctx, bs_ip1, bs_port1);
|
||||
eggsfs_add_span_initiate_block_info_get_block_service_ip2(&ctx, bs_port1, bs_ip2);
|
||||
eggsfs_add_span_initiate_block_info_get_block_service_port2(&ctx, bs_ip2, bs_port2);
|
||||
eggsfs_add_span_initiate_block_info_get_block_service_id(&ctx, bs_port2, bs_id);
|
||||
eggsfs_add_span_initiate_block_info_get_block_service_failure_domain(&ctx, bs_id, failure_domain_start);
|
||||
eggsfs_failure_domain_get(&ctx, failure_domain_start, failure_domain_end, failure_domain);
|
||||
eggsfs_block_info_get_block_id(&ctx, failure_domain_end, block_id);
|
||||
eggsfs_block_info_get_certificate(&ctx, block_id, certificate);
|
||||
eggsfs_add_span_initiate_block_info_get_block_id(&ctx, failure_domain_end, block_id);
|
||||
eggsfs_add_span_initiate_block_info_get_certificate(&ctx, block_id, certificate);
|
||||
if (likely(ctx.err == 0)) {
|
||||
blocks_out[i].ip1 = bs_ip1.x;
|
||||
blocks_out[i].port1 = bs_port1.x;
|
||||
|
||||
Reference in New Issue
Block a user