src/backend/storage/smgr/md.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * md.c
   4  *        This code manages relations that reside on magnetic disk.
   5  *
   6  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL$
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include <unistd.h>
  18 #include <fcntl.h>
  19 #include <sys/file.h>
  20
  21 #include "catalog/catalog.h"
  22 #include "miscadmin.h"
  23 #include "postmaster/bgwriter.h"
  24 #include "storage/fd.h"
  25 #include "storage/bufmgr.h"
  26 #include "storage/relfilenode.h"
  27 #include "storage/smgr.h"
  28 #include "utils/hsearch.h"
  29 #include "utils/memutils.h"
  30
  31
  32 /* interval for calling AbsorbFsyncRequests in mdsync */
  33 #define FSYNCS_PER_ABSORB               10
  34
  35 /* special values for the segno arg to RememberFsyncRequest */
  36 #define FORGET_RELATION_FSYNC   (InvalidBlockNumber)
  37 #define FORGET_DATABASE_FSYNC   (InvalidBlockNumber-1)
  38 #define UNLINK_RELATION_REQUEST (InvalidBlockNumber-2)
  39
  40 /*
  41  * On Windows, we have to interpret EACCES as possibly meaning the same as
  42  * ENOENT, because if a file is unlinked-but-not-yet-gone on that platform,
  43  * that's what you get.  Ugh.  This code is designed so that we don't
  44  * actually believe these cases are okay without further evidence (namely,
  45  * a pending fsync request getting revoked ... see mdsync).
  46  */
  47 #ifndef WIN32
  48 #define FILE_POSSIBLY_DELETED(err)      ((err) == ENOENT)
  49 #else
  50 #define FILE_POSSIBLY_DELETED(err)      ((err) == ENOENT || (err) == EACCES)
  51 #endif
  52
  53 /*
  54  *      The magnetic disk storage manager keeps track of open file
  55  *      descriptors in its own descriptor pool.  This is done to make it
  56  *      easier to support relations that are larger than the operating
  57  *      system's file size limit (often 2GBytes).  In order to do that,
  58  *      we break relations up into "segment" files that are each shorter than
  59  *      the OS file size limit.  The segment size is set by the RELSEG_SIZE
  60  *      configuration constant in pg_config.h.
  61  *
  62  *      On disk, a relation must consist of consecutively numbered segment
  63  *      files in the pattern
  64  *              -- Zero or more full segments of exactly RELSEG_SIZE blocks each
  65  *              -- Exactly one partial segment of size 0 <= size < RELSEG_SIZE blocks
  66  *              -- Optionally, any number of inactive segments of size 0 blocks.
  67  *      The full and partial segments are collectively the "active" segments.
  68  *      Inactive segments are those that once contained data but are currently
  69  *      not needed because of an mdtruncate() operation.  The reason for leaving
  70  *      them present at size zero, rather than unlinking them, is that other
  71  *      backends and/or the bgwriter might be holding open file references to
  72  *      such segments.  If the relation expands again after mdtruncate(), such
  73  *      that a deactivated segment becomes active again, it is important that
  74  *      such file references still be valid --- else data might get written
  75  *      out to an unlinked old copy of a segment file that will eventually
  76  *      disappear.
  77  *
  78  *      The file descriptor pointer (md_fd field) stored in the SMgrRelation
  79  *      cache is, therefore, just the head of a list of MdfdVec objects, one
  80  *      per segment.  But note the md_fd pointer can be NULL, indicating
  81  *      relation not open.
  82  *
  83  *      Also note that mdfd_chain == NULL does not necessarily mean the relation
  84  *      doesn't have another segment after this one; we may just not have
  85  *      opened the next segment yet.  (We could not have "all segments are
  86  *      in the chain" as an invariant anyway, since another backend could
  87  *      extend the relation when we weren't looking.)  We do not make chain
  88  *      entries for inactive segments, however; as soon as we find a partial
  89  *      segment, we assume that any subsequent segments are inactive.
  90  *
  91  *      All MdfdVec objects are palloc'd in the MdCxt memory context.
  92  */
  93
  94 typedef struct _MdfdVec
  95 {
  96         File            mdfd_vfd;               /* fd number in fd.c's pool */
  97         BlockNumber mdfd_segno;         /* segment number, from 0 */
  98         struct _MdfdVec *mdfd_chain;    /* next segment, or NULL */
  99 } MdfdVec;
 100
 101 static MemoryContext MdCxt;             /* context for all md.c allocations */
 102
 103
 104 /*
 105  * In some contexts (currently, standalone backends and the bgwriter process)
 106  * we keep track of pending fsync operations: we need to remember all relation
 107  * segments that have been written since the last checkpoint, so that we can
 108  * fsync them down to disk before completing the next checkpoint.  This hash
 109  * table remembers the pending operations.      We use a hash table mostly as
 110  * a convenient way of eliminating duplicate requests.
 111  *
 112  * We use a similar mechanism to remember no-longer-needed files that can
 113  * be deleted after the next checkpoint, but we use a linked list instead of
 114  * a hash table, because we don't expect there to be any duplicate requests.
 115  *
 116  * (Regular backends do not track pending operations locally, but forward
 117  * them to the bgwriter.)
 118  */
 119 typedef struct
 120 {
 121         RelFileNode rnode;                      /* the targeted relation */
 122         ForkNumber forknum;
 123         BlockNumber segno;                      /* which segment */
 124 } PendingOperationTag;
 125
 126 typedef uint16 CycleCtr;                /* can be any convenient integer size */
 127
 128 typedef struct
 129 {
 130         PendingOperationTag tag;        /* hash table key (must be first!) */
 131         bool            canceled;               /* T => request canceled, not yet removed */
 132         CycleCtr        cycle_ctr;              /* mdsync_cycle_ctr when request was made */
 133 } PendingOperationEntry;
 134
 135 typedef struct
 136 {
 137         RelFileNode rnode;                      /* the dead relation to delete */
 138         CycleCtr        cycle_ctr;              /* mdckpt_cycle_ctr when request was made */
 139 } PendingUnlinkEntry;
 140
 141 static HTAB *pendingOpsTable = NULL;
 142 static List *pendingUnlinks = NIL;
 143
 144 static CycleCtr mdsync_cycle_ctr = 0;
 145 static CycleCtr mdckpt_cycle_ctr = 0;
 146
 147
 148 typedef enum                                    /* behavior for mdopen & _mdfd_getseg */
 149 {
 150         EXTENSION_FAIL,                         /* ereport if segment not present */
 151         EXTENSION_RETURN_NULL,          /* return NULL if not present */
 152         EXTENSION_CREATE                        /* create new segments as needed */
 153 } ExtensionBehavior;
 154
 155 /* local routines */
 156 static MdfdVec *mdopen(SMgrRelation reln, ForkNumber forknum,
 157                                            ExtensionBehavior behavior);
 158 static void register_dirty_segment(SMgrRelation reln, ForkNumber forknum,
 159                                                                    MdfdVec *seg);
 160 static void register_unlink(RelFileNode rnode);
 161 static MdfdVec *_fdvec_alloc(void);
 162 static MdfdVec *_mdfd_openseg(SMgrRelation reln, ForkNumber forkno,
 163                                                           BlockNumber segno, int oflags);
 164 static MdfdVec *_mdfd_getseg(SMgrRelation reln, ForkNumber forkno,
 165                          BlockNumber blkno, bool isTemp, ExtensionBehavior behavior);
 166 static BlockNumber _mdnblocks(SMgrRelation reln, ForkNumber forknum,
 167                                                           MdfdVec *seg);
 168
 169
 170 /*
 171  *      mdinit() -- Initialize private state for magnetic disk storage manager.
 172  */
 173 void
 174 mdinit(void)
 175 {
 176         MdCxt = AllocSetContextCreate(TopMemoryContext,
 177                                                                   "MdSmgr",
 178                                                                   ALLOCSET_DEFAULT_MINSIZE,
 179                                                                   ALLOCSET_DEFAULT_INITSIZE,
 180                                                                   ALLOCSET_DEFAULT_MAXSIZE);
 181
 182         /*
 183          * Create pending-operations hashtable if we need it.  Currently, we need
 184          * it if we are standalone (not under a postmaster) OR if we are a
 185          * bootstrap-mode subprocess of a postmaster (that is, a startup or
 186          * bgwriter process).
 187          */
 188         if (!IsUnderPostmaster || IsBootstrapProcessingMode())
 189         {
 190                 HASHCTL         hash_ctl;
 191
 192                 MemSet(&hash_ctl, 0, sizeof(hash_ctl));
 193                 hash_ctl.keysize = sizeof(PendingOperationTag);
 194                 hash_ctl.entrysize = sizeof(PendingOperationEntry);
 195                 hash_ctl.hash = tag_hash;
 196                 hash_ctl.hcxt = MdCxt;
 197                 pendingOpsTable = hash_create("Pending Ops Table",
 198                                                                           100L,
 199                                                                           &hash_ctl,
 200                                                                    HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
 201                 pendingUnlinks = NIL;
 202         }
 203 }
 204
 205 /*
 206  *  mdexists() -- Does the physical file exist?
 207  *
 208  * Note: this will return true for lingering files, with pending deletions
 209  */
 210 bool
 211 mdexists(SMgrRelation reln, ForkNumber forkNum)
 212 {
 213         /*
 214          * Close it first, to ensure that we notice if the fork has been
 215          * unlinked since we opened it.
 216          */
 217         mdclose(reln, forkNum);
 218
 219         return (mdopen(reln, forkNum, EXTENSION_RETURN_NULL) != NULL);
 220 }
 221
 222 /*
 223  *      mdcreate() -- Create a new relation on magnetic disk.
 224  *
 225  * If isRedo is true, it's okay for the relation to exist already.
 226  */
 227 void
 228 mdcreate(SMgrRelation reln, ForkNumber forkNum, bool isRedo)
 229 {
 230         char       *path;
 231         File            fd;
 232
 233         if (isRedo && reln->md_fd[forkNum] != NULL)
 234                 return;                                 /* created and opened already... */
 235
 236         Assert(reln->md_fd[forkNum] == NULL);
 237
 238         path = relpath(reln->smgr_rnode, forkNum);
 239
 240         fd = PathNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL | PG_BINARY, 0600);
 241
 242         if (fd < 0)
 243         {
 244                 int                     save_errno = errno;
 245
 246                 /*
 247                  * During bootstrap, there are cases where a system relation will be
 248                  * accessed (by internal backend processes) before the bootstrap
 249                  * script nominally creates it.  Therefore, allow the file to exist
 250                  * already, even if isRedo is not set.  (See also mdopen)
 251                  */
 252                 if (isRedo || IsBootstrapProcessingMode())
 253                         fd = PathNameOpenFile(path, O_RDWR | PG_BINARY, 0600);
 254                 if (fd < 0)
 255                 {
 256                         pfree(path);
 257                         /* be sure to report the error reported by create, not open */
 258                         errno = save_errno;
 259                         ereport(ERROR,
 260                                         (errcode_for_file_access(),
 261                                          errmsg("could not create relation %u/%u/%u/%u: %m",
 262                                                         reln->smgr_rnode.spcNode,
 263                                                         reln->smgr_rnode.dbNode,
 264                                                         reln->smgr_rnode.relNode,
 265                                                         forkNum)));
 266                 }
 267         }
 268
 269         pfree(path);
 270
 271         reln->md_fd[forkNum] = _fdvec_alloc();
 272
 273         reln->md_fd[forkNum]->mdfd_vfd = fd;
 274         reln->md_fd[forkNum]->mdfd_segno = 0;
 275         reln->md_fd[forkNum]->mdfd_chain = NULL;
 276 }
 277
 278 /*
 279  *      mdunlink() -- Unlink a relation.
 280  *
 281  * Note that we're passed a RelFileNode --- by the time this is called,
 282  * there won't be an SMgrRelation hashtable entry anymore.
 283  *
 284  * Actually, we don't unlink the first segment file of the relation, but
 285  * just truncate it to zero length, and record a request to unlink it after
 286  * the next checkpoint.  Additional segments can be unlinked immediately,
 287  * however.  Leaving the empty file in place prevents that relfilenode
 288  * number from being reused.  The scenario this protects us from is:
 289  * 1. We delete a relation (and commit, and actually remove its file).
 290  * 2. We create a new relation, which by chance gets the same relfilenode as
 291  *        the just-deleted one (OIDs must've wrapped around for that to happen).
 292  * 3. We crash before another checkpoint occurs.
 293  * During replay, we would delete the file and then recreate it, which is fine
 294  * if the contents of the file were repopulated by subsequent WAL entries.
 295  * But if we didn't WAL-log insertions, but instead relied on fsyncing the
 296  * file after populating it (as for instance CLUSTER and CREATE INDEX do),
 297  * the contents of the file would be lost forever.      By leaving the empty file
 298  * until after the next checkpoint, we prevent reassignment of the relfilenode
 299  * number until it's safe, because relfilenode assignment skips over any
 300  * existing file.
 301  *
 302  * If isRedo is true, it's okay for the relation to be already gone.
 303  * Also, we should remove the file immediately instead of queuing a request
 304  * for later, since during redo there's no possibility of creating a
 305  * conflicting relation.
 306  *
 307  * Note: any failure should be reported as WARNING not ERROR, because
 308  * we are usually not in a transaction anymore when this is called.
 309  */
 310 void
 311 mdunlink(RelFileNode rnode, ForkNumber forkNum, bool isRedo)
 312 {
 313         char       *path;
 314         int                     ret;
 315
 316         /*
 317          * We have to clean out any pending fsync requests for the doomed
 318          * relation, else the next mdsync() will fail.
 319          */
 320         ForgetRelationFsyncRequests(rnode, forkNum);
 321
 322         path = relpath(rnode, forkNum);
 323
 324         /*
 325          * Delete or truncate the first segment.
 326          */
 327         if (isRedo || forkNum != MAIN_FORKNUM)
 328                 ret = unlink(path);
 329         else
 330         {
 331                 /* truncate(2) would be easier here, but Windows hasn't got it */
 332                 int                     fd;
 333
 334                 fd = BasicOpenFile(path, O_RDWR | PG_BINARY, 0);
 335                 if (fd >= 0)
 336                 {
 337                         int                     save_errno;
 338
 339                         ret = ftruncate(fd, 0);
 340                         save_errno = errno;
 341                         close(fd);
 342                         errno = save_errno;
 343                 }
 344                 else
 345                         ret = -1;
 346         }
 347         if (ret < 0)
 348         {
 349                 if (!isRedo || errno != ENOENT)
 350                         ereport(WARNING,
 351                                         (errcode_for_file_access(),
 352                                          errmsg("could not remove relation %u/%u/%u/%u: %m",
 353                                                         rnode.spcNode,
 354                                                         rnode.dbNode,
 355                                                         rnode.relNode,
 356                                                         forkNum)));
 357         }
 358
 359         /*
 360          * Delete any additional segments.
 361          */
 362         else
 363         {
 364                 char       *segpath = (char *) palloc(strlen(path) + 12);
 365                 BlockNumber segno;
 366
 367                 /*
 368                  * Note that because we loop until getting ENOENT, we will correctly
 369                  * remove all inactive segments as well as active ones.
 370                  */
 371                 for (segno = 1;; segno++)
 372                 {
 373                         sprintf(segpath, "%s.%u", path, segno);
 374                         if (unlink(segpath) < 0)
 375                         {
 376                                 /* ENOENT is expected after the last segment... */
 377                                 if (errno != ENOENT)
 378                                         ereport(WARNING,
 379                                                         (errcode_for_file_access(),
 380                                                          errmsg("could not remove segment %u of relation %u/%u/%u/%u: %m",
 381                                                                         segno,
 382                                                                         rnode.spcNode,
 383                                                                         rnode.dbNode,
 384                                                                         rnode.relNode,
 385                                                                         forkNum)));
 386                                 break;
 387                         }
 388                 }
 389                 pfree(segpath);
 390         }
 391
 392         pfree(path);
 393
 394         /* Register request to unlink first segment later */
 395         if (!isRedo && forkNum == MAIN_FORKNUM)
 396                 register_unlink(rnode);
 397 }
 398
 399 /*
 400  *      mdextend() -- Add a block to the specified relation.
 401  *
 402  *              The semantics are nearly the same as mdwrite(): write at the
 403  *              specified position.  However, this is to be used for the case of
 404  *              extending a relation (i.e., blocknum is at or beyond the current
 405  *              EOF).  Note that we assume writing a block beyond current EOF
 406  *              causes intervening file space to become filled with zeroes.
 407  */
 408 void
 409 mdextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 410                  char *buffer, bool isTemp)
 411 {
 412         off_t           seekpos;
 413         int                     nbytes;
 414         MdfdVec    *v;
 415
 416         /* This assert is too expensive to have on normally ... */
 417 #ifdef CHECK_WRITE_VS_EXTEND
 418         Assert(blocknum >= mdnblocks(reln, forknum));
 419 #endif
 420
 421         /*
 422          * If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
 423          * more --- we mustn't create a block whose number actually is
 424          * InvalidBlockNumber.
 425          */
 426         if (blocknum == InvalidBlockNumber)
 427                 ereport(ERROR,
 428                                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 429                                  errmsg("cannot extend relation %u/%u/%u/%u beyond %u blocks",
 430                                                 reln->smgr_rnode.spcNode,
 431                                                 reln->smgr_rnode.dbNode,
 432                                                 reln->smgr_rnode.relNode,
 433                                                 forknum,
 434                                                 InvalidBlockNumber)));
 435
 436         v = _mdfd_getseg(reln, forknum, blocknum, isTemp, EXTENSION_CREATE);
 437
 438         seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 439         Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 440
 441         /*
 442          * Note: because caller usually obtained blocknum by calling mdnblocks,
 443          * which did a seek(SEEK_END), this seek is often redundant and will be
 444          * optimized away by fd.c.      It's not redundant, however, if there is a
 445          * partial page at the end of the file. In that case we want to try to
 446          * overwrite the partial page with a full page.  It's also not redundant
 447          * if bufmgr.c had to dump another buffer of the same file to make room
 448          * for the new page's buffer.
 449          */
 450         if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
 451                 ereport(ERROR,
 452                                 (errcode_for_file_access(),
 453                                  errmsg("could not seek to block %u of relation %u/%u/%u/%u: %m",
 454                                                 blocknum,
 455                                                 reln->smgr_rnode.spcNode,
 456                                                 reln->smgr_rnode.dbNode,
 457                                                 reln->smgr_rnode.relNode,
 458                                                 forknum)));
 459
 460         if ((nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ)) != BLCKSZ)
 461         {
 462                 if (nbytes < 0)
 463                         ereport(ERROR,
 464                                         (errcode_for_file_access(),
 465                                          errmsg("could not extend relation %u/%u/%u/%u: %m",
 466                                                         reln->smgr_rnode.spcNode,
 467                                                         reln->smgr_rnode.dbNode,
 468                                                         reln->smgr_rnode.relNode,
 469                                                         forknum),
 470                                          errhint("Check free disk space.")));
 471                 /* short write: complain appropriately */
 472                 ereport(ERROR,
 473                                 (errcode(ERRCODE_DISK_FULL),
 474                                  errmsg("could not extend relation %u/%u/%u/%u: wrote only %d of %d bytes at block %u",
 475                                                 reln->smgr_rnode.spcNode,
 476                                                 reln->smgr_rnode.dbNode,
 477                                                 reln->smgr_rnode.relNode,
 478                                                 forknum,
 479                                                 nbytes, BLCKSZ, blocknum),
 480                                  errhint("Check free disk space.")));
 481         }
 482
 483         if (!isTemp)
 484                 register_dirty_segment(reln, forknum, v);
 485
 486         Assert(_mdnblocks(reln, forknum, v) <= ((BlockNumber) RELSEG_SIZE));
 487 }
 488
 489 /*
 490  *      mdopen() -- Open the specified relation.
 491  *
 492  * Note we only open the first segment, when there are multiple segments.
 493  *
 494  * If first segment is not present, either ereport or return NULL according
 495  * to "behavior".  We treat EXTENSION_CREATE the same as EXTENSION_FAIL;
 496  * EXTENSION_CREATE means it's OK to extend an existing relation, not to
 497  * invent one out of whole cloth.
 498  */
 499 static MdfdVec *
 500 mdopen(SMgrRelation reln, ForkNumber forknum, ExtensionBehavior behavior)
 501 {
 502         MdfdVec    *mdfd;
 503         char       *path;
 504         File            fd;
 505
 506         /* No work if already open */
 507         if (reln->md_fd[forknum])
 508                 return reln->md_fd[forknum];
 509
 510         path = relpath(reln->smgr_rnode, forknum);
 511
 512         fd = PathNameOpenFile(path, O_RDWR | PG_BINARY, 0600);
 513
 514         if (fd < 0)
 515         {
 516                 /*
 517                  * During bootstrap, there are cases where a system relation will be
 518                  * accessed (by internal backend processes) before the bootstrap
 519                  * script nominally creates it.  Therefore, accept mdopen() as a
 520                  * substitute for mdcreate() in bootstrap mode only. (See mdcreate)
 521                  */
 522                 if (IsBootstrapProcessingMode())
 523                         fd = PathNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL | PG_BINARY, 0600);
 524                 if (fd < 0)
 525                 {
 526                         pfree(path);
 527                         if (behavior == EXTENSION_RETURN_NULL &&
 528                                 FILE_POSSIBLY_DELETED(errno))
 529                                 return NULL;
 530                         ereport(ERROR,
 531                                         (errcode_for_file_access(),
 532                                          errmsg("could not open relation %u/%u/%u/%u: %m",
 533                                                         reln->smgr_rnode.spcNode,
 534                                                         reln->smgr_rnode.dbNode,
 535                                                         reln->smgr_rnode.relNode,
 536                                                         forknum)));
 537                 }
 538         }
 539
 540         pfree(path);
 541
 542         reln->md_fd[forknum] = mdfd = _fdvec_alloc();
 543
 544         mdfd->mdfd_vfd = fd;
 545         mdfd->mdfd_segno = 0;
 546         mdfd->mdfd_chain = NULL;
 547         Assert(_mdnblocks(reln, forknum, mdfd) <= ((BlockNumber) RELSEG_SIZE));
 548
 549         return mdfd;
 550 }
 551
 552 /*
 553  *      mdclose() -- Close the specified relation, if it isn't closed already.
 554  */
 555 void
 556 mdclose(SMgrRelation reln, ForkNumber forknum)
 557 {
 558         MdfdVec    *v = reln->md_fd[forknum];
 559
 560         /* No work if already closed */
 561         if (v == NULL)
 562                 return;
 563
 564         reln->md_fd[forknum] = NULL;                    /* prevent dangling pointer after error */
 565
 566         while (v != NULL)
 567         {
 568                 MdfdVec    *ov = v;
 569
 570                 /* if not closed already */
 571                 if (v->mdfd_vfd >= 0)
 572                         FileClose(v->mdfd_vfd);
 573                 /* Now free vector */
 574                 v = v->mdfd_chain;
 575                 pfree(ov);
 576         }
 577 }
 578
 579 /*
 580  *      mdread() -- Read the specified block from a relation.
 581  */
 582 void
 583 mdread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 584            char *buffer)
 585 {
 586         off_t           seekpos;
 587         int                     nbytes;
 588         MdfdVec    *v;
 589
 590         v = _mdfd_getseg(reln, forknum, blocknum, false, EXTENSION_FAIL);
 591
 592         seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 593         Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 594
 595         if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
 596                 ereport(ERROR,
 597                                 (errcode_for_file_access(),
 598                                  errmsg("could not seek to block %u of relation %u/%u/%u/%u: %m",
 599                                                 blocknum,
 600                                                 reln->smgr_rnode.spcNode,
 601                                                 reln->smgr_rnode.dbNode,
 602                                                 reln->smgr_rnode.relNode,
 603                                                 forknum)));
 604
 605         if ((nbytes = FileRead(v->mdfd_vfd, buffer, BLCKSZ)) != BLCKSZ)
 606         {
 607                 if (nbytes < 0)
 608                         ereport(ERROR,
 609                                         (errcode_for_file_access(),
 610                                    errmsg("could not read block %u of relation %u/%u/%u/%u: %m",
 611                                                   blocknum,
 612                                                   reln->smgr_rnode.spcNode,
 613                                                   reln->smgr_rnode.dbNode,
 614                                                   reln->smgr_rnode.relNode,
 615                                                   forknum)));
 616
 617                 /*
 618                  * Short read: we are at or past EOF, or we read a partial block at
 619                  * EOF.  Normally this is an error; upper levels should never try to
 620                  * read a nonexistent block.  However, if zero_damaged_pages is ON or
 621                  * we are InRecovery, we should instead return zeroes without
 622                  * complaining.  This allows, for example, the case of trying to
 623                  * update a block that was later truncated away.
 624                  */
 625                 if (zero_damaged_pages || InRecovery)
 626                         MemSet(buffer, 0, BLCKSZ);
 627                 else
 628                         ereport(ERROR,
 629                                         (errcode(ERRCODE_DATA_CORRUPTED),
 630                                          errmsg("could not read block %u of relation %u/%u/%u/%u: read only %d of %d bytes",
 631                                                         blocknum,
 632                                                         reln->smgr_rnode.spcNode,
 633                                                         reln->smgr_rnode.dbNode,
 634                                                         reln->smgr_rnode.relNode,
 635                                                         forknum,
 636                                                         nbytes, BLCKSZ)));
 637         }
 638 }
 639
 640 /*
 641  *      mdwrite() -- Write the supplied block at the appropriate location.
 642  *
 643  *              This is to be used only for updating already-existing blocks of a
 644  *              relation (ie, those before the current EOF).  To extend a relation,
 645  *              use mdextend().
 646  */
 647 void
 648 mdwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 649                 char *buffer, bool isTemp)
 650 {
 651         off_t           seekpos;
 652         int                     nbytes;
 653         MdfdVec    *v;
 654
 655         /* This assert is too expensive to have on normally ... */
 656 #ifdef CHECK_WRITE_VS_EXTEND
 657         Assert(blocknum < mdnblocks(reln, forknum));
 658 #endif
 659
 660         v = _mdfd_getseg(reln, forknum, blocknum, isTemp, EXTENSION_FAIL);
 661
 662         seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
 663         Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
 664
 665         if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
 666                 ereport(ERROR,
 667                                 (errcode_for_file_access(),
 668                                  errmsg("could not seek to block %u of relation %u/%u/%u/%u: %m",
 669                                                 blocknum,
 670                                                 reln->smgr_rnode.spcNode,
 671                                                 reln->smgr_rnode.dbNode,
 672                                                 reln->smgr_rnode.relNode,
 673                                                 forknum)));
 674
 675         if ((nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ)) != BLCKSZ)
 676         {
 677                 if (nbytes < 0)
 678                         ereport(ERROR,
 679                                         (errcode_for_file_access(),
 680                                   errmsg("could not write block %u of relation %u/%u/%u/%u: %m",
 681                                                  blocknum,
 682                                                  reln->smgr_rnode.spcNode,
 683                                                  reln->smgr_rnode.dbNode,
 684                                                  reln->smgr_rnode.relNode,
 685                                                  forknum)));
 686                 /* short write: complain appropriately */
 687                 ereport(ERROR,
 688                                 (errcode(ERRCODE_DISK_FULL),
 689                                  errmsg("could not write block %u of relation %u/%u/%u/%u: wrote only %d of %d bytes",
 690                                                 blocknum,
 691                                                 reln->smgr_rnode.spcNode,
 692                                                 reln->smgr_rnode.dbNode,
 693                                                 reln->smgr_rnode.relNode,
 694                                                 forknum,
 695                                                 nbytes, BLCKSZ),
 696                                  errhint("Check free disk space.")));
 697         }
 698
 699         if (!isTemp)
 700                 register_dirty_segment(reln, forknum, v);
 701 }
 702
 703 /*
 704  *      mdnblocks() -- Get the number of blocks stored in a relation.
 705  *
 706  *              Important side effect: all active segments of the relation are opened
 707  *              and added to the mdfd_chain list.  If this routine has not been
 708  *              called, then only segments up to the last one actually touched
 709  *              are present in the chain.
 710  */
 711 BlockNumber
 712 mdnblocks(SMgrRelation reln, ForkNumber forknum)
 713 {
 714         MdfdVec    *v = mdopen(reln, forknum, EXTENSION_FAIL);
 715         BlockNumber nblocks;
 716         BlockNumber segno = 0;
 717
 718         /*
 719          * Skip through any segments that aren't the last one, to avoid redundant
 720          * seeks on them.  We have previously verified that these segments are
 721          * exactly RELSEG_SIZE long, and it's useless to recheck that each time.
 722          *
 723          * NOTE: this assumption could only be wrong if another backend has
 724          * truncated the relation.      We rely on higher code levels to handle that
 725          * scenario by closing and re-opening the md fd, which is handled via
 726          * relcache flush.      (Since the bgwriter doesn't participate in relcache
 727          * flush, it could have segment chain entries for inactive segments;
 728          * that's OK because the bgwriter never needs to compute relation size.)
 729          */
 730         while (v->mdfd_chain != NULL)
 731         {
 732                 segno++;
 733                 v = v->mdfd_chain;
 734         }
 735
 736         for (;;)
 737         {
 738                 nblocks = _mdnblocks(reln, forknum, v);
 739                 if (nblocks > ((BlockNumber) RELSEG_SIZE))
 740                         elog(FATAL, "segment too big");
 741                 if (nblocks < ((BlockNumber) RELSEG_SIZE))
 742                         return (segno * ((BlockNumber) RELSEG_SIZE)) + nblocks;
 743
 744                 /*
 745                  * If segment is exactly RELSEG_SIZE, advance to next one.
 746                  */
 747                 segno++;
 748
 749                 if (v->mdfd_chain == NULL)
 750                 {
 751                         /*
 752                          * Because we pass O_CREAT, we will create the next segment (with
 753                          * zero length) immediately, if the last segment is of length
 754                          * RELSEG_SIZE.  While perhaps not strictly necessary, this keeps
 755                          * the logic simple.
 756                          */
 757                         v->mdfd_chain = _mdfd_openseg(reln, forknum, segno, O_CREAT);
 758                         if (v->mdfd_chain == NULL)
 759                                 ereport(ERROR,
 760                                                 (errcode_for_file_access(),
 761                                  errmsg("could not open segment %u of relation %u/%u/%u/%u: %m",
 762                                                 segno,
 763                                                 reln->smgr_rnode.spcNode,
 764                                                 reln->smgr_rnode.dbNode,
 765                                                 reln->smgr_rnode.relNode,
 766                                                 forknum)));
 767                 }
 768
 769                 v = v->mdfd_chain;
 770         }
 771 }
 772
 773 /*
 774  *      mdtruncate() -- Truncate relation to specified number of blocks.
 775  */
 776 void
 777 mdtruncate(SMgrRelation reln, ForkNumber forknum, BlockNumber nblocks,
 778                    bool isTemp)
 779 {
 780         MdfdVec    *v;
 781         BlockNumber curnblk;
 782         BlockNumber priorblocks;
 783
 784         /*
 785          * NOTE: mdnblocks makes sure we have opened all active segments, so that
 786          * truncation loop will get them all!
 787          */
 788         curnblk = mdnblocks(reln, forknum);
 789         if (nblocks > curnblk)
 790         {
 791                 /* Bogus request ... but no complaint if InRecovery */
 792                 if (InRecovery)
 793                         return;
 794                 ereport(ERROR,
 795                                 (errmsg("could not truncate relation %u/%u/%u/%u to %u blocks: it's only %u blocks now",
 796                                                 reln->smgr_rnode.spcNode,
 797                                                 reln->smgr_rnode.dbNode,
 798                                                 reln->smgr_rnode.relNode,
 799                                                 forknum,
 800                                                 nblocks, curnblk)));
 801         }
 802         if (nblocks == curnblk)
 803                 return;                                 /* no work */
 804
 805         v = mdopen(reln, forknum, EXTENSION_FAIL);
 806
 807         priorblocks = 0;
 808         while (v != NULL)
 809         {
 810                 MdfdVec    *ov = v;
 811
 812                 if (priorblocks > nblocks)
 813                 {
 814                         /*
 815                          * This segment is no longer active (and has already been unlinked
 816                          * from the mdfd_chain). We truncate the file, but do not delete
 817                          * it, for reasons explained in the header comments.
 818                          */
 819                         if (FileTruncate(v->mdfd_vfd, 0) < 0)
 820                                 ereport(ERROR,
 821                                                 (errcode_for_file_access(),
 822                                                  errmsg("could not truncate relation %u/%u/%u/%u to %u blocks: %m",
 823                                                                 reln->smgr_rnode.spcNode,
 824                                                                 reln->smgr_rnode.dbNode,
 825                                                                 reln->smgr_rnode.relNode,
 826                                                                 forknum,
 827                                                                 nblocks)));
 828                         if (!isTemp)
 829                                 register_dirty_segment(reln, forknum, v);
 830                         v = v->mdfd_chain;
 831                         Assert(ov != reln->md_fd[forknum]);     /* we never drop the 1st segment */
 832                         pfree(ov);
 833                 }
 834                 else if (priorblocks + ((BlockNumber) RELSEG_SIZE) > nblocks)
 835                 {
 836                         /*
 837                          * This is the last segment we want to keep. Truncate the file to
 838                          * the right length, and clear chain link that points to any
 839                          * remaining segments (which we shall zap). NOTE: if nblocks is
 840                          * exactly a multiple K of RELSEG_SIZE, we will truncate the K+1st
 841                          * segment to 0 length but keep it. This adheres to the invariant
 842                          * given in the header comments.
 843                          */
 844                         BlockNumber lastsegblocks = nblocks - priorblocks;
 845
 846                         if (FileTruncate(v->mdfd_vfd, (off_t) lastsegblocks * BLCKSZ) < 0)
 847                                 ereport(ERROR,
 848                                                 (errcode_for_file_access(),
 849                                                  errmsg("could not truncate relation %u/%u/%u/%u to %u blocks: %m",
 850                                                                 reln->smgr_rnode.spcNode,
 851                                                                 reln->smgr_rnode.dbNode,
 852                                                                 reln->smgr_rnode.relNode,
 853                                                                 forknum,
 854                                                                 nblocks)));
 855                         if (!isTemp)
 856                                 register_dirty_segment(reln, forknum, v);
 857                         v = v->mdfd_chain;
 858                         ov->mdfd_chain = NULL;
 859                 }
 860                 else
 861                 {
 862                         /*
 863                          * We still need this segment and 0 or more blocks beyond it, so
 864                          * nothing to do here.
 865                          */
 866                         v = v->mdfd_chain;
 867                 }
 868                 priorblocks += RELSEG_SIZE;
 869         }
 870 }
 871
 872 /*
 873  *      mdimmedsync() -- Immediately sync a relation to stable storage.
 874  *
 875  * Note that only writes already issued are synced; this routine knows
 876  * nothing of dirty buffers that may exist inside the buffer manager.
 877  */
 878 void
 879 mdimmedsync(SMgrRelation reln, ForkNumber forknum)
 880 {
 881         MdfdVec    *v;
 882         BlockNumber curnblk;
 883
 884         /*
 885          * NOTE: mdnblocks makes sure we have opened all active segments, so that
 886          * fsync loop will get them all!
 887          */
 888         curnblk = mdnblocks(reln, forknum);
 889
 890         v = mdopen(reln, forknum, EXTENSION_FAIL);
 891
 892         while (v != NULL)
 893         {
 894                 if (FileSync(v->mdfd_vfd) < 0)
 895                         ereport(ERROR,
 896                                         (errcode_for_file_access(),
 897                                 errmsg("could not fsync segment %u of relation %u/%u/%u/%u: %m",
 898                                            v->mdfd_segno,
 899                                            reln->smgr_rnode.spcNode,
 900                                            reln->smgr_rnode.dbNode,
 901                                            reln->smgr_rnode.relNode,
 902                                            forknum)));
 903                 v = v->mdfd_chain;
 904         }
 905 }
 906
 907 /*
 908  *      mdsync() -- Sync previous writes to stable storage.
 909  */
 910 void
 911 mdsync(void)
 912 {
 913         static bool mdsync_in_progress = false;
 914
 915         HASH_SEQ_STATUS hstat;
 916         PendingOperationEntry *entry;
 917         int                     absorb_counter;
 918
 919         /*
 920          * This is only called during checkpoints, and checkpoints should only
 921          * occur in processes that have created a pendingOpsTable.
 922          */
 923         if (!pendingOpsTable)
 924                 elog(ERROR, "cannot sync without a pendingOpsTable");
 925
 926         /*
 927          * If we are in the bgwriter, the sync had better include all fsync
 928          * requests that were queued by backends up to this point.      The tightest
 929          * race condition that could occur is that a buffer that must be written
 930          * and fsync'd for the checkpoint could have been dumped by a backend just
 931          * before it was visited by BufferSync().  We know the backend will have
 932          * queued an fsync request before clearing the buffer's dirtybit, so we
 933          * are safe as long as we do an Absorb after completing BufferSync().
 934          */
 935         AbsorbFsyncRequests();
 936
 937         /*
 938          * To avoid excess fsync'ing (in the worst case, maybe a never-terminating
 939          * checkpoint), we want to ignore fsync requests that are entered into the
 940          * hashtable after this point --- they should be processed next time,
 941          * instead.  We use mdsync_cycle_ctr to tell old entries apart from new
 942          * ones: new ones will have cycle_ctr equal to the incremented value of
 943          * mdsync_cycle_ctr.
 944          *
 945          * In normal circumstances, all entries present in the table at this point
 946          * will have cycle_ctr exactly equal to the current (about to be old)
 947          * value of mdsync_cycle_ctr.  However, if we fail partway through the
 948          * fsync'ing loop, then older values of cycle_ctr might remain when we
 949          * come back here to try again.  Repeated checkpoint failures would
 950          * eventually wrap the counter around to the point where an old entry
 951          * might appear new, causing us to skip it, possibly allowing a checkpoint
 952          * to succeed that should not have.  To forestall wraparound, any time the
 953          * previous mdsync() failed to complete, run through the table and
 954          * forcibly set cycle_ctr = mdsync_cycle_ctr.
 955          *
 956          * Think not to merge this loop with the main loop, as the problem is
 957          * exactly that that loop may fail before having visited all the entries.
 958          * From a performance point of view it doesn't matter anyway, as this path
 959          * will never be taken in a system that's functioning normally.
 960          */
 961         if (mdsync_in_progress)
 962         {
 963                 /* prior try failed, so update any stale cycle_ctr values */
 964                 hash_seq_init(&hstat, pendingOpsTable);
 965                 while ((entry = (PendingOperationEntry *) hash_seq_search(&hstat)) != NULL)
 966                 {
 967                         entry->cycle_ctr = mdsync_cycle_ctr;
 968                 }
 969         }
 970
 971         /* Advance counter so that new hashtable entries are distinguishable */
 972         mdsync_cycle_ctr++;
 973
 974         /* Set flag to detect failure if we don't reach the end of the loop */
 975         mdsync_in_progress = true;
 976
 977         /* Now scan the hashtable for fsync requests to process */
 978         absorb_counter = FSYNCS_PER_ABSORB;
 979         hash_seq_init(&hstat, pendingOpsTable);
 980         while ((entry = (PendingOperationEntry *) hash_seq_search(&hstat)) != NULL)
 981         {
 982                 /*
 983                  * If the entry is new then don't process it this time.  Note that
 984                  * "continue" bypasses the hash-remove call at the bottom of the loop.
 985                  */
 986                 if (entry->cycle_ctr == mdsync_cycle_ctr)
 987                         continue;
 988
 989                 /* Else assert we haven't missed it */
 990                 Assert((CycleCtr) (entry->cycle_ctr + 1) == mdsync_cycle_ctr);
 991
 992                 /*
 993                  * If fsync is off then we don't have to bother opening the file at
 994                  * all.  (We delay checking until this point so that changing fsync on
 995                  * the fly behaves sensibly.)  Also, if the entry is marked canceled,
 996                  * fall through to delete it.
 997                  */
 998                 if (enableFsync && !entry->canceled)
 999                 {
1000                         int                     failures;
1001
1002                         /*
1003                          * If in bgwriter, we want to absorb pending requests every so
1004                          * often to prevent overflow of the fsync request queue.  It is
1005                          * unspecified whether newly-added entries will be visited by
1006                          * hash_seq_search, but we don't care since we don't need to
1007                          * process them anyway.
1008                          */
1009                         if (--absorb_counter <= 0)
1010                         {
1011                                 AbsorbFsyncRequests();
1012                                 absorb_counter = FSYNCS_PER_ABSORB;
1013                         }
1014
1015                         /*
1016                          * The fsync table could contain requests to fsync segments that
1017                          * have been deleted (unlinked) by the time we get to them. Rather
1018                          * than just hoping an ENOENT (or EACCES on Windows) error can be
1019                          * ignored, what we do on error is absorb pending requests and
1020                          * then retry.  Since mdunlink() queues a "revoke" message before
1021                          * actually unlinking, the fsync request is guaranteed to be
1022                          * marked canceled after the absorb if it really was this case.
1023                          * DROP DATABASE likewise has to tell us to forget fsync requests
1024                          * before it starts deletions.
1025                          */
1026                         for (failures = 0;; failures++)         /* loop exits at "break" */
1027                         {
1028                                 SMgrRelation reln;
1029                                 MdfdVec    *seg;
1030
1031                                 /*
1032                                  * Find or create an smgr hash entry for this relation. This
1033                                  * may seem a bit unclean -- md calling smgr?  But it's really
1034                                  * the best solution.  It ensures that the open file reference
1035                                  * isn't permanently leaked if we get an error here. (You may
1036                                  * say "but an unreferenced SMgrRelation is still a leak!" Not
1037                                  * really, because the only case in which a checkpoint is done
1038                                  * by a process that isn't about to shut down is in the
1039                                  * bgwriter, and it will periodically do smgrcloseall(). This
1040                                  * fact justifies our not closing the reln in the success path
1041                                  * either, which is a good thing since in non-bgwriter cases
1042                                  * we couldn't safely do that.)  Furthermore, in many cases
1043                                  * the relation will have been dirtied through this same smgr
1044                                  * relation, and so we can save a file open/close cycle.
1045                                  */
1046                                 reln = smgropen(entry->tag.rnode);
1047
1048                                 /*
1049                                  * It is possible that the relation has been dropped or
1050                                  * truncated since the fsync request was entered.  Therefore,
1051                                  * allow ENOENT, but only if we didn't fail already on this
1052                                  * file.  This applies both during _mdfd_getseg() and during
1053                                  * FileSync, since fd.c might have closed the file behind our
1054                                  * back.
1055                                  */
1056                                 seg = _mdfd_getseg(reln, entry->tag.forknum,
1057                                                           entry->tag.segno * ((BlockNumber) RELSEG_SIZE),
1058                                                                    false, EXTENSION_RETURN_NULL);
1059                                 if (seg != NULL &&
1060                                         FileSync(seg->mdfd_vfd) >= 0)
1061                                         break;          /* success; break out of retry loop */
1062
1063                                 /*
1064                                  * XXX is there any point in allowing more than one retry?
1065                                  * Don't see one at the moment, but easy to change the test
1066                                  * here if so.
1067                                  */
1068                                 if (!FILE_POSSIBLY_DELETED(errno) ||
1069                                         failures > 0)
1070                                         ereport(ERROR,
1071                                                         (errcode_for_file_access(),
1072                                                          errmsg("could not fsync segment %u of relation %u/%u/%u/%u: %m",
1073                                                                         entry->tag.segno,
1074                                                                         entry->tag.rnode.spcNode,
1075                                                                         entry->tag.rnode.dbNode,
1076                                                                         entry->tag.rnode.relNode,
1077                                                                         entry->tag.forknum)));
1078                                 else
1079                                         ereport(DEBUG1,
1080                                                         (errcode_for_file_access(),
1081                                                          errmsg("could not fsync segment %u of relation %u/%u/%u/%u but retrying: %m",
1082                                                                         entry->tag.segno,
1083                                                                         entry->tag.rnode.spcNode,
1084                                                                         entry->tag.rnode.dbNode,
1085                                                                         entry->tag.rnode.relNode,
1086                                                                         entry->tag.forknum)));
1087
1088                                 /*
1089                                  * Absorb incoming requests and check to see if canceled.
1090                                  */
1091                                 AbsorbFsyncRequests();
1092                                 absorb_counter = FSYNCS_PER_ABSORB;             /* might as well... */
1093
1094                                 if (entry->canceled)
1095                                         break;
1096                         }                                       /* end retry loop */
1097                 }
1098
1099                 /*
1100                  * If we get here, either we fsync'd successfully, or we don't have to
1101                  * because enableFsync is off, or the entry is (now) marked canceled.
1102                  * Okay to delete it.
1103                  */
1104                 if (hash_search(pendingOpsTable, &entry->tag,
1105                                                 HASH_REMOVE, NULL) == NULL)
1106                         elog(ERROR, "pendingOpsTable corrupted");
1107         }                                                       /* end loop over hashtable entries */
1108
1109         /* Flag successful completion of mdsync */
1110         mdsync_in_progress = false;
1111 }
1112
1113 /*
1114  * mdpreckpt() -- Do pre-checkpoint work
1115  *
1116  * To distinguish unlink requests that arrived before this checkpoint
1117  * started from those that arrived during the checkpoint, we use a cycle
1118  * counter similar to the one we use for fsync requests. That cycle
1119  * counter is incremented here.
1120  *
1121  * This must be called *before* the checkpoint REDO point is determined.
1122  * That ensures that we won't delete files too soon.
1123  *
1124  * Note that we can't do anything here that depends on the assumption
1125  * that the checkpoint will be completed.
1126  */
1127 void
1128 mdpreckpt(void)
1129 {
1130         ListCell   *cell;
1131
1132         /*
1133          * In case the prior checkpoint wasn't completed, stamp all entries in the
1134          * list with the current cycle counter.  Anything that's in the list at
1135          * the start of checkpoint can surely be deleted after the checkpoint is
1136          * finished, regardless of when the request was made.
1137          */
1138         foreach(cell, pendingUnlinks)
1139         {
1140                 PendingUnlinkEntry *entry = (PendingUnlinkEntry *) lfirst(cell);
1141
1142                 entry->cycle_ctr = mdckpt_cycle_ctr;
1143         }
1144
1145         /*
1146          * Any unlink requests arriving after this point will be assigned the next
1147          * cycle counter, and won't be unlinked until next checkpoint.
1148          */
1149         mdckpt_cycle_ctr++;
1150 }
1151
1152 /*
1153  * mdpostckpt() -- Do post-checkpoint work
1154  *
1155  * Remove any lingering files that can now be safely removed.
1156  */
1157 void
1158 mdpostckpt(void)
1159 {
1160         while (pendingUnlinks != NIL)
1161         {
1162                 PendingUnlinkEntry *entry = (PendingUnlinkEntry *) linitial(pendingUnlinks);
1163                 char       *path;
1164
1165                 /*
1166                  * New entries are appended to the end, so if the entry is new we've
1167                  * reached the end of old entries.
1168                  */
1169                 if (entry->cycle_ctr == mdckpt_cycle_ctr)
1170                         break;
1171
1172                 /* Else assert we haven't missed it */
1173                 Assert((CycleCtr) (entry->cycle_ctr + 1) == mdckpt_cycle_ctr);
1174
1175                 /* Unlink the file */
1176                 path = relpath(entry->rnode, MAIN_FORKNUM);
1177                 if (unlink(path) < 0)
1178                 {
1179                         /*
1180                          * There's a race condition, when the database is dropped at the
1181                          * same time that we process the pending unlink requests. If the
1182                          * DROP DATABASE deletes the file before we do, we will get ENOENT
1183                          * here. rmtree() also has to ignore ENOENT errors, to deal with
1184                          * the possibility that we delete the file first.
1185                          */
1186                         if (errno != ENOENT)
1187                                 ereport(WARNING,
1188                                                 (errcode_for_file_access(),
1189                                                  errmsg("could not remove relation %u/%u/%u/%u: %m",
1190                                                                 entry->rnode.spcNode,
1191                                                                 entry->rnode.dbNode,
1192                                                                 entry->rnode.relNode,
1193                                                                 MAIN_FORKNUM)));
1194                 }
1195                 pfree(path);
1196
1197                 pendingUnlinks = list_delete_first(pendingUnlinks);
1198                 pfree(entry);
1199         }
1200 }
1201
1202 /*
1203  * register_dirty_segment() -- Mark a relation segment as needing fsync
1204  *
1205  * If there is a local pending-ops table, just make an entry in it for
1206  * mdsync to process later.  Otherwise, try to pass off the fsync request
1207  * to the background writer process.  If that fails, just do the fsync
1208  * locally before returning (we expect this will not happen often enough
1209  * to be a performance problem).
1210  */
1211 static void
1212 register_dirty_segment(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
1213 {
1214         if (pendingOpsTable)
1215         {
1216                 /* push it into local pending-ops table */
1217                 RememberFsyncRequest(reln->smgr_rnode, forknum, seg->mdfd_segno);
1218         }
1219         else
1220         {
1221                 if (ForwardFsyncRequest(reln->smgr_rnode, forknum, seg->mdfd_segno))
1222                         return;                         /* passed it off successfully */
1223
1224                 if (FileSync(seg->mdfd_vfd) < 0)
1225                         ereport(ERROR,
1226                                         (errcode_for_file_access(),
1227                                 errmsg("could not fsync segment %u of relation %u/%u/%u/%u: %m",
1228                                            seg->mdfd_segno,
1229                                            reln->smgr_rnode.spcNode,
1230                                            reln->smgr_rnode.dbNode,
1231                                            reln->smgr_rnode.relNode,
1232                                            forknum)));
1233         }
1234 }
1235
1236 /*
1237  * register_unlink() -- Schedule a file to be deleted after next checkpoint
1238  *
1239  * As with register_dirty_segment, this could involve either a local or
1240  * a remote pending-ops table.
1241  */
1242 static void
1243 register_unlink(RelFileNode rnode)
1244 {
1245         if (pendingOpsTable)
1246         {
1247                 /* push it into local pending-ops table */
1248                 RememberFsyncRequest(rnode, MAIN_FORKNUM, UNLINK_RELATION_REQUEST);
1249         }
1250         else
1251         {
1252                 /*
1253                  * Notify the bgwriter about it.  If we fail to queue the request
1254                  * message, we have to sleep and try again, because we can't simply
1255                  * delete the file now.  Ugly, but hopefully won't happen often.
1256                  *
1257                  * XXX should we just leave the file orphaned instead?
1258                  */
1259                 Assert(IsUnderPostmaster);
1260                 while (!ForwardFsyncRequest(rnode, MAIN_FORKNUM,
1261                                                                         UNLINK_RELATION_REQUEST))
1262                         pg_usleep(10000L);      /* 10 msec seems a good number */
1263         }
1264 }
1265
1266 /*
1267  * RememberFsyncRequest() -- callback from bgwriter side of fsync request
1268  *
1269  * We stuff most fsync requests into the local hash table for execution
1270  * during the bgwriter's next checkpoint.  UNLINK requests go into a
1271  * separate linked list, however, because they get processed separately.
1272  *
1273  * The range of possible segment numbers is way less than the range of
1274  * BlockNumber, so we can reserve high values of segno for special purposes.
1275  * We define three:
1276  * - FORGET_RELATION_FSYNC means to cancel pending fsyncs for a relation
1277  * - FORGET_DATABASE_FSYNC means to cancel pending fsyncs for a whole database
1278  * - UNLINK_RELATION_REQUEST is a request to delete the file after the next
1279  *       checkpoint.
1280  *
1281  * (Handling the FORGET_* requests is a tad slow because the hash table has
1282  * to be searched linearly, but it doesn't seem worth rethinking the table
1283  * structure for them.)
1284  */
1285 void
1286 RememberFsyncRequest(RelFileNode rnode, ForkNumber forknum, BlockNumber segno)
1287 {
1288         Assert(pendingOpsTable);
1289
1290         if (segno == FORGET_RELATION_FSYNC)
1291         {
1292                 /* Remove any pending requests for the entire relation */
1293                 HASH_SEQ_STATUS hstat;
1294                 PendingOperationEntry *entry;
1295
1296                 hash_seq_init(&hstat, pendingOpsTable);
1297                 while ((entry = (PendingOperationEntry *) hash_seq_search(&hstat)) != NULL)
1298                 {
1299                         if (RelFileNodeEquals(entry->tag.rnode, rnode) &&
1300                                 entry->tag.forknum == forknum)
1301                         {
1302                                 /* Okay, cancel this entry */
1303                                 entry->canceled = true;
1304                         }
1305                 }
1306         }
1307         else if (segno == FORGET_DATABASE_FSYNC)
1308         {
1309                 /* Remove any pending requests for the entire database */
1310                 HASH_SEQ_STATUS hstat;
1311                 PendingOperationEntry *entry;
1312                 ListCell   *cell,
1313                                    *prev,
1314                                    *next;
1315
1316                 /* Remove fsync requests */
1317                 hash_seq_init(&hstat, pendingOpsTable);
1318                 while ((entry = (PendingOperationEntry *) hash_seq_search(&hstat)) != NULL)
1319                 {
1320                         if (entry->tag.rnode.dbNode == rnode.dbNode)
1321                         {
1322                                 /* Okay, cancel this entry */
1323                                 entry->canceled = true;
1324                         }
1325                 }
1326
1327                 /* Remove unlink requests */
1328                 prev = NULL;
1329                 for (cell = list_head(pendingUnlinks); cell; cell = next)
1330                 {
1331                         PendingUnlinkEntry *entry = (PendingUnlinkEntry *) lfirst(cell);
1332
1333                         next = lnext(cell);
1334                         if (entry->rnode.dbNode == rnode.dbNode)
1335                         {
1336                                 pendingUnlinks = list_delete_cell(pendingUnlinks, cell, prev);
1337                                 pfree(entry);
1338                         }
1339                         else
1340                                 prev = cell;
1341                 }
1342         }
1343         else if (segno == UNLINK_RELATION_REQUEST)
1344         {
1345                 /* Unlink request: put it in the linked list */
1346                 MemoryContext oldcxt = MemoryContextSwitchTo(MdCxt);
1347                 PendingUnlinkEntry *entry;
1348
1349                 entry = palloc(sizeof(PendingUnlinkEntry));
1350                 entry->rnode = rnode;
1351                 entry->cycle_ctr = mdckpt_cycle_ctr;
1352
1353                 pendingUnlinks = lappend(pendingUnlinks, entry);
1354
1355                 MemoryContextSwitchTo(oldcxt);
1356         }
1357         else
1358         {
1359                 /* Normal case: enter a request to fsync this segment */
1360                 PendingOperationTag key;
1361                 PendingOperationEntry *entry;
1362                 bool            found;
1363
1364                 /* ensure any pad bytes in the hash key are zeroed */
1365                 MemSet(&key, 0, sizeof(key));
1366                 key.rnode = rnode;
1367                 key.forknum = forknum;
1368                 key.segno = segno;
1369
1370                 entry = (PendingOperationEntry *) hash_search(pendingOpsTable,
1371                                                                                                           &key,
1372                                                                                                           HASH_ENTER,
1373                                                                                                           &found);
1374                 /* if new or previously canceled entry, initialize it */
1375                 if (!found || entry->canceled)
1376                 {
1377                         entry->canceled = false;
1378                         entry->cycle_ctr = mdsync_cycle_ctr;
1379                 }
1380
1381                 /*
1382                  * NB: it's intentional that we don't change cycle_ctr if the entry
1383                  * already exists.      The fsync request must be treated as old, even
1384                  * though the new request will be satisfied too by any subsequent
1385                  * fsync.
1386                  *
1387                  * However, if the entry is present but is marked canceled, we should
1388                  * act just as though it wasn't there.  The only case where this could
1389                  * happen would be if a file had been deleted, we received but did not
1390                  * yet act on the cancel request, and the same relfilenode was then
1391                  * assigned to a new file.      We mustn't lose the new request, but it
1392                  * should be considered new not old.
1393                  */
1394         }
1395 }
1396
1397 /*
1398  * ForgetRelationFsyncRequests -- forget any fsyncs for a rel
1399  */
1400 void
1401 ForgetRelationFsyncRequests(RelFileNode rnode, ForkNumber forknum)
1402 {
1403         if (pendingOpsTable)
1404         {
1405                 /* standalone backend or startup process: fsync state is local */
1406                 RememberFsyncRequest(rnode, forknum, FORGET_RELATION_FSYNC);
1407         }
1408         else if (IsUnderPostmaster)
1409         {
1410                 /*
1411                  * Notify the bgwriter about it.  If we fail to queue the revoke
1412                  * message, we have to sleep and try again ... ugly, but hopefully
1413                  * won't happen often.
1414                  *
1415                  * XXX should we CHECK_FOR_INTERRUPTS in this loop?  Escaping with an
1416                  * error would leave the no-longer-used file still present on disk,
1417                  * which would be bad, so I'm inclined to assume that the bgwriter
1418                  * will always empty the queue soon.
1419                  */
1420                 while (!ForwardFsyncRequest(rnode, forknum, FORGET_RELATION_FSYNC))
1421                         pg_usleep(10000L);      /* 10 msec seems a good number */
1422
1423                 /*
1424                  * Note we don't wait for the bgwriter to actually absorb the revoke
1425                  * message; see mdsync() for the implications.
1426                  */
1427         }
1428 }
1429
1430 /*
1431  * ForgetDatabaseFsyncRequests -- forget any fsyncs and unlinks for a DB
1432  */
1433 void
1434 ForgetDatabaseFsyncRequests(Oid dbid)
1435 {
1436         RelFileNode rnode;
1437
1438         rnode.dbNode = dbid;
1439         rnode.spcNode = 0;
1440         rnode.relNode = 0;
1441
1442         if (pendingOpsTable)
1443         {
1444                 /* standalone backend or startup process: fsync state is local */
1445                 RememberFsyncRequest(rnode, InvalidForkNumber, FORGET_DATABASE_FSYNC);
1446         }
1447         else if (IsUnderPostmaster)
1448         {
1449                 /* see notes in ForgetRelationFsyncRequests */
1450                 while (!ForwardFsyncRequest(rnode, InvalidForkNumber,
1451                                                                         FORGET_DATABASE_FSYNC))
1452                         pg_usleep(10000L);      /* 10 msec seems a good number */
1453         }
1454 }
1455
1456
1457 /*
1458  *      _fdvec_alloc() -- Make a MdfdVec object.
1459  */
1460 static MdfdVec *
1461 _fdvec_alloc(void)
1462 {
1463         return (MdfdVec *) MemoryContextAlloc(MdCxt, sizeof(MdfdVec));
1464 }
1465
1466 /*
1467  * Open the specified segment of the relation,
1468  * and make a MdfdVec object for it.  Returns NULL on failure.
1469  */
1470 static MdfdVec *
1471 _mdfd_openseg(SMgrRelation reln, ForkNumber forknum, BlockNumber segno,
1472                           int oflags)
1473 {
1474         MdfdVec    *v;
1475         int                     fd;
1476         char       *path,
1477                            *fullpath;
1478
1479         path = relpath(reln->smgr_rnode, forknum);
1480
1481         if (segno > 0)
1482         {
1483                 /* be sure we have enough space for the '.segno' */
1484                 fullpath = (char *) palloc(strlen(path) + 12);
1485                 sprintf(fullpath, "%s.%u", path, segno);
1486                 pfree(path);
1487         }
1488         else
1489                 fullpath = path;
1490
1491         /* open the file */
1492         fd = PathNameOpenFile(fullpath, O_RDWR | PG_BINARY | oflags, 0600);
1493
1494         pfree(fullpath);
1495
1496         if (fd < 0)
1497                 return NULL;
1498
1499         /* allocate an mdfdvec entry for it */
1500         v = _fdvec_alloc();
1501
1502         /* fill the entry */
1503         v->mdfd_vfd = fd;
1504         v->mdfd_segno = segno;
1505         v->mdfd_chain = NULL;
1506         Assert(_mdnblocks(reln, forknum, v) <= ((BlockNumber) RELSEG_SIZE));
1507
1508         /* all done */
1509         return v;
1510 }
1511
1512 /*
1513  *      _mdfd_getseg() -- Find the segment of the relation holding the
1514  *              specified block.
1515  *
1516  * If the segment doesn't exist, we ereport, return NULL, or create the
1517  * segment, according to "behavior".  Note: isTemp need only be correct
1518  * in the EXTENSION_CREATE case.
1519  */
1520 static MdfdVec *
1521 _mdfd_getseg(SMgrRelation reln, ForkNumber forknum, BlockNumber blkno,
1522                          bool isTemp, ExtensionBehavior behavior)
1523 {
1524         MdfdVec    *v = mdopen(reln, forknum, behavior);
1525         BlockNumber targetseg;
1526         BlockNumber nextsegno;
1527
1528         if (!v)
1529                 return NULL;                    /* only possible if EXTENSION_RETURN_NULL */
1530
1531         targetseg = blkno / ((BlockNumber) RELSEG_SIZE);
1532         for (nextsegno = 1; nextsegno <= targetseg; nextsegno++)
1533         {
1534                 Assert(nextsegno == v->mdfd_segno + 1);
1535
1536                 if (v->mdfd_chain == NULL)
1537                 {
1538                         /*
1539                          * Normally we will create new segments only if authorized by the
1540                          * caller (i.e., we are doing mdextend()).      But when doing WAL
1541                          * recovery, create segments anyway; this allows cases such as
1542                          * replaying WAL data that has a write into a high-numbered
1543                          * segment of a relation that was later deleted.  We want to go
1544                          * ahead and create the segments so we can finish out the replay.
1545                          *
1546                          * We have to maintain the invariant that segments before the last
1547                          * active segment are of size RELSEG_SIZE; therefore, pad them out
1548                          * with zeroes if needed.  (This only matters if caller is
1549                          * extending the relation discontiguously, but that can happen in
1550                          * hash indexes.)
1551                          */
1552                         if (behavior == EXTENSION_CREATE || InRecovery)
1553                         {
1554                                 if (_mdnblocks(reln, forknum, v) < RELSEG_SIZE)
1555                                 {
1556                                         char       *zerobuf = palloc0(BLCKSZ);
1557
1558                                         mdextend(reln, forknum,
1559                                                          nextsegno * ((BlockNumber) RELSEG_SIZE) - 1,
1560                                                          zerobuf, isTemp);
1561                                         pfree(zerobuf);
1562                                 }
1563                                 v->mdfd_chain = _mdfd_openseg(reln, forknum, +nextsegno, O_CREAT);
1564                         }
1565                         else
1566                         {
1567                                 /* We won't create segment if not existent */
1568                                 v->mdfd_chain = _mdfd_openseg(reln, forknum, nextsegno, 0);
1569                         }
1570                         if (v->mdfd_chain == NULL)
1571                         {
1572                                 if (behavior == EXTENSION_RETURN_NULL &&
1573                                         FILE_POSSIBLY_DELETED(errno))
1574                                         return NULL;
1575                                 ereport(ERROR,
1576                                                 (errcode_for_file_access(),
1577                                                  errmsg("could not open segment %u of relation %u/%u/%u/%u (target block %u): %m",
1578                                                                 nextsegno,
1579                                                                 reln->smgr_rnode.spcNode,
1580                                                                 reln->smgr_rnode.dbNode,
1581                                                                 reln->smgr_rnode.relNode,
1582                                                                 forknum,
1583                                                                 blkno)));
1584                         }
1585                 }
1586                 v = v->mdfd_chain;
1587         }
1588         return v;
1589 }
1590
1591 /*
1592  * Get number of blocks present in a single disk file
1593  */
1594 static BlockNumber
1595 _mdnblocks(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
1596 {
1597         off_t           len;
1598
1599         len = FileSeek(seg->mdfd_vfd, 0L, SEEK_END);
1600         if (len < 0)
1601                 ereport(ERROR,
1602                                 (errcode_for_file_access(),
1603                 errmsg("could not seek to end of segment %u of relation %u/%u/%u/%u: %m",
1604                            seg->mdfd_segno,
1605                            reln->smgr_rnode.spcNode,
1606                            reln->smgr_rnode.dbNode,
1607                            reln->smgr_rnode.relNode,
1608                            forknum)));
1609         /* note that this calculation will ignore any partial block at EOF */
1610         return (BlockNumber) (len / BLCKSZ);
1611 }