Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit2ffa66f

Browse files
committed
Fix walsender failure at promotion.
If a standby server has a cascading standby server connected to it, it'spossible that WAL has already been sent up to the next WAL page boundary,splitting a WAL record in the middle, when the first standby server ispromoted. Don't throw an assertion failure or error in walsender if thathappens.Also, fix a variant of the same bug in pg_receivexlog: if it had alreadyreceived WAL on previous timeline up to a segment boundary, when theupstream standby server is promoted so that the timeline switch record fallson the previous segment, pg_receivexlog would miss the segment containingthe timeline switch. To fix that, have walsender send the position of thetimeline switch at end-of-streaming, in addition to the next timeline's ID.It was previously assumed that the switch happened exactly where thestreaming stopped.Note: this is an incompatible change in the streaming protocol. You mightget an error if you try to stream over timeline switches, if the client isrunning 9.3beta1 and the server is more recent. It should be fine after areconnect, however.Reported by Fujii Masao.
1 parentcb953d8 commit2ffa66f

File tree

7 files changed

+142
-43
lines changed

7 files changed

+142
-43
lines changed

‎doc/src/sgml/protocol.sgml

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1423,10 +1423,15 @@ The commands accepted in walsender mode are:
14231423
<para>
14241424
After streaming all the WAL on a timeline that is not the latest one,
14251425
the server will end streaming by exiting the COPY mode. When the client
1426-
acknowledges this by also exiting COPY mode, the server sends a
1427-
single-row, single-column result set indicating the next timeline in
1428-
this server's history. That is followed by a CommandComplete message,
1429-
and the server is ready to accept a new command.
1426+
acknowledges this by also exiting COPY mode, the server sends a result
1427+
set with one row and two columns, indicating the next timeline in this
1428+
server's history. The first column is the next timeline's ID, and the
1429+
second column is the XLOG position where the switch happened. Usually,
1430+
the switch position is the end of the WAL that was streamed, but there
1431+
are corner cases where the server can send some WAL from the old
1432+
timeline that it has not itself replayed before promoting. Finally, the
1433+
server sends CommandComplete message, and is ready to accept a new
1434+
command.
14301435
</para>
14311436

14321437
<para>

‎src/backend/access/transam/xlog.c

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9598,7 +9598,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
95989598
}
95999599
else
96009600
{
9601-
ptr=RecPtr;
9601+
ptr=tliRecPtr;
96029602
tli=tliOfPointInHistory(tliRecPtr,expectedTLEs);
96039603

96049604
if (curFileTLI>0&&tli<curFileTLI)
@@ -9607,7 +9607,8 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
96079607
tli,curFileTLI);
96089608
}
96099609
curFileTLI=tli;
9610-
RequestXLogStreaming(curFileTLI,ptr,PrimaryConnInfo);
9610+
RequestXLogStreaming(tli,ptr,PrimaryConnInfo);
9611+
receivedUpto=0;
96119612
}
96129613
/*
96139614
* Move to XLOG_FROM_STREAM state in either case. We'll get

‎src/backend/replication/libpqwalreceiver/libpqwalreceiver.c

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -224,8 +224,11 @@ libpqrcv_endstreaming(TimeLineID *next_tli)
224224
res=PQgetResult(streamConn);
225225
if (PQresultStatus(res)==PGRES_TUPLES_OK)
226226
{
227-
/* Read the next timeline's ID */
228-
if (PQnfields(res)!=1||PQntuples(res)!=1)
227+
/*
228+
* Read the next timeline's ID. The server also sends the timeline's
229+
* starting point, but it is ignored.
230+
*/
231+
if (PQnfields(res)<2||PQntuples(res)!=1)
229232
ereport(ERROR,
230233
(errmsg("unexpected result set after end-of-streaming")));
231234
*next_tli=pg_atoi(PQgetvalue(res,0,0),sizeof(uint32),0);

‎src/backend/replication/walreceiverfuncs.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -260,12 +260,13 @@ RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr, const char *conninfo)
260260
walrcv->startTime=now;
261261

262262
/*
263-
* If this is the first startup of walreceiver, we initialize receivedUpto
264-
* and latestChunkStart toreceiveStart.
263+
* If this is the first startup of walreceiver (on this timeline),
264+
*initialize receivedUptoand latestChunkStart tothe starting point.
265265
*/
266-
if (walrcv->receiveStart==0)
266+
if (walrcv->receiveStart==0||walrcv->receivedTLI!=tli)
267267
{
268268
walrcv->receivedUpto=recptr;
269+
walrcv->receivedTLI=tli;
269270
walrcv->latestChunkStart=recptr;
270271
}
271272
walrcv->receiveStart=recptr;

‎src/backend/replication/walsender.c

Lines changed: 41 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -567,16 +567,21 @@ StartReplication(StartReplicationCmd *cmd)
567567
*/
568568
if (sendTimeLineIsHistoric)
569569
{
570-
charstr[11];
571-
snprintf(str,sizeof(str),"%u",sendTimeLineNextTLI);
570+
chartli_str[11];
571+
charstartpos_str[8+1+8+1];
572572

573-
pq_beginmessage(&buf,'T');/* RowDescription */
574-
pq_sendint(&buf,1,2);/* 1 field */
573+
snprintf(tli_str,sizeof(tli_str),"%u",sendTimeLineNextTLI);
574+
snprintf(startpos_str,sizeof(startpos_str),"%X/%X",
575+
(uint32) (sendTimeLineValidUpto >>32),
576+
(uint32)sendTimeLineValidUpto);
577+
578+
pq_beginmessage(&buf,'T');/* RowDescription */
579+
pq_sendint(&buf,2,2);/* 2 fields */
575580

576581
/* Field header */
577582
pq_sendstring(&buf,"next_tli");
578-
pq_sendint(&buf,0,4);/* table oid */
579-
pq_sendint(&buf,0,2);/* attnum */
583+
pq_sendint(&buf,0,4);/* table oid */
584+
pq_sendint(&buf,0,2);/* attnum */
580585
/*
581586
* int8 may seem like a surprising data type for this, but in theory
582587
* int4 would not be wide enough for this, as TimeLineID is unsigned.
@@ -585,13 +590,26 @@ StartReplication(StartReplicationCmd *cmd)
585590
pq_sendint(&buf,-1,2);
586591
pq_sendint(&buf,0,4);
587592
pq_sendint(&buf,0,2);
593+
594+
pq_sendstring(&buf,"next_tli_startpos");
595+
pq_sendint(&buf,0,4);/* table oid */
596+
pq_sendint(&buf,0,2);/* attnum */
597+
pq_sendint(&buf,TEXTOID,4);/* type oid */
598+
pq_sendint(&buf,-1,2);
599+
pq_sendint(&buf,0,4);
600+
pq_sendint(&buf,0,2);
588601
pq_endmessage(&buf);
589602

590603
/* Data row */
591604
pq_beginmessage(&buf,'D');
592-
pq_sendint(&buf,1,2);/* number of columns */
593-
pq_sendint(&buf,strlen(str),4);/* length */
594-
pq_sendbytes(&buf,str,strlen(str));
605+
pq_sendint(&buf,2,2);/* number of columns */
606+
607+
pq_sendint(&buf,strlen(tli_str),4);/* length */
608+
pq_sendbytes(&buf,tli_str,strlen(tli_str));
609+
610+
pq_sendint(&buf,strlen(startpos_str),4);/* length */
611+
pq_sendbytes(&buf,startpos_str,strlen(startpos_str));
612+
595613
pq_endmessage(&buf);
596614
}
597615

@@ -1462,19 +1480,10 @@ XLogSend(bool *caughtup)
14621480

14631481
history=readTimeLineHistory(ThisTimeLineID);
14641482
sendTimeLineValidUpto=tliSwitchPoint(sendTimeLine,history,&sendTimeLineNextTLI);
1465-
Assert(sentPtr <=sendTimeLineValidUpto);
1483+
14661484
Assert(sendTimeLine<sendTimeLineNextTLI);
14671485
list_free_deep(history);
14681486

1469-
/* the current send pointer should be <= the switchpoint */
1470-
if (!(sentPtr <=sendTimeLineValidUpto))
1471-
elog(ERROR,"server switched off timeline %u at %X/%X, but walsender already streamed up to %X/%X",
1472-
sendTimeLine,
1473-
(uint32) (sendTimeLineValidUpto >>32),
1474-
(uint32)sendTimeLineValidUpto,
1475-
(uint32) (sentPtr >>32),
1476-
(uint32)sentPtr);
1477-
14781487
sendTimeLineIsHistoric= true;
14791488

14801489
SendRqstPtr=sendTimeLineValidUpto;
@@ -1498,6 +1507,15 @@ XLogSend(bool *caughtup)
14981507
/*
14991508
* If this is a historic timeline and we've reached the point where we
15001509
* forked to the next timeline, stop streaming.
1510+
*
1511+
* Note: We might already have sent WAL > sendTimeLineValidUpto. The
1512+
* startup process will normally replay all WAL that has been received from
1513+
* the master, before promoting, but if the WAL streaming is terminated at
1514+
* a WAL page boundary, the valid portion of the timeline might end in the
1515+
* middle of a WAL record. We might've already sent the first half of that
1516+
* partial WAL record to the cascading standby, so that sentPtr >
1517+
* sendTimeLineValidUpto. That's OK; the cascading standby can't replay the
1518+
* partial WAL record either, so it can still follow our timeline switch.
15011519
*/
15021520
if (sendTimeLineIsHistoric&&sendTimeLineValidUpto <=sentPtr)
15031521
{
@@ -1511,6 +1529,10 @@ XLogSend(bool *caughtup)
15111529
streamingDoneSending= true;
15121530

15131531
*caughtup= true;
1532+
1533+
elog(DEBUG1,"walsender reached end of timeline at %X/%X (sent up to %X/%X)",
1534+
(uint32) (sendTimeLineValidUpto >>32), (uint32)sendTimeLineValidUpto,
1535+
(uint32) (sentPtr >>32), (uint32)sentPtr);
15141536
return;
15151537
}
15161538

‎src/bin/pg_basebackup/pg_receivexlog.c

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -83,10 +83,12 @@ stop_streaming(XLogRecPtr xlogpos, uint32 timeline, bool segment_finished)
8383
timeline);
8484

8585
/*
86-
* Note that we report the previous, not current, position here. That's
87-
* the exact location where the timeline switch happend. After the switch,
88-
* we restart streaming from the beginning of the segment, so xlogpos can
89-
* smaller than prevpos if we just switched to new timeline.
86+
* Note that we report the previous, not current, position here. After a
87+
* timeline switch, xlogpos points to the beginning of the segment because
88+
* that's where we always begin streaming. Reporting the end of previous
89+
* timeline isn't totally accurate, because the next timeline can begin
90+
* slightly before the end of the WAL that we received on the previous
91+
* timeline, but it's close enough for reporting purposes.
9092
*/
9193
if (prevtimeline!=0&&prevtimeline!=timeline)
9294
fprintf(stderr,_("%s: switched to timeline %u at %X/%X\n"),

‎src/bin/pg_basebackup/receivelog.c

Lines changed: 74 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,9 @@ static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
3737
stream_stop_callbackstream_stop,intstandby_message_timeout,
3838
char*partial_suffix,XLogRecPtr*stoppos);
3939

40+
staticboolReadEndOfStreamingResult(PGresult*res,XLogRecPtr*startpos,
41+
uint32*timeline);
42+
4043
/*
4144
* Open a new WAL file in the specified directory.
4245
*
@@ -627,26 +630,44 @@ ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
627630
* There are two possible reasons for that: a controlled shutdown,
628631
* or we reached the end of the current timeline. In case of
629632
* end-of-timeline, the server sends a result set after Copy has
630-
* finished, containing the next timeline's ID. Read that, and
631-
* restart streaming from the next timeline.
633+
* finished, containing information about the next timeline. Read
634+
* that, and restart streaming from the next timeline. In case of
635+
* controlled shutdown, stop here.
632636
*/
633-
634637
if (PQresultStatus(res)==PGRES_TUPLES_OK)
635638
{
636639
/*
637-
* End-of-timeline. Read the next timeline's ID.
640+
* End-of-timeline. Read the next timeline's ID and starting
641+
* position. Usually, the starting position will match the end of
642+
* the previous timeline, but there are corner cases like if the
643+
* server had sent us half of a WAL record, when it was promoted.
644+
* The new timeline will begin at the end of the last complete
645+
* record in that case, overlapping the partial WAL record on the
646+
* the old timeline.
638647
*/
639648
uint32newtimeline;
649+
boolparsed;
640650

641-
newtimeline=atoi(PQgetvalue(res,0,0));
651+
parsed=ReadEndOfStreamingResult(res,&startpos,&newtimeline);
642652
PQclear(res);
653+
if (!parsed)
654+
gotoerror;
643655

656+
/* Sanity check the values the server gave us */
644657
if (newtimeline <=timeline)
645658
{
646-
/* shouldn't happen */
647659
fprintf(stderr,
648-
"server reported unexpected next timeline %u, following timeline %u\n",
649-
newtimeline,timeline);
660+
_("%s: server reported unexpected next timeline %u, following timeline %u\n"),
661+
progname,newtimeline,timeline);
662+
gotoerror;
663+
}
664+
if (startpos>stoppos)
665+
{
666+
fprintf(stderr,
667+
_("%s: server stopped streaming timeline %u at %X/%X, but reported next timeline %u to begin at %X/%X\n"),
668+
progname,
669+
timeline, (uint32) (stoppos >>32), (uint32)stoppos,
670+
newtimeline, (uint32) (startpos >>32), (uint32)startpos);
650671
gotoerror;
651672
}
652673

@@ -666,7 +687,7 @@ ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
666687
* Always start streaming at the beginning of a segment.
667688
*/
668689
timeline=newtimeline;
669-
startpos=stoppos- (stoppos %XLOG_SEG_SIZE);
690+
startpos=startpos- (startpos %XLOG_SEG_SIZE);
670691
continue;
671692
}
672693
elseif (PQresultStatus(res)==PGRES_COMMAND_OK)
@@ -704,6 +725,50 @@ ReceiveXlogStream(PGconn *conn, XLogRecPtr startpos, uint32 timeline,
704725
return false;
705726
}
706727

728+
/*
729+
* Helper function to parse the result set returned by server after streaming
730+
* has finished. On failure, prints an error to stderr and returns false.
731+
*/
732+
staticbool
733+
ReadEndOfStreamingResult(PGresult*res,XLogRecPtr*startpos,uint32*timeline)
734+
{
735+
uint32startpos_xlogid,
736+
startpos_xrecoff;
737+
738+
/*----------
739+
* The result set consists of one row and two columns, e.g:
740+
*
741+
* next_tli | next_tli_startpos
742+
* ----------+-------------------
743+
* 4 | 0/9949AE0
744+
*
745+
* next_tli is the timeline ID of the next timeline after the one that
746+
* just finished streaming. next_tli_startpos is the XLOG position where
747+
* the server switched to it.
748+
*----------
749+
*/
750+
if (PQnfields(res)<2||PQntuples(res)!=1)
751+
{
752+
fprintf(stderr,
753+
_("%s: unexpected result set after end-of-timeline: got %d rows and %d fields, expected %d rows and %d fields\n"),
754+
progname,PQntuples(res),PQnfields(res),1,2);
755+
return false;
756+
}
757+
758+
*timeline=atoi(PQgetvalue(res,0,0));
759+
if (sscanf(PQgetvalue(res,0,1),"%X/%X",&startpos_xlogid,
760+
&startpos_xrecoff)!=2)
761+
{
762+
fprintf(stderr,
763+
_("%s: could not parse next timeline's starting point \"%s\"\n"),
764+
progname,PQgetvalue(res,0,1));
765+
return false;
766+
}
767+
*startpos= ((uint64)startpos_xlogid <<32) |startpos_xrecoff;
768+
769+
return true;
770+
}
771+
707772
/*
708773
* The main loop of ReceiveXLogStream. Handles the COPY stream after
709774
* initiating streaming with the START_STREAMING command.

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp