ERROR: database is not accepting commands to avoid wraparound data loss in database "xxx"
HINT: Stop the postmaster and vacuum that database in single-user mode. You might also need to commit or roll back old prepared transactions, or drop stale replication slots.

typedef uint32 TransactionId;

提示：PG中有2类事务号，>=3的为正常事务号；0 1 2事务号有特殊含义，并且永远比正常事务号小
PG源码中事务号定义如下：
#define InvalidTransactionId    ((TransactionId) 0)  不可用的事务id 
#define BootstrapTransactionId    ((TransactionId) 1)  pg初始化cluster时用的事务id
#define FrozenTransactionId     ((TransactionId) 2)  frozen的事务id

/*
 * TransactionIdFollowsOrEquals --- is id1 logically >= id2?
 */
bool
TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
{
  int32   diff;
  if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
    return (id1 >= id2); //如果有非正常事务号，永远是非正常事务号小
  diff = (int32) (id1 - id2); //如果
  return (diff >= 0);  
}

define XidGenLock (&MainLWLockArray[3].lock)

*   lwlock.h
*   Lightweight lock manager
typedef struct LWLock
{
  uint16    tranche;    /* tranche ID */
  pg_atomic_uint32 state;   /* state of exclusive/nonexclusive lockers */
  proclist_head waiters;    /* list of waiting PGPROCs */
#ifdef LOCK_DEBUG
  pg_atomic_uint32 nwaiters;  /* number of waiters */
  struct PGPROC *owner;   /* last exclusive owner of the lock */
#endif
} LWLock;
* src/include/port/atomics/fallback.h
typedef struct pg_atomic_uint32
{
  /* Check pg_atomic_flag's definition above for an explanation */
#if defined(__hppa) || defined(__hppa__)  /* HP PA-RISC, GCC and HP compilers */
  int     sema[4];
#else
  int     sema;
#endif
  volatile uint32 value;
} pg_atomic_uint32;
proc是每个进程共享内存的结构
/*
 * src/include/storage/proclist_types.h
 * Header of a doubly-linked list of PGPROCs, identified by pgprocno.
 * An empty list is represented by head == tail == INVALID_PGPROCNO.
 */
typedef struct proclist_head
{
  int     head;     /* pgprocno of the head PGPROC */
  int     tail;     /* pgprocno of the tail PGPROC */
} proclist_head;

static bool
LWLockAttemptLock(LWLock *lock, LWLockMode mode)
{
/* loop until we've determined whether we could acquire the lock or not */
  while (true)
  {
    uint32    desired_state;
    bool    lock_free;
    desired_state = old_state;
    if (mode == LW_EXCLUSIVE)
    {
      lock_free = (old_state & LW_LOCK_MASK) == 0;
      if (lock_free)
        desired_state += LW_VAL_EXCLUSIVE;
    }
    else
    {
      lock_free = (old_state & LW_VAL_EXCLUSIVE) == 0;
      if (lock_free)
        desired_state += LW_VAL_SHARED;
    }
    ...
  }
  ...
}

(gdb)p old_state
$5 = 536870912
(gdb) p /x old_state
$6 = 0x20000000
(gdb) p /t old_state
$7 = 100000 00000000 00000000 00000000
 old_state & LW_LOCK_MASK =  0 所以 lock_free 是true
desired_state += LW_VAL_EXCLUSIVE;  （LW_VAL_EXCLUSIVE =1 00000000 00000000 00000000）
(gdb) p desired_state
$9 = 553648128
(gdb) p /x desired_state
$10 = 0x21000000
(gdb) p /t desired_state
$11 = 100001 00000000 00000000 00000000

if (pg_atomic_compare_exchange_u32(&lock->state,
                       &old_state, desired_state))
#define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32
static inline bool
pg_atomic_compare_exchange_u32_impl(volatile pg_atomic_uint32 *ptr,
                  uint32 *expected, uint32 newval)
{
  char  ret;
  /*
   * Perform cmpxchg and use the zero flag which it implicitly sets when
   * equal to measure the success.
   */
  __asm__ __volatile__(
    " lock        \n"
    " cmpxchgl  %4,%5 \n"
    "   setz    %2    \n"
:   "=a" (*expected), "=m"(ptr->value), "=q" (ret)
:   "a" (*expected), "r" (newval), "m"(ptr->value)
:   "memory", "cc");
  return (bool) ret;
}

伪代码：
%rax = *expected;
if ( *expected ==ptr->value) {
    ptr->value = newval;
    ZF = 1;
} else {
    %rax = ptr->value
    ZF = 0;
}
*expected = %rax
ret = ZF;
return ret;