diff --git a/src/gallium/drivers/zink/zink_bo.c b/src/gallium/drivers/zink/zink_bo.c
index 10099d31d97..6829bce59e5 100644
--- a/src/gallium/drivers/zink/zink_bo.c
+++ b/src/gallium/drivers/zink/zink_bo.c
@@ -131,7 +131,7 @@ bo_destroy(struct zink_screen *screen, struct zink_bo *bo)
 }
 
 static bool
-bo_can_reclaim(struct zink_screen *screen, struct pb_buffer *pbuf)
+bo_can_reclaim(struct zink_screen *screen, struct pb_buffer_lean *pbuf)
 {
    struct zink_bo *bo = zink_bo(pbuf);
 
@@ -150,7 +150,7 @@ static void
 bo_slab_free(struct zink_screen *screen, struct pb_slab *pslab)
 {
    struct zink_slab *slab = zink_slab(pslab);
-   ASSERTED unsigned slab_size = slab->buffer->base.base.size;
+   ASSERTED unsigned slab_size = slab->buffer->base.size;
 
    assert(slab->base.num_entries * slab->base.entry_size <= slab_size);
    FREE(slab->entries);
@@ -273,7 +273,7 @@ bo_create_internal(struct zink_screen *screen,
 
    if (init_pb_cache) {
       bo->u.real.use_reusable_pool = true;
-      pb_cache_init_entry(&screen->pb.bo_cache, bo->cache_entry, &bo->base.base, mem_type_idx);
+      pb_cache_init_entry(&screen->pb.bo_cache, bo->cache_entry, &bo->base, mem_type_idx);
    } else {
 #ifdef ZINK_USE_DMABUF
       list_inithead(&bo->u.real.exports);
@@ -283,12 +283,12 @@ bo_create_internal(struct zink_screen *screen,
 
 
    simple_mtx_init(&bo->lock, mtx_plain);
-   pipe_reference_init(&bo->base.base.reference, 1);
-   bo->base.base.alignment_log2 = util_logbase2(alignment);
-   bo->base.base.size = mai.allocationSize;
+   pipe_reference_init(&bo->base.reference, 1);
+   bo->base.alignment_log2 = util_logbase2(alignment);
+   bo->base.size = mai.allocationSize;
    bo->type = ZINK_BO_REAL;
-   bo->base.base.placement = mem_type_idx;
-   bo->base.base.usage = flags;
+   bo->base.placement = mem_type_idx;
+   bo->base.usage = flags;
    bo->unique_id = p_atomic_inc_return(&screen->pb.next_bo_unique_id);
 
    return bo;
@@ -330,7 +330,7 @@ sparse_backing_alloc(struct zink_screen *screen, struct zink_bo *bo,
 
    /* Allocate a new backing buffer if necessary. */
    if (!best_backing) {
-      struct pb_buffer *buf;
+      struct pb_buffer_lean *buf;
       uint64_t size;
       uint32_t pages;
 
@@ -346,11 +346,11 @@ sparse_backing_alloc(struct zink_screen *screen, struct zink_bo *bo,
          return NULL;
       }
 
-      assert(bo->u.sparse.num_backing_pages < DIV_ROUND_UP(bo->base.base.size, ZINK_SPARSE_BUFFER_PAGE_SIZE));
+      assert(bo->u.sparse.num_backing_pages < DIV_ROUND_UP(bo->base.size, ZINK_SPARSE_BUFFER_PAGE_SIZE));
 
-      size = MIN3(bo->base.base.size / 16,
+      size = MIN3(bo->base.size / 16,
                   8 * 1024 * 1024,
-                  bo->base.base.size - (uint64_t)bo->u.sparse.num_backing_pages * ZINK_SPARSE_BUFFER_PAGE_SIZE);
+                  bo->base.size - (uint64_t)bo->u.sparse.num_backing_pages * ZINK_SPARSE_BUFFER_PAGE_SIZE);
       size = MAX2(size, ZINK_SPARSE_BUFFER_PAGE_SIZE);
 
       buf = zink_bo_create(screen, size, ZINK_SPARSE_BUFFER_PAGE_SIZE,
@@ -362,7 +362,7 @@ sparse_backing_alloc(struct zink_screen *screen, struct zink_bo *bo,
       }
 
       /* We might have gotten a bigger buffer than requested via caching. */
-      pages = buf->base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
+      pages = buf->size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
 
       best_backing->bo = zink_bo(buf);
       best_backing->num_chunks = 1;
@@ -393,7 +393,7 @@ static void
 sparse_free_backing_buffer(struct zink_screen *screen, struct zink_bo *bo,
                            struct zink_sparse_backing *backing)
 {
-   bo->u.sparse.num_backing_pages -= backing->bo->base.base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
+   bo->u.sparse.num_backing_pages -= backing->bo->base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
 
    list_del(&backing->list);
    zink_bo_unref(screen, backing->bo);
@@ -460,7 +460,7 @@ sparse_backing_free(struct zink_screen *screen, struct zink_bo *bo,
    }
 
    if (backing->num_chunks == 1 && backing->chunks[0].begin == 0 &&
-       backing->chunks[0].end == backing->bo->base.base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE)
+       backing->chunks[0].end == backing->bo->base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE)
       sparse_free_backing_buffer(screen, bo, backing);
 
    return true;
@@ -469,7 +469,7 @@ sparse_backing_free(struct zink_screen *screen, struct zink_bo *bo,
 static void
 bo_sparse_destroy(struct zink_screen *screen, struct zink_bo *bo)
 {
-   assert(!bo->mem && bo->base.base.usage & ZINK_ALLOC_SPARSE);
+   assert(!bo->mem && bo->base.usage & ZINK_ALLOC_SPARSE);
 
    while (!list_is_empty(&bo->u.sparse.backing)) {
       sparse_free_backing_buffer(screen, bo,
@@ -482,7 +482,7 @@ bo_sparse_destroy(struct zink_screen *screen, struct zink_bo *bo)
    FREE(bo);
 }
 
-static struct pb_buffer *
+static struct pb_buffer_lean *
 bo_sparse_create(struct zink_screen *screen, uint64_t size)
 {
    struct zink_bo *bo;
@@ -499,15 +499,15 @@ bo_sparse_create(struct zink_screen *screen, uint64_t size)
       return NULL;
 
    simple_mtx_init(&bo->lock, mtx_plain);
-   pipe_reference_init(&bo->base.base.reference, 1);
-   bo->base.base.alignment_log2 = util_logbase2(ZINK_SPARSE_BUFFER_PAGE_SIZE);
-   bo->base.base.size = size;
+   pipe_reference_init(&bo->base.reference, 1);
+   bo->base.alignment_log2 = util_logbase2(ZINK_SPARSE_BUFFER_PAGE_SIZE);
+   bo->base.size = size;
    bo->type = ZINK_BO_SPARSE;
    unsigned placement = zink_mem_type_idx_from_types(screen, ZINK_HEAP_DEVICE_LOCAL_SPARSE, UINT32_MAX);
    assert(placement != UINT32_MAX);
-   bo->base.base.placement = placement;
+   bo->base.placement = placement;
    bo->unique_id = p_atomic_inc_return(&screen->pb.next_bo_unique_id);
-   bo->base.base.usage = ZINK_ALLOC_SPARSE;
+   bo->base.usage = ZINK_ALLOC_SPARSE;
 
    bo->u.sparse.num_va_pages = DIV_ROUND_UP(size, ZINK_SPARSE_BUFFER_PAGE_SIZE);
    bo->u.sparse.commitments = CALLOC(bo->u.sparse.num_va_pages,
@@ -525,7 +525,7 @@ error_alloc_commitments:
    return NULL;
 }
 
-struct pb_buffer *
+struct pb_buffer_lean *
 zink_bo_create(struct zink_screen *screen, uint64_t size, unsigned alignment, enum zink_heap heap, enum zink_alloc_flag flags, unsigned mem_type_idx, const void *pNext)
 {
    struct zink_bo *bo;
@@ -586,13 +586,13 @@ zink_bo_create(struct zink_screen *screen, uint64_t size, unsigned alignment, en
          return NULL;
 
       bo = container_of(entry, struct zink_bo, u.slab.entry);
-      assert(bo->base.base.placement == mem_type_idx);
-      pipe_reference_init(&bo->base.base.reference, 1);
-      bo->base.base.size = size;
+      assert(bo->base.placement == mem_type_idx);
+      pipe_reference_init(&bo->base.reference, 1);
+      bo->base.size = size;
       memset(&bo->reads, 0, sizeof(bo->reads));
       memset(&bo->writes, 0, sizeof(bo->writes));
       bo->unique_id = p_atomic_inc_return(&screen->pb.next_bo_unique_id);
-      assert(alignment <= 1 << bo->base.base.alignment_log2);
+      assert(alignment <= 1 << bo->base.alignment_log2);
 
       return &bo->base;
    }
@@ -619,7 +619,7 @@ no_slab:
        /* Get a buffer from the cache. */
        bo = (struct zink_bo*)
             pb_cache_reclaim_buffer(&screen->pb.bo_cache, size, alignment, 0, mem_type_idx);
-       assert(!bo || bo->base.base.placement == mem_type_idx);
+       assert(!bo || bo->base.placement == mem_type_idx);
        if (bo) {
           memset(&bo->reads, 0, sizeof(bo->reads));
           memset(&bo->writes, 0, sizeof(bo->writes));
@@ -636,7 +636,7 @@ no_slab:
       if (!bo)
          return NULL;
    }
-   assert(bo->base.base.placement == mem_type_idx);
+   assert(bo->base.placement == mem_type_idx);
 
    return &bo->base;
 }
@@ -663,7 +663,7 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo)
        * be atomic thanks to the lock. */
       cpu = real->u.real.cpu_ptr;
       if (!cpu) {
-         VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.base.size, 0, &cpu);
+         VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.size, 0, &cpu);
          if (result != VK_SUCCESS) {
             mesa_loge("ZINK: vkMapMemory failed (%s)", vk_Result_to_str(result));
             simple_mtx_unlock(&real->lock);
@@ -671,8 +671,8 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo)
             return NULL;
          }
          if (unlikely(zink_debug & ZINK_DEBUG_MAP)) {
-            p_atomic_add(&screen->mapped_vram, real->base.base.size);
-            mesa_loge("NEW MAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.base.size, screen->mapped_vram);
+            p_atomic_add(&screen->mapped_vram, real->base.size);
+            mesa_loge("NEW MAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.size, screen->mapped_vram);
          }
          p_atomic_set(&real->u.real.cpu_ptr, cpu);
       }
@@ -695,8 +695,8 @@ zink_bo_unmap(struct zink_screen *screen, struct zink_bo *bo)
       if (!p_atomic_read(&real->u.real.map_count)) {
          p_atomic_set(&real->u.real.cpu_ptr, NULL);
          if (unlikely(zink_debug & ZINK_DEBUG_MAP)) {
-            p_atomic_add(&screen->mapped_vram, -real->base.base.size);
-            mesa_loge("UNMAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.base.size, screen->mapped_vram);
+            p_atomic_add(&screen->mapped_vram, -real->base.size);
+            mesa_loge("UNMAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.size, screen->mapped_vram);
          }
          VKSCR(UnmapMemory)(screen->dev, real->mem);
       }
@@ -708,7 +708,7 @@ zink_bo_unmap(struct zink_screen *screen, struct zink_bo *bo)
 static void
 track_freed_sparse_bo(struct zink_context *ctx, struct zink_sparse_backing *backing)
 {
-   pipe_reference(NULL, &backing->bo->base.base.reference);
+   pipe_reference(NULL, &backing->bo->base.reference);
    util_dynarray_append(&ctx->bs->freed_sparse_backing_bos, backing->bo);
 }
 
@@ -788,8 +788,8 @@ buffer_bo_commit(struct zink_context *ctx, struct zink_resource *res, uint32_t o
    struct zink_screen *screen = zink_screen(ctx->base.screen);
    struct zink_bo *bo = res->obj->bo;
    assert(offset % ZINK_SPARSE_BUFFER_PAGE_SIZE == 0);
-   assert(offset <= bo->base.base.size);
-   assert(size <= bo->base.base.size - offset);
+   assert(offset <= bo->base.size);
+   assert(size <= bo->base.size - offset);
    assert(size % ZINK_SPARSE_BUFFER_PAGE_SIZE == 0 || offset + size == res->obj->size);
 
    struct zink_sparse_commitment *comm = bo->u.sparse.commitments;
@@ -1284,7 +1284,7 @@ bo_slab_alloc(void *priv, unsigned mem_type_idx, unsigned entry_size, unsigned g
    if (!slab->buffer)
       goto fail;
 
-   slab_size = slab->buffer->base.base.size;
+   slab_size = slab->buffer->base.size;
 
    slab->base.num_entries = slab_size / entry_size;
    slab->base.num_free = slab->base.num_entries;
@@ -1300,8 +1300,8 @@ bo_slab_alloc(void *priv, unsigned mem_type_idx, unsigned entry_size, unsigned g
       struct zink_bo *bo = &slab->entries[i];
 
       simple_mtx_init(&bo->lock, mtx_plain);
-      bo->base.base.alignment_log2 = util_logbase2(get_slab_entry_alignment(screen, entry_size));
-      bo->base.base.size = entry_size;
+      bo->base.alignment_log2 = util_logbase2(get_slab_entry_alignment(screen, entry_size));
+      bo->base.size = entry_size;
       bo->type = ZINK_BO_SLAB;
       bo->offset = slab->buffer->offset + i * entry_size;
       bo->u.slab.entry.slab = &slab->base;
@@ -1314,7 +1314,7 @@ bo_slab_alloc(void *priv, unsigned mem_type_idx, unsigned entry_size, unsigned g
          bo->u.slab.real = slab->buffer->u.slab.real;
          assert(bo->u.slab.real->mem);
       }
-      bo->base.base.placement = bo->u.slab.real->base.base.placement;
+      bo->base.placement = bo->u.slab.real->base.placement;
 
       list_addtail(&bo->u.slab.entry.head, &slab->base.free);
    }
diff --git a/src/gallium/drivers/zink/zink_bo.h b/src/gallium/drivers/zink/zink_bo.h
index 4dbf8b9516a..6f0a481c806 100644
--- a/src/gallium/drivers/zink/zink_bo.h
+++ b/src/gallium/drivers/zink/zink_bo.h
@@ -110,7 +110,7 @@ zink_bo_init(struct zink_screen *screen);
 void
 zink_bo_deinit(struct zink_screen *screen);
 
-struct pb_buffer *
+struct pb_buffer_lean *
 zink_bo_create(struct zink_screen *screen, uint64_t size, unsigned alignment, enum zink_heap heap, enum zink_alloc_flag flags, unsigned mem_type_idx, const void *pNext);
 
 void
@@ -134,7 +134,7 @@ zink_bo_get_mem(const struct zink_bo *bo)
 static ALWAYS_INLINE VkDeviceSize
 zink_bo_get_size(const struct zink_bo *bo)
 {
-   return bo->mem ? bo->base.base.size : bo->u.slab.real->base.base.size;
+   return bo->mem ? bo->base.size : bo->u.slab.real->base.size;
 }
 
 void *
@@ -241,7 +241,7 @@ zink_bo_usage_unset(struct zink_bo *bo, struct zink_batch_state *bs)
 static ALWAYS_INLINE void
 zink_bo_unref(struct zink_screen *screen, struct zink_bo *bo)
 {
-   if (pipe_reference(&bo->base.base.reference, NULL))
+   if (pipe_reference(&bo->base.reference, NULL))
       zink_bo_destroy(screen, bo);
 }
 
diff --git a/src/gallium/drivers/zink/zink_resource.c b/src/gallium/drivers/zink/zink_resource.c
index 0d494889d91..1dac6d291b5 100644
--- a/src/gallium/drivers/zink/zink_resource.c
+++ b/src/gallium/drivers/zink/zink_resource.c
@@ -1217,9 +1217,9 @@ update_obj_info(struct zink_screen *screen, struct zink_resource_object *obj,
       obj->size = zink_bo_get_size(obj->bo);
    }
 
-   obj->coherent = screen->info.mem_props.memoryTypes[obj->bo->base.base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+   obj->coherent = screen->info.mem_props.memoryTypes[obj->bo->base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
    if (!(templ->flags & PIPE_RESOURCE_FLAG_SPARSE)) {
-      obj->host_visible = screen->info.mem_props.memoryTypes[obj->bo->base.base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+      obj->host_visible = screen->info.mem_props.memoryTypes[obj->bo->base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    }
 }
 
@@ -2678,7 +2678,7 @@ zink_buffer_map(struct pipe_context *pctx,
 
    unsigned map_offset = box->x;
    /* ideally never ever read or write to non-cached mem */
-   bool is_cached_mem = (screen->info.mem_props.memoryTypes[res->obj->bo->base.base.placement].propertyFlags & VK_STAGING_RAM) == VK_STAGING_RAM;
+   bool is_cached_mem = (screen->info.mem_props.memoryTypes[res->obj->bo->base.placement].propertyFlags & VK_STAGING_RAM) == VK_STAGING_RAM;
    /* but this is only viable with a certain amount of vram since it may fully duplicate lots of large buffers */
    bool host_mem_type_check = res->obj->host_visible;
    if (screen->always_cached_upload)
diff --git a/src/gallium/drivers/zink/zink_types.h b/src/gallium/drivers/zink/zink_types.h
index 4e720cd1a0e..9e6d43d3ea3 100644
--- a/src/gallium/drivers/zink/zink_types.h
+++ b/src/gallium/drivers/zink/zink_types.h
@@ -708,7 +708,7 @@ enum zink_bo_type {
 };
 
 struct zink_bo {
-   struct pb_buffer base;
+   struct pb_buffer_lean base;
    enum zink_bo_type type;
 
    union {
@@ -756,7 +756,7 @@ struct zink_bo {
 };
 
 static inline struct zink_bo *
-zink_bo(struct pb_buffer *pbuf)
+zink_bo(struct pb_buffer_lean *pbuf)
 {
    return (struct zink_bo*)pbuf;
 }