Add contrib/pg_freespacemap to display free space map information.

Mark Kirkwood

contrib/Makefile

-# $PostgreSQL: pgsql/contrib/Makefile,v 1.61 2005/09/01 22:02:44 tgl Exp $
+# $PostgreSQL: pgsql/contrib/Makefile,v 1.62 2006/02/12 03:55:52 momjian Exp $
 
 subdir = contrib
 top_builddir = ..
@@ -21,6 +21,7 @@ WANTED_DIRS = \
 		ltree		\
 		oid2name	\
 		pg_buffercache	\
+		pg_freespacemap \
 		pg_trgm		\
 		pgbench		\
 		pgcrypto	\

contrib/README

@@ -106,6 +106,10 @@ pg_buffercache -
 	Real time queries on the shared buffer cache
 	by Mark Kirkwood <markir@paradise.net.nz>
 
+pg_freespacemap -
+	Displays the contents of the free space map (FSM)
+	by Mark Kirkwood <markir@paradise.net.nz>
+
 pg_trgm -
 	Functions for determining the similarity of text based on trigram
 	matching.

contrib/pg_freespacemap/Makefile

+# $PostgreSQL: pgsql/contrib/pg_freespacemap/Makefile,v 1.1 2006/02/12 03:55:53 momjian Exp $
+
+MODULE_big = pg_freespacemap
+OBJS	= pg_freespacemap.o
+
+DATA_built = pg_freespacemap.sql 
+DOCS = README.pg_freespacemap
+
+ifdef USE_PGXS
+PGXS := $(shell pg_config --pgxs)
+include $(PGXS)
+else
+subdir = contrib/pg_freespacemap
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif

contrib/pg_freespacemap/README.pg_freespacemap

+Pg_freespacemap - Real time queries on the free space map (FSM).
+---------------
+
+  This module consists of a C function 'pg_freespacemap()' that returns 
+  a set of records, and a view 'pg_freespacemap' to wrapper the function.
+
+  The module provides the ability to examine the contents of the free space
+  map, without having to restart or rebuild the server with additional
+  debugging code.
+
+  By default public access is REVOKED from both of these, just in case there
+  are security issues lurking.
+
+
+Installation
+------------
+
+  Build and install the main Postgresql source, then this contrib module:
+
+  $ cd contrib/pg_freespacemap
+  $ gmake
+  $ gmake install
+
+
+  To register the functions:
+
+  $ psql -d <database> -f pg_freespacemap.sql
+
+
+Notes
+-----
+
+  The definition of the columns exposed in the view is:
+
+       Column     |  references          | Description
+  ----------------+----------------------+------------------------------------
+   blockid        |                      | Id, 1.. max_fsm_pages
+   relfilenode    | pg_class.relfilenode | Refilenode of the relation.
+   reltablespace  | pg_tablespace.oid    | Tablespace oid of the relation.
+   reldatabase    | pg_database.oid      | Database for the relation.
+   relblocknumber |                      | Offset of the page in the relation.
+   blockfreebytes |                      | Free bytes in the block/page.
+
+
+  There is one row for each page in the free space map.
+
+  Because the map is shared by all the databases, there are pages from
+  relations not belonging to the current database.
+
+  When the pg_freespacemap view is accessed, internal free space map locks are
+  taken, and a copy of the map data is made for the view to display. 
+  This ensures that the view produces a consistent set of results, while not 
+  blocking normal activity longer than necessary.  Nonetheless there 
+  could be some impact on database performance if this view is read often.
+
+
+Sample output
+-------------
+
+  regression=# \d pg_freespacemap
+      View "public.pg_freespacemap"
+      Column     |  Type   | Modifiers 
+  ---------------+---------+-----------
+  blockid        | integer | 
+  relfilenode    | oid     | 
+  reltablespace  | oid     | 
+  reldatabase    | oid     | 
+  relblocknumber | bigint  | 
+  blockfreebytes | integer | 
+ View definition:
+  SELECT p.blockid, p.relfilenode, p.reltablespace, p.reldatabase, p.relblocknumber, p.blockfreebytes
+    FROM pg_freespacemap() p(blockid integer, relfilenode oid, reltablespace oid, reldatabase oid, relblocknumber bigint, blockfreebytes integer);
+
+  regression=# SELECT c.relname, m.relblocknumber, m.blockfreebytes  
+               FROM pg_freespacemap m INNER JOIN pg_class c 
+               ON c.relfilenode = m.relfilenode LIMIT 10;
+      relname             | relblocknumber | blockfreebytes 
+  ------------------------+----------------+----------------
+  sql_features            |              5 |           2696
+  sql_implementation_info |              0 |           7104
+  sql_languages           |              0 |           8016
+  sql_packages            |              0 |           7376
+  sql_sizing              |              0 |           6032
+  pg_authid               |              0 |           7424
+  pg_toast_2618           |             13 |           4588
+  pg_toast_2618           |             12 |           1680
+  pg_toast_2618           |             10 |           1436
+  pg_toast_2618           |              7 |           1136
+  (10 rows)
+
+  regression=# 
+
+
+Author
+------
+
+  * Mark Kirkwood <markir@paradise.net.nz>
+

contrib/pg_freespacemap/pg_freespacemap.c

+/*-------------------------------------------------------------------------
+ *
+ * pg_freespacemap.c
+ *	  display some contents of the free space map.
+ *
+ *	  $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.c,v 1.1 2006/02/12 03:55:53 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 	6
+
+#if defined(WIN32) || defined(__CYGWIN__)
+extern DLLIMPORT volatile uint32 InterruptHoldoffCount;
+#endif
+
+Datum		pg_freespacemap(PG_FUNCTION_ARGS);
+
+
+/*
+ * Record structure holding the to be exposed free space data.
+ */
+typedef struct
+{
+
+	uint32				blockid;
+	uint32				relfilenode;
+	uint32				reltablespace;
+	uint32				reldatabase;
+	uint32				relblocknumber;
+	uint32				blockfreebytes;
+
+}	FreeSpacePagesRec;
+
+
+/*
+ * Function context for data persisting over repeated calls.
+ */
+typedef struct
+{
+
+	AttInMetadata 		*attinmeta;
+	FreeSpacePagesRec	*record;
+	char	   			*values[NUM_FREESPACE_PAGES_ELEM];
+
+}	FreeSpacePagesContext;
+
+
+/*
+ * Function returning data from the Free Space Map (FSM).
+ */
+PG_FUNCTION_INFO_V1(pg_freespacemap);
+Datum
+pg_freespacemap(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, "blockid",
+						   INT4OID, -1, 0);
+		TupleDescInitEntry(tupledesc, (AttrNumber) 2, "relfilenode",
+						   OIDOID, -1, 0);
+		TupleDescInitEntry(tupledesc, (AttrNumber) 3, "reltablespace",
+						   OIDOID, -1, 0);
+		TupleDescInitEntry(tupledesc, (AttrNumber) 4, "reldatabase",
+						   OIDOID, -1, 0);
+		TupleDescInitEntry(tupledesc, (AttrNumber) 5, "relblocknumber",
+						   INT8OID, -1, 0);
+		TupleDescInitEntry(tupledesc, (AttrNumber) 6, "blockfreebytes",
+						   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);
+		fctx->values[5] = (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].blockid = i;
+					fctx->record[i].relfilenode = fsmrel->key.relNode;
+					fctx->record[i].reltablespace = fsmrel->key.spcNode;
+					fctx->record[i].reldatabase = fsmrel->key.dbNode;
+					fctx->record[i].relblocknumber = IndexFSMPageGetPageNum(page);	
+					fctx->record[i].blockfreebytes = 0;	/* index.*/
+
+					page++;
+					i++;
+				}
+			}
+			else
+			{	/* Heap relation. */
+				FSMPageData *page;
+
+				page = (FSMPageData *)
+						(FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
+
+				for (nPages = 0; nPages < fsmrel->storedPages; nPages++)
+				{
+					fctx->record[i].blockid = i;
+					fctx->record[i].relfilenode = fsmrel->key.relNode;
+					fctx->record[i].reltablespace = fsmrel->key.spcNode;
+					fctx->record[i].reldatabase = fsmrel->key.dbNode;
+					fctx->record[i].relblocknumber = FSMPageGetPageNum(page);
+					fctx->record[i].blockfreebytes = FSMPageGetSpace(page);	
+					
+					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;
+
+
+		sprintf(fctx->values[0], "%u", fctx->record[i].blockid);
+		sprintf(fctx->values[1], "%u", fctx->record[i].relfilenode);
+		sprintf(fctx->values[2], "%u", fctx->record[i].reltablespace);
+		sprintf(fctx->values[3], "%u", fctx->record[i].reldatabase);
+		sprintf(fctx->values[4], "%u", fctx->record[i].relblocknumber);
+		sprintf(fctx->values[5], "%u", fctx->record[i].blockfreebytes);
+
+
+
+		/* Build and return the tuple. */
+		tuple = BuildTupleFromCStrings(funcctx->attinmeta, fctx->values);
+		result = HeapTupleGetDatum(tuple);
+
+
+		SRF_RETURN_NEXT(funcctx, result);
+	}
+	else
+		SRF_RETURN_DONE(funcctx);
+
+}

contrib/pg_freespacemap/pg_freespacemap.sql.in

+-- Adjust this setting to control where the objects get created.
+BEGIN;
+SET search_path = public;
+
+-- Register the function.
+CREATE OR REPLACE FUNCTION pg_freespacemap()
+RETURNS SETOF RECORD
+AS 'MODULE_PATHNAME', 'pg_freespacemap'
+LANGUAGE 'C';
+
+-- Create a view for convenient access.
+CREATE VIEW pg_freespacemap AS
+	SELECT P.* FROM pg_freespacemap() AS P
+ 	(blockid int4, relfilenode oid, reltablespace oid, reldatabase oid, relblocknumber int8, blockfreebytes int4);
+ 
+-- Don't want these to be available at public.
+REVOKE ALL ON FUNCTION pg_freespacemap() FROM PUBLIC;
+REVOKE ALL ON pg_freespacemap FROM PUBLIC;
+COMMIT;

src/backend/storage/freespace/freespace.c

@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/storage/freespace/freespace.c,v 1.50 2005/10/29 00:31:51 petere Exp $
+ *	  $PostgreSQL: pgsql/src/backend/storage/freespace/freespace.c,v 1.51 2006/02/12 03:55:53 momjian Exp $
  *
  *
  * NOTES:
@@ -71,44 +71,6 @@
 #include "storage/shmem.h"
 
 
-/* Initial value for average-request moving average */
-#define INITIAL_AVERAGE ((Size) (BLCKSZ / 32))
-
-/*
- * Number of pages and bytes per allocation chunk.	Indexes can squeeze 50%
- * more pages into the same space because they don't need to remember how much
- * free space on each page.  The nominal number of pages, CHUNKPAGES, is for
- * regular rels, and INDEXCHUNKPAGES is for indexes.  CHUNKPAGES should be
- * even so that no space is wasted in the index case.
- */
-#define CHUNKPAGES	16
-#define CHUNKBYTES	(CHUNKPAGES * sizeof(FSMPageData))
-#define INDEXCHUNKPAGES ((int) (CHUNKBYTES / sizeof(IndexFSMPageData)))
-
-
-/*
- * Typedefs and macros for items in the page-storage arena.  We use the
- * existing ItemPointer and BlockId data structures, which are designed
- * to pack well (they should be 6 and 4 bytes apiece regardless of machine
- * alignment issues).  Unfortunately we can't use the ItemPointer access
- * macros, because they include Asserts insisting that ip_posid != 0.
- */
-typedef ItemPointerData FSMPageData;
-typedef BlockIdData IndexFSMPageData;
-
-#define FSMPageGetPageNum(ptr)	\
-	BlockIdGetBlockNumber(&(ptr)->ip_blkid)
-#define FSMPageGetSpace(ptr)	\
-	((Size) (ptr)->ip_posid)
-#define FSMPageSetPageNum(ptr, pg)	\
-	BlockIdSet(&(ptr)->ip_blkid, pg)
-#define FSMPageSetSpace(ptr, sz)	\
-	((ptr)->ip_posid = (OffsetNumber) (sz))
-#define IndexFSMPageGetPageNum(ptr) \
-	BlockIdGetBlockNumber(ptr)
-#define IndexFSMPageSetPageNum(ptr, pg) \
-	BlockIdSet(ptr, pg)
-
 /*----------
  * During database shutdown, we store the contents of FSM into a disk file,
  * which is re-read during startup.  This way we don't have a startup
@@ -156,63 +118,6 @@ typedef struct FsmCacheRelHeader
 	int32		storedPages;	/* # of pages stored in arena */
 } FsmCacheRelHeader;
 
-
-/*
- * Shared free-space-map objects
- *
- * The per-relation objects are indexed by a hash table, and are also members
- * of two linked lists: one ordered by recency of usage (most recent first),
- * and the other ordered by physical location of the associated storage in
- * the page-info arena.
- *
- * Each relation owns one or more chunks of per-page storage in the "arena".
- * The chunks for each relation are always consecutive, so that it can treat
- * its page storage as a simple array.	We further insist that its page data
- * be ordered by block number, so that binary search is possible.
- *
- * Note: we handle pointers to these items as pointers, not as SHMEM_OFFSETs.
- * This assumes that all processes accessing the map will have the shared
- * memory segment mapped at the same place in their address space.
- */
-typedef struct FSMHeader FSMHeader;
-typedef struct FSMRelation FSMRelation;
-
-/* Header for whole map */
-struct FSMHeader
-{
-	FSMRelation *usageList;		/* FSMRelations in usage-recency order */
-	FSMRelation *usageListTail; /* tail of usage-recency list */
-	FSMRelation *firstRel;		/* FSMRelations in arena storage order */
-	FSMRelation *lastRel;		/* tail of storage-order list */
-	int			numRels;		/* number of FSMRelations now in use */
-	double		sumRequests;	/* sum of requested chunks over all rels */
-	char	   *arena;			/* arena for page-info storage */
-	int			totalChunks;	/* total size of arena, in chunks */
-	int			usedChunks;		/* # of chunks assigned */
-	/* NB: there are totalChunks - usedChunks free chunks at end of arena */
-};
-
-/*
- * Per-relation struct --- this is an entry in the shared hash table.
- * The hash key is the RelFileNode value (hence, we look at the physical
- * relation ID, not the logical ID, which is appropriate).
- */
-struct FSMRelation
-{
-	RelFileNode key;			/* hash key (must be first) */
-	FSMRelation *nextUsage;		/* next rel in usage-recency order */
-	FSMRelation *priorUsage;	/* prior rel in usage-recency order */
-	FSMRelation *nextPhysical;	/* next rel in arena-storage order */
-	FSMRelation *priorPhysical; /* prior rel in arena-storage order */
-	bool		isIndex;		/* if true, we store only page numbers */
-	Size		avgRequest;		/* moving average of space requests */
-	int			lastPageCount;	/* pages passed to RecordRelationFreeSpace */
-	int			firstChunk;		/* chunk # of my first chunk in arena */
-	int			storedPages;	/* # of pages stored in arena */
-	int			nextPage;		/* index (from 0) to start next search at */
-};
-
-
 int			MaxFSMRelations;	/* these are set by guc.c */
 int			MaxFSMPages;
 
@@ -1838,6 +1743,17 @@ fsm_current_allocation(FSMRelation *fsmrel)
 }
 
 
+/*
+ * Return the FreeSpaceMap structure for examination.
+ */
+FSMHeader *
+GetFreeSpaceMap(void)
+{
+
+	return FreeSpaceMap;
+}
+
+
 #ifdef FREESPACE_DEBUG
 /*
  * Dump contents of freespace map for debugging.

src/include/storage/freespace.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/storage/freespace.h,v 1.18 2005/08/20 23:26:33 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/storage/freespace.h,v 1.19 2006/02/12 03:55:53 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -16,6 +16,7 @@
 
 #include "storage/block.h"
 #include "storage/relfilenode.h"
+#include "storage/itemptr.h"
 
 
 /*
@@ -28,6 +29,101 @@ typedef struct PageFreeSpaceInfo
 } PageFreeSpaceInfo;
 
 
+/* Initial value for average-request moving average */
+#define INITIAL_AVERAGE ((Size) (BLCKSZ / 32))
+
+/*
+ * Number of pages and bytes per allocation chunk.	Indexes can squeeze 50%
+ * more pages into the same space because they don't need to remember how much
+ * free space on each page.  The nominal number of pages, CHUNKPAGES, is for
+ * regular rels, and INDEXCHUNKPAGES is for indexes.  CHUNKPAGES should be
+ * even so that no space is wasted in the index case.
+ */
+#define CHUNKPAGES	16
+#define CHUNKBYTES	(CHUNKPAGES * sizeof(FSMPageData))
+#define INDEXCHUNKPAGES ((int) (CHUNKBYTES / sizeof(IndexFSMPageData)))
+
+
+/*
+ * Typedefs and macros for items in the page-storage arena.  We use the
+ * existing ItemPointer and BlockId data structures, which are designed
+ * to pack well (they should be 6 and 4 bytes apiece regardless of machine
+ * alignment issues).  Unfortunately we can't use the ItemPointer access
+ * macros, because they include Asserts insisting that ip_posid != 0.
+ */
+typedef ItemPointerData FSMPageData;
+typedef BlockIdData IndexFSMPageData;
+
+#define FSMPageGetPageNum(ptr)	\
+	BlockIdGetBlockNumber(&(ptr)->ip_blkid)
+#define FSMPageGetSpace(ptr)	\
+	((Size) (ptr)->ip_posid)
+#define FSMPageSetPageNum(ptr, pg)	\
+	BlockIdSet(&(ptr)->ip_blkid, pg)
+#define FSMPageSetSpace(ptr, sz)	\
+	((ptr)->ip_posid = (OffsetNumber) (sz))
+#define IndexFSMPageGetPageNum(ptr) \
+	BlockIdGetBlockNumber(ptr)
+#define IndexFSMPageSetPageNum(ptr, pg) \
+	BlockIdSet(ptr, pg)
+
+/*
+ * Shared free-space-map objects
+ *
+ * The per-relation objects are indexed by a hash table, and are also members
+ * of two linked lists: one ordered by recency of usage (most recent first),
+ * and the other ordered by physical location of the associated storage in
+ * the page-info arena.
+ *
+ * Each relation owns one or more chunks of per-page storage in the "arena".
+ * The chunks for each relation are always consecutive, so that it can treat
+ * its page storage as a simple array.	We further insist that its page data
+ * be ordered by block number, so that binary search is possible.
+ *
+ * Note: we handle pointers to these items as pointers, not as SHMEM_OFFSETs.
+ * This assumes that all processes accessing the map will have the shared
+ * memory segment mapped at the same place in their address space.
+ */
+typedef struct FSMHeader FSMHeader;
+typedef struct FSMRelation FSMRelation;
+
+/* Header for whole map */
+struct FSMHeader
+{
+	FSMRelation *usageList;		/* FSMRelations in usage-recency order */
+	FSMRelation *usageListTail; /* tail of usage-recency list */
+	FSMRelation *firstRel;		/* FSMRelations in arena storage order */
+	FSMRelation *lastRel;		/* tail of storage-order list */
+	int			numRels;		/* number of FSMRelations now in use */
+	double		sumRequests;	/* sum of requested chunks over all rels */
+	char	   *arena;			/* arena for page-info storage */
+	int			totalChunks;	/* total size of arena, in chunks */
+	int			usedChunks;		/* # of chunks assigned */
+	/* NB: there are totalChunks - usedChunks free chunks at end of arena */
+};
+
+/*
+ * Per-relation struct --- this is an entry in the shared hash table.
+ * The hash key is the RelFileNode value (hence, we look at the physical
+ * relation ID, not the logical ID, which is appropriate).
+ */
+struct FSMRelation
+{
+	RelFileNode key;			/* hash key (must be first) */
+	FSMRelation *nextUsage;		/* next rel in usage-recency order */
+	FSMRelation *priorUsage;	/* prior rel in usage-recency order */
+	FSMRelation *nextPhysical;	/* next rel in arena-storage order */
+	FSMRelation *priorPhysical; /* prior rel in arena-storage order */
+	bool		isIndex;		/* if true, we store only page numbers */
+	Size		avgRequest;		/* moving average of space requests */
+	int			lastPageCount;	/* pages passed to RecordRelationFreeSpace */
+	int			firstChunk;		/* chunk # of my first chunk in arena */
+	int			storedPages;	/* # of pages stored in arena */
+	int			nextPage;		/* index (from 0) to start next search at */
+};
+
+
+
 /* GUC variables */
 extern int	MaxFSMRelations;
 extern int	MaxFSMPages;
@@ -62,6 +158,7 @@ extern void PrintFreeSpaceMapStatistics(int elevel);
 
 extern void DumpFreeSpaceMap(int code, Datum arg);
 extern void LoadFreeSpaceMap(void);
+extern FSMHeader *GetFreeSpaceMap(void);
 
 #ifdef FREESPACE_DEBUG
 extern void DumpFreeSpace(void);