diff --git a/src/osd/osd_primary.cpp b/src/osd/osd_primary.cpp
index 33c9f477..e7a1cbcc 100644
--- a/src/osd/osd_primary.cpp
+++ b/src/osd/osd_primary.cpp
@@ -28,7 +28,6 @@ bool osd_t::prepare_primary_rw(osd_op_t *cur_op)
         return false;
     }
     auto & pool_cfg = pool_cfg_it->second;
-    // FIXME: op_data->pg_data_size can probably be removed (there's pg.pg_data_size)
     uint64_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
     uint64_t pg_block_size = bs_block_size * pg_data_size;
     object_id oid = {
@@ -110,12 +109,10 @@ bool osd_t::prepare_primary_rw(osd_op_t *cur_op)
     );
     void *data_buf = (uint8_t*)op_data + sizeof(osd_primary_op_data_t);
     op_data->pg_num = pg_num;
+    op_data->pg = &pg_it->second;
     op_data->oid = oid;
     op_data->stripes = (osd_rmw_stripe_t*)data_buf;
     data_buf = (uint8_t*)data_buf + sizeof(osd_rmw_stripe_t) * stripe_count;
-    op_data->scheme = pool_cfg.scheme;
-    op_data->pg_data_size = pg_data_size;
-    op_data->pg_size = pg_it->second.pg_size;
     cur_op->op_data = op_data;
     split_stripes(pg_data_size, bs_block_size, (uint32_t)(cur_op->req.rw.offset - oid.stripe), cur_op->req.rw.len, op_data->stripes);
     // Resulting bitmaps have to survive op_data and be freed with the op itself
@@ -205,11 +202,11 @@ void osd_t::continue_primary_read(osd_op_t *cur_op)
 resume_0:
     cur_op->reply.rw.bitmap_len = 0;
     {
-        auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
+        auto & pg = *op_data->pg;
         if (cur_op->req.rw.len == 0)
         {
             // len=0 => bitmap read
-            for (int role = 0; role < op_data->pg_data_size; role++)
+            for (int role = 0; role < pg.pg_data_size; role++)
             {
                 op_data->stripes[role].read_start = 0;
                 op_data->stripes[role].read_end = UINT32_MAX;
@@ -217,7 +214,7 @@ resume_0:
         }
         else
         {
-            for (int role = 0; role < op_data->pg_data_size; role++)
+            for (int role = 0; role < pg.pg_data_size; role++)
             {
                 op_data->stripes[role].read_start = op_data->stripes[role].req_start;
                 op_data->stripes[role].read_end = op_data->stripes[role].req_end;
@@ -228,29 +225,27 @@ resume_0:
         op_data->target_ver = vo_it != pg.ver_override.end() ? vo_it->second : UINT64_MAX;
         // PG may have degraded or misplaced objects
         op_data->prev_set = get_object_osd_set(pg, op_data->oid, &op_data->object_state);
-        if (pg.state == PG_ACTIVE || op_data->scheme == POOL_SCHEME_REPLICATED)
+        if (pg.state == PG_ACTIVE || pg.scheme == POOL_SCHEME_REPLICATED)
         {
             // Fast happy-path
-            if (op_data->scheme == POOL_SCHEME_REPLICATED &&
+            if (pg.scheme == POOL_SCHEME_REPLICATED &&
                 op_data->object_state && (op_data->object_state->state & OBJ_INCOMPLETE))
             {
                 finish_op(cur_op, -EIO);
                 return;
             }
-            cur_op->buf = alloc_read_buffer(op_data->stripes, op_data->pg_data_size, 0);
+            cur_op->buf = alloc_read_buffer(op_data->stripes, pg.pg_data_size, 0);
             submit_primary_subops(SUBMIT_RMW_READ, op_data->target_ver, op_data->prev_set, cur_op);
             op_data->st = 1;
         }
         else
         {
-            if (extend_missing_stripes(op_data->stripes, op_data->prev_set, op_data->pg_data_size, pg.pg_size) < 0)
+            if (extend_missing_stripes(op_data->stripes, op_data->prev_set, pg.pg_data_size, pg.pg_size) < 0)
             {
                 finish_op(cur_op, -EIO);
                 return;
             }
             // Submit reads
-            op_data->pg_size = pg.pg_size;
-            op_data->scheme = pg.scheme;
             op_data->degraded = 1;
             cur_op->buf = alloc_read_buffer(op_data->stripes, pg.pg_size, 0);
             submit_primary_subops(SUBMIT_RMW_READ, op_data->target_ver, op_data->prev_set, cur_op);
@@ -265,30 +260,29 @@ resume_2:
         if (op_data->errcode == -EIO || op_data->errcode == -EDOM)
         {
             // I/O or checksum error
-            auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
             // FIXME: ref = true ideally... because new_state != state is not necessarily true if it's freed and recreated
-            op_data->object_state = mark_object_corrupted(pg, op_data->oid, op_data->object_state, op_data->stripes, false, false);
+            op_data->object_state = mark_object_corrupted(*op_data->pg, op_data->oid, op_data->object_state, op_data->stripes, false, false);
             goto resume_0;
         }
         finish_op(cur_op, op_data->errcode);
         return;
     }
     cur_op->reply.rw.version = op_data->fact_ver;
-    cur_op->reply.rw.bitmap_len = op_data->pg_data_size * clean_entry_bitmap_size;
+    cur_op->reply.rw.bitmap_len = op_data->pg->pg_data_size * clean_entry_bitmap_size;
     if (op_data->degraded)
     {
         // Reconstruct missing stripes
         osd_rmw_stripe_t *stripes = op_data->stripes;
-        if (op_data->scheme == POOL_SCHEME_XOR)
+        if (op_data->pg->scheme == POOL_SCHEME_XOR)
         {
-            reconstruct_stripes_xor(stripes, op_data->pg_size, clean_entry_bitmap_size);
+            reconstruct_stripes_xor(stripes, op_data->pg->pg_size, clean_entry_bitmap_size);
         }
-        else if (op_data->scheme == POOL_SCHEME_EC)
+        else if (op_data->pg->scheme == POOL_SCHEME_EC)
         {
-            reconstruct_stripes_ec(stripes, op_data->pg_size, op_data->pg_data_size, clean_entry_bitmap_size);
+            reconstruct_stripes_ec(stripes, op_data->pg->pg_size, op_data->pg->pg_data_size, clean_entry_bitmap_size);
         }
         cur_op->iov.push_back(op_data->stripes[0].bmp_buf, cur_op->reply.rw.bitmap_len);
-        for (int role = 0; role < op_data->pg_size; role++)
+        for (int role = 0; role < op_data->pg->pg_size; role++)
         {
             if (stripes[role].req_end != 0)
             {
@@ -695,7 +689,7 @@ void osd_t::continue_primary_del(osd_op_t *cur_op)
         return;
     }
     osd_primary_op_data_t *op_data = cur_op->op_data;
-    auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
+    auto & pg = *op_data->pg;
     if (op_data->st == 1)      goto resume_1;
     else if (op_data->st == 2) goto resume_2;
     else if (op_data->st == 3) goto resume_3;
diff --git a/src/osd/osd_primary.h b/src/osd/osd_primary.h
index ae8b7c48..a8600be1 100644
--- a/src/osd/osd_primary.h
+++ b/src/osd/osd_primary.h
@@ -20,14 +20,14 @@ struct unstable_osd_num_t
 struct osd_primary_op_data_t
 {
     int st = 0;
-    pg_num_t pg_num;
-    object_id oid;
-    uint64_t target_ver;
+    pg_num_t pg_num = 0;
+    object_id oid = {};
+    uint64_t target_ver = 0;
     uint64_t orig_ver = 0, fact_ver = 0;
-    uint64_t scheme = 0;
     int n_subops = 0, done = 0, errors = 0, drops = 0, errcode = 0;
-    int degraded = 0, pg_size, pg_data_size;
-    osd_rmw_stripe_t *stripes;
+    int degraded = 0;
+    osd_rmw_stripe_t *stripes = NULL;
+    pg_t *pg = NULL;
     osd_op_t *subops = NULL;
     uint64_t *prev_set = NULL;
     pg_osd_set_state_t *object_state = NULL;
diff --git a/src/osd/osd_primary_chain.cpp b/src/osd/osd_primary_chain.cpp
index 37d58ec4..4f826798 100644
--- a/src/osd/osd_primary_chain.cpp
+++ b/src/osd/osd_primary_chain.cpp
@@ -7,7 +7,7 @@
 void osd_t::continue_chained_read(osd_op_t *cur_op)
 {
     osd_primary_op_data_t *op_data = cur_op->op_data;
-    auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
+    auto & pg = *op_data->pg;
     if (op_data->st == 1)
         goto resume_1;
     else if (op_data->st == 2)
@@ -17,7 +17,7 @@ void osd_t::continue_chained_read(osd_op_t *cur_op)
     else if (op_data->st == 4)
         goto resume_4;
     cur_op->reply.rw.bitmap_len = 0;
-    for (int role = 0; role < op_data->pg_data_size; role++)
+    for (int role = 0; role < pg.pg_data_size; role++)
     {
         op_data->stripes[role].read_start = op_data->stripes[role].req_start;
         op_data->stripes[role].read_end = op_data->stripes[role].req_end;
@@ -329,7 +329,7 @@ std::vector<osd_chain_read_t> osd_t::collect_chained_read_requests(osd_op_t *cur
 {
     osd_primary_op_data_t *op_data = cur_op->op_data;
     std::vector<osd_chain_read_t> chain_reads;
-    int stripe_count = (op_data->scheme == POOL_SCHEME_REPLICATED ? 1 : op_data->pg_size);
+    int stripe_count = (op_data->pg->scheme == POOL_SCHEME_REPLICATED ? 1 : op_data->pg->pg_size);
     memset(op_data->stripes[0].bmp_buf, 0, stripe_count * clean_entry_bitmap_size);
     uint8_t *global_bitmap = (uint8_t*)op_data->stripes[0].bmp_buf;
     // We always use at most 1 read request per layer
@@ -337,7 +337,7 @@ std::vector<osd_chain_read_t> osd_t::collect_chained_read_requests(osd_op_t *cur
     {
         uint8_t *part_bitmap = ((uint8_t*)op_data->snapshot_bitmaps) + chain_pos*stripe_count*clean_entry_bitmap_size;
         int start = !cur_op->req.rw.len ? 0 : (cur_op->req.rw.offset - op_data->oid.stripe)/bs_bitmap_granularity;
-        int end = !cur_op->req.rw.len ? op_data->pg_data_size*clean_entry_bitmap_size*8 : start + cur_op->req.rw.len/bs_bitmap_granularity;
+        int end = !cur_op->req.rw.len ? op_data->pg->pg_data_size*clean_entry_bitmap_size*8 : start + cur_op->req.rw.len/bs_bitmap_granularity;
         // Skip unneeded part in the beginning
         while (start < end && (
             ((global_bitmap[start>>3] >> (start&7)) & 1) ||
@@ -410,11 +410,11 @@ int osd_t::submit_chained_read_requests(pg_t & pg, osd_op_t *cur_op)
         // FIXME: maybe introduce split_read_stripes to shorten these lines and to remove read_start=req_start
         osd_rmw_stripe_t *stripes = chain_stripes + chain_reads[cri].chain_pos*stripe_count;
         split_stripes(pg.pg_data_size, bs_block_size, chain_reads[cri].offset, chain_reads[cri].len, stripes);
-        if (op_data->scheme == POOL_SCHEME_REPLICATED && !stripes[0].req_end)
+        if (pg.scheme == POOL_SCHEME_REPLICATED && !stripes[0].req_end)
         {
             continue;
         }
-        for (int role = 0; role < op_data->pg_data_size; role++)
+        for (int role = 0; role < pg.pg_data_size; role++)
         {
             stripes[role].read_start = stripes[role].req_start;
             stripes[role].read_end = stripes[role].req_end;
@@ -423,7 +423,7 @@ int osd_t::submit_chained_read_requests(pg_t & pg, osd_op_t *cur_op)
         if (pg.state != PG_ACTIVE)
         {
             cur_set = get_object_osd_set(pg, cur_oid, &op_data->chain_states[chain_reads[cri].chain_pos]);
-            if (op_data->scheme != POOL_SCHEME_REPLICATED)
+            if (pg.scheme != POOL_SCHEME_REPLICATED)
             {
                 if (extend_missing_stripes(stripes, cur_set, pg.pg_data_size, pg.pg_size) < 0)
                 {
@@ -446,7 +446,7 @@ int osd_t::submit_chained_read_requests(pg_t & pg, osd_op_t *cur_op)
                 }
             }
         }
-        if (op_data->scheme == POOL_SCHEME_REPLICATED)
+        if (pg.scheme == POOL_SCHEME_REPLICATED)
         {
             n_subops++;
             read_buffer_size += stripes[0].read_end - stripes[0].read_start;
@@ -491,7 +491,7 @@ int osd_t::submit_chained_read_requests(pg_t & pg, osd_op_t *cur_op)
     for (int cri = 0; cri < chain_reads.size(); cri++)
     {
         osd_rmw_stripe_t *stripes = chain_stripes + chain_reads[cri].chain_pos*stripe_count;
-        if (op_data->scheme == POOL_SCHEME_REPLICATED && !stripes[0].req_end)
+        if (pg.scheme == POOL_SCHEME_REPLICATED && !stripes[0].req_end)
         {
             continue;
         }
@@ -501,9 +501,9 @@ int osd_t::submit_chained_read_requests(pg_t & pg, osd_op_t *cur_op)
         auto cur_state = op_data->chain_states[chain_reads[cri].chain_pos];
         uint64_t *cur_set = (pg.state != PG_ACTIVE && cur_state ? cur_state->read_target.data() : pg.cur_set.data());
         int zero_read = -1;
-        if (op_data->scheme == POOL_SCHEME_REPLICATED)
+        if (pg.scheme == POOL_SCHEME_REPLICATED)
         {
-            for (int role = 0; role < op_data->pg_size; role++)
+            for (int role = 0; role < pg.pg_size; role++)
                 if (cur_set[role] == this->osd_num || zero_read == -1)
                     zero_read = role;
         }
@@ -555,18 +555,18 @@ void osd_t::send_chained_read_results(pg_t & pg, osd_op_t *cur_op)
         {
             // Reconstruct missing stripes
             osd_rmw_stripe_t *stripes = chain_stripes + op_data->chain_reads[cri].chain_pos*stripe_count;
-            if (op_data->scheme == POOL_SCHEME_XOR)
+            if (pg.scheme == POOL_SCHEME_XOR)
             {
                 reconstruct_stripes_xor(stripes, pg.pg_size, clean_entry_bitmap_size);
             }
-            else if (op_data->scheme == POOL_SCHEME_EC)
+            else if (pg.scheme == POOL_SCHEME_EC)
             {
                 reconstruct_stripes_ec(stripes, pg.pg_size, pg.pg_data_size, clean_entry_bitmap_size);
             }
         }
     }
     // Send bitmap
-    cur_op->reply.rw.bitmap_len = op_data->pg_data_size * clean_entry_bitmap_size;
+    cur_op->reply.rw.bitmap_len = pg.pg_data_size * clean_entry_bitmap_size;
     cur_op->iov.push_back(op_data->stripes[0].bmp_buf, cur_op->reply.rw.bitmap_len);
     // And finally compose the result
     uint64_t sent = 0;
diff --git a/src/osd/osd_primary_subops.cpp b/src/osd/osd_primary_subops.cpp
index a397bd61..dfec8669 100644
--- a/src/osd/osd_primary_subops.cpp
+++ b/src/osd/osd_primary_subops.cpp
@@ -67,7 +67,7 @@ void osd_t::finish_op(osd_op_t *cur_op, int retval)
         if (cur_op->req.hdr.opcode == OSD_OP_DELETE)
         {
             if (cur_op->op_data)
-                inode_stats[cur_op->req.rw.inode].op_bytes[inode_st_op] += cur_op->op_data->pg_data_size * bs_block_size;
+                inode_stats[cur_op->req.rw.inode].op_bytes[inode_st_op] += cur_op->op_data->pg->pg_data_size * bs_block_size;
         }
         else
             inode_stats[cur_op->req.rw.inode].op_bytes[inode_st_op] += cur_op->req.rw.len;
@@ -76,7 +76,7 @@ void osd_t::finish_op(osd_op_t *cur_op, int retval)
     {
         if (cur_op->op_data->pg_num > 0)
         {
-            auto & pg = pgs.at({ .pool_id = INODE_POOL(cur_op->op_data->oid.inode), .pg_num = cur_op->op_data->pg_num });
+            auto & pg = *cur_op->op_data->pg;
             pg.inflight--;
             assert(pg.inflight >= 0);
             if ((pg.state & PG_STOPPING) && pg.inflight == 0 && !pg.flush_batch)
@@ -126,10 +126,10 @@ void osd_t::submit_primary_subops(int submit_type, uint64_t op_version, const ui
     bool wr = submit_type == SUBMIT_WRITE;
     osd_primary_op_data_t *op_data = cur_op->op_data;
     osd_rmw_stripe_t *stripes = op_data->stripes;
-    bool rep = op_data->scheme == POOL_SCHEME_REPLICATED;
+    bool rep = op_data->pg->scheme == POOL_SCHEME_REPLICATED;
     // Allocate subops
     int n_subops = 0, zero_read = -1;
-    for (int role = 0; role < op_data->pg_size; role++)
+    for (int role = 0; role < op_data->pg->pg_size; role++)
     {
         if (osd_set[role] == this->osd_num || osd_set[role] != 0 && zero_read == -1)
             zero_read = role;
@@ -154,9 +154,9 @@ int osd_t::submit_primary_subop_batch(int submit_type, inode_t inode, uint64_t o
 {
     bool wr = submit_type == SUBMIT_WRITE;
     osd_primary_op_data_t *op_data = cur_op->op_data;
-    bool rep = op_data->scheme == POOL_SCHEME_REPLICATED;
+    bool rep = op_data->pg->scheme == POOL_SCHEME_REPLICATED;
     int i = subop_idx;
-    for (int role = 0; role < op_data->pg_size; role++)
+    for (int role = 0; role < op_data->pg->pg_size; role++)
     {
         // We always submit zero-length writes to all replicas, even if the stripe is not modified
         if (!(wr || !rep && stripes[role].read_end != 0 || zero_read == role || submit_type == SUBMIT_SCRUB_READ))
@@ -526,7 +526,7 @@ bool contains_osd(osd_num_t *osd_set, uint64_t size, osd_num_t osd_num)
 void osd_t::submit_primary_del_subops(osd_op_t *cur_op, osd_num_t *cur_set, uint64_t set_size, pg_osd_set_t & loc_set)
 {
     osd_primary_op_data_t *op_data = cur_op->op_data;
-    bool rep = op_data->scheme == POOL_SCHEME_REPLICATED;
+    bool rep = op_data->pg->scheme == POOL_SCHEME_REPLICATED;
     obj_ver_osd_t extra_chunks[loc_set.size()];
     int chunks_to_del = 0;
     for (auto & chunk: loc_set)
@@ -738,10 +738,10 @@ void osd_t::submit_primary_rollback_subops(osd_op_t *cur_op, const uint64_t* osd
 {
     osd_primary_op_data_t *op_data = cur_op->op_data;
     osd_rmw_stripe_t *stripes = op_data->stripes;
-    assert(op_data->scheme != POOL_SCHEME_REPLICATED);
+    assert(op_data->pg->scheme != POOL_SCHEME_REPLICATED);
     // Allocate subops
     int n_subops = 0;
-    for (int role = 0; role < op_data->pg_size; role++)
+    for (int role = 0; role < op_data->pg->pg_size; role++)
     {
         if (osd_set[role] != 0 && !stripes[role].read_error &&
             (osd_set[role] == this->osd_num || msgr.osd_peer_fds.find(osd_set[role]) != msgr.osd_peer_fds.end()))
@@ -758,7 +758,7 @@ void osd_t::submit_primary_rollback_subops(osd_op_t *cur_op, const uint64_t* osd
     op_data->subops = new osd_op_t[n_subops];
     op_data->unstable_writes = new obj_ver_id[n_subops];
     int i = 0;
-    for (int role = 0; role < op_data->pg_size; role++)
+    for (int role = 0; role < op_data->pg->pg_size; role++)
     {
         if (osd_set[role] != 0 && !stripes[role].read_error &&
             (osd_set[role] == this->osd_num || msgr.osd_peer_fds.find(osd_set[role]) != msgr.osd_peer_fds.end()))
diff --git a/src/osd/osd_primary_write.cpp b/src/osd/osd_primary_write.cpp
index 6f0ca25e..ab54cdfe 100644
--- a/src/osd/osd_primary_write.cpp
+++ b/src/osd/osd_primary_write.cpp
@@ -44,7 +44,7 @@ void osd_t::continue_primary_write(osd_op_t *cur_op)
         return;
     }
     osd_primary_op_data_t *op_data = cur_op->op_data;
-    auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
+    auto & pg = *cur_op->op_data->pg;
     if (op_data->st == 1)      goto resume_1;
     else if (op_data->st == 2) goto resume_2;
     else if (op_data->st == 3) goto resume_3;
@@ -73,7 +73,7 @@ resume_1:
         op_data->object_state->ref_count++;
     }
 retry_1:
-    if (op_data->scheme == POOL_SCHEME_REPLICATED)
+    if (pg.scheme == POOL_SCHEME_REPLICATED)
     {
         // Simplified algorithm
         op_data->stripes[0].write_start = op_data->stripes[0].req_start;
@@ -99,7 +99,7 @@ retry_1:
     {
         assert(!cur_op->rmw_buf);
         cur_op->rmw_buf = calc_rmw(cur_op->buf, op_data->stripes, op_data->prev_set,
-            pg.pg_size, op_data->pg_data_size, pg.pg_cursize, pg.cur_set.data(), bs_block_size, clean_entry_bitmap_size);
+            pg.pg_size, pg.pg_data_size, pg.pg_cursize, pg.cur_set.data(), bs_block_size, clean_entry_bitmap_size);
         if (!cur_op->rmw_buf)
         {
             // Refuse partial overwrite of an incomplete object
@@ -114,7 +114,7 @@ retry_1:
             // Allow to read version number (just version number!) from corrupted chunks
             // to allow full overwrite of a corrupted object
             bool found = false;
-            for (int role = 0; role < op_data->pg_size; role++)
+            for (int role = 0; role < pg.pg_size; role++)
             {
                 if (op_data->prev_set[role] != 0 || op_data->stripes[role].read_end > op_data->stripes[role].read_start)
                 {
@@ -124,8 +124,8 @@ retry_1:
             }
             if (!found)
             {
-                osd_num_t corrupted_target[op_data->pg_size];
-                for (int role = 0; role < op_data->pg_size; role++)
+                osd_num_t corrupted_target[pg.pg_size];
+                for (int role = 0; role < pg.pg_size; role++)
                 {
                     corrupted_target[role] = 0;
                 }
@@ -172,7 +172,7 @@ resume_3:
         cur_op->reply.rw.version = op_data->fact_ver;
         goto continue_others;
     }
-    if (op_data->scheme == POOL_SCHEME_REPLICATED)
+    if (pg.scheme == POOL_SCHEME_REPLICATED)
     {
         // Set bitmap bits
         bitmap_set(op_data->stripes[0].bmp_buf, op_data->stripes[0].write_start,
@@ -203,7 +203,7 @@ resume_3:
         }
         else if (pg.scheme == POOL_SCHEME_EC)
         {
-            calc_rmw_parity_ec(op_data->stripes, pg.pg_size, op_data->pg_data_size, op_data->prev_set, pg.cur_set.data(), bs_block_size, clean_entry_bitmap_size);
+            calc_rmw_parity_ec(op_data->stripes, pg.pg_size, pg.pg_data_size, op_data->prev_set, pg.cur_set.data(), bs_block_size, clean_entry_bitmap_size);
         }
     }
     // Send writes
@@ -269,7 +269,7 @@ resume_5:
         // and rollback successful part updates in case of EC.
         if (op_data->done > 0 && !op_data->drops)
         {
-            if (op_data->scheme != POOL_SCHEME_REPLICATED)
+            if (pg.scheme != POOL_SCHEME_REPLICATED)
             {
                 submit_primary_rollback_subops(cur_op, pg.cur_set.data());
 resume_11:
@@ -293,7 +293,7 @@ resume_12:
         pg_cancel_write_queue(pg, cur_op, op_data->oid, op_data->errcode);
         return;
     }
-    if (op_data->scheme != POOL_SCHEME_REPLICATED)
+    if (pg.scheme != POOL_SCHEME_REPLICATED)
     {
         // Remove version override just after the write, but before stabilizing
         pg.ver_override.erase(op_data->oid);
@@ -329,7 +329,7 @@ resume_7:
                 memset(&recovery_stat[recovery_type], 0, sizeof(recovery_stat[recovery_type]));
                 recovery_stat[recovery_type].count++;
             }
-            for (int role = 0; role < (op_data->scheme == POOL_SCHEME_REPLICATED ? 1 : pg.pg_size); role++)
+            for (int role = 0; role < (pg.scheme == POOL_SCHEME_REPLICATED ? 1 : pg.pg_size); role++)
             {
                 recovery_stat[recovery_type].bytes += op_data->stripes[role].write_end - op_data->stripes[role].write_start;
             }
@@ -353,7 +353,7 @@ resume_7:
             for (auto & chunk: op_data->object_state->osd_set)
             {
                 // Check is the same as in submit_primary_del_subops()
-                if (op_data->scheme == POOL_SCHEME_REPLICATED
+                if (pg.scheme == POOL_SCHEME_REPLICATED
                     ? !contains_osd(pg.cur_set.data(), pg.pg_size, chunk.osd_num)
                     : (chunk.osd_num != pg.cur_set[chunk.role]))
                 {
@@ -361,7 +361,7 @@ resume_7:
                         .osd_num = chunk.osd_num,
                         .oid = {
                             .inode = op_data->oid.inode,
-                            .stripe = op_data->oid.stripe | (op_data->scheme == POOL_SCHEME_REPLICATED ? 0 : chunk.role),
+                            .stripe = op_data->oid.stripe | (pg.scheme == POOL_SCHEME_REPLICATED ? 0 : chunk.role),
                         },
                         .version = op_data->fact_ver,
                     });
@@ -472,7 +472,7 @@ bool osd_t::remember_unstable_write(osd_op_t *cur_op, pg_t & pg, pg_osd_set_t &
     if (immediate_commit == IMMEDIATE_ALL)
     {
 immediate:
-        if (op_data->scheme != POOL_SCHEME_REPLICATED)
+        if (pg.scheme != POOL_SCHEME_REPLICATED)
         {
             // Send STABILIZE ops immediately
             op_data->unstable_write_osds = new std::vector<unstable_osd_num_t>();
@@ -515,7 +515,7 @@ resume_7:
     }
     else if (immediate_commit == IMMEDIATE_SMALL)
     {
-        int stripe_count = (op_data->scheme == POOL_SCHEME_REPLICATED ? 1 : op_data->pg_size);
+        int stripe_count = (pg.scheme == POOL_SCHEME_REPLICATED ? 1 : pg.pg_size);
         for (int role = 0; role < stripe_count; role++)
         {
             if (op_data->stripes[role].write_start == 0 &&
@@ -531,7 +531,7 @@ resume_7:
     {
 lazy:
         unstable_write_count++;
-        if (op_data->scheme != POOL_SCHEME_REPLICATED)
+        if (pg.scheme != POOL_SCHEME_REPLICATED)
         {
             // Remember version as unstable for EC/XOR
             for (auto & chunk: loc_set)
diff --git a/src/osd/osd_scrub.cpp b/src/osd/osd_scrub.cpp
index cbf3d6ad..0460c9c3 100644
--- a/src/osd/osd_scrub.cpp
+++ b/src/osd/osd_scrub.cpp
@@ -379,7 +379,7 @@ void osd_t::continue_primary_scrub(osd_op_t *cur_op)
     else if (op_data->st == 2)
         goto resume_2;
     {
-        auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
+        auto & pg = *cur_op->op_data->pg;
         cur_op->req.rw.len = bs_block_size * pg.pg_data_size;
         // Determine version
         auto vo_it = pg.ver_override.find(op_data->oid);
@@ -389,7 +389,7 @@ void osd_t::continue_primary_scrub(osd_op_t *cur_op)
         // Read all available chunks
         int n_copies = 0;
         op_data->degraded = false;
-        for (int role = 0; role < op_data->pg_size; role++)
+        for (int role = 0; role < pg.pg_size; role++)
         {
             op_data->stripes[role].write_buf = NULL;
             op_data->stripes[role].read_start = 0;
@@ -401,19 +401,19 @@ void osd_t::continue_primary_scrub(osd_op_t *cur_op)
             else
             {
                 op_data->stripes[role].missing = true;
-                if (op_data->scheme != POOL_SCHEME_REPLICATED && role < op_data->pg_data_size)
+                if (pg.scheme != POOL_SCHEME_REPLICATED && role < pg.pg_data_size)
                 {
                     op_data->degraded = true;
                 }
             }
         }
-        if (n_copies <= op_data->pg_data_size)
+        if (n_copies <= pg.pg_data_size)
         {
             // Nothing to compare, even if we'd like to
             finish_op(cur_op, 0);
             return;
         }
-        cur_op->buf = alloc_read_buffer(op_data->stripes, op_data->pg_size, 0);
+        cur_op->buf = alloc_read_buffer(op_data->stripes, pg.pg_size, 0);
         // Submit reads
         osd_op_t *subops = new osd_op_t[n_copies];
         op_data->fact_ver = 0;
@@ -434,12 +434,12 @@ resume_2:
         {
             // I/O or checksum error
             int n_copies = 0;
-            for (int role = 0; role < op_data->pg_size; role++)
+            for (int role = 0; role < op_data->pg->pg_size; role++)
             {
                 if (op_data->stripes[role].read_error)
                 {
                     op_data->stripes[role].missing = true;
-                    if (op_data->scheme != POOL_SCHEME_REPLICATED && role < op_data->pg_data_size)
+                    if (op_data->pg->scheme != POOL_SCHEME_REPLICATED && role < op_data->pg->pg_data_size)
                     {
                         op_data->degraded = true;
                     }
@@ -449,14 +449,13 @@ resume_2:
                     n_copies++;
                 }
             }
-            if (n_copies <= op_data->pg_data_size)
+            if (n_copies <= op_data->pg->pg_data_size)
             {
                 // Nothing to compare, just mark the object as corrupted
-                auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
                 // FIXME: ref = true ideally... because new_state != state is not necessarily true if it's freed and recreated
-                op_data->object_state = mark_object_corrupted(pg, op_data->oid, op_data->object_state, op_data->stripes, false, false);
+                op_data->object_state = mark_object_corrupted(*op_data->pg, op_data->oid, op_data->object_state, op_data->stripes, false, false);
                 // Operation is treated as unsuccessful only if the object becomes unreadable
-                finish_op(cur_op, n_copies < op_data->pg_data_size ? op_data->errcode : 0);
+                finish_op(cur_op, n_copies < op_data->pg->pg_data_size ? op_data->errcode : 0);
                 return;
             }
             // Proceed, we can still compare chunks that were successfully read
@@ -468,12 +467,12 @@ resume_2:
         }
     }
     bool inconsistent = false;
-    if (op_data->scheme == POOL_SCHEME_REPLICATED)
+    if (op_data->pg->scheme == POOL_SCHEME_REPLICATED)
     {
         // Check that all chunks have returned the same data
         int total = 0;
-        int eq_to[op_data->pg_size];
-        for (int role = 0; role < op_data->pg_size; role++)
+        int eq_to[op_data->pg->pg_size];
+        for (int role = 0; role < op_data->pg->pg_size; role++)
         {
             eq_to[role] = -1;
             if (op_data->stripes[role].read_end != 0 && !op_data->stripes[role].missing &&
@@ -492,16 +491,16 @@ resume_2:
                 }
             }
         }
-        int votes[op_data->pg_size];
-        for (int role = 0; role < op_data->pg_size; role++)
+        int votes[op_data->pg->pg_size];
+        for (int role = 0; role < op_data->pg->pg_size; role++)
             votes[role] = 0;
-        for (int role = 0; role < op_data->pg_size; role++)
+        for (int role = 0; role < op_data->pg->pg_size; role++)
         {
             if (eq_to[role] != -1)
                 votes[eq_to[role]]++;
         }
         int best = -1;
-        for (int role = 0; role < op_data->pg_size; role++)
+        for (int role = 0; role < op_data->pg->pg_size; role++)
         {
             if (votes[role] > (best >= 0 ? votes[best] : 0))
                 best = role;
@@ -509,7 +508,7 @@ resume_2:
         if (best >= 0 && votes[best] < total)
         {
             bool unknown = false;
-            for (int role = 0; role < op_data->pg_size; role++)
+            for (int role = 0; role < op_data->pg->pg_size; role++)
             {
                 if (role != best && votes[role] == votes[best])
                 {
@@ -550,9 +549,9 @@ resume_2:
     }
     else
     {
-        assert(op_data->scheme == POOL_SCHEME_EC || op_data->scheme == POOL_SCHEME_XOR);
+        assert(op_data->pg->scheme == POOL_SCHEME_EC || op_data->pg->scheme == POOL_SCHEME_XOR);
         auto good_subset = ec_find_good(
-            op_data->stripes, op_data->pg_size, op_data->pg_data_size, op_data->scheme == POOL_SCHEME_XOR,
+            op_data->stripes, op_data->pg->pg_size, op_data->pg->pg_data_size, op_data->pg->scheme == POOL_SCHEME_XOR,
             bs_block_size, clean_entry_bitmap_size, scrub_ec_max_bruteforce
         );
         if (!good_subset.size())
@@ -567,7 +566,7 @@ resume_2:
         else
         {
             int total = 0;
-            for (int role = 0; role < op_data->pg_size; role++)
+            for (int role = 0; role < op_data->pg->pg_size; role++)
             {
                 if (!op_data->stripes[role].missing)
                 {
@@ -579,7 +578,7 @@ resume_2:
             {
                 op_data->stripes[role].read_error = false;
             }
-            for (int role = 0; role < op_data->pg_size; role++)
+            for (int role = 0; role < op_data->pg->pg_size; role++)
             {
                 if (!op_data->stripes[role].missing && op_data->stripes[role].read_error)
                 {
@@ -600,7 +599,7 @@ resume_2:
                     INODE_POOL(op_data->oid.inode), op_data->pg_num,
                     op_data->oid.inode, op_data->oid.stripe, op_data->fact_ver
                 );
-                for (int role = 0; role < op_data->pg_size; role++)
+                for (int role = 0; role < op_data->pg->pg_size; role++)
                 {
                     if (!op_data->stripes[role].missing && op_data->stripes[role].read_error)
                     {
@@ -611,16 +610,15 @@ resume_2:
             }
         }
     }
-    for (int role = 0; role < op_data->pg_size; role++)
+    for (int role = 0; role < op_data->pg->pg_size; role++)
     {
         if (op_data->stripes[role].osd_num != 0 &&
             (op_data->stripes[role].read_error || op_data->stripes[role].not_exists) ||
             inconsistent)
         {
             // Got at least 1 read error or mismatch, mark the object as corrupted
-            auto & pg = pgs.at({ .pool_id = INODE_POOL(op_data->oid.inode), .pg_num = op_data->pg_num });
             // FIXME: ref = true ideally... because new_state != state is not necessarily true if it's freed and recreated
-            op_data->object_state = mark_object_corrupted(pg, op_data->oid, op_data->object_state, op_data->stripes, false, inconsistent);
+            op_data->object_state = mark_object_corrupted(*op_data->pg, op_data->oid, op_data->object_state, op_data->stripes, false, inconsistent);
             break;
         }
     }