...

/*

 * Update the average distance between checkpoints if the prior checkpoint

 * exists.

 */

if (PriorRedoPtr != InvalidXLogRecPtr)

UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);

/*

 * Delete old log files, those no longer needed for last checkpoint to

 * prevent the disk holding the xlog from growing full.

 */

XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);

KeepLogSeg(recptr, &_logSegNo);

_logSegNo--;

RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr);

/*

 * Make more log segments if needed.  (Do this after recycling old log

 * segments, since that may supply some of the needed files.)

 */

if (!shutdown)

PreallocXlogFiles(recptr);

static void

UpdateCheckPointDistanceEstimate(uint64 nbytes)

{

PrevCheckPointDistance = nbytes;

if (CheckPointDistanceEstimate < nbytes)

CheckPointDistanceEstimate = nbytes;

else

CheckPointDistanceEstimate =

(0.90 * CheckPointDistanceEstimate + 0.10 * (double) nbytes);

}

#define XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes) \

logSegNo = (xlrp) / (wal_segsz_bytes)

#define XLByteToPrevSeg(xlrp, logSegNo, wal_segsz_bytes) \

logSegNo = ((xlrp) - 1) / (wal_segsz_bytes)

static void

KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)

{

XLogSegNosegno;

XLogRecPtrkeep;

XLByteToSeg(recptr, segno, wal_segment_size);

keep = XLogGetReplicationSlotMinimumLSN();

/* compute limit for wal_keep_segments first */

if (wal_keep_segments > 0)

{

/* avoid underflow, don't go below 1 */

        --假如当前WAL日志是第5个，那么就向前推进，保留到第一个WAL日志

if (segno <= wal_keep_segments)

segno = 1;

        --否则推进到两者相减的那个WAL日志，之前的都可删除

else

segno = segno - wal_keep_segments;

}

/* then check whether slots limit removal further */

if (max_replication_slots > 0 && keep != InvalidXLogRecPtr)

{

XLogSegNoslotSegNo;

XLByteToSeg(keep, slotSegNo, wal_segment_size);

        --计算slot，假如计算出的值小于wal_keep_segments，则保留

if (slotSegNo <= 0)

segno = 1;

else if (slotSegNo < segno)

segno = slotSegNo;

}

/* don't delete WAL segments newer than the calculated segment */

if (segno < *logSegNo)

*logSegNo = segno;

}

static void

RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr RedoRecPtr, XLogRecPtr endptr)

{

DIR   *xldir;

struct dirent *xlde;

charlastoff[MAXFNAMELEN];

...

...

/*

 * We ignore the timeline part of the XLOG segment identifiers in

 * deciding whether a segment is still needed.  This ensures that we

 * won't prematurely remove a segment from a parent timeline. We could

 * probably be a little more proactive about removing segments of

 * non-parent timelines, but that would be a whole lot more

 * complicated.

 *

 * We use the alphanumeric sorting property of the filenames to decide

 * which ones are earlier than the lastoff segment.

 */

if (strcmp(xlde->d_name + 8, lastoff + 8) <= 0)

{

if (XLogArchiveCheckDone(xlde->d_name))

{

/* Update the last removed location in shared memory first */

UpdateLastRemovedPtr(xlde->d_name);

RemoveXlogFile(xlde->d_name, RedoRecPtr, endptr);

}

}

}

static void

RemoveXlogFile(const char *segname, XLogRecPtr RedoRecPtr, XLogRecPtr endptr)

{

charpath[MAXPGPATH];

#ifdef WIN32

charnewpath[MAXPGPATH];

#endif

struct stat statbuf;

XLogSegNoendlogSegNo;

XLogSegNorecycleSegNo;

if (wal_recycle)

{

/*

 * Initialize info about where to try to recycle to.

 */

XLByteToSeg(endptr, endlogSegNo, wal_segment_size);

if (RedoRecPtr == InvalidXLogRecPtr)

recycleSegNo = endlogSegNo + 10;

else

recycleSegNo = XLOGfileslop(RedoRecPtr);

}

static XLogSegNo

XLOGfileslop(XLogRecPtr RedoRecPtr)

{

XLogSegNominSegNo;

XLogSegNomaxSegNo;

doubledistance;

XLogSegNorecycleSegNo;

/*

 * Calculate the segment numbers that min_wal_size_mb and max_wal_size_mb

 * correspond to. Always recycle enough segments to meet the minimum, and

 * remove enough segments to stay below the maximum.

 */

minSegNo = RedoRecPtr / wal_segment_size +

ConvertToXSegs(min_wal_size_mb, wal_segment_size) - 1;

maxSegNo = RedoRecPtr / wal_segment_size +

ConvertToXSegs(max_wal_size_mb, wal_segment_size) - 1;

/*

 * Between those limits, recycle enough segments to get us through to the

 * estimated end of next checkpoint.

 *

 * To estimate where the next checkpoint will finish, assume that the

 * system runs steadily consuming CheckPointDistanceEstimate bytes between

 * every checkpoint.

 */

distance = (1.0 + CheckPointCompletionTarget) * CheckPointDistanceEstimate;

/* add 10% for good measure. */

distance *= 1.10;

recycleSegNo = (XLogSegNo) ceil(((double) RedoRecPtr + distance) /

wal_segment_size);

if (recycleSegNo < minSegNo)

recycleSegNo = minSegNo;

if (recycleSegNo > maxSegNo)

recycleSegNo = maxSegNo;

return recycleSegNo;

}

if (wal_recycle &&

endlogSegNo <= recycleSegNo &&

lstat(path, &statbuf) == 0 && S_ISREG(statbuf.st_mode) &&

InstallXLogFileSegment(&endlogSegNo, path,

   true, recycleSegNo, true))

{

ereport(DEBUG2,

(errmsg("recycled write-ahead log file \"%s\"",

segname)));

CheckpointStats.ckpt_segs_recycled++;

/* Needn't recheck that slot on future iterations */

endlogSegNo++;

}

else

{

/* No need for any more future segments... */

intrc;

ereport(DEBUG2,

(errmsg("removing write-ahead log file \"%s\"",

segname)));