Line data    Source code

       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * block.h
       4              :  *        POSTGRES disk block definitions.
       5              :  *
       6              :  *
       7              :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       8              :  * Portions Copyright (c) 1994, Regents of the University of California
       9              :  *
      10              :  * src/include/storage/block.h
      11              :  *
      12              :  *-------------------------------------------------------------------------
      13              :  */
      14              : #ifndef BLOCK_H
      15              : #define BLOCK_H
      16              : 
      17              : /*
      18              :  * BlockNumber:
      19              :  *
      20              :  * each data file (heap or index) is divided into postgres disk blocks
      21              :  * (which may be thought of as the unit of i/o -- a postgres buffer
      22              :  * contains exactly one disk block).  the blocks are numbered
      23              :  * sequentially, 0 to 0xFFFFFFFE.
      24              :  *
      25              :  * InvalidBlockNumber is the same thing as P_NEW in bufmgr.h.
      26              :  *
      27              :  * the access methods, the buffer manager and the storage manager are
      28              :  * more or less the only pieces of code that should be accessing disk
      29              :  * blocks directly.
      30              :  */
      31              : typedef uint32 BlockNumber;
      32              : 
      33              : #define InvalidBlockNumber              ((BlockNumber) 0xFFFFFFFF)
      34              : 
      35              : #define MaxBlockNumber                  ((BlockNumber) 0xFFFFFFFE)
      36              : 
      37              : /*
      38              :  * BlockId:
      39              :  *
      40              :  * this is a storage type for BlockNumber.  in other words, this type
      41              :  * is used for on-disk structures (e.g., in HeapTupleData) whereas
      42              :  * BlockNumber is the type on which calculations are performed (e.g.,
      43              :  * in access method code).
      44              :  *
      45              :  * there doesn't appear to be any reason to have separate types except
      46              :  * for the fact that BlockIds can be SHORTALIGN'd (and therefore any
      47              :  * structures that contains them, such as ItemPointerData, can also be
      48              :  * SHORTALIGN'd).  this is an important consideration for reducing the
      49              :  * space requirements of the line pointer (ItemIdData) array on each
      50              :  * page and the header of each heap or index tuple, so it doesn't seem
      51              :  * wise to change this without good reason.
      52              :  */
      53              : typedef struct BlockIdData
      54              : {
      55              :         uint16          bi_hi;
      56              :         uint16          bi_lo;
      57              : } BlockIdData;
      58              : 
      59              : typedef BlockIdData *BlockId;   /* block identifier */
      60              : 
      61              : /* ----------------
      62              :  *              support functions
      63              :  * ----------------
      64              :  */
      65              : 
      66              : /*
      67              :  * BlockNumberIsValid
      68              :  *              True iff blockNumber is valid.
      69              :  */
      70              : static inline bool
      71     31601597 : BlockNumberIsValid(BlockNumber blockNumber)
      72              : {
      73     31601597 :         return blockNumber != InvalidBlockNumber;
      74              : }
      75              : 
      76              : /*
      77              :  * BlockIdSet
      78              :  *              Sets a block identifier to the specified value.
      79              :  */
      80              : static inline void
      81     67001482 : BlockIdSet(BlockIdData *blockId, BlockNumber blockNumber)
      82              : {
      83     67001482 :         blockId->bi_hi = blockNumber >> 16;
      84     67001482 :         blockId->bi_lo = blockNumber & 0xffff;
      85     67001482 : }
      86              : 
      87              : /*
      88              :  * BlockIdEquals
      89              :  *              Check for block number equality.
      90              :  */
      91              : static inline bool
      92              : BlockIdEquals(const BlockIdData *blockId1, const BlockIdData *blockId2)
      93              : {
      94              :         return (blockId1->bi_hi == blockId2->bi_hi &&
      95              :                         blockId1->bi_lo == blockId2->bi_lo);
      96              : }
      97              : 
      98              : /*
      99              :  * BlockIdGetBlockNumber
     100              :  *              Retrieve the block number from a block identifier.
     101              :  */
     102              : static inline BlockNumber
     103     65449293 : BlockIdGetBlockNumber(const BlockIdData *blockId)
     104              : {
     105     65449293 :         return (((BlockNumber) blockId->bi_hi) << 16) | ((BlockNumber) blockId->bi_lo);
     106              : }
     107              : 
     108              : #endif                                                  /* BLOCK_H */