mirror of
https://github.com/versity/scoutfs.git
synced 2026-01-08 13:01:23 +00:00
38a4a56741
The core quorum work loop assumes that it has exclusive access to its slot's quorum block. It uniquely marks blocks it writes and verifies the marks on read to discover if another mount has written to its slot under the assumption that this must be a configuration error that put two mounts in the same slot. But the design of the leader bit in the block violates the invariant that only a slot will write to its block. As the server comes up and fences previous leaders it writes to their block to clear their leader bit. The final hole in the design is that because we're fencing mounts, not slots, each slot can have two mounts in play. An active mount can be using the slot and there can still be a persistent record of a previous mount in the slot that crashed that needs to be fenced. All this comes together to have the server fence an old mount in a slot while a new mount is coming up. The new mount sees the mark change and freaks out and stops participating in quorum. The fix is to rework the quorum blocks so that each slot only writes to its own block. Instead of the server writing to each fenced mount's slot, it writes a fence event to its block once all previous mounts have been fenced. We add a bit of bookkeeping so that the server can discover when all block leader fence operations have completed. Each event gets its own term so we can compare events to discover live servers. We get rid of the write marks and instead have an event that is written as a quorum agent starts up and is then checked on every read to make sure it still matches. Signed-off-by: Zach Brown <zab@versity.com>
21 lines
700 B
C
21 lines
700 B
C
#ifndef _SCOUTFS_FENCE_H_
|
|
#define _SCOUTFS_FENCE_H_
|
|
|
|
enum {
|
|
SCOUTFS_FENCE_CLIENT_RECOVERY,
|
|
SCOUTFS_FENCE_CLIENT_RECONNECT,
|
|
SCOUTFS_FENCE_QUORUM_BLOCK_LEADER,
|
|
};
|
|
|
|
int scoutfs_fence_start(struct super_block *sb, u64 rid, __be32 ipv4_addr, int reason);
|
|
int scoutfs_fence_next(struct super_block *sb, u64 *rid, int *reason, bool *error);
|
|
int scoutfs_fence_reason_pending(struct super_block *sb, int reason);
|
|
int scoutfs_fence_free(struct super_block *sb, u64 rid);
|
|
int scoutfs_fence_wait_fenced(struct super_block *sb, long timeout_jiffies);
|
|
|
|
int scoutfs_fence_setup(struct super_block *sb);
|
|
void scoutfs_fence_stop(struct super_block *sb);
|
|
void scoutfs_fence_destroy(struct super_block *sb);
|
|
|
|
#endif
|