git.postgresql.org Git - postgresql.git/commitdiff

git projects / postgresql.git / commitdiff

Add GUC to enable WAL-logging of hint bits, even with checksums disabled.

author Heikki Linnakangas <heikki.linnakangas@iki.fi>

2013年12月13日 14:26:14 +0000 (16:26 +0200)

committer Heikki Linnakangas <heikki.linnakangas@iki.fi>

2013年12月13日 14:26:14 +0000 (16:26 +0200)

WAL records of hint bit updates is useful to tools that want to examine
which pages have been modified. In particular, this is required to make
the pg_rewind tool safe (without checksums).

This can also be used to test how much extra WAL-logging would occur if
you enabled checksums, without actually enabling them (which you can't
currently do without re-initdb'ing).

Sawada Masahiko, docs by Samrat Revagade. Reviewed by Dilip Kumar, with
further changes by me.

13 files changed:

doc/src/sgml/config.sgml patch | blob | blame | history

src/backend/access/heap/heapam.c patch | blob | blame | history

src/backend/access/heap/visibilitymap.c patch | blob | blame | history

src/backend/access/transam/xlog.c patch | blob | blame | history

src/backend/storage/buffer/bufmgr.c patch | blob | blame | history

src/backend/utils/misc/guc.c patch | blob | blame | history

src/backend/utils/misc/postgresql.conf.sample patch | blob | blame | history

src/bin/pg_controldata/pg_controldata.c patch | blob | blame | history

src/bin/pg_resetxlog/pg_resetxlog.c patch | blob | blame | history

src/include/access/xlog.h patch | blob | blame | history

src/include/access/xlog_internal.h patch | blob | blame | history

src/include/catalog/catversion.h patch | blob | blame | history

src/include/catalog/pg_control.h patch | blob | blame | history

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml

index 8896988e5aa9a8f53e6b81190bb13f6e1a08b4ee..f0794467ba47c748717cfb99b65061818d9038ff 100644 (file)

--- a/doc/src/sgml/config.sgml

+++ b/doc/src/sgml/config.sgml

@@ -1944,6 +1944,32 @@ include 'filename'

</listitem>

</varlistentry>

+ <varlistentry id="guc-wal-log-hintbits" xreflabel="wal_log_hintbits">

+ <term><varname>wal_log_hintbits</varname> (<type>boolean</type>)</term>

+ <indexterm>

+ <primary><varname>wal_log_hintbits</> configuration parameter</primary>

+ </indexterm>

+ <listitem>

+ <para>

+ When this parameter is <literal>on</>, the <productname>PostgreSQL</>

+ server writes the entire content of each disk page to WAL during the

+ first modification of that page after a checkpoint, even for

+ non-critical modifications of so-called hint bits.

+ </para>

+ <para>

+ If data checksums are enabled, hint bit updates are always WAL-logged

+ and this setting is ignored. You can use this setting to test how much

+ extra WAL-logging would occur if your database had data checksums

+ enabled.

+ </para>

+ <para>

+ This parameter can only be set at server start. The default value is <literal>off</>.

+ </para>

+ </listitem>

+ </varlistentry>

<term><varname>wal_buffers</varname> (<type>integer</type>)</term>

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c

index 09174b472b06a00b6aa74db9b7f1690e7a34eafb..91cfae1603d674632b2376a5d4bbb895e20fb89e 100644 (file)

--- a/src/backend/access/heap/heapam.c

+++ b/src/backend/access/heap/heapam.c

@@ -6271,7 +6271,7 @@ log_heap_visible(RelFileNode rnode, Buffer heap_buffer, Buffer vm_buffer,

rdata[1].buffer_std = false;

rdata[1].next = NULL;

- if (DataChecksumsEnabled())

+ if (XLogHintBitIsNeeded())

{

rdata[1].next = &(rdata[2]);

diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c

index 7f40d89b9f1ac722772ec52325333cd4c0f6ae95..60ee76a208133f55b419f8e0993836bcf89e0540 100644 (file)

--- a/src/backend/access/heap/visibilitymap.c

+++ b/src/backend/access/heap/visibilitymap.c

@@ -287,10 +287,10 @@ visibilitymap_set(Relation rel, BlockNumber heapBlk, Buffer heapBuf,

cutoff_xid);

- * If data checksums are enabled, we need to protect the heap

- * page from being torn.

+ * If data checksums are enabled (or wal_log_hintbits=on), we

+ * need to protect the heap page from being torn.

- if (DataChecksumsEnabled())

+ if (XLogHintBitIsNeeded())

{

Page heapPage = BufferGetPage(heapBuf);

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c

index a76aef37f3d2f6066153fa6080d0183efe224390..0efb50b17ef9669a977d9dd4a4592a476bbb75c8 100644 (file)

--- a/src/backend/access/transam/xlog.c

+++ b/src/backend/access/transam/xlog.c

@@ -79,6 +79,7 @@ bool XLogArchiveMode = false;

char *XLogArchiveCommand = NULL;

bool EnableHotStandby = false;

bool fullPageWrites = true;

+bool walLogHintbits = false;

bool log_checkpoints = false;

int sync_method = DEFAULT_SYNC_METHOD;

int wal_level = WAL_LEVEL_MINIMAL;

@@ -5270,6 +5271,7 @@ BootStrapXLOG(void)

ControlFile->max_prepared_xacts = max_prepared_xacts;

ControlFile->max_locks_per_xact = max_locks_per_xact;

ControlFile->wal_level = wal_level;

+ ControlFile->wal_log_hintbits = walLogHintbits;

ControlFile->data_checksum_version = bootstrap_data_checksum_version;

/* some additional ControlFile fields are set in WriteControlFile() */

@@ -9058,6 +9060,7 @@ static void

XLogReportParameters(void)

{

if (wal_level != ControlFile->wal_level ||

+ walLogHintbits != ControlFile->wal_log_hintbits ||

MaxConnections != ControlFile->MaxConnections ||

max_worker_processes != ControlFile->max_worker_processes ||

max_prepared_xacts != ControlFile->max_prepared_xacts ||

@@ -9080,6 +9083,7 @@ XLogReportParameters(void)

xlrec.max_prepared_xacts = max_prepared_xacts;

xlrec.max_locks_per_xact = max_locks_per_xact;

xlrec.wal_level = wal_level;

+ xlrec.wal_log_hintbits = walLogHintbits;

rdata.buffer = InvalidBuffer;

rdata.data = (char *) &xlrec;

@@ -9094,6 +9098,7 @@ XLogReportParameters(void)

ControlFile->max_prepared_xacts = max_prepared_xacts;

ControlFile->max_locks_per_xact = max_locks_per_xact;

ControlFile->wal_level = wal_level;

+ ControlFile->wal_log_hintbits = walLogHintbits;

UpdateControlFile();

}

@@ -9480,6 +9485,7 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record)

ControlFile->max_prepared_xacts = xlrec.max_prepared_xacts;

ControlFile->max_locks_per_xact = xlrec.max_locks_per_xact;

ControlFile->wal_level = xlrec.wal_level;

+ ControlFile->wal_log_hintbits = walLogHintbits;

* Update minRecoveryPoint to ensure that if recovery is aborted, we

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c

index f84839181161e2aaedf3ef6a806d0647116ab5c0..081165faef09484f607562e0ec6fb8650859389e 100644 (file)

--- a/src/backend/storage/buffer/bufmgr.c

+++ b/src/backend/storage/buffer/bufmgr.c

@@ -2626,16 +2626,15 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std)

bool delayChkpt = false;

- * If checksums are enabled, and the buffer is permanent, then a full

- * page image may be required even for some hint bit updates to

- * protect against torn pages. This full page image is only necessary

+ * If we need to protect hint bit updates from torn writes, WAL-log a

+ * full page image of the page. This full page image is only necessary

* if the hint bit update is the first change to the page since the

* last checkpoint.

* We don't check full_page_writes here because that logic is included

* when we call XLogInsert() since the value changes dynamically.

- if (DataChecksumsEnabled() && (bufHdr->flags & BM_PERMANENT))

+ if (XLogHintBitIsNeeded() && (bufHdr->flags & BM_PERMANENT))

{

* If we're in recovery we cannot dirty a page because of a hint.

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c

index e69e132f056288d5bcb0fe3f6d230a7e6256b3a4..b0c14a2dfce41b1631e15ce3b26c6b5feaeb49e9 100644 (file)

--- a/src/backend/utils/misc/guc.c

+++ b/src/backend/utils/misc/guc.c

@@ -866,6 +866,17 @@ static struct config_bool ConfigureNamesBool[] =

true,

NULL, NULL, NULL

+ {

+ {"wal_log_hintbits", PGC_POSTMASTER, WAL_SETTINGS,

+ gettext_noop("Writes full pages to WAL when first modified after a checkpoint, even for a non-critical modifications"),

+ NULL

+ },

+ &walLogHintbits,

+ false,

+ NULL, NULL, NULL

+ },

{

{"log_checkpoints", PGC_SIGHUP, LOGGING_WHAT,

gettext_noop("Logs each checkpoint."),

diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample

index f8bdce34d3307aba3cbadf152525b95286835a11..d049159444f481815be4ac180e649ea5eae31696 100644 (file)

--- a/src/backend/utils/misc/postgresql.conf.sample

+++ b/src/backend/utils/misc/postgresql.conf.sample

@@ -184,6 +184,7 @@

# fsync_writethrough

# open_sync

#full_page_writes = on # recover from partial page writes

+#wal_log_hintbits = off # also do full pages writes of non-critical updates

#wal_buffers = -1 # min 32kB, -1 sets based on shared_buffers

# (change requires restart)

#wal_writer_delay = 200ms # 1-10000 milliseconds

diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c

index 8c6cf24d23755217d400536a5c26ac21efea6d36..da48e98ff99282236f83b36ed0a7ecbff19f32fe 100644 (file)

--- a/src/bin/pg_controldata/pg_controldata.c

+++ b/src/bin/pg_controldata/pg_controldata.c

@@ -260,6 +260,8 @@ main(int argc, char *argv[])

ControlFile.backupEndRequired ? _("yes") : _("no"));

printf(_("Current wal_level setting: %s\n"),

wal_level_str(ControlFile.wal_level));

+ printf(_("Current wal_log_hintbits setting: %s\n"),

+ ControlFile.wal_log_hintbits ? _("on") : _("off"));

printf(_("Current max_connections setting: %d\n"),

ControlFile.MaxConnections);

printf(_("Current max_worker_processes setting: %d\n"),

diff --git a/src/bin/pg_resetxlog/pg_resetxlog.c b/src/bin/pg_resetxlog/pg_resetxlog.c

index ed0f945679649d3bd21d5c2b65e3660b87824e50..da13ff4d134b7c185b3c62af6cc6eeec9f2ab31e 100644 (file)

--- a/src/bin/pg_resetxlog/pg_resetxlog.c

+++ b/src/bin/pg_resetxlog/pg_resetxlog.c

@@ -525,6 +525,7 @@ GuessControlValues(void)

/* minRecoveryPoint, backupStartPoint and backupEndPoint can be left zero */

ControlFile.wal_level = WAL_LEVEL_MINIMAL;

+ ControlFile.wal_log_hintbits = false;

ControlFile.MaxConnections = 100;

ControlFile.max_worker_processes = 8;

ControlFile.max_prepared_xacts = 0;

@@ -721,6 +722,7 @@ RewriteControlFile(void)

* anyway at startup.

ControlFile.wal_level = WAL_LEVEL_MINIMAL;

+ ControlFile.wal_log_hintbits = false;

ControlFile.MaxConnections = 100;

ControlFile.max_worker_processes = 8;

ControlFile.max_prepared_xacts = 0;

diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h

index 7415a261bbdfe0c673a0c6f5985cbce4489c160c..e69accd4b2e010fce8376fe31729d13d8b0f04ee 100644 (file)

--- a/src/include/access/xlog.h

+++ b/src/include/access/xlog.h

@@ -189,6 +189,7 @@ extern bool XLogArchiveMode;

extern char *XLogArchiveCommand;

extern bool EnableHotStandby;

extern bool fullPageWrites;

+extern bool walLogHintbits;

extern bool log_checkpoints;

extern int num_xloginsert_slots;

@@ -211,6 +212,17 @@ extern int wal_level;

#define XLogIsNeeded() (wal_level >= WAL_LEVEL_ARCHIVE)

+/*

+ * Is a full-page image needed for hint bit updates?

+ *

+ * Normally, we don't WAL-log hint bit updates, but if checksums are enabled,

+ * we have to protect them against torn page writes. When you only set

+ * individual bits on a page, it's still consistent no matter what combination

+ * of the bits make it to disk, but the checksum wouldn't match. Also WAL-log

+ * them if forced by wal_log_hintbits=on.

+ */

+#define XLogHintBitIsNeeded() (DataChecksumsEnabled() || walLogHintbits)

/* Do we need to WAL-log information required only for Hot Standby and logical replication? */

#define XLogStandbyInfoActive() (wal_level >= WAL_LEVEL_HOT_STANDBY)

diff --git a/src/include/access/xlog_internal.h b/src/include/access/xlog_internal.h

index 64ba55355b9857184a1679fca4850bb700df2ca8..c78a2fbfae8f0668bb14555402de22bc5863e8a5 100644 (file)

--- a/src/include/access/xlog_internal.h

+++ b/src/include/access/xlog_internal.h

@@ -209,6 +209,7 @@ typedef struct xl_parameter_change

int max_prepared_xacts;

int max_locks_per_xact;

int wal_level;

+ bool wal_log_hintbits;

} xl_parameter_change;

/* logs restore point */

diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h

index 759395a24b942be8480456b0bf85f37f6025d847..b7610e8c3f86a12bad4923bc09efd4703f4e365c 100644 (file)

--- a/src/include/catalog/catversion.h

+++ b/src/include/catalog/catversion.h

@@ -53,6 +53,6 @@

/* yyyymmddN */

-#define CATALOG_VERSION_NO 201311261

+#define CATALOG_VERSION_NO 201312131

#endif

diff --git a/src/include/catalog/pg_control.h b/src/include/catalog/pg_control.h

index 637221e6347c1e673a24675176dce751caa9d872..8f23508ad0f16a6dd2bc337cbe18eef2b0836efc 100644 (file)

--- a/src/include/catalog/pg_control.h

+++ b/src/include/catalog/pg_control.h

@@ -171,6 +171,7 @@ typedef struct ControlFileData

* or hot standby.

int wal_level;

+ bool wal_log_hintbits;

int MaxConnections;

int max_worker_processes;

int max_prepared_xacts;

This is the main PostgreSQL git repository.

RSS Atom