PostgreSQL Source Code  git master
pg_prewarm.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pg_prewarm.c
4  * prewarming utilities
5  *
6  * Copyright (c) 2010-2021, PostgreSQL Global Development Group
7  *
8  * IDENTIFICATION
9  * contrib/pg_prewarm/pg_prewarm.c
10  *
11  *-------------------------------------------------------------------------
12  */
13 #include "postgres.h"
14 
15 #include <sys/stat.h>
16 #include <unistd.h>
17 
18 #include "access/relation.h"
19 #include "fmgr.h"
20 #include "miscadmin.h"
21 #include "storage/bufmgr.h"
22 #include "storage/smgr.h"
23 #include "utils/acl.h"
24 #include "utils/builtins.h"
25 #include "utils/lsyscache.h"
26 #include "utils/rel.h"
27 
29 
31 
32 typedef enum
33 {
37 } PrewarmType;
38 
40 
41 /*
42  * pg_prewarm(regclass, mode text, fork text,
43  * first_block int8, last_block int8)
44  *
45  * The first argument is the relation to be prewarmed; the second controls
46  * how prewarming is done; legal options are 'prefetch', 'read', and 'buffer'.
47  * The third is the name of the relation fork to be prewarmed. The fourth
48  * and fifth arguments specify the first and last block to be prewarmed.
49  * If the fourth argument is NULL, it will be taken as 0; if the fifth argument
50  * is NULL, it will be taken as the number of blocks in the relation. The
51  * return value is the number of blocks successfully prewarmed.
52  */
53 Datum
55 {
56  Oid relOid;
57  text *forkName;
58  text *type;
59  int64 first_block;
60  int64 last_block;
61  int64 nblocks;
62  int64 blocks_done = 0;
63  int64 block;
64  Relation rel;
65  ForkNumber forkNumber;
66  char *forkString;
67  char *ttype;
68  PrewarmType ptype;
69  AclResult aclresult;
70 
71  /* Basic sanity checking. */
72  if (PG_ARGISNULL(0))
73  ereport(ERROR,
74  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
75  errmsg("relation cannot be null")));
76  relOid = PG_GETARG_OID(0);
77  if (PG_ARGISNULL(1))
78  ereport(ERROR,
79  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
80  errmsg("prewarm type cannot be null")));
81  type = PG_GETARG_TEXT_PP(1);
82  ttype = text_to_cstring(type);
83  if (strcmp(ttype, "prefetch") == 0)
84  ptype = PREWARM_PREFETCH;
85  else if (strcmp(ttype, "read") == 0)
86  ptype = PREWARM_READ;
87  else if (strcmp(ttype, "buffer") == 0)
88  ptype = PREWARM_BUFFER;
89  else
90  {
91  ereport(ERROR,
92  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
93  errmsg("invalid prewarm type"),
94  errhint("Valid prewarm types are \"prefetch\", \"read\", and \"buffer\".")));
95  PG_RETURN_INT64(0); /* Placate compiler. */
96  }
97  if (PG_ARGISNULL(2))
98  ereport(ERROR,
99  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
100  errmsg("relation fork cannot be null")));
101  forkName = PG_GETARG_TEXT_PP(2);
102  forkString = text_to_cstring(forkName);
103  forkNumber = forkname_to_number(forkString);
104 
105  /* Open relation and check privileges. */
106  rel = relation_open(relOid, AccessShareLock);
107  aclresult = pg_class_aclcheck(relOid, GetUserId(), ACL_SELECT);
108  if (aclresult != ACLCHECK_OK)
109  aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind), get_rel_name(relOid));
110 
111  /* Check that the fork exists. */
112  if (!smgrexists(RelationGetSmgr(rel), forkNumber))
113  ereport(ERROR,
114  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
115  errmsg("fork \"%s\" does not exist for this relation",
116  forkString)));
117 
118  /* Validate block numbers, or handle nulls. */
119  nblocks = RelationGetNumberOfBlocksInFork(rel, forkNumber);
120  if (PG_ARGISNULL(3))
121  first_block = 0;
122  else
123  {
124  first_block = PG_GETARG_INT64(3);
125  if (first_block < 0 || first_block >= nblocks)
126  ereport(ERROR,
127  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
128  errmsg("starting block number must be between 0 and %lld",
129  (long long) (nblocks - 1))));
130  }
131  if (PG_ARGISNULL(4))
132  last_block = nblocks - 1;
133  else
134  {
135  last_block = PG_GETARG_INT64(4);
136  if (last_block < 0 || last_block >= nblocks)
137  ereport(ERROR,
138  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
139  errmsg("ending block number must be between 0 and %lld",
140  (long long) (nblocks - 1))));
141  }
142 
143  /* Now we're ready to do the real work. */
144  if (ptype == PREWARM_PREFETCH)
145  {
146 #ifdef USE_PREFETCH
147 
148  /*
149  * In prefetch mode, we just hint the OS to read the blocks, but we
150  * don't know whether it really does it, and we don't wait for it to
151  * finish.
152  *
153  * It would probably be better to pass our prefetch requests in chunks
154  * of a megabyte or maybe even a whole segment at a time, but there's
155  * no practical way to do that at present without a gross modularity
156  * violation, so we just do this.
157  */
158  for (block = first_block; block <= last_block; ++block)
159  {
161  PrefetchBuffer(rel, forkNumber, block);
162  ++blocks_done;
163  }
164 #else
165  ereport(ERROR,
166  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
167  errmsg("prefetch is not supported by this build")));
168 #endif
169  }
170  else if (ptype == PREWARM_READ)
171  {
172  /*
173  * In read mode, we actually read the blocks, but not into shared
174  * buffers. This is more portable than prefetch mode (it works
175  * everywhere) and is synchronous.
176  */
177  for (block = first_block; block <= last_block; ++block)
178  {
180  smgrread(RelationGetSmgr(rel), forkNumber, block, blockbuffer.data);
181  ++blocks_done;
182  }
183  }
184  else if (ptype == PREWARM_BUFFER)
185  {
186  /*
187  * In buffer mode, we actually pull the data into shared_buffers.
188  */
189  for (block = first_block; block <= last_block; ++block)
190  {
191  Buffer buf;
192 
194  buf = ReadBufferExtended(rel, forkNumber, block, RBM_NORMAL, NULL);
195  ReleaseBuffer(buf);
196  ++blocks_done;
197  }
198  }
199 
200  /* Close relation, release lock. */
202 
203  PG_RETURN_INT64(blocks_done);
204 }
PrewarmType
Definition: pg_prewarm.c:32
int errhint(const char *fmt,...)
Definition: elog.c:1156
Oid GetUserId(void)
Definition: miscinit.c:495
PG_MODULE_MAGIC
Definition: pg_prewarm.c:28
#define PG_RETURN_INT64(x)
Definition: fmgr.h:368
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
Definition: bufmgr.c:741
#define AccessShareLock
Definition: lockdefs.h:36
Datum pg_prewarm(PG_FUNCTION_ARGS)
Definition: pg_prewarm.c:54
int errcode(int sqlerrcode)
Definition: elog.c:698
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3768
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:247
Form_pg_class rd_rel
Definition: rel.h:109
unsigned int Oid
Definition: postgres_ext.h:31
ForkNumber forkname_to_number(const char *forkName)
Definition: relpath.c:50
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
void smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
Definition: smgr.c:501
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:3308
char data[BLCKSZ]
Definition: c.h:1141
#define ERROR
Definition: elog.h:46
static PGAlignedBlock blockbuffer
Definition: pg_prewarm.c:39
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:48
static char * buf
Definition: pg_test_fsync.c:68
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
ForkNumber
Definition: relpath.h:40
AclResult
Definition: acl.h:177
uintptr_t Datum
Definition: postgres.h:411
#define ACL_SELECT
Definition: parsenodes.h:83
#define ereport(elevel,...)
Definition: elog.h:157
BlockNumber RelationGetNumberOfBlocksInFork(Relation relation, ForkNumber forkNum)
Definition: bufmgr.c:2935
#define PG_ARGISNULL(n)
Definition: fmgr.h:209
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:206
PG_FUNCTION_INFO_V1(pg_prewarm)
static SMgrRelation RelationGetSmgr(Relation rel)
Definition: rel.h:544
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4680
char * text_to_cstring(const text *t)
Definition: varlena.c:222
int errmsg(const char *fmt,...)
Definition: elog.c:909
ObjectType get_relkind_objtype(char relkind)
PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
Definition: bufmgr.c:587
Definition: c.h:621
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:120
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1899
int Buffer
Definition: buf.h:23