diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c
index e52599dc75..1b201ce829 100644
--- a/src/backend/postmaster/checkpointer.c
+++ b/src/backend/postmaster/checkpointer.c
@@ -1090,7 +1090,7 @@ ForwardSyncRequest(const FileTag *ftag, SyncRequestType type)
 		 * Count the subset of writes where backends have to do their own
 		 * fsync
 		 */
-		pgstat_increment_buffer_action(BA_Fsync);
+		pgstat_increment_buffer_action(BT_Shared, BA_Fsync);
 		LWLockRelease(CheckpointerCommLock);
 		return false;
 	}
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index ff219038e2..0aa1ba8830 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -966,7 +966,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 		/*
 		 * Extends counted here are only those that go through shared buffers
 		 */
-		pgstat_increment_buffer_action(BA_Extend);
+		pgstat_increment_buffer_action(BT_Shared, BA_Extend);
 		/* new buffers are zero-filled */
 		MemSet((char *) bufBlock, 0, BLCKSZ);
 		/* don't set checksum for all-zero page */
@@ -1215,7 +1215,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 			if (LWLockConditionalAcquire(BufferDescriptorGetContentLock(buf),
 										 LW_SHARED))
 			{
-				BufferActionType buffer_action;
+				BufferType buffer_type;
 				/*
 				 * If using a nondefault strategy, and writing the buffer
 				 * would require a WAL flush, let the strategy decide whether
@@ -1253,8 +1253,8 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 				 * only be a "regular" write of a dirty buffer.
 				 */
 
-				buffer_action = from_ring ? BA_Write_Strat : BA_Write;
-				pgstat_increment_buffer_action(buffer_action);
+				buffer_type = from_ring ? BT_Strategy : BT_Shared;
+				pgstat_increment_buffer_action(buffer_type, BA_Write);
 
 
 				/* OK, do the I/O */
@@ -2559,7 +2559,7 @@ SyncOneBuffer(int buf_id, bool skip_recently_used, WritebackContext *wb_context)
 	 * buffer is clean by the time we've locked it.)
 	 */
 
-	pgstat_increment_buffer_action(BA_Write);
+	pgstat_increment_buffer_action(BT_Shared, BA_Write);
 	PinBuffer_Locked(bufHdr);
 	LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED);
 
diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c
index 17b76e9c2c..fd95cba478 100644
--- a/src/backend/storage/buffer/freelist.c
+++ b/src/backend/storage/buffer/freelist.c
@@ -249,7 +249,7 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state, bool *from_r
 	 * the rate of buffer consumption.  Note that buffers recycled by a
 	 * strategy object are intentionally not counted here.
 	 */
-	pgstat_increment_buffer_action(BA_Alloc);
+	pgstat_increment_buffer_action(BT_Shared, BA_Alloc);
 	pg_atomic_fetch_add_u32(&StrategyControl->numBufferAllocs, 1);
 
 	/*
diff --git a/src/backend/utils/activity/backend_status.c b/src/backend/utils/activity/backend_status.c
index f8f914ac7e..a0833a733b 100644
--- a/src/backend/utils/activity/backend_status.c
+++ b/src/backend/utils/activity/backend_status.c
@@ -1057,14 +1057,14 @@ pgstat_access_backend_status_array(void)
 }
 
 void
-pgstat_increment_buffer_action(BufferActionType ba_type)
+pgstat_increment_buffer_action(BufferType buffer_type, BufferActionType buffer_action_type)
 {
 	volatile PgBackendStatus *beentry   = MyBEEntry;
 
 	if (!beentry || !pgstat_track_activities)
 		return;
 
-	switch (ba_type)
+	switch (buffer_action_type)
 	{
 		case BA_Alloc:
 			pg_atomic_write_u64(&beentry->buffer_action_stats.allocs,
@@ -1079,18 +1079,18 @@ pgstat_increment_buffer_action(BufferActionType ba_type)
 					pg_atomic_read_u64(&beentry->buffer_action_stats.fsyncs) + 1);
 			break;
 		case BA_Write:
-			pg_atomic_write_u64(&beentry->buffer_action_stats.writes,
-					pg_atomic_read_u64(&beentry->buffer_action_stats.writes) + 1);
-			break;
-		case BA_Write_Strat:
-			pg_atomic_write_u64(&beentry->buffer_action_stats.writes_strat,
-					pg_atomic_read_u64(&beentry->buffer_action_stats.writes_strat) + 1);
+			if (buffer_type == BT_Strategy)
+				pg_atomic_write_u64(&beentry->buffer_action_stats.writes_strat,
+						pg_atomic_read_u64(&beentry->buffer_action_stats.writes_strat) + 1);
+			else if (buffer_type == BT_Shared)
+				pg_atomic_write_u64(&beentry->buffer_action_stats.writes,
+						pg_atomic_read_u64(&beentry->buffer_action_stats.writes) + 1);
 			break;
 		default:
 			ereport(LOG,
 					(errmsg(
 							"Statistics on Buffer Action Type, %d, are not currently collected.",
-							ba_type)));
+							buffer_action_type)));
 	}
 
 }
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index 03d5e464a9..b6885a5d66 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -339,6 +339,15 @@ typedef enum BackendType
 	BACKEND_NUM_TYPES,
 } BackendType;
 
+typedef enum BufferType
+{
+	BT_Shared,
+	BT_Strategy,
+	BT_Local,
+	BUFFER_NUM_TYPES,
+} BufferType;
+
+// TODO: should BufferAction be BufferAccess? See BufferAccessStrategyType
 typedef enum BufferActionType
 {
 	BA_Invalid = 0,
@@ -346,7 +355,6 @@ typedef enum BufferActionType
 	BA_Extend,
 	BA_Fsync,
 	BA_Write,
-	BA_Write_Strat,
 	BUFFER_ACTION_NUM_TYPES,
 }	BufferActionType;
 
diff --git a/src/include/utils/backend_status.h b/src/include/utils/backend_status.h
index c23b74b4a6..fb1334401e 100644
--- a/src/include/utils/backend_status.h
+++ b/src/include/utils/backend_status.h
@@ -317,7 +317,7 @@ extern const char *pgstat_get_crashed_backend_activity(int pid, char *buffer,
 extern uint64 pgstat_get_my_query_id(void);
 
 extern volatile PgBackendStatus *pgstat_access_backend_status_array(void);
-extern void pgstat_increment_buffer_action(BufferActionType ba_type);
+extern void pgstat_increment_buffer_action(BufferType buffer_type, BufferActionType buffer_action_type);
 
 
 /* ----------