mirror of
https://github.com/versity/scoutfs.git
synced 2026-09-01 05:37:33 +00:00
Zach Brown
8e34c5d66a
Previously quorum configuration specified the number of votes needed to elected the leader. This was an excessive amount of freedom in the configuration of the cluster which created all sorts of problems which had to be designed around. Most acutely, though, it required a probabilistic mechanism for mounts to persistently record that they're starting a server so that future servers could find and possibly fence them. They would write to a lot of quorum blocks and trust that it was unlikely that future servers would overwrite all of their written blocks. Overwriting was always possible, which would be bad enough, but it also required so much IO that we had to use long election timeouts to avoid spurious fencing. These longer timeouts had already gone wrong on some storage configurations, leading to hung mounts. To fix this and other problems we see coming, like live membership changes, we now specifically configure the number and identity of mounts which will be participating in quorum voting. With specific identities, mounts now have a corresponding specific block they can write to and which future servers can read from to see if they're still running. We change the quorum config in the super block from a single quorum_count to an array of quorum slots which specify the address of the mount that is assigned to that slot. The mount argument to specify a quorum voter changes from "server_addr=$addr" to "quorum_slot_nr=$nr" which specifies the mount's slot. The slot's address is used for udp election messages and tcp server connections. Now that we specifically have configured unique IP addresses for all the quorum members, we can use UDP messages to send and receive the vote mesages in the raft protocol to elect a leader. The quorum code doesn't have to read and write disk block votes and is a more reasonable core loop that either waits for received network messages or timeouts to advance the raft election state machine. The quorum blocks are now used for slots to store their persistent raft term and to set their leader state. We have event fields in the block to record the timestamp of the most recent interesting events that happened to the slot. Now that raft doesn't use IO, we can leave the quorum election work running in the background. The raft work in the quorum members is always running so we can use a much more typical raft implementation with heartbeats. Critically, this decouples the client and election life cycles. Quorum is always running and is responsible for starting and stopping the server. The client repeatedly tries to connect to a server, it has nothing to do with deciding to participate in quorum. Finally, we add a quorum/status sysfs file which shows the state of the quorum raft protocol in a member mount and has the last messages that were sent to or received from the other members. Signed-off-by: Zach Brown <zab@versity.com>
80 lines
2.6 KiB
C
80 lines
2.6 KiB
C
#ifndef _SCOUTFS_SERVER_H_
|
|
#define _SCOUTFS_SERVER_H_
|
|
|
|
#define SI4_FMT "%u.%u.%u.%u:%u"
|
|
|
|
#define si4_trace_define(name) \
|
|
__field(__u32, name##_addr) \
|
|
__field(__u16, name##_port)
|
|
|
|
#define si4_trace_assign(name, sin) \
|
|
do { \
|
|
__typeof__(sin) _sin = (sin); \
|
|
\
|
|
__entry->name##_addr = be32_to_cpu(_sin->sin_addr.s_addr); \
|
|
__entry->name##_port = be16_to_cpu(_sin->sin_port); \
|
|
} while(0)
|
|
|
|
#define si4_trace_args(name) \
|
|
(__entry->name##_addr >> 24), \
|
|
(__entry->name##_addr >> 16) & 255, \
|
|
(__entry->name##_addr >> 8) & 255, \
|
|
__entry->name##_addr & 255, \
|
|
__entry->name##_port
|
|
|
|
#define SNH_FMT \
|
|
"seq %llu recv_seq %llu id %llu data_len %u cmd %u flags 0x%x error %u"
|
|
#define SNH_ARG(nh) \
|
|
le64_to_cpu((nh)->seq), le64_to_cpu((nh)->recv_seq), \
|
|
le64_to_cpu((nh)->id), le16_to_cpu((nh)->data_len), (nh)->cmd, \
|
|
(nh)->flags, (nh)->error
|
|
|
|
#define snh_trace_define(name) \
|
|
__field(__u64, name##_seq) \
|
|
__field(__u64, name##_recv_seq) \
|
|
__field(__u64, name##_id) \
|
|
__field(__u16, name##_data_len) \
|
|
__field(__u8, name##_cmd) \
|
|
__field(__u8, name##_flags) \
|
|
__field(__u8, name##_error)
|
|
|
|
#define snh_trace_assign(name, nh) \
|
|
do { \
|
|
__typeof__(nh) _nh = (nh); \
|
|
\
|
|
__entry->name##_seq = le64_to_cpu(_nh->seq); \
|
|
__entry->name##_recv_seq = le64_to_cpu(_nh->recv_seq); \
|
|
__entry->name##_id = le64_to_cpu(_nh->id); \
|
|
__entry->name##_data_len = le16_to_cpu(_nh->data_len); \
|
|
__entry->name##_cmd = _nh->cmd; \
|
|
__entry->name##_flags = _nh->flags; \
|
|
__entry->name##_error = _nh->error; \
|
|
} while (0)
|
|
|
|
#define snh_trace_args(name) \
|
|
__entry->name##_seq, __entry->name##_recv_seq, __entry->name##_id, \
|
|
__entry->name##_data_len, __entry->name##_cmd, __entry->name##_flags, \
|
|
__entry->name##_error
|
|
|
|
int scoutfs_server_lock_request(struct super_block *sb, u64 rid,
|
|
struct scoutfs_net_lock *nl);
|
|
int scoutfs_server_lock_response(struct super_block *sb, u64 rid, u64 id,
|
|
struct scoutfs_net_lock_grant_response *gr);
|
|
int scoutfs_server_lock_recover_request(struct super_block *sb, u64 rid,
|
|
struct scoutfs_key *key);
|
|
void scoutfs_server_get_roots(struct super_block *sb,
|
|
struct scoutfs_net_roots *roots);
|
|
int scoutfs_server_hold_commit(struct super_block *sb);
|
|
int scoutfs_server_apply_commit(struct super_block *sb, int err);
|
|
|
|
struct sockaddr_in;
|
|
struct scoutfs_quorum_elected_info;
|
|
int scoutfs_server_start(struct super_block *sb, u64 term);
|
|
void scoutfs_server_abort(struct super_block *sb);
|
|
void scoutfs_server_stop(struct super_block *sb);
|
|
|
|
int scoutfs_server_setup(struct super_block *sb);
|
|
void scoutfs_server_destroy(struct super_block *sb);
|
|
|
|
#endif
|