static const uint FILE_NUM_OFFSET = 1;

static const uint FILE_POS_OFFSET = 5;

static const uint FILE_DATA_OFFSET = 13;

public:

Binlog_redo_log_reader(const uchar *buffer, uint length)

: m_buffer(buffer), m_length(length) {}

/* return the value of File Num field. */

uint log_num() {

return *reinterpret_cast<const uint *>(m_buffer + FILE_NUM_OFFSET);

}

/* return the value of File Pos field */

my_off_t log_pos() { return uint8korr(m_buffer + FILE_POS_OFFSET); }

/* return the pointer of File Data field */

const uchar *data() { return m_buffer + FILE_DATA_OFFSET; }

/* return the length of File Data field */

uint data_len() { return m_length - FILE_DATA_OFFSET; }

private:

const uchar *m_buffer;

uint m_length;

public:

class Async_writer;

Binlog_ext();

/* Lock for sync binlog file in redo flusher thread */

Spin_lock *get_file_sync_lock() { return &m_file_sync_lock; }

bool file_sync_lock_no_wait() { return m_file_sync_lock.lock_no_wait(); }

void file_sync_lock() { m_file_sync_lock.lock(); }

void file_sync_unlock() { m_file_sync_lock.unlock(); }

/**

bool force_ha_flush_log(THD *thd);

/*

void init_pthread_objects();

/**

bool init(bool is_normal_startup = true);

void cleanup();

/**

bool open_binlog_file();

/**

bool should_persist_to_redo(THD *thd);

/**

bool commit(THD *thd);

/**

void switch_to_sync_mode(THD *thd);

/**

class XA_rotate_guard {

public:

XA_rotate_guard(THD *thd, const bool *has_error)

: m_thd(thd), m_has_error(has_error) {}

~XA_rotate_guard();

private:

THD *m_thd;

const bool *m_has_error;

};

/**

void xa_inc_prep_xids(THD *thd);

/**

bool xa_delay_rotate(THD *thd, bool do_rotate);

mysql_mutex_t *get_writeset_history_lock() {

return &m_writeset_history_mutex;

}

/**

bool duckdb_binlog_init();

/**

bool duckdb_commit(THD *thd);

/**

bool duckdb_recover(const char *log_name);

/**

bool duckdb_binlog_rotate();

private:

Binlog_ext &operator=(const Binlog_ext &) = delete;

Binlog_ext(const Binlog_ext &) = delete;

Binlog_ext(Binlog_ext &&) = delete;

void update_gtid_after_commit(THD *first_seen);

/**

bool m_inited = false;

/**

mysql_mutex_t m_writeset_history_mutex;

/**

Spin_lock m_file_sync_lock;

class Redo_observer : public server_redo_log::Observer {

public:

bool before_checkpoint(uint64) override;

};

Redo_observer m_redo_observer;

/** The suffix number of current binlog file. It is stored in big-endian. */

uint m_log_num;

/** Points to the log name without path */

char *m_log_name;

rpl_sidno m_current_server_sidno;

void rotate(THD *thd);

public:

Binlog_cache_free_flush();

/**

void init_binlog_cache_dir();

/**

void save_new_file_name(const char *new_name);

/**

bool commit(THD *thd);

/**

inline bool check(THD *thd);

/**

inline bool check_reserved_space_enough(my_off_t reserved_size);

/**

ulonglong inc_tmp_file_count() { return m_tmp_file_count.fetch_add(1); }

const char *get_tmp_file_name() const { return m_tmp_file_name; }

bool is_free_flushing() const { return m_is_free_flushing; }

bool is_enabled() const { return m_is_enabled; }

bool is_dir_initialized() const { return m_is_dir_initialized; }

ulong get_reserved_size() const { return m_reserved_size.load(); }

void update_reserved_size(ulong position) {

m_reserved_size.store(position + binary_log::Gtid_event::MAX_EVENT_LENGTH +

512);

}

const ulonglong &get_limit_size_var() { return m_limit_size; }

const bool &get_enabled_var() { return m_is_enabled; }

private:

Binlog_cache_free_flush &operator=(const Binlog_cache_free_flush &) = delete;

Binlog_cache_free_flush(const Binlog_cache_free_flush &) = delete;

Binlog_cache_free_flush(Binlog_cache_free_flush &&) = delete;

/**

bool rename_temp_to_binlog();

/**

my_off_t get_gtid_event_length(THD *thd);

/**

ulong calculate_front_event_length();

/** New name generated by binlog rotate. */

char m_current_new_name[FN_REFLEN];

/** Tmp file name of binlog cache. */

char m_tmp_file_name[FN_REFLEN];

/** Var of binlog cache free flush limit size. */

ulonglong m_limit_size;

/** Var of binlog cache free flush. */

bool m_is_enabled;

/** Whether binlog cache dir initialized success. */

bool m_is_dir_initialized;

/** Whether in binlog cache free flush process. */

bool m_is_free_flushing;

/** Size of binlog cache reserve for front events. */

std::atomic<ulong> m_reserved_size;

/** Record the number of keep tmp files created. */

std::atomic<ulonglong> m_tmp_file_count;

public:

Binlog_redo_recovery();

~Binlog_redo_recovery();

bool recovery_begin() override;

bool recovery_end() override;

bool apply(const unsigned char *ptr, uint len) override;

private:

/** name of the last binlog file */

char m_log_name[FN_REFLEN];

/** the suffix number of the last binlog file. It is in big-endian */

uint m_log_num = 0;

/** length of the last binlog file */

my_off_t m_log_length = 0;

/** The last binlog file has checksum or not */

bool m_have_checksum = false;

/** It is for writing binlog events back to the last binlog file */

std::unique_ptr<MYSQL_BIN_LOG::Binlog_ofile> m_ofile;

uchar *m_buffer = {nullptr};

size_t m_buffer_size = 0;

/**

std::map<uint64_t, uint64_t> m_binlog_blocks;

/**

bool increase_buffer(size_t size);

/**

void copy_to_buffer(const uchar *src, size_t len, my_off_t log_pos);

/**

bool copy_to_file(my_off_t log_pos, size_t len, Basic_ostream *ostream);