granicus.if.org Git - postgresql/blob - src/backend/postmaster/bgwriter.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * bgwriter.c
   4  *
   5  * The background writer (bgwriter) is new in Postgres 7.5.  It attempts
   6  * to keep regular backends from having to write out dirty shared buffers
   7  * (which they would only do when needing to free a shared buffer to read in
   8  * another page).  In the best scenario all writes from shared buffers will
   9  * be issued by the background writer process.  However, regular backends are
  10  * still empowered to issue writes if the bgwriter fails to maintain enough
  11  * clean shared buffers.
  12  *
  13  * The bgwriter is also charged with handling all checkpoints.  It will
  14  * automatically dispatch a checkpoint after a certain amount of time has
  15  * elapsed since the last one, and it can be signaled to perform requested
  16  * checkpoints as well.  (The GUC parameter that mandates a checkpoint every
  17  * so many WAL segments is implemented by having backends signal the bgwriter
  18  * when they fill WAL segments; the bgwriter itself doesn't watch for the
  19  * condition.)
  20  *
  21  * The bgwriter is started by the postmaster as soon as the startup subprocess
  22  * finishes.  It remains alive until the postmaster commands it to terminate.
  23  * Normal termination is by SIGUSR2, which instructs the bgwriter to execute
  24  * a shutdown checkpoint and then exit(0).  (All backends must be stopped
  25  * before SIGUSR2 is issued!)  Emergency termination is by SIGQUIT; like any
  26  * backend, the bgwriter will simply abort and exit on SIGQUIT.
  27  *
  28  * If the bgwriter exits unexpectedly, the postmaster treats that the same
  29  * as a backend crash: shared memory may be corrupted, so remaining backends
  30  * should be killed by SIGQUIT and then a recovery cycle started.  (Even if
  31  * shared memory isn't corrupted, we have lost information about which
  32  * files need to be fsync'd for the next checkpoint, and so a system
  33  * restart needs to be forced.)
  34  *
  35  *
  36  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  37  *
  38  *
  39  * IDENTIFICATION
  40  *        $PostgreSQL: pgsql/src/backend/postmaster/bgwriter.c,v 1.2 2004/05/31 03:47:59 tgl Exp $
  41  *
  42  *-------------------------------------------------------------------------
  43  */
  44 #include "postgres.h"
  45
  46 #include <signal.h>
  47
  48 #include "access/xlog.h"
  49 #include "libpq/pqsignal.h"
  50 #include "miscadmin.h"
  51 #include "postmaster/bgwriter.h"
  52 #include "storage/bufmgr.h"
  53 #include "storage/freespace.h"
  54 #include "storage/ipc.h"
  55 #include "storage/pmsignal.h"
  56 #include "storage/smgr.h"
  57 #include "tcop/tcopprot.h"
  58 #include "utils/guc.h"
  59
  60
  61 /*----------
  62  * Shared memory area for communication between bgwriter and backends
  63  *
  64  * The ckpt counters allow backends to watch for completion of a checkpoint
  65  * request they send.  Here's how it works:
  66  *      * At start of a checkpoint, bgwriter increments ckpt_started.
  67  *      * On completion of a checkpoint, bgwriter sets ckpt_done to
  68  *        equal ckpt_started.
  69  *      * On failure of a checkpoint, bgwrite first increments ckpt_failed,
  70  *        then sets ckpt_done to equal ckpt_started.
  71  * All three fields are declared sig_atomic_t to ensure they can be read
  72  * and written without explicit locking.  The algorithm for backends is:
  73  *      1. Record current values of ckpt_failed and ckpt_started (in that
  74  *         order!).
  75  *      2. Send signal to request checkpoint.
  76  *      3. Sleep until ckpt_started changes.  Now you know a checkpoint has
  77  *         begun since you started this algorithm (although *not* that it was
  78  *         specifically initiated by your signal).
  79  *      4. Record new value of ckpt_started.
  80  *      5. Sleep until ckpt_done >= saved value of ckpt_started.  (Use modulo
  81  *         arithmetic here in case counters wrap around.)  Now you know a
  82  *         checkpoint has started and completed, but not whether it was
  83  *         successful.
  84  *      6. If ckpt_failed is different from the originally saved value,
  85  *         assume request failed; otherwise it was definitely successful.
  86  *
  87  * The requests array holds fsync requests sent by backends and not yet
  88  * absorbed by the bgwriter.
  89  *----------
  90  */
  91 typedef struct
  92 {
  93         RelFileNode             rnode;
  94         BlockNumber             segno;
  95         /* might add a request-type field later */
  96 } BgWriterRequest;
  97
  98 typedef struct
  99 {
 100         pid_t   bgwriter_pid;           /* PID of bgwriter (0 if not started) */
 101
 102         sig_atomic_t    ckpt_started;   /* advances when checkpoint starts */
 103         sig_atomic_t    ckpt_done;              /* advances when checkpoint done */
 104         sig_atomic_t    ckpt_failed;    /* advances when checkpoint fails */
 105
 106         int                             num_requests;   /* current # of requests */
 107         int                             max_requests;   /* allocated array size */
 108         BgWriterRequest requests[1];    /* VARIABLE LENGTH ARRAY */
 109 } BgWriterShmemStruct;
 110
 111 static BgWriterShmemStruct *BgWriterShmem;
 112
 113 /*
 114  * GUC parameters
 115  */
 116 int                     BgWriterDelay = 200;
 117 int                     BgWriterPercent = 1;
 118 int                     BgWriterMaxPages = 100;
 119
 120 int                     CheckPointTimeout = 300;
 121 int                     CheckPointWarning = 30;
 122
 123 /*
 124  * Flags set by interrupt handlers for later service in the main loop.
 125  */
 126 static volatile sig_atomic_t got_SIGHUP = false;
 127 static volatile sig_atomic_t checkpoint_requested = false;
 128 static volatile sig_atomic_t shutdown_requested = false;
 129
 130 /*
 131  * Private state
 132  */
 133 static bool             am_bg_writer = false;
 134
 135 static bool             ckpt_active = false;
 136
 137 static time_t   last_checkpoint_time;
 138
 139
 140 static void bg_quickdie(SIGNAL_ARGS);
 141 static void BgSigHupHandler(SIGNAL_ARGS);
 142 static void ReqCheckpointHandler(SIGNAL_ARGS);
 143 static void ReqShutdownHandler(SIGNAL_ARGS);
 144
 145
 146 /*
 147  * Main entry point for bgwriter process
 148  *
 149  * This is invoked from BootstrapMain, which has already created the basic
 150  * execution environment, but not enabled signals yet.
 151  */
 152 void
 153 BackgroundWriterMain(void)
 154 {
 155         Assert(BgWriterShmem != NULL);
 156         BgWriterShmem->bgwriter_pid = MyProcPid;
 157         am_bg_writer = true;
 158
 159         /*
 160          * Properly accept or ignore signals the postmaster might send us
 161          *
 162          * Note: we deliberately ignore SIGTERM, because during a standard Unix
 163          * system shutdown cycle, init will SIGTERM all processes at once.  We
 164          * want to wait for the backends to exit, whereupon the postmaster will
 165          * tell us it's okay to shut down (via SIGUSR2).
 166          *
 167          * SIGUSR1 is presently unused; keep it spare in case someday we want
 168          * this process to participate in sinval messaging.
 169          */
 170         pqsignal(SIGHUP, BgSigHupHandler);      /* set flag to read config file */
 171         pqsignal(SIGINT, ReqCheckpointHandler);         /* request checkpoint */
 172         pqsignal(SIGTERM, SIG_IGN);                     /* ignore SIGTERM */
 173         pqsignal(SIGQUIT, bg_quickdie);         /* hard crash time */
 174         pqsignal(SIGALRM, SIG_IGN);
 175         pqsignal(SIGPIPE, SIG_IGN);
 176         pqsignal(SIGUSR1, SIG_IGN);                     /* reserve for sinval */
 177         pqsignal(SIGUSR2, ReqShutdownHandler);          /* request shutdown */
 178
 179         /*
 180          * Reset some signals that are accepted by postmaster but not here
 181          */
 182         pqsignal(SIGCHLD, SIG_DFL);
 183         pqsignal(SIGTTIN, SIG_DFL);
 184         pqsignal(SIGTTOU, SIG_DFL);
 185         pqsignal(SIGCONT, SIG_DFL);
 186         pqsignal(SIGWINCH, SIG_DFL);
 187
 188         /* We allow SIGQUIT (quickdie) at all times */
 189 #ifdef HAVE_SIGPROCMASK
 190         sigdelset(&BlockSig, SIGQUIT);
 191 #else
 192         BlockSig &= ~(sigmask(SIGQUIT));
 193 #endif
 194
 195         /*
 196          * Initialize so that first time-driven checkpoint happens
 197          * at the correct time.
 198          */
 199         last_checkpoint_time = time(NULL);
 200
 201         /*
 202          * If an exception is encountered, processing resumes here.
 203          */
 204         if (sigsetjmp(Warn_restart, 1) != 0)
 205         {
 206                 /*
 207                  * Make sure we're not interrupted while cleaning up.  Also forget
 208                  * any pending QueryCancel request, since we're aborting anyway.
 209                  * Force InterruptHoldoffCount to a known state in case we
 210                  * ereport'd from inside a holdoff section.
 211                  */
 212                 ImmediateInterruptOK = false;
 213                 QueryCancelPending = false;
 214                 InterruptHoldoffCount = 1;
 215                 CritSectionCount = 0;   /* should be unnecessary, but... */
 216
 217                 /*
 218                  * These operations are really just a minimal subset of
 219                  * AbortTransaction().  We don't have very many resources
 220                  * to worry about in bgwriter, but we do have LWLocks and buffers.
 221                  */
 222                 LWLockReleaseAll();
 223                 AbortBufferIO();
 224                 UnlockBuffers();
 225
 226                 /*
 227                  * Clear flag to indicate that we got out of error recovery mode
 228                  * successfully.  (Flag was set in elog.c before longjmp().)
 229                  */
 230                 InError = false;
 231
 232                 /* Warn any waiting backends that the checkpoint failed. */
 233                 if (ckpt_active)
 234                 {
 235                         /* use volatile pointer to prevent code rearrangement */
 236                         volatile BgWriterShmemStruct *bgs = BgWriterShmem;
 237
 238                         bgs->ckpt_failed++;
 239                         bgs->ckpt_done = bgs->ckpt_started;
 240                         ckpt_active = false;
 241                 }
 242
 243                 /*
 244                  * Exit interrupt holdoff section we implicitly established above.
 245                  */
 246                 RESUME_INTERRUPTS();
 247
 248                 /*
 249                  * Sleep at least 1 second after any error.  A write error is
 250                  * likely to be repeated, and we don't want to be filling the
 251                  * error logs as fast as we can.  (XXX think about ways to make
 252                  * progress when the LRU dirty buffer cannot be written...)
 253                  */
 254                 pg_usleep(1000000L);
 255         }
 256
 257         Warn_restart_ready = true;      /* we can now handle ereport(ERROR) */
 258
 259         /*
 260          * Unblock signals (they were blocked when the postmaster forked us)
 261          */
 262         PG_SETMASK(&UnBlockSig);
 263
 264         /*
 265          * Loop forever
 266          */
 267         for (;;)
 268         {
 269                 bool            do_checkpoint = false;
 270                 bool            force_checkpoint = false;
 271                 time_t          now;
 272                 int                     elapsed_secs;
 273                 int                     n;
 274                 long            udelay;
 275
 276                 /*
 277                  * Emergency bailout if postmaster has died.  This is to avoid the
 278                  * necessity for manual cleanup of all postmaster children.
 279                  */
 280                 if (!PostmasterIsAlive(true))
 281                         exit(1);
 282
 283                 /*
 284                  * Process any requests or signals received recently.
 285                  */
 286                 AbsorbFsyncRequests();
 287
 288                 if (got_SIGHUP)
 289                 {
 290                         got_SIGHUP = false;
 291                         ProcessConfigFile(PGC_SIGHUP);
 292                 }
 293                 if (checkpoint_requested)
 294                 {
 295                         checkpoint_requested = false;
 296                         do_checkpoint = true;
 297                         force_checkpoint = true;
 298                 }
 299                 if (shutdown_requested)
 300                 {
 301                         ShutdownXLOG(0, 0);
 302                         DumpFreeSpaceMap(0, 0);
 303                         /* Normal exit from the bgwriter is here */
 304                         proc_exit(0);           /* done */
 305                 }
 306
 307                 /*
 308                  * Do an unforced checkpoint if too much time has elapsed
 309                  * since the last one.
 310                  */
 311                 now = time(NULL);
 312                 elapsed_secs = now - last_checkpoint_time;
 313                 if (elapsed_secs >= CheckPointTimeout)
 314                         do_checkpoint = true;
 315
 316                 /*
 317                  * Do a checkpoint if requested, otherwise do one cycle of
 318                  * dirty-buffer writing.
 319                  */
 320                 if (do_checkpoint)
 321                 {
 322                         if (CheckPointWarning != 0)
 323                         {
 324                                 /*
 325                                  * Ideally we should only warn if this checkpoint was
 326                                  * requested due to running out of segment files, and not
 327                                  * if it was manually requested.  However we can't tell the
 328                                  * difference with the current signalling mechanism.
 329                                  */
 330                                 if (elapsed_secs < CheckPointWarning)
 331                                         ereport(LOG,
 332                                                         (errmsg("checkpoints are occurring too frequently (%d seconds apart)",
 333                                                                         elapsed_secs),
 334                                                          errhint("Consider increasing the configuration parameter \"checkpoint_segments\".")));
 335                         }
 336
 337                         /*
 338                          * Indicate checkpoint start to any waiting backends.
 339                          */
 340                         ckpt_active = true;
 341                         BgWriterShmem->ckpt_started++;
 342
 343                         CreateCheckPoint(false, force_checkpoint);
 344
 345                         /*
 346                          * Indicate checkpoint completion to any waiting backends.
 347                          */
 348                         BgWriterShmem->ckpt_done = BgWriterShmem->ckpt_started;
 349                         ckpt_active = false;
 350
 351                         /*
 352                          * Note we record the checkpoint start time not end time as
 353                          * last_checkpoint_time.  This is so that time-driven checkpoints
 354                          * happen at a predictable spacing.
 355                          */
 356                         last_checkpoint_time = now;
 357
 358                         /*
 359                          * After any checkpoint, close all smgr files.  This is so we
 360                          * won't hang onto smgr references to deleted files indefinitely.
 361                          * (It is safe to do this because this process does not have a
 362                          * relcache, and so no dangling references could remain.)
 363                          */
 364                         smgrcloseall();
 365
 366                         /* Nap for configured time before rechecking */
 367                         n = 1;
 368                 }
 369                 else
 370                 {
 371                         n = BufferSync(BgWriterPercent, BgWriterMaxPages);
 372                 }
 373
 374                 /*
 375                  * Nap for the configured time or sleep for 10 seconds if
 376                  * there was nothing to do at all.
 377                  *
 378                  * On some platforms, signals won't interrupt the sleep.  To ensure
 379                  * we respond reasonably promptly when someone signals us,
 380                  * break down the sleep into 1-second increments, and check for
 381                  * interrupts after each nap.
 382                  *
 383                  * We absorb pending requests after each short sleep.
 384                  */
 385                 udelay = ((n > 0) ? BgWriterDelay : 10000) * 1000L;
 386                 while (udelay > 1000000L)
 387                 {
 388                         if (got_SIGHUP || checkpoint_requested || shutdown_requested)
 389                                 break;
 390                         pg_usleep(1000000L);
 391                         AbsorbFsyncRequests();
 392                         udelay -= 1000000L;
 393                 }
 394                 if (!(got_SIGHUP || checkpoint_requested || shutdown_requested))
 395                         pg_usleep(udelay);
 396         }
 397 }
 398
 399
 400 /* --------------------------------
 401  *              signal handler routines
 402  * --------------------------------
 403  */
 404
 405 /*
 406  * bg_quickdie() occurs when signalled SIGQUIT by the postmaster.
 407  *
 408  * Some backend has bought the farm,
 409  * so we need to stop what we're doing and exit.
 410  */
 411 static void
 412 bg_quickdie(SIGNAL_ARGS)
 413 {
 414         PG_SETMASK(&BlockSig);
 415
 416         /*
 417          * DO NOT proc_exit() -- we're here because shared memory may be
 418          * corrupted, so we don't want to try to clean up our transaction.
 419          * Just nail the windows shut and get out of town.
 420          *
 421          * Note we do exit(1) not exit(0).      This is to force the postmaster into
 422          * a system reset cycle if some idiot DBA sends a manual SIGQUIT to a
 423          * random backend.      This is necessary precisely because we don't clean
 424          * up our shared memory state.
 425          */
 426         exit(1);
 427 }
 428
 429 /* SIGHUP: set flag to re-read config file at next convenient time */
 430 static void
 431 BgSigHupHandler(SIGNAL_ARGS)
 432 {
 433         got_SIGHUP = true;
 434 }
 435
 436 /* SIGINT: set flag to run a normal checkpoint right away */
 437 static void
 438 ReqCheckpointHandler(SIGNAL_ARGS)
 439 {
 440         checkpoint_requested = true;
 441 }
 442
 443 /* SIGUSR2: set flag to run a shutdown checkpoint and exit */
 444 static void
 445 ReqShutdownHandler(SIGNAL_ARGS)
 446 {
 447         shutdown_requested = true;
 448 }
 449
 450
 451 /* --------------------------------
 452  *              communication with backends
 453  * --------------------------------
 454  */
 455
 456 /*
 457  * BgWriterShmemSize
 458  *              Compute space needed for bgwriter-related shared memory
 459  */
 460 int
 461 BgWriterShmemSize(void)
 462 {
 463         /*
 464          * Currently, the size of the requests[] array is arbitrarily set
 465          * equal to NBuffers.  This may prove too large or small ...
 466          */
 467         return MAXALIGN(sizeof(BgWriterShmemStruct) +
 468                                         (NBuffers - 1) * sizeof(BgWriterRequest));
 469 }
 470
 471 /*
 472  * BgWriterShmemInit
 473  *              Allocate and initialize bgwriter-related shared memory
 474  */
 475 void
 476 BgWriterShmemInit(void)
 477 {
 478         bool found;
 479
 480         BgWriterShmem = (BgWriterShmemStruct *)
 481                 ShmemInitStruct("Background Writer Data",
 482                                                 BgWriterShmemSize(),
 483                                                 &found);
 484         if (BgWriterShmem == NULL)
 485                 ereport(FATAL,
 486                                 (errcode(ERRCODE_OUT_OF_MEMORY),
 487                                  errmsg("insufficient shared memory for bgwriter")));
 488         if (found)
 489                 return;                                 /* already initialized */
 490
 491         MemSet(BgWriterShmem, 0, sizeof(BgWriterShmemStruct));
 492         BgWriterShmem->max_requests = NBuffers;
 493 }
 494
 495 /*
 496  * RequestCheckpoint
 497  *              Called in backend processes to request an immediate checkpoint
 498  *
 499  * If waitforit is true, wait until the checkpoint is completed
 500  * before returning; otherwise, just signal the request and return
 501  * immediately.
 502  */
 503 void
 504 RequestCheckpoint(bool waitforit)
 505 {
 506         /* use volatile pointer to prevent code rearrangement */
 507         volatile BgWriterShmemStruct *bgs = BgWriterShmem;
 508         sig_atomic_t    old_failed = bgs->ckpt_failed;
 509         sig_atomic_t    old_started = bgs->ckpt_started;
 510
 511         /*
 512          * Send signal to request checkpoint.  When waitforit is false,
 513          * we consider failure to send the signal to be nonfatal.
 514          */
 515         if (BgWriterShmem->bgwriter_pid == 0)
 516                 elog(waitforit ? ERROR : LOG,
 517                          "could not request checkpoint because bgwriter not running");
 518         if (kill(BgWriterShmem->bgwriter_pid, SIGINT) != 0)
 519                 elog(waitforit ? ERROR : LOG,
 520                          "could not signal for checkpoint: %m");
 521
 522         /*
 523          * If requested, wait for completion.  We detect completion according
 524          * to the algorithm given above.
 525          */
 526         if (waitforit)
 527         {
 528                 while (bgs->ckpt_started == old_started)
 529                 {
 530                         CHECK_FOR_INTERRUPTS();
 531                         pg_usleep(100000L);
 532                 }
 533                 old_started = bgs->ckpt_started;
 534                 /*
 535                  * We are waiting for ckpt_done >= old_started, in a modulo
 536                  * sense.  This is a little tricky since we don't know the
 537                  * width or signedness of sig_atomic_t.  We make the lowest
 538                  * common denominator assumption that it is only as wide
 539                  * as "char".  This means that this algorithm will cope
 540                  * correctly as long as we don't sleep for more than 127
 541                  * completed checkpoints.  (If we do, we will get another
 542                  * chance to exit after 128 more checkpoints...)
 543                  */
 544                 while (((signed char) (bgs->ckpt_done - old_started)) < 0)
 545                 {
 546                         CHECK_FOR_INTERRUPTS();
 547                         pg_usleep(100000L);
 548                 }
 549                 if (bgs->ckpt_failed != old_failed)
 550                         ereport(ERROR,
 551                                         (errmsg("checkpoint request failed"),
 552                                          errhint("Consult the postmaster log for details.")));
 553         }
 554 }
 555
 556 /*
 557  * ForwardFsyncRequest
 558  *              Forward a file-fsync request from a backend to the bgwriter
 559  *
 560  * Whenever a backend is compelled to write directly to a relation
 561  * (which should be seldom, if the bgwriter is getting its job done),
 562  * the backend calls this routine to pass over knowledge that the relation
 563  * is dirty and must be fsync'd before next checkpoint.
 564  *
 565  * If we are unable to pass over the request (at present, this can happen
 566  * if the shared memory queue is full), we return false.  That forces
 567  * the backend to do its own fsync.  We hope that will be even more seldom.
 568  *
 569  * Note: we presently make no attempt to eliminate duplicate requests
 570  * in the requests[] queue.  The bgwriter will have to eliminate dups
 571  * internally anyway, so we may as well avoid holding the lock longer
 572  * than we have to here.
 573  */
 574 bool
 575 ForwardFsyncRequest(RelFileNode rnode, BlockNumber segno)
 576 {
 577         BgWriterRequest *request;
 578
 579         if (!IsUnderPostmaster)
 580                 return false;                   /* probably shouldn't even get here */
 581         Assert(BgWriterShmem != NULL);
 582
 583         LWLockAcquire(BgWriterCommLock, LW_EXCLUSIVE);
 584         if (BgWriterShmem->bgwriter_pid == 0 ||
 585                 BgWriterShmem->num_requests >= BgWriterShmem->max_requests)
 586         {
 587                 LWLockRelease(BgWriterCommLock);
 588                 return false;
 589         }
 590         request = &BgWriterShmem->requests[BgWriterShmem->num_requests++];
 591         request->rnode = rnode;
 592         request->segno = segno;
 593         LWLockRelease(BgWriterCommLock);
 594         return true;
 595 }
 596
 597 /*
 598  * AbsorbFsyncRequests
 599  *              Retrieve queued fsync requests and pass them to local smgr.
 600  *
 601  * This is exported because it must be called during CreateCheckpoint;
 602  * we have to be sure we have accepted all pending requests *after* we
 603  * establish the checkpoint redo pointer.  Since CreateCheckpoint
 604  * sometimes runs in non-bgwriter processes, do nothing if not bgwriter.
 605  */
 606 void
 607 AbsorbFsyncRequests(void)
 608 {
 609         BgWriterRequest *requests = NULL;
 610         BgWriterRequest *request;
 611         int                     n;
 612
 613         if (!am_bg_writer)
 614                 return;
 615
 616         /*
 617          * We try to avoid holding the lock for a long time by copying the
 618          * request array.
 619          */
 620         LWLockAcquire(BgWriterCommLock, LW_EXCLUSIVE);
 621
 622         n = BgWriterShmem->num_requests;
 623         if (n > 0)
 624         {
 625                 requests = (BgWriterRequest *) palloc(n * sizeof(BgWriterRequest));
 626                 memcpy(requests, BgWriterShmem->requests, n * sizeof(BgWriterRequest));
 627         }
 628         BgWriterShmem->num_requests = 0;
 629
 630         LWLockRelease(BgWriterCommLock);
 631
 632         for (request = requests; n > 0; request++, n--)
 633         {
 634                 RememberFsyncRequest(request->rnode, request->segno);
 635         }
 636         if (requests)
 637                 pfree(requests);
 638 }