/*------------------------------------------------------------------------- * * pg_freespacemap.c * display some contents of the free space relation and page maps. * * $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.c,v 1.4 2006/04/26 22:46:09 momjian Exp $ *------------------------------------------------------------------------- */ #include "postgres.h" #include "funcapi.h" #include "catalog/pg_type.h" #include "storage/freespace.h" #include "utils/relcache.h" #define NUM_FREESPACE_PAGES_ELEM 5 #define NUM_FREESPACE_RELATIONS_ELEM 6 #if defined(WIN32) || defined(__CYGWIN__) /* Need DLLIMPORT for some things that are not so marked in main headers */ extern DLLIMPORT int MaxFSMPages; extern DLLIMPORT int MaxFSMRelations; extern DLLIMPORT volatile uint32 InterruptHoldoffCount; #endif Datum pg_freespacemap_pages(PG_FUNCTION_ARGS); Datum pg_freespacemap_relations(PG_FUNCTION_ARGS); /* * Record structure holding the to be exposed free space page data. */ typedef struct { uint32 reltablespace; uint32 reldatabase; uint32 relfilenode; uint32 relblocknumber; uint32 bytes; bool isindex; } FreeSpacePagesRec; /* * Record structure holding the to be exposed free space relation data. */ typedef struct { uint32 reltablespace; uint32 reldatabase; uint32 relfilenode; int64 avgrequest; int lastpagecount; int nextpage; } FreeSpaceRelationsRec; /* * Function context for page data persisting over repeated calls. */ typedef struct { AttInMetadata *attinmeta; FreeSpacePagesRec *record; char *values[NUM_FREESPACE_PAGES_ELEM]; } FreeSpacePagesContext; /* * Function context for relation data persisting over repeated calls. */ typedef struct { AttInMetadata *attinmeta; FreeSpaceRelationsRec *record; char *values[NUM_FREESPACE_RELATIONS_ELEM]; } FreeSpaceRelationsContext; /* * Function returning page data from the Free Space Map (FSM). */ PG_FUNCTION_INFO_V1(pg_freespacemap_pages); Datum pg_freespacemap_pages(PG_FUNCTION_ARGS) { FuncCallContext *funcctx; Datum result; MemoryContext oldcontext; FreeSpacePagesContext *fctx; /* User function context. */ TupleDesc tupledesc; HeapTuple tuple; FSMHeader *FreeSpaceMap; /* FSM main structure. */ FSMRelation *fsmrel; /* Individual relation. */ if (SRF_IS_FIRSTCALL()) { uint32 i; uint32 numPages; /* Max possible no. of pages in map. */ int nPages; /* Mapped pages for a relation. */ /* * Get the free space map data structure. */ FreeSpaceMap = GetFreeSpaceMap(); numPages = MaxFSMPages; funcctx = SRF_FIRSTCALL_INIT(); /* Switch context when allocating stuff to be used in later calls */ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); /* Construct a tuple to return. */ tupledesc = CreateTemplateTupleDesc(NUM_FREESPACE_PAGES_ELEM, false); TupleDescInitEntry(tupledesc, (AttrNumber) 1, "reltablespace", OIDOID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 2, "reldatabase", OIDOID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 3, "relfilenode", OIDOID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 4, "relblocknumber", INT8OID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 5, "bytes", INT4OID, -1, 0); /* Generate attribute metadata needed later to produce tuples */ funcctx->attinmeta = TupleDescGetAttInMetadata(tupledesc); /* * Create a function context for cross-call persistence and initialize * the counters. */ fctx = (FreeSpacePagesContext *) palloc(sizeof(FreeSpacePagesContext)); funcctx->user_fctx = fctx; /* Set an upper bound on the calls */ funcctx->max_calls = numPages; /* Allocate numPages worth of FreeSpacePagesRec records, this is also * an upper bound. */ fctx->record = (FreeSpacePagesRec *) palloc(sizeof(FreeSpacePagesRec) * numPages); /* allocate the strings for tuple formation */ fctx->values[0] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[1] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[2] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[3] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[4] = (char *) palloc(3 * sizeof(uint32) + 1); /* Return to original context when allocating transient memory */ MemoryContextSwitchTo(oldcontext); /* * Lock free space map and scan though all the relations, * for each relation, gets all its mapped pages. */ LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE); i = 0; for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) { if (fsmrel->isIndex) { /* Index relation. */ IndexFSMPageData *page; page = (IndexFSMPageData *) (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES); for (nPages = 0; nPages < fsmrel->storedPages; nPages++) { fctx->record[i].reltablespace = fsmrel->key.spcNode; fctx->record[i].reldatabase = fsmrel->key.dbNode; fctx->record[i].relfilenode = fsmrel->key.relNode; fctx->record[i].relblocknumber = IndexFSMPageGetPageNum(page); fctx->record[i].bytes = 0; fctx->record[i].isindex = true; page++; i++; } } else { /* Heap relation. */ FSMPageData *page; page = (FSMPageData *) (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES); for (nPages = 0; nPages < fsmrel->storedPages; nPages++) { fctx->record[i].reltablespace = fsmrel->key.spcNode; fctx->record[i].reldatabase = fsmrel->key.dbNode; fctx->record[i].relfilenode = fsmrel->key.relNode; fctx->record[i].relblocknumber = FSMPageGetPageNum(page); fctx->record[i].bytes = FSMPageGetSpace(page); fctx->record[i].isindex = false; page++; i++; } } } /* Set the real no. of calls as we know it now! */ funcctx->max_calls = i; /* Release free space map. */ LWLockRelease(FreeSpaceLock); } funcctx = SRF_PERCALL_SETUP(); /* Get the saved state */ fctx = funcctx->user_fctx; if (funcctx->call_cntr < funcctx->max_calls) { uint32 i = funcctx->call_cntr; char *values[NUM_FREESPACE_PAGES_ELEM]; int j; /* * Use a temporary values array, initially pointing to fctx->values, * so it can be reassigned w/o losing the storage for subsequent * calls. */ for (j = 0; j < NUM_FREESPACE_PAGES_ELEM; j++) { values[j] = fctx->values[j]; } sprintf(values[0], "%u", fctx->record[i].reltablespace); sprintf(values[1], "%u", fctx->record[i].reldatabase); sprintf(values[2], "%u", fctx->record[i].relfilenode); sprintf(values[3], "%u", fctx->record[i].relblocknumber); /* * Set (free) bytes to NULL for an index relation. */ if (fctx->record[i].isindex == true) { values[4] = NULL; } else { sprintf(values[4], "%u", fctx->record[i].bytes); } /* Build and return the tuple. */ tuple = BuildTupleFromCStrings(funcctx->attinmeta, values); result = HeapTupleGetDatum(tuple); SRF_RETURN_NEXT(funcctx, result); } else SRF_RETURN_DONE(funcctx); } /* * Function returning relation data from the Free Space Map (FSM). */ PG_FUNCTION_INFO_V1(pg_freespacemap_relations); Datum pg_freespacemap_relations(PG_FUNCTION_ARGS) { FuncCallContext *funcctx; Datum result; MemoryContext oldcontext; FreeSpaceRelationsContext *fctx; /* User function context. */ TupleDesc tupledesc; HeapTuple tuple; FSMHeader *FreeSpaceMap; /* FSM main structure. */ FSMRelation *fsmrel; /* Individual relation. */ if (SRF_IS_FIRSTCALL()) { uint32 i; uint32 numRelations; /* Max no. of Relations in map. */ /* * Get the free space map data structure. */ FreeSpaceMap = GetFreeSpaceMap(); numRelations = MaxFSMRelations; funcctx = SRF_FIRSTCALL_INIT(); /* Switch context when allocating stuff to be used in later calls */ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); /* Construct a tuple to return. */ tupledesc = CreateTemplateTupleDesc(NUM_FREESPACE_RELATIONS_ELEM, false); TupleDescInitEntry(tupledesc, (AttrNumber) 1, "reltablespace", OIDOID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 2, "reldatabase", OIDOID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 3, "relfilenode", OIDOID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 4, "avgrequest", INT8OID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 5, "lastpageCount", INT4OID, -1, 0); TupleDescInitEntry(tupledesc, (AttrNumber) 6, "nextpage", INT4OID, -1, 0); /* Generate attribute metadata needed later to produce tuples */ funcctx->attinmeta = TupleDescGetAttInMetadata(tupledesc); /* * Create a function context for cross-call persistence and initialize * the counters. */ fctx = (FreeSpaceRelationsContext *) palloc(sizeof(FreeSpaceRelationsContext)); funcctx->user_fctx = fctx; /* Set an upper bound on the calls */ funcctx->max_calls = numRelations; /* Allocate numRelations worth of FreeSpaceRelationsRec records, * this is also an upper bound. */ fctx->record = (FreeSpaceRelationsRec *) palloc(sizeof(FreeSpaceRelationsRec) * numRelations); /* allocate the strings for tuple formation */ fctx->values[0] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[1] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[2] = (char *) palloc(3 * sizeof(uint32) + 1); fctx->values[3] = (char *) palloc(3 * sizeof(int64) + 1); fctx->values[4] = (char *) palloc(3 * sizeof(int32) + 1); fctx->values[5] = (char *) palloc(3 * sizeof(int32) + 1); /* Return to original context when allocating transient memory */ MemoryContextSwitchTo(oldcontext); /* * Lock free space map and scan though all the relations, */ LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE); i = 0; for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) { fctx->record[i].reltablespace = fsmrel->key.spcNode; fctx->record[i].reldatabase = fsmrel->key.dbNode; fctx->record[i].relfilenode = fsmrel->key.relNode; fctx->record[i].avgrequest = (int64)fsmrel->avgRequest; fctx->record[i].lastpagecount = fsmrel->lastPageCount; fctx->record[i].nextpage = fsmrel->nextPage; i++; } /* Set the real no. of calls as we know it now! */ funcctx->max_calls = i; /* Release free space map. */ LWLockRelease(FreeSpaceLock); } funcctx = SRF_PERCALL_SETUP(); /* Get the saved state */ fctx = funcctx->user_fctx; if (funcctx->call_cntr < funcctx->max_calls) { uint32 i = funcctx->call_cntr; char *values[NUM_FREESPACE_RELATIONS_ELEM]; int j; /* * Use a temporary values array, initially pointing to fctx->values, * so it can be reassigned w/o losing the storage for subsequent * calls. */ for (j = 0; j < NUM_FREESPACE_RELATIONS_ELEM; j++) { values[j] = fctx->values[j]; } sprintf(values[0], "%u", fctx->record[i].reltablespace); sprintf(values[1], "%u", fctx->record[i].reldatabase); sprintf(values[2], "%u", fctx->record[i].relfilenode); sprintf(values[3], INT64_FORMAT, fctx->record[i].avgrequest); sprintf(values[4], "%d", fctx->record[i].lastpagecount); sprintf(values[5], "%d", fctx->record[i].nextpage); /* Build and return the tuple. */ tuple = BuildTupleFromCStrings(funcctx->attinmeta, values); result = HeapTupleGetDatum(tuple); SRF_RETURN_NEXT(funcctx, result); } else SRF_RETURN_DONE(funcctx); }