New upstream version 8.1.0

client_module/source/common/nodes/TargetStateStore.c

@@ -0,0 +1,184 @@
+#include "TargetStateStore.h"
+
+BEEGFS_RBTREE_FUNCTIONS(static, _TargetStateStore, struct TargetStateStore, states,
+      uint16_t,
+      struct TargetStateInfo, targetID, _node,
+      BEEGFS_RB_KEYCMP_LT_INTEGRAL)
+
+void TargetStateStore_init(TargetStateStore* this)
+{
+   RWLock_init(&this->rwlock);
+   this->states = RB_ROOT;
+}
+
+TargetStateStore* TargetStateStore_construct(void)
+{
+   TargetStateStore* this = (TargetStateStore*)os_kmalloc(sizeof(*this) );
+
+   if (likely(this) )
+      TargetStateStore_init(this);
+
+   return this;
+}
+
+void TargetStateStore_uninit(TargetStateStore* this)
+{
+   BEEGFS_KFREE_RBTREE(&this->states, struct TargetStateInfo, _node);
+}
+
+void TargetStateStore_destruct(TargetStateStore* this)
+{
+   TargetStateStore_uninit(this);
+
+   kfree(this);
+}
+
+/**
+ * Atomically update target states and buddy groups together. This is important to avoid races
+ * during a switch (e.g. where an outside viewer could see an offline primary).
+ *
+ * Of course, this implies that states and groups also have to be read atomically together via
+ * getStatesAndGroupsAsLists() through GetStatesAndBuddyGroupsMsg.
+ */
+void TargetStateStore_syncStatesAndGroupsFromLists(TargetStateStore* this, Config* config,
+   MirrorBuddyGroupMapper* buddyGroups, struct list_head* states, struct list_head* groups)
+{
+   RWLock_writeLock(&this->rwlock); // L O C K targetStates
+   RWLock_writeLock(&buddyGroups->rwlock); // L O C K buddyGroups
+
+   __TargetStateStore_syncStatesUnlocked(this, states);
+
+   __MirrorBuddyGroupMapper_syncGroupsUnlocked(buddyGroups, config, groups);
+
+   RWLock_writeUnlock(&buddyGroups->rwlock); // U N L O C K buddyGroups
+   RWLock_writeUnlock(&this->rwlock); // U N L O C K targetStates
+}
+
+/**
+ * Note: Caller must hold writelock.
+ */
+void __TargetStateStore_syncStatesUnlocked(TargetStateStore* this, struct list_head* states)
+{
+   struct TargetStateMapping* state;
+
+   // clear existing map
+   BEEGFS_KFREE_RBTREE(&this->states, struct TargetStateInfo, _node);
+
+   list_for_each_entry(state, states, _list)
+   {
+      CombinedTargetState currentState = { state->reachabilityState, state->consistencyState };
+
+      TargetStateInfo* stateInfo = kmalloc(sizeof(TargetStateInfo), GFP_NOFS | __GFP_NOFAIL);
+
+      stateInfo->targetID = state->targetID;
+      stateInfo->state = currentState;
+
+      kfree(_TargetStateStore_insertOrReplace(this, stateInfo));
+   }
+}
+
+/**
+ * @return pointer to static string (so don't free it)
+ */
+const char* TargetStateStore_reachabilityStateToStr(TargetReachabilityState state)
+{
+   switch(state)
+   {
+      case TargetReachabilityState_ONLINE:
+         return "Online";
+
+      case TargetReachabilityState_POFFLINE:
+         return "Probably-offline";
+
+      case TargetReachabilityState_OFFLINE:
+         return "Offline";
+
+      default:
+         return "<invalid_value>";
+   }
+}
+
+/**
+ * @return pointer to static string (so don't free it)
+ */
+const char* TargetStateStore_consistencyStateToStr(TargetConsistencyState state)
+{
+   switch(state)
+   {
+      case TargetConsistencyState_GOOD:
+         return "Good";
+
+      case TargetConsistencyState_NEEDS_RESYNC:
+         return "Needs-resync";
+
+      case TargetConsistencyState_BAD:
+         return "Bad";
+
+      default:
+         return "<invalid_value>";
+   }
+}
+
+void TargetStateStore_getStatesAsLists(TargetStateStore* this, UInt16List* outTargetIDs,
+   UInt8List* outReachabilityStates, UInt8List* outConsistencyStates)
+{
+   struct TargetStateInfo* stateInfo;
+   RWLock_readLock(&this->rwlock); // L O C K
+
+   BEEGFS_RBTREE_FOR_EACH_ENTRY(stateInfo, &this->states, _node)
+   {
+      UInt16List_append(outTargetIDs, stateInfo->targetID);
+      UInt8List_append(outReachabilityStates, stateInfo->state.reachabilityState);
+      UInt8List_append(outConsistencyStates, stateInfo->state.consistencyState);
+   }
+
+   RWLock_readUnlock(&this->rwlock); // U N L O C K
+}
+
+bool TargetStateStore_setAllStates(TargetStateStore* this, TargetReachabilityState state)
+{
+   bool res = false;
+   struct TargetStateInfo* stateInfo;
+
+   RWLock_writeLock(&this->rwlock); // L O C K
+
+   BEEGFS_RBTREE_FOR_EACH_ENTRY(stateInfo, &this->states, _node)
+   {
+      if (stateInfo->state.reachabilityState != state)
+      {
+         res = true;
+         stateInfo->state.reachabilityState = state;
+      }
+   }
+
+   RWLock_writeUnlock(&this->rwlock); // U N L O C K
+
+   return res;
+}
+
+bool TargetStateStore_getState(TargetStateStore* this, uint16_t targetID,
+   CombinedTargetState* state)
+{
+   TargetStateInfo* stateInfo;
+   bool res;
+
+   RWLock_readLock(&this->rwlock); // L O C K
+
+   stateInfo = _TargetStateStore_find(this, targetID);
+
+   if(likely(stateInfo) )
+   {
+      *state = stateInfo->state;
+      res = true;
+   }
+   else
+   {
+      state->reachabilityState = TargetReachabilityState_OFFLINE;
+      state->consistencyState = TargetConsistencyState_GOOD;
+      res = false;
+   }
+
+   RWLock_readUnlock(&this->rwlock); // U N L O C K
+
+   return res;
+}