Reliability is an important property of any serious database
system, and PostgreSQL does
everything possible to guarantee reliable operation. One aspect
of reliable operation is that all data recorded by a committed
transaction should be stored in a nonvolatile area that is safe
from power loss, operating system failure, and hardware failure
(except failure of the nonvolatile area itself, of course).
Successfully writing the data to the computer's permanent storage
(disk drive or equivalent) ordinarily meets this requirement. In
fact, even if a computer is fatally damaged, if the disk drives
survive they can be moved to another computer with similar
hardware and all committed transactions will remain intact.

While forcing data periodically to the disk platters might
seem like a simple operation, it is not. Because disk drives are
dramatically slower than main memory and CPUs, several layers of
caching exist between the computer's main memory and the disk
platters. First, there is the operating system's buffer cache,
which caches frequently requested disk blocks and combines disk
writes. Fortunately, all operating systems give applications a
way to force writes from the buffer cache to disk, and
PostgreSQL uses those features.
(See the wal_sync_method
parameter to adjust how this is done.)

Next, there might be a cache in the disk drive controller;
this is particularly common on RAID controller cards. Some of these caches
are write-through, meaning writes are
passed along to the drive as soon as they arrive. Others are
write-back, meaning data is passed on to
the drive at some later time. Such caches can be a reliability
hazard because the memory in the disk controller cache is
volatile, and will lose its contents in a power failure. Better
controller cards have battery-backed
caches, meaning the card has a battery that maintains power to
the cache in case of system power loss. After power is restored
the data will be written to the disk drives.

And finally, most disk drives have caches. Some are
write-through while some are write-back, and the same concerns
about data loss exist for write-back drive caches as exist for
disk controller caches. Consumer-grade IDE and SATA drives are
particularly likely to have write-back caches that will not
survive a power failure. To check write caching on Linux use hdparm
-I; it is enabled if there is a *
next to Write cache. hdparm -W to turn off write caching. On
FreeBSD use atacontrol. (For SCSI disks use sdparm to turn off WCE.) On Solaris
the disk write cache is controlled by format -e. (The
Solaris ZFS file system is
safe with disk write-cache enabled because it issues its own disk
cache flush commands.) On Windows if wal_sync_method is open_datasync (the default), write caching is
disabled by unchecking My
Computer\Open\{select disk
drive}\Properties\Hardware\Properties\Policies\Enable write
caching on the disk. Also on Windows, fsync and fsync_writethrough never do write caching. The
fsync_writethrough option can also be
used to disable write caching on MacOS
X.

When the operating system sends a write request to the disk
hardware, there is little it can do to make sure the data has
arrived at a truly non-volatile storage area. Rather, it is the
administrator's responsibility to be sure that all storage
components ensure data integrity. Avoid disk controllers that
have non-battery-backed write caches. At the drive level, disable
write-back caching if the drive cannot guarantee the data will be
written before shutdown.

Another risk of data loss is posed by the disk platter write
operations themselves. Disk platters are divided into sectors,
commonly 512 bytes each. Every physical read or write operation
processes a whole sector. When a write request arrives at the
drive, it might be for 512 bytes, 1024 bytes, or 8192 bytes, and
the process of writing could fail due to power loss at any time,
meaning some of the 512-byte sectors were written, and others
were not. To guard against such failures, PostgreSQL periodically writes full page
images to permanent storage before modifying the actual page on
disk. By doing this, during crash recovery PostgreSQL can restore partially-written
pages. If you have a battery-backed disk controller or
file-system software that prevents partial page writes (e.g.,
ReiserFS 4), you can turn off this page imaging by using the
full_page_writes
parameter.