diff --git a/Makefile b/Makefile
index 3c2bded..ebea697 100644
--- a/Makefile
+++ b/Makefile
@@ -43,7 +43,7 @@
 
 
 CHECKPATCH := $(CURDIR)/third_party/linux/scripts/checkpatch.pl \
-	--ignore BRACES,SPDX_LICENSE_TAG,VOLATILE,SPLIT_STRING,AVOID_EXTERNS,USE_SPINLOCK_T,NEW_TYPEDEFS,INITIALISED_STATIC,FILE_PATH_CHANGES,EMBEDDED_FUNCTION_NAME,SINGLE_STATEMENT_DO_WHILE_MACRO,MACRO_WITH_FLOW_CONTROL,PREFER_PACKED,PREFER_ALIGNED,INDENTED_LABEL --quiet
+	--ignore BRACES,SPDX_LICENSE_TAG,VOLATILE,SPLIT_STRING,AVOID_EXTERNS,USE_SPINLOCK_T,NEW_TYPEDEFS,INITIALISED_STATIC,FILE_PATH_CHANGES,EMBEDDED_FUNCTION_NAME,SINGLE_STATEMENT_DO_WHILE_MACRO,MACRO_WITH_FLOW_CONTROL,PREFER_PACKED,PREFER_ALIGNED,INDENTED_LABEL,SPACING --quiet
 
 # Specifies the grep pattern for ignoring specific files in checkpatch.
 # C++ headers, *.hh, are automatically excluded.
diff --git a/inc/hf/api.h b/inc/hf/api.h
index ebc533b..07b9061 100644
--- a/inc/hf/api.h
+++ b/inc/hf/api.h
@@ -60,14 +60,16 @@
 struct spci_value api_spci_features(uint32_t function_id);
 struct spci_value api_spci_run(spci_vm_id_t vm_id, spci_vcpu_index_t vcpu_idx,
 			       const struct vcpu *current, struct vcpu **next);
-struct spci_value api_spci_mem_send(uint32_t share_func, ipaddr_t address,
-				    uint32_t page_count,
-				    uint32_t fragment_length, uint32_t length,
-				    spci_cookie_t cookie, struct vcpu *current,
+struct spci_value api_spci_mem_send(uint32_t share_func, uint32_t length,
+				    uint32_t fragment_length, ipaddr_t address,
+				    uint32_t page_count, struct vcpu *current,
 				    struct vcpu **next);
-struct spci_value api_spci_mem_retrieve_req(
-	ipaddr_t address, uint32_t page_count, uint32_t fragment_length,
-	uint32_t length, spci_cookie_t cookie, struct vcpu *current);
+struct spci_value api_spci_mem_retrieve_req(uint32_t length,
+					    uint32_t fragment_length,
+					    ipaddr_t address,
+					    uint32_t page_count,
+					    struct vcpu *current);
 struct spci_value api_spci_mem_relinquish(struct vcpu *current);
-struct spci_value api_spci_mem_reclaim(uint32_t handle, uint32_t flags,
+struct spci_value api_spci_mem_reclaim(spci_memory_handle_t handle,
+				       spci_memory_region_flags_t flags,
 				       struct vcpu *current);
diff --git a/inc/hf/spci_memory.h b/inc/hf/spci_memory.h
index 023a8ce..6956102 100644
--- a/inc/hf/spci_memory.h
+++ b/inc/hf/spci_memory.h
@@ -27,8 +27,7 @@
 				   uint32_t share_func,
 				   struct mpool *page_pool);
 struct spci_value spci_memory_retrieve(
-	struct vm_locked to_locked,
-	struct spci_memory_retrieve_request *retrieve_request,
+	struct vm_locked to_locked, struct spci_memory_region *retrieve_request,
 	uint32_t retrieve_request_size, struct mpool *page_pool);
 struct spci_value spci_memory_relinquish(
 	struct vm_locked from_locked,
diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index d4119d6..1fa31cf 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -131,44 +131,36 @@
 		.arg4 = attributes});
 }
 
-static inline struct spci_value spci_mem_donate(uint32_t fragment_length,
-						uint32_t length,
-						spci_cookie_t cookie)
+static inline struct spci_value spci_mem_donate(uint32_t length,
+						uint32_t fragment_length)
 {
 	return spci_call((struct spci_value){.func = SPCI_MEM_DONATE_32,
-					     .arg3 = fragment_length,
-					     .arg4 = length,
-					     .arg5 = cookie});
+					     .arg1 = length,
+					     .arg2 = fragment_length});
 }
 
-static inline struct spci_value spci_mem_lend(uint32_t fragment_length,
-					      uint32_t length,
-					      spci_cookie_t cookie)
+static inline struct spci_value spci_mem_lend(uint32_t length,
+					      uint32_t fragment_length)
 {
 	return spci_call((struct spci_value){.func = SPCI_MEM_LEND_32,
-					     .arg3 = fragment_length,
-					     .arg4 = length,
-					     .arg5 = cookie});
+					     .arg1 = length,
+					     .arg2 = fragment_length});
 }
 
-static inline struct spci_value spci_mem_share(uint32_t fragment_length,
-					       uint32_t length,
-					       spci_cookie_t cookie)
+static inline struct spci_value spci_mem_share(uint32_t length,
+					       uint32_t fragment_length)
 {
 	return spci_call((struct spci_value){.func = SPCI_MEM_SHARE_32,
-					     .arg3 = fragment_length,
-					     .arg4 = length,
-					     .arg5 = cookie});
+					     .arg1 = length,
+					     .arg2 = fragment_length});
 }
 
-static inline struct spci_value spci_mem_retrieve_req(uint32_t fragment_length,
-						      uint32_t length,
-						      spci_cookie_t cookie)
+static inline struct spci_value spci_mem_retrieve_req(uint32_t length,
+						      uint32_t fragment_length)
 {
 	return spci_call((struct spci_value){.func = SPCI_MEM_RETRIEVE_REQ_32,
-					     .arg3 = fragment_length,
-					     .arg4 = length,
-					     .arg5 = cookie});
+					     .arg1 = length,
+					     .arg2 = fragment_length});
 }
 
 static inline struct spci_value spci_mem_relinquish(void)
@@ -176,11 +168,13 @@
 	return spci_call((struct spci_value){.func = SPCI_MEM_RELINQUISH_32});
 }
 
-static inline struct spci_value spci_mem_reclaim(uint32_t handle,
-						 uint32_t flags)
+static inline struct spci_value spci_mem_reclaim(
+	spci_memory_handle_t handle, spci_memory_region_flags_t flags)
 {
-	return spci_call((struct spci_value){
-		.func = SPCI_MEM_RECLAIM_32, .arg1 = handle, .arg2 = flags});
+	return spci_call((struct spci_value){.func = SPCI_MEM_RECLAIM_32,
+					     .arg1 = (uint32_t)handle,
+					     .arg2 = (uint32_t)(handle >> 32),
+					     .arg3 = flags});
 }
 
 /**
diff --git a/inc/vmapi/hf/spci.h b/inc/vmapi/hf/spci.h
index 9c10acf..887b745 100644
--- a/inc/vmapi/hf/spci.h
+++ b/inc/vmapi/hf/spci.h
@@ -62,9 +62,11 @@
 #define SPCI_RETRY              INT32_C(-7)
 #define SPCI_ABORTED            INT32_C(-8)
 
+/* clang-format on */
+
 /* SPCI function specific constants. */
-#define SPCI_MSG_RECV_BLOCK  0x1
-#define SPCI_MSG_RECV_BLOCK_MASK  0x1
+#define SPCI_MSG_RECV_BLOCK 0x1
+#define SPCI_MSG_RECV_BLOCK_MASK 0x1
 
 #define SPCI_MSG_SEND_NOTIFY 0x1
 #define SPCI_MSG_SEND_NOTIFY_MASK 0x1
@@ -83,14 +85,22 @@
 /* The maximum length possible for a single message. */
 #define SPCI_MSG_PAYLOAD_MAX HF_MAILBOX_SIZE
 
-enum spci_memory_access {
-	SPCI_MEMORY_RO_NX,
-	SPCI_MEMORY_RO_X,
-	SPCI_MEMORY_RW_NX,
-	SPCI_MEMORY_RW_X,
+enum spci_data_access {
+	SPCI_DATA_ACCESS_NOT_SPECIFIED,
+	SPCI_DATA_ACCESS_RO,
+	SPCI_DATA_ACCESS_RW,
+	SPCI_DATA_ACCESS_RESERVED,
+};
+
+enum spci_instruction_access {
+	SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+	SPCI_INSTRUCTION_ACCESS_NX,
+	SPCI_INSTRUCTION_ACCESS_X,
+	SPCI_INSTRUCTION_ACCESS_RESERVED,
 };
 
 enum spci_memory_type {
+	SPCI_MEMORY_NOT_SPECIFIED_MEM,
 	SPCI_MEMORY_DEVICE_MEM,
 	SPCI_MEMORY_NORMAL_MEM,
 };
@@ -98,8 +108,8 @@
 enum spci_memory_cacheability {
 	SPCI_MEMORY_CACHE_RESERVED = 0x0,
 	SPCI_MEMORY_CACHE_NON_CACHEABLE = 0x1,
-	SPCI_MEMORY_CACHE_WRITE_THROUGH = 0x2,
-	SPCI_MEMORY_CACHE_WRITE_BACK = 0x4,
+	SPCI_MEMORY_CACHE_RESERVED_1 = 0x2,
+	SPCI_MEMORY_CACHE_WRITE_BACK = 0x3,
 	SPCI_MEMORY_DEV_NGNRNE = 0x0,
 	SPCI_MEMORY_DEV_NGNRE = 0x1,
 	SPCI_MEMORY_DEV_NGRE = 0x2,
@@ -108,64 +118,83 @@
 
 enum spci_memory_shareability {
 	SPCI_MEMORY_SHARE_NON_SHAREABLE,
-	SPCI_MEMORY_RESERVED,
+	SPCI_MEMORY_SHARE_RESERVED,
 	SPCI_MEMORY_OUTER_SHAREABLE,
 	SPCI_MEMORY_INNER_SHAREABLE,
 };
 
-#define SPCI_MEMORY_ACCESS_OFFSET (0x5U)
-#define SPCI_MEMORY_ACCESS_MASK ((0x3U) << SPCI_MEMORY_ACCESS_OFFSET)
+typedef uint8_t spci_memory_access_permissions_t;
+
+/**
+ * This corresponds to table 44 of the FF-A 1.0 EAC specification, "Memory
+ * region attributes descriptor".
+ */
+typedef uint8_t spci_memory_attributes_t;
+
+#define SPCI_DATA_ACCESS_OFFSET (0x0U)
+#define SPCI_DATA_ACCESS_MASK ((0x3U) << SPCI_DATA_ACCESS_OFFSET)
+
+#define SPCI_INSTRUCTION_ACCESS_OFFSET (0x2U)
+#define SPCI_INSTRUCTION_ACCESS_MASK ((0x3U) << SPCI_INSTRUCTION_ACCESS_OFFSET)
 
 #define SPCI_MEMORY_TYPE_OFFSET (0x4U)
-#define SPCI_MEMORY_TYPE_MASK ((0x1U) << SPCI_MEMORY_TYPE_OFFSET)
+#define SPCI_MEMORY_TYPE_MASK ((0x3U) << SPCI_MEMORY_TYPE_OFFSET)
 
 #define SPCI_MEMORY_CACHEABILITY_OFFSET (0x2U)
-#define SPCI_MEMORY_CACHEABILITY_MASK ((0x3U) <<\
-	SPCI_MEMORY_CACHEABILITY_OFFSET)
+#define SPCI_MEMORY_CACHEABILITY_MASK \
+	((0x3U) << SPCI_MEMORY_CACHEABILITY_OFFSET)
 
 #define SPCI_MEMORY_SHAREABILITY_OFFSET (0x0U)
-#define SPCI_MEMORY_SHAREABILITY_MASK ((0x3U) <<\
-	SPCI_MEMORY_SHAREABILITY_OFFSET)
+#define SPCI_MEMORY_SHAREABILITY_MASK \
+	((0x3U) << SPCI_MEMORY_SHAREABILITY_OFFSET)
 
-#define LEND_ATTR_FUNCTION_SET(name, offset, mask) \
-static inline void spci_set_memory_##name##_attr(uint16_t *attr,\
-	const enum spci_memory_##name perm)\
-{\
-	*attr = (*attr & ~(mask)) | ((perm  << offset) & mask);\
-}
+#define ATTR_FUNCTION_SET(name, container_type, offset, mask)                  \
+	static inline void spci_set_##name##_attr(container_type *attr,        \
+						  const enum spci_##name perm) \
+	{                                                                      \
+		*attr = (*attr & ~(mask)) | ((perm << offset) & mask);         \
+	}
 
-#define LEND_ATTR_FUNCTION_GET(name, offset, mask) \
-static inline enum spci_memory_##name spci_get_memory_##name##_attr(\
-	uint16_t attr)\
-{\
-	return (enum spci_memory_##name)((attr & mask) >> offset);\
-}
+#define ATTR_FUNCTION_GET(name, container_type, offset, mask)       \
+	static inline enum spci_##name spci_get_##name##_attr(      \
+		container_type attr)                                \
+	{                                                           \
+		return (enum spci_##name)((attr & mask) >> offset); \
+	}
 
-LEND_ATTR_FUNCTION_SET(access, SPCI_MEMORY_ACCESS_OFFSET,
-	SPCI_MEMORY_ACCESS_MASK)
-LEND_ATTR_FUNCTION_GET(access, SPCI_MEMORY_ACCESS_OFFSET,
-	SPCI_MEMORY_ACCESS_MASK)
+ATTR_FUNCTION_SET(data_access, spci_memory_access_permissions_t,
+		  SPCI_DATA_ACCESS_OFFSET, SPCI_DATA_ACCESS_MASK)
+ATTR_FUNCTION_GET(data_access, spci_memory_access_permissions_t,
+		  SPCI_DATA_ACCESS_OFFSET, SPCI_DATA_ACCESS_MASK)
 
-LEND_ATTR_FUNCTION_SET(type, SPCI_MEMORY_TYPE_OFFSET, SPCI_MEMORY_TYPE_MASK)
-LEND_ATTR_FUNCTION_GET(type, SPCI_MEMORY_TYPE_OFFSET, SPCI_MEMORY_TYPE_MASK)
+ATTR_FUNCTION_SET(instruction_access, spci_memory_access_permissions_t,
+		  SPCI_INSTRUCTION_ACCESS_OFFSET, SPCI_INSTRUCTION_ACCESS_MASK)
+ATTR_FUNCTION_GET(instruction_access, spci_memory_access_permissions_t,
+		  SPCI_INSTRUCTION_ACCESS_OFFSET, SPCI_INSTRUCTION_ACCESS_MASK)
 
-LEND_ATTR_FUNCTION_SET(cacheability, SPCI_MEMORY_CACHEABILITY_OFFSET,
-	SPCI_MEMORY_CACHEABILITY_MASK)
+ATTR_FUNCTION_SET(memory_type, spci_memory_attributes_t,
+		  SPCI_MEMORY_TYPE_OFFSET, SPCI_MEMORY_TYPE_MASK)
+ATTR_FUNCTION_GET(memory_type, spci_memory_attributes_t,
+		  SPCI_MEMORY_TYPE_OFFSET, SPCI_MEMORY_TYPE_MASK)
 
-LEND_ATTR_FUNCTION_GET(cacheability, SPCI_MEMORY_CACHEABILITY_OFFSET,
-	SPCI_MEMORY_CACHEABILITY_MASK)
+ATTR_FUNCTION_SET(memory_cacheability, spci_memory_attributes_t,
+		  SPCI_MEMORY_CACHEABILITY_OFFSET,
+		  SPCI_MEMORY_CACHEABILITY_MASK)
+ATTR_FUNCTION_GET(memory_cacheability, spci_memory_attributes_t,
+		  SPCI_MEMORY_CACHEABILITY_OFFSET,
+		  SPCI_MEMORY_CACHEABILITY_MASK)
 
-LEND_ATTR_FUNCTION_SET(shareability, SPCI_MEMORY_SHAREABILITY_OFFSET,
-	SPCI_MEMORY_SHAREABILITY_MASK)
+ATTR_FUNCTION_SET(memory_shareability, spci_memory_attributes_t,
+		  SPCI_MEMORY_SHAREABILITY_OFFSET,
+		  SPCI_MEMORY_SHAREABILITY_MASK)
+ATTR_FUNCTION_GET(memory_shareability, spci_memory_attributes_t,
+		  SPCI_MEMORY_SHAREABILITY_OFFSET,
+		  SPCI_MEMORY_SHAREABILITY_MASK)
 
-LEND_ATTR_FUNCTION_GET(shareability, SPCI_MEMORY_SHAREABILITY_OFFSET,
-	SPCI_MEMORY_SHAREABILITY_MASK)
-
-/* clang-format on */
-
-#define SPCI_MEMORY_HANDLE_ALLOCATOR_MASK ((spci_memory_handle_t)(1U << 31))
+#define SPCI_MEMORY_HANDLE_ALLOCATOR_MASK \
+	((spci_memory_handle_t)(UINT64_C(1) << 63))
 #define SPCI_MEMORY_HANDLE_ALLOCATOR_HYPERVISOR \
-	((spci_memory_handle_t)(1U << 31))
+	((spci_memory_handle_t)(UINT64_C(1) << 63))
 
 /** The ID of a VM. These are assigned sequentially starting with an offset. */
 typedef uint16_t spci_vm_id_t;
@@ -174,13 +203,7 @@
  * A globally-unique ID assigned by the hypervisor for a region of memory being
  * sent between VMs.
  */
-typedef uint32_t spci_memory_handle_t;
-
-/**
- * A unique-per-VM ID used to associate fragments of a memory sharing message,
- * assigned by the sender of the message.
- */
-typedef uint32_t spci_cookie_t;
+typedef uint64_t spci_memory_handle_t;
 
 /**
  * A count of VMs. This has the same range as the VM IDs but we give it a
@@ -251,158 +274,28 @@
 	return ((uint32_t)vm_id << 16) | vcpu_index;
 }
 
+/**
+ * A set of contiguous pages which is part of a memory region. This corresponds
+ * to table 40 of the FF-A 1.0 EAC specification, "Constituent memory region
+ * descriptor".
+ */
 struct spci_memory_region_constituent {
 	/**
 	 * The base IPA of the constituent memory region, aligned to 4 kiB page
 	 * size granularity.
 	 */
-	uint32_t address_low;
-	uint32_t address_high;
+	uint64_t address;
 	/** The number of 4 kiB pages in the constituent memory region. */
 	uint32_t page_count;
 	/** Reserved field, must be 0. */
 	uint32_t reserved;
 };
 
-struct spci_memory_region_attributes {
-	/** The ID of the VM to which the memory is being given or shared. */
-	spci_vm_id_t receiver;
-	/**
-	 * The attributes with which the memory region should be mapped in the
-	 * receiver's page table.
-	 */
-	uint16_t memory_attributes;
-	/** Reserved field, must be 0. */
-	uint32_t reserved_0;
-	/** Reserved field, must be 0. */
-	uint64_t reserved_1;
-};
-
-/** Flags to control the behaviour of a memory sharing transaction. */
-typedef uint32_t spci_memory_region_flags_t;
-
 /**
- * Clear memory region contents after unmapping it from the sender and before
- * mapping it for any receiver.
+ * A set of pages comprising a memory region. This corresponds to table 39 of
+ * the FF-A 1.0 EAC specification, "Composite memory region descriptor".
  */
-#define SPCI_MEMORY_REGION_FLAG_CLEAR 0x1
-
-struct spci_memory_region {
-	/**
-	 * An implementation defined value associated with the receiver and the
-	 * memory region.
-	 */
-	uint32_t tag;
-	/** Flags to control behaviour of the transaction. */
-	spci_memory_region_flags_t flags;
-	/** Sender VM ID. */
-	spci_vm_id_t sender;
-	/** Reserved field, must be 0. */
-	uint16_t reserved_0;
-	/**
-	 * The total number of 4 kiB pages included in this memory region. This
-	 * must be equal to the sum of page counts specified in each
-	 * `spci_memory_region_constituent`.
-	 */
-	uint32_t page_count;
-	/**
-	 * The number of constituents (`spci_memory_region_constituent`)
-	 * included in this memory region.
-	 */
-	uint32_t constituent_count;
-	/**
-	 * The offset in bytes from the base address of this
-	 * `spci_memory_region` to the start of the first
-	 * `spci_memory_region_constituent`.
-	 */
-	uint32_t constituent_offset;
-	/**
-	 * The number of `spci_memory_region_attributes` entries included in
-	 * this memory region.
-	 */
-	uint32_t attribute_count;
-	/** Reserved field, must be 0. */
-	uint32_t reserved_1;
-	/**
-	 * An array of `attribute_count` memory region attribute descriptors.
-	 * Each one specifies an endpoint and the attributes with which this
-	 * memory region should be mapped in that endpoint's page table.
-	 */
-	struct spci_memory_region_attributes attributes[];
-};
-
-/**
- * Retrieval attributes for a single receiver. This corresponds to table 138 of
- * the SPCI beta specification, "Descriptor with properties to retrieve a memory
- * region".
- */
-struct spci_memory_retrieve_properties {
-	struct spci_memory_region_attributes attributes;
-	uint32_t page_count;
-	uint32_t constituent_count;
-	/** Reserved field, must be 0. */
-	uint32_t reserved;
-	struct spci_memory_region_constituent constituents[];
-};
-
-/**
- * Descriptor used for SPCI_MEM_RETRIEVE_REQ. This corresponds to table 137 of
- * the SPCI beta specification, "Descriptor to retrieve a donated, lent or
- * shared memory region".
- */
-struct spci_memory_retrieve_request {
-	/** Globally unique handle to identify the memory transaction. */
-	spci_memory_handle_t handle;
-	/** ID of the VM which sent the memory. */
-	spci_vm_id_t sender;
-	/** Reserved field, must be 0. */
-	uint16_t reserved_0;
-	/** Function ID of the memory sharing operation. */
-	uint32_t share_func;
-	/**
-	 * An implementation defined value associated with the receiver and the
-	 * memory region.
-	 */
-	uint32_t tag;
-	/**
-	 * The number of descriptors to specify the attributes with which the
-	 * memory region will be mapped in the other recipients. Hafnium doesn't
-	 * support multi-way memory sharing so this should always be 0.
-	 */
-	uint32_t attribute_count;
-	/**
-	 * The offset in bytes from the base address of this
-	 * `spci_memory_retrieve_request` to the start of the first attribute
-	 * descriptor.
-	 */
-	uint32_t attribute_offset;
-	/**
-	 * The number of `spci_memory_retrieve_properties` entries included
-	 * in this retrieve request, i.e. the number of receivers including the
-	 * caller and any stream endpoints for which the caller is a proxy.
-	 * Hafnium doesn't support stream endpoints, so this should always be 1.
-	 */
-	uint32_t retrieve_properties_count;
-	/** Reserved field, must be 0. */
-	uint32_t reserved_1;
-	/*
-	 * 'Array' of `struct spci_memory_retrieve_properties` goes here, but it
-	 * is not included in the struct as the entries are variable length. Use
-	 * `spci_memory_retrieve_request_first_retrieve_properties` to get the
-	 * first one.
-	 */
-};
-
-/**
- * Receiver address range descriptor. This corresponds to table 144 of the SPCI
- * beta specification, "Descriptor with address ranges of retrieved memory
- * region", and is included as part of the `spci_retrieved_memory_region`.
- */
-struct spci_receiver_address_range {
-	/** Receiver VM ID. */
-	spci_vm_id_t receiver;
-	/** Reserved field, must be 0. */
-	uint16_t reserved_0;
+struct spci_composite_memory_region {
 	/**
 	 * The total number of 4 kiB pages included in this memory region. This
 	 * must be equal to the sum of page counts specified in each
@@ -415,101 +308,155 @@
 	 */
 	uint32_t constituent_count;
 	/** Reserved field, must be 0. */
-	uint32_t reserved_1;
+	uint64_t reserved_0;
 	/** An array of `constituent_count` memory region constituents. */
 	struct spci_memory_region_constituent constituents[];
 };
 
+/** Flags to indicate properties of receivers during memory region retrieval. */
+typedef uint8_t spci_memory_receiver_flags_t;
+
 /**
- * Descriptor used for SPCI_MEM_RETRIEVE_RESP. This corresponds to table 143 of
- * the SPCI beta specification, "Encoding of mapped address ranges of retrieved
- * memory region".
+ * This corresponds to table 41 of the FF-A 1.0 EAC specification, "Memory
+ * access permissions descriptor".
  */
-struct spci_retrieved_memory_region {
+struct spci_memory_region_attributes {
+	/** The ID of the VM to which the memory is being given or shared. */
+	spci_vm_id_t receiver;
 	/**
-	 * The number of `spci_receiver_address_range` entries included
-	 * in this memory region.
+	 * The permissions with which the memory region should be mapped in the
+	 * receiver's page table.
+	 */
+	spci_memory_access_permissions_t permissions;
+	/**
+	 * Flags used during SPCI_MEM_RETRIEVE_REQ and SPCI_MEM_RETRIEVE_RESP
+	 * for memory regions with multiple borrowers.
+	 */
+	spci_memory_receiver_flags_t flags;
+};
+
+/** Flags to control the behaviour of a memory sharing transaction. */
+typedef uint32_t spci_memory_region_flags_t;
+
+/**
+ * Clear memory region contents after unmapping it from the sender and before
+ * mapping it for any receiver.
+ */
+#define SPCI_MEMORY_REGION_FLAG_CLEAR 0x1
+
+/**
+ * Whether the hypervisor may time slice the memory sharing or retrieval
+ * operation.
+ */
+#define SPCI_MEMORY_REGION_FLAG_TIME_SLICE 0x2
+
+/**
+ * Whether the hypervisor should clear the memory region after the receiver
+ * relinquishes it or is aborted.
+ */
+#define SPCI_MEMORY_REGION_FLAG_CLEAR_RELINQUISH 0x4
+
+#define SPCI_MEMORY_REGION_TRANSACTION_TYPE_MASK ((0x3U) << 3)
+#define SPCI_MEMORY_REGION_TRANSACTION_TYPE_UNSPECIFIED ((0x0U) << 3)
+#define SPCI_MEMORY_REGION_TRANSACTION_TYPE_SHARE ((0x1U) << 3)
+#define SPCI_MEMORY_REGION_TRANSACTION_TYPE_LEND ((0x2U) << 3)
+#define SPCI_MEMORY_REGION_TRANSACTION_TYPE_DONATE ((0x3U) << 3)
+
+/**
+ * This corresponds to table 42 of the FF-A 1.0 EAC specification, "Endpoint
+ * memory access descriptor".
+ */
+struct spci_memory_access {
+	struct spci_memory_region_attributes receiver_permissions;
+	/**
+	 * Offset in bytes from the start of the outer `spci_memory_region` to
+	 * an `spci_composite_memory_region` struct.
+	 */
+	uint32_t composite_memory_region_offset;
+	uint64_t reserved_0;
+};
+
+/**
+ * Information about a set of pages which are being shared. This corresponds to
+ * table 45 of the FF-A 1.0 EAC specification, "Lend, donate or share memory
+ * transaction descriptor". Note that it is also used for retrieve requests and
+ * responses.
+ */
+struct spci_memory_region {
+	/**
+	 * The ID of the VM which originally sent the memory region, i.e. the
+	 * owner.
+	 */
+	spci_vm_id_t sender;
+	spci_memory_attributes_t attributes;
+	/** Reserved field, must be 0. */
+	uint8_t reserved_0;
+	/** Flags to control behaviour of the transaction. */
+	spci_memory_region_flags_t flags;
+	spci_memory_handle_t handle;
+	/**
+	 * An implementation defined value associated with the receiver and the
+	 * memory region.
+	 */
+	uint64_t tag;
+	/** Reserved field, must be 0. */
+	uint32_t reserved_1;
+	/**
+	 * The number of `spci_memory_access` entries included in this
+	 * transaction.
 	 */
 	uint32_t receiver_count;
-	/** Reserved field, must be 0. */
-	uint32_t reserved_0;
-	/** Reserved field, must be 0. */
-	uint64_t reserved_1;
-	/*
-	 * 'Array' of `struct spci_receiver_address_range` goes here, but it is
-	 * not included in the struct as the entries are variable length. Use
-	 * `spci_retrieved_memory_region_first_receiver_range` to get the first
-	 * one.
+	/**
+	 * An array of `attribute_count` endpoint memory access descriptors.
+	 * Each one specifies a memory region offset, an endpoint and the
+	 * attributes with which this memory region should be mapped in that
+	 * endpoint's page table.
 	 */
+	struct spci_memory_access receivers[];
 };
 
 /**
  * Descriptor used for SPCI_MEM_RELINQUISH requests. This corresponds to table
- * 146 of the SPCI beta specification, "Descriptor to relinquish a memory
+ * 150 of the FF-A 1.0 EAC specification, "Descriptor to relinquish a memory
  * region".
  */
 struct spci_mem_relinquish {
 	spci_memory_handle_t handle;
-	uint32_t flags;
-	spci_vm_id_t sender;
-	uint16_t reserved;
+	spci_memory_region_flags_t flags;
 	uint32_t endpoint_count;
 	spci_vm_id_t endpoints[];
 };
 
-static inline struct spci_memory_region_constituent
-spci_memory_region_constituent_init(uint64_t address, uint32_t page_count)
-{
-	return (struct spci_memory_region_constituent){
-		.address_high = (uint32_t)(address >> 32),
-		.address_low = (uint32_t)address,
-		.page_count = page_count,
-	};
-}
-
-static inline uint64_t spci_memory_region_constituent_get_address(
-	struct spci_memory_region_constituent *constituent)
-{
-	return (uint64_t)constituent->address_high << 32 |
-	       constituent->address_low;
-}
-
 /**
- * Gets the constituent array for an `spci_memory_region`.
+ * Gets the `spci_composite_memory_region` for the given receiver from an
+ * `spci_memory_region`, or NULL if it is not valid.
  */
-static inline struct spci_memory_region_constituent *
-spci_memory_region_get_constituents(struct spci_memory_region *memory_region)
+static inline struct spci_composite_memory_region *
+spci_memory_region_get_composite(struct spci_memory_region *memory_region,
+				 uint32_t receiver_index)
 {
-	return (struct spci_memory_region_constituent
-			*)((uint8_t *)memory_region +
-			   memory_region->constituent_offset);
+	uint32_t offset = memory_region->receivers[receiver_index]
+				  .composite_memory_region_offset;
+
+	if (offset == 0) {
+		return NULL;
+	}
+
+	return (struct spci_composite_memory_region *)((uint8_t *)
+							       memory_region +
+						       offset);
 }
 
-/**
- * Gets the first descriptor with address ranges of a retrieved memory region.
- *
- * Note that getting the second requires parsing the first, as they are variable
- * length due to the variable number of constituents.
- */
-static inline struct spci_receiver_address_range *
-spci_retrieved_memory_region_first_receiver_range(
-	struct spci_retrieved_memory_region *memory_region)
+static inline uint32_t spci_mem_relinquish_init(
+	struct spci_mem_relinquish *relinquish_request,
+	spci_memory_handle_t handle, spci_memory_region_flags_t flags,
+	spci_vm_id_t sender)
 {
-	return (struct spci_receiver_address_range *)(memory_region + 1);
-}
-
-/**
- * Gets the first retrieval attributes descriptor of a memory region retrieval
- * request.
- *
- * Note that getting the second requires parsing the first, as they are variable
- * length due to the variable number of constituents.
- */
-static inline struct spci_memory_retrieve_properties *
-spci_memory_retrieve_request_first_retrieve_properties(
-	struct spci_memory_retrieve_request *retrieve_request)
-{
-	return (struct spci_memory_retrieve_properties *)(retrieve_request + 1);
+	relinquish_request->handle = handle;
+	relinquish_request->flags = flags;
+	relinquish_request->endpoint_count = 1;
+	relinquish_request->endpoints[0] = sender;
+	return sizeof(struct spci_mem_relinquish) + sizeof(spci_vm_id_t);
 }
 
 uint32_t spci_memory_region_init(
@@ -517,18 +464,21 @@
 	spci_vm_id_t receiver,
 	const struct spci_memory_region_constituent constituents[],
 	uint32_t constituent_count, uint32_t tag,
-	spci_memory_region_flags_t flags, enum spci_memory_access access,
+	spci_memory_region_flags_t flags, enum spci_data_access data_access,
+	enum spci_instruction_access instruction_access,
 	enum spci_memory_type type, enum spci_memory_cacheability cacheability,
 	enum spci_memory_shareability shareability);
 uint32_t spci_memory_retrieve_request_init(
-	struct spci_memory_retrieve_request *request,
-	spci_memory_handle_t handle, spci_vm_id_t sender, spci_vm_id_t receiver,
-	uint32_t share_func, uint32_t tag, uint32_t page_count,
-	enum spci_memory_access access, enum spci_memory_type type,
-	enum spci_memory_cacheability cacheability,
+	struct spci_memory_region *memory_region, spci_memory_handle_t handle,
+	spci_vm_id_t sender, spci_vm_id_t receiver, uint32_t tag,
+	spci_memory_region_flags_t flags, enum spci_data_access data_access,
+	enum spci_instruction_access instruction_access,
+	enum spci_memory_type type, enum spci_memory_cacheability cacheability,
 	enum spci_memory_shareability shareability);
 uint32_t spci_retrieved_memory_region_init(
-	struct spci_retrieved_memory_region *response, size_t response_max_size,
-	spci_vm_id_t receiver,
+	struct spci_memory_region *response, size_t response_max_size,
+	spci_vm_id_t sender, spci_memory_attributes_t attributes,
+	spci_memory_region_flags_t flags, spci_memory_handle_t handle,
+	spci_vm_id_t receiver, spci_memory_access_permissions_t permissions,
 	const struct spci_memory_region_constituent constituents[],
-	uint32_t constituent_count, uint32_t page_count);
+	uint32_t constituent_count);
diff --git a/src/api.c b/src/api.c
index 46aaefa..4b84c91 100644
--- a/src/api.c
+++ b/src/api.c
@@ -386,8 +386,8 @@
 	case SPCI_MEM_LEND_32:
 	case SPCI_MEM_SHARE_32:
 		return (struct spci_value){.func = receiver->mailbox.recv_func,
-					   .arg3 = receiver->mailbox.recv_size,
-					   .arg4 = receiver->mailbox.recv_size};
+					   .arg1 = receiver->mailbox.recv_size,
+					   .arg2 = receiver->mailbox.recv_size};
 	default:
 		/* This should never be reached, but return an error in case. */
 		dlog_error("Tried to return an invalid message function %#x\n",
@@ -1461,10 +1461,9 @@
 	}
 }
 
-struct spci_value api_spci_mem_send(uint32_t share_func, ipaddr_t address,
-				    uint32_t page_count,
-				    uint32_t fragment_length, uint32_t length,
-				    spci_cookie_t cookie, struct vcpu *current,
+struct spci_value api_spci_mem_send(uint32_t share_func, uint32_t length,
+				    uint32_t fragment_length, ipaddr_t address,
+				    uint32_t page_count, struct vcpu *current,
 				    struct vcpu **next)
 {
 	struct vm *from = current->vm;
@@ -1481,8 +1480,8 @@
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
-	if ((cookie == 0) != (fragment_length == length)) {
-		/* Cookie is required iff there are multiple fragments. */
+	if (fragment_length != length) {
+		dlog_verbose("Fragmentation not yet supported.\n");
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
@@ -1523,12 +1522,12 @@
 		goto out;
 	}
 
-	if (memory_region->attribute_count != 1) {
+	if (memory_region->receiver_count != 1) {
 		/* Hafnium doesn't support multi-way memory sharing for now. */
 		dlog_verbose(
 			"Multi-way memory sharing not supported (got %d "
-			"attribute descriptors, expected 0).\n",
-			memory_region->attribute_count);
+			"endpoint memory access descriptors, expected 1).\n",
+			memory_region->receiver_count);
 		ret = spci_error(SPCI_INVALID_PARAMETERS);
 		goto out;
 	}
@@ -1536,7 +1535,7 @@
 	/*
 	 * Ensure that the receiver VM exists and isn't the same as the sender.
 	 */
-	to = vm_find(memory_region->attributes[0].receiver);
+	to = vm_find(memory_region->receivers[0].receiver_permissions.receiver);
 	if (to == NULL || to == from) {
 		dlog_verbose("Invalid receiver.\n");
 		ret = spci_error(SPCI_INVALID_PARAMETERS);
@@ -1593,14 +1592,16 @@
 	return ret;
 }
 
-struct spci_value api_spci_mem_retrieve_req(
-	ipaddr_t address, uint32_t page_count, uint32_t fragment_length,
-	uint32_t length, spci_cookie_t cookie, struct vcpu *current)
+struct spci_value api_spci_mem_retrieve_req(uint32_t length,
+					    uint32_t fragment_length,
+					    ipaddr_t address,
+					    uint32_t page_count,
+					    struct vcpu *current)
 {
 	struct vm *to = current->vm;
 	struct vm_locked to_locked;
 	const void *to_msg;
-	struct spci_memory_retrieve_request *retrieve_request;
+	struct spci_memory_region *retrieve_request;
 	uint32_t message_buffer_size;
 	struct spci_value ret;
 
@@ -1612,15 +1613,13 @@
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
-	if (fragment_length == length && cookie != 0) {
-		/* Cookie is only allowed if there are multiple fragments. */
-		dlog_verbose("Unexpected cookie %d.\n", cookie);
+	if (fragment_length != length) {
+		dlog_verbose("Fragmentation not yet supported.\n");
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	retrieve_request =
-		(struct spci_memory_retrieve_request *)cpu_get_buffer(
-			current->cpu);
+		(struct spci_memory_region *)cpu_get_buffer(current->cpu);
 	message_buffer_size = cpu_get_buffer_size(current->cpu);
 	if (length > HF_MAILBOX_SIZE || length > message_buffer_size) {
 		dlog_verbose("Retrieve request too long.\n");
@@ -1718,7 +1717,8 @@
 	return ret;
 }
 
-struct spci_value api_spci_mem_reclaim(uint32_t handle, uint32_t flags,
+struct spci_value api_spci_mem_reclaim(spci_memory_handle_t handle,
+				       spci_memory_region_flags_t flags,
 				       struct vcpu *current)
 {
 	struct vm *to = current->vm;
diff --git a/src/arch/aarch64/hypervisor/handler.c b/src/arch/aarch64/hypervisor/handler.c
index 924d024..d3a4a75 100644
--- a/src/arch/aarch64/hypervisor/handler.c
+++ b/src/arch/aarch64/hypervisor/handler.c
@@ -366,20 +366,22 @@
 	case SPCI_MEM_DONATE_32:
 	case SPCI_MEM_LEND_32:
 	case SPCI_MEM_SHARE_32:
-		*args = api_spci_mem_send(func, ipa_init(args->arg1),
-					  args->arg2, args->arg3, args->arg4,
-					  args->arg5, current(), next);
+		*args = api_spci_mem_send(func, args->arg1, args->arg2,
+					  ipa_init(args->arg3), args->arg4,
+					  current(), next);
 		return true;
 	case SPCI_MEM_RETRIEVE_REQ_32:
-		*args = api_spci_mem_retrieve_req(
-			ipa_init(args->arg1), args->arg2, args->arg3,
-			args->arg4, args->arg5, current());
+		*args = api_spci_mem_retrieve_req(args->arg1, args->arg2,
+						  ipa_init(args->arg3),
+						  args->arg4, current());
 		return true;
 	case SPCI_MEM_RELINQUISH_32:
 		*args = api_spci_mem_relinquish(current());
 		return true;
 	case SPCI_MEM_RECLAIM_32:
-		*args = api_spci_mem_reclaim(args->arg1, args->arg2, current());
+		*args = api_spci_mem_reclaim(
+			(args->arg1 & 0xffffffff) | args->arg2 << 32,
+			args->arg3, current());
 		return true;
 	}
 
diff --git a/src/spci_memory.c b/src/spci_memory.c
index eeafc05..5da022c 100644
--- a/src/spci_memory.c
+++ b/src/spci_memory.c
@@ -37,22 +37,17 @@
 static_assert(sizeof(struct spci_memory_region_constituent) % 16 == 0,
 	      "struct spci_memory_region_constituent must be a multiple of 16 "
 	      "bytes long.");
-static_assert(sizeof(struct spci_memory_region_attributes) % 16 == 0,
-	      "struct spci_memory_region_attributes must be a multiple of 16 "
+static_assert(sizeof(struct spci_composite_memory_region) % 16 == 0,
+	      "struct spci_composite_memory_region must be a multiple of 16 "
 	      "bytes long.");
+static_assert(sizeof(struct spci_memory_region_attributes) == 4,
+	      "struct spci_memory_region_attributes must be 4bytes long.");
+static_assert(sizeof(struct spci_memory_access) % 16 == 0,
+	      "struct spci_memory_access must be a multiple of 16 bytes long.");
 static_assert(sizeof(struct spci_memory_region) % 16 == 0,
 	      "struct spci_memory_region must be a multiple of 16 bytes long.");
-static_assert(sizeof(struct spci_receiver_address_range) % 16 == 0,
-	      "struct spci_receiver_address_range must be a multiple of 16 "
-	      "bytes long.");
-static_assert(sizeof(struct spci_retrieved_memory_region) % 16 == 0,
-	      "struct spci_retrieved_memory_region must be a multiple of 16 "
-	      "bytes long.");
-static_assert(sizeof(struct spci_memory_retrieve_properties) % 16 == 0,
-	      "struct spci_memory_retrieve_properties must be a multiple of 16 "
-	      "bytes long.");
-static_assert(sizeof(struct spci_memory_retrieve_request) % 16 == 0,
-	      "struct spci_memory_retrieve_request must be a multiple of 16 "
+static_assert(sizeof(struct spci_mem_relinquish) % 16 == 0,
+	      "struct spci_mem_relinquish must be a multiple of 16 "
 	      "bytes long.");
 
 struct spci_memory_share_state {
@@ -101,7 +96,7 @@
 				 struct spci_memory_region *memory_region,
 				 spci_memory_handle_t *handle)
 {
-	uint32_t i;
+	uint64_t i;
 
 	CHECK(memory_region != NULL);
 
@@ -208,17 +203,21 @@
 		return;
 	}
 
-	dlog("from VM %d, tag %d, flags %#x, %d total pages in %d constituents "
-	     "to %d recipients [",
-	     memory_region->sender, memory_region->tag, memory_region->flags,
-	     memory_region->page_count, memory_region->constituent_count,
-	     memory_region->attribute_count);
-	for (i = 0; i < memory_region->attribute_count; ++i) {
+	dlog("from VM %d, attributes %#x, flags %#x, handle %#x, tag %d, to %d "
+	     "recipients [",
+	     memory_region->sender, memory_region->attributes,
+	     memory_region->flags, memory_region->handle, memory_region->tag,
+	     memory_region->receiver_count);
+	for (i = 0; i < memory_region->receiver_count; ++i) {
 		if (i != 0) {
 			dlog(", ");
 		}
-		dlog("VM %d: %#x", memory_region->attributes[i].receiver,
-		     memory_region->attributes[i].memory_attributes);
+		dlog("VM %d: %#x (offset %d)",
+		     memory_region->receivers[i].receiver_permissions.receiver,
+		     memory_region->receivers[i]
+			     .receiver_permissions.permissions,
+		     memory_region->receivers[i]
+			     .composite_memory_region_offset);
 	}
 	dlog("]");
 }
@@ -264,23 +263,32 @@
 }
 
 /* TODO: Add device attributes: GRE, cacheability, shareability. */
-static inline uint32_t spci_memory_attrs_to_mode(uint16_t memory_attributes)
+static inline uint32_t spci_memory_permissions_to_mode(
+	spci_memory_access_permissions_t permissions)
 {
 	uint32_t mode = 0;
 
-	switch (spci_get_memory_access_attr(memory_attributes)) {
-	case SPCI_MEMORY_RO_NX:
+	switch (spci_get_data_access_attr(permissions)) {
+	case SPCI_DATA_ACCESS_RO:
 		mode = MM_MODE_R;
 		break;
-	case SPCI_MEMORY_RO_X:
-		mode = MM_MODE_R | MM_MODE_X;
-		break;
-	case SPCI_MEMORY_RW_NX:
+	case SPCI_DATA_ACCESS_RW:
+	case SPCI_DATA_ACCESS_NOT_SPECIFIED:
 		mode = MM_MODE_R | MM_MODE_W;
 		break;
-	case SPCI_MEMORY_RW_X:
-		mode = MM_MODE_R | MM_MODE_W | MM_MODE_X;
+	case SPCI_DATA_ACCESS_RESERVED:
+		panic("Tried to convert SPCI_DATA_ACCESS_RESERVED.");
+	}
+
+	switch (spci_get_instruction_access_attr(permissions)) {
+	case SPCI_INSTRUCTION_ACCESS_NX:
 		break;
+	case SPCI_INSTRUCTION_ACCESS_X:
+	case SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED:
+		mode |= MM_MODE_X;
+		break;
+	case SPCI_INSTRUCTION_ACCESS_RESERVED:
+		panic("Tried to convert SPCI_INSTRUCTION_ACCESS_RESVERVED.");
 	}
 
 	return mode;
@@ -289,9 +297,9 @@
 /**
  * Get the current mode in the stage-2 page table of the given vm of all the
  * pages in the given constituents, if they all have the same mode, or return
- * false if not.
+ * an appropriate SPCI error if not.
  */
-static bool constituents_get_mode(
+static struct spci_value constituents_get_mode(
 	struct vm_locked vm, uint32_t *orig_mode,
 	struct spci_memory_region_constituent *constituents,
 	uint32_t constituent_count)
@@ -303,13 +311,11 @@
 		 * Fail if there are no constituents. Otherwise we would get an
 		 * uninitialised *orig_mode.
 		 */
-		return false;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	for (i = 0; i < constituent_count; ++i) {
-		ipaddr_t begin =
-			ipa_init(spci_memory_region_constituent_get_address(
-				&constituents[i]));
+		ipaddr_t begin = ipa_init(constituents[i].address);
 		size_t size = constituents[i].page_count * PAGE_SIZE;
 		ipaddr_t end = ipa_add(begin, size);
 		uint32_t current_mode;
@@ -317,7 +323,7 @@
 		/* Fail if addresses are not page-aligned. */
 		if (!is_aligned(ipa_addr(begin), PAGE_SIZE) ||
 		    !is_aligned(ipa_addr(end), PAGE_SIZE)) {
-			return false;
+			return spci_error(SPCI_INVALID_PARAMETERS);
 		}
 
 		/*
@@ -326,7 +332,7 @@
 		 */
 		if (!mm_vm_get_mode(&vm.vm->ptable, begin, end,
 				    &current_mode)) {
-			return false;
+			return spci_error(SPCI_DENIED);
 		}
 
 		/*
@@ -335,11 +341,11 @@
 		if (i == 0) {
 			*orig_mode = current_mode;
 		} else if (current_mode != *orig_mode) {
-			return false;
+			return spci_error(SPCI_DENIED);
 		}
 	}
 
-	return true;
+	return (struct spci_value){.func = SPCI_SUCCESS_32};
 }
 
 /**
@@ -348,32 +354,37 @@
  * to the sending VM.
  *
  * Returns:
- *  The error code false indicates that:
- *   1) a state transition was not found;
- *   2) the pages being shared do not have the same mode within the <from> VM;
- *   3) The beginning and end IPAs are not page aligned;
- *   4) The requested share type was not handled.
- *  Success is indicated by true.
- *
+ *   1) SPCI_DENIED if a state transition was not found;
+ *   2) SPCI_DENIED if the pages being shared do not have the same mode within
+ *     the <from> VM;
+ *   3) SPCI_INVALID_PARAMETERS if the beginning and end IPAs are not page
+ *     aligned;
+ *   4) SPCI_INVALID_PARAMETERS if the requested share type was not handled.
+ *  Or SPCI_SUCCESS on success.
  */
-static bool spci_send_check_transition(
-	struct vm_locked from, uint32_t share_func, uint32_t *orig_from_mode,
+static struct spci_value spci_send_check_transition(
+	struct vm_locked from, uint32_t share_func,
+	spci_memory_access_permissions_t permissions, uint32_t *orig_from_mode,
 	struct spci_memory_region_constituent *constituents,
 	uint32_t constituent_count, uint32_t *from_mode)
 {
 	const uint32_t state_mask =
 		MM_MODE_INVALID | MM_MODE_UNOWNED | MM_MODE_SHARED;
+	const uint32_t required_from_mode =
+		spci_memory_permissions_to_mode(permissions);
+	struct spci_value ret;
 
-	if (!constituents_get_mode(from, orig_from_mode, constituents,
-				   constituent_count)) {
-		return false;
+	ret = constituents_get_mode(from, orig_from_mode, constituents,
+				    constituent_count);
+	if (ret.func != SPCI_SUCCESS_32) {
+		return ret;
 	}
 
 	/* Ensure the address range is normal memory and not a device. */
 	if (*orig_from_mode & MM_MODE_D) {
 		dlog_verbose("Can't share device memory (mode is %#x).\n",
 			     *orig_from_mode);
-		return false;
+		return spci_error(SPCI_DENIED);
 	}
 
 	/*
@@ -381,7 +392,15 @@
 	 * memory.
 	 */
 	if ((*orig_from_mode & state_mask) != 0) {
-		return false;
+		return spci_error(SPCI_DENIED);
+	}
+
+	if ((*orig_from_mode & required_from_mode) != required_from_mode) {
+		dlog_verbose(
+			"Sender tried to send memory with permissions which "
+			"required mode %#x but only had %#x itself.\n",
+			required_from_mode, *orig_from_mode);
+		return spci_error(SPCI_DENIED);
 	}
 
 	/* Find the appropriate new mode. */
@@ -400,13 +419,13 @@
 		break;
 
 	default:
-		return false;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
-	return true;
+	return (struct spci_value){.func = SPCI_SUCCESS_32};
 }
 
-static bool spci_relinquish_check_transition(
+static struct spci_value spci_relinquish_check_transition(
 	struct vm_locked from, uint32_t *orig_from_mode,
 	struct spci_memory_region_constituent *constituents,
 	uint32_t constituent_count, uint32_t *from_mode)
@@ -414,17 +433,19 @@
 	const uint32_t state_mask =
 		MM_MODE_INVALID | MM_MODE_UNOWNED | MM_MODE_SHARED;
 	uint32_t orig_from_state;
+	struct spci_value ret;
 
-	if (!constituents_get_mode(from, orig_from_mode, constituents,
-				   constituent_count)) {
-		return false;
+	ret = constituents_get_mode(from, orig_from_mode, constituents,
+				    constituent_count);
+	if (ret.func != SPCI_SUCCESS_32) {
+		return ret;
 	}
 
 	/* Ensure the address range is normal memory and not a device. */
 	if (*orig_from_mode & MM_MODE_D) {
 		dlog_verbose("Can't relinquish device memory (mode is %#x).\n",
 			     *orig_from_mode);
-		return false;
+		return spci_error(SPCI_DENIED);
 	}
 
 	/*
@@ -438,13 +459,13 @@
 			"but "
 			"should be %#x).\n",
 			*orig_from_mode, orig_from_state, MM_MODE_UNOWNED);
-		return false;
+		return spci_error(SPCI_DENIED);
 	}
 
 	/* Find the appropriate new mode. */
 	*from_mode = (~state_mask & *orig_from_mode) | MM_MODE_UNMAPPED_MASK;
 
-	return true;
+	return (struct spci_value){.func = SPCI_SUCCESS_32};
 }
 
 /**
@@ -453,24 +474,27 @@
  * to the retrieving VM.
  *
  * Returns:
- *  The error code false indicates that:
- *   1) a state transition was not found;
- *   2) the pages being shared do not have the same mode within the <to> VM;
- *   3) The beginning and end IPAs are not page aligned;
- *   4) The requested share type was not handled.
- *  Success is indicated by true.
+ *   1) SPCI_DENIED if a state transition was not found;
+ *   2) SPCI_DENIED if the pages being shared do not have the same mode within
+ *     the <to> VM;
+ *   3) SPCI_INVALID_PARAMETERS if the beginning and end IPAs are not page
+ *     aligned;
+ *   4) SPCI_INVALID_PARAMETERS if the requested share type was not handled.
+ *  Or SPCI_SUCCESS on success.
  */
-static bool spci_retrieve_check_transition(
+static struct spci_value spci_retrieve_check_transition(
 	struct vm_locked to, uint32_t share_func,
 	struct spci_memory_region_constituent *constituents,
 	uint32_t constituent_count, uint32_t memory_to_attributes,
 	uint32_t *to_mode)
 {
 	uint32_t orig_to_mode;
+	struct spci_value ret;
 
-	if (!constituents_get_mode(to, &orig_to_mode, constituents,
-				   constituent_count)) {
-		return false;
+	ret = constituents_get_mode(to, &orig_to_mode, constituents,
+				    constituent_count);
+	if (ret.func != SPCI_SUCCESS_32) {
+		return ret;
 	}
 
 	if (share_func == SPCI_MEM_RECLAIM_32) {
@@ -480,7 +504,7 @@
 
 		if (orig_to_state != MM_MODE_INVALID &&
 		    orig_to_state != MM_MODE_SHARED) {
-			return false;
+			return spci_error(SPCI_DENIED);
 		}
 	} else {
 		/*
@@ -490,7 +514,7 @@
 		 */
 		if ((orig_to_mode & MM_MODE_UNMAPPED_MASK) !=
 		    MM_MODE_UNMAPPED_MASK) {
-			return false;
+			return spci_error(SPCI_DENIED);
 		}
 	}
 
@@ -514,10 +538,10 @@
 		break;
 
 	default:
-		return false;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
-	return true;
+	return (struct spci_value){.func = SPCI_SUCCESS_32};
 }
 
 /**
@@ -546,9 +570,8 @@
 	/* Iterate over the memory region constituents. */
 	for (uint32_t index = 0; index < constituent_count; index++) {
 		size_t size = constituents[index].page_count * PAGE_SIZE;
-		paddr_t pa_begin = pa_from_ipa(
-			ipa_init(spci_memory_region_constituent_get_address(
-				&constituents[index])));
+		paddr_t pa_begin =
+			pa_from_ipa(ipa_init(constituents[index].address));
 		paddr_t pa_end = pa_add(pa_begin, size);
 
 		if (commit) {
@@ -626,9 +649,7 @@
 	/* Iterate over the memory region constituents. */
 	for (uint32_t i = 0; i < constituent_count; ++i) {
 		size_t size = constituents[i].page_count * PAGE_SIZE;
-		paddr_t begin = pa_from_ipa(
-			ipa_init(spci_memory_region_constituent_get_address(
-				&constituents[i])));
+		paddr_t begin = pa_from_ipa(ipa_init(constituents[i].address));
 		paddr_t end = pa_add(begin, size);
 
 		if (!clear_memory(begin, end, &local_page_pool)) {
@@ -666,13 +687,16 @@
  *     erroneous;
  *   2) SPCI_NO_MEMORY - Hafnium did not have sufficient memory to complete
  *     the request.
+ *   3) SPCI_DENIED - The sender doesn't have sufficient access to send the
+ *     memory with the given permissions.
  *  Success is indicated by SPCI_SUCCESS.
  */
 static struct spci_value spci_send_memory(
 	struct vm_locked from_locked,
 	struct spci_memory_region_constituent *constituents,
 	uint32_t constituent_count, uint32_t share_func,
-	struct mpool *page_pool, bool clear)
+	spci_memory_access_permissions_t permissions, struct mpool *page_pool,
+	bool clear)
 {
 	struct vm *from = from_locked.vm;
 	uint32_t orig_from_mode;
@@ -681,10 +705,10 @@
 	struct spci_value ret;
 
 	/*
-	 * Make sure constituents are properly aligned to a 32-bit boundary. If
-	 * not we would get alignment faults trying to read (32-bit) values.
+	 * Make sure constituents are properly aligned to a 64-bit boundary. If
+	 * not we would get alignment faults trying to read (64-bit) values.
 	 */
-	if (!is_aligned(constituents, 4)) {
+	if (!is_aligned(constituents, 8)) {
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
@@ -693,10 +717,11 @@
 	 * all constituents of a memory region being shared are at the same
 	 * state.
 	 */
-	if (!spci_send_check_transition(from_locked, share_func,
-					&orig_from_mode, constituents,
-					constituent_count, &from_mode)) {
-		return spci_error(SPCI_INVALID_PARAMETERS);
+	ret = spci_send_check_transition(from_locked, share_func, permissions,
+					 &orig_from_mode, constituents,
+					 constituent_count, &from_mode);
+	if (ret.func != SPCI_SUCCESS_32) {
+		return ret;
 	}
 
 	/*
@@ -798,11 +823,12 @@
 	 * that all constituents of the memory region being retrieved are at the
 	 * same state.
 	 */
-	if (!spci_retrieve_check_transition(to_locked, share_func, constituents,
-					    constituent_count,
-					    memory_to_attributes, &to_mode)) {
+	ret = spci_retrieve_check_transition(to_locked, share_func,
+					     constituents, constituent_count,
+					     memory_to_attributes, &to_mode);
+	if (ret.func != SPCI_SUCCESS_32) {
 		dlog_verbose("Invalid transition.\n");
-		return spci_error(SPCI_INVALID_PARAMETERS);
+		return ret;
 	}
 
 	/*
@@ -868,11 +894,12 @@
 	struct mpool local_page_pool;
 	struct spci_value ret;
 
-	if (!spci_relinquish_check_transition(from_locked, &orig_from_mode,
-					      constituents, constituent_count,
-					      &from_mode)) {
+	ret = spci_relinquish_check_transition(from_locked, &orig_from_mode,
+					       constituents, constituent_count,
+					       &from_mode);
+	if (ret.func != SPCI_SUCCESS_32) {
 		dlog_verbose("Invalid transition.\n");
-		return spci_error(SPCI_INVALID_PARAMETERS);
+		return ret;
 	}
 
 	/*
@@ -937,6 +964,154 @@
 }
 
 /**
+ * Check that the given `memory_region` represents a valid memory send request
+ * of the given `share_func` type, return the clear flag and permissions via the
+ * respective output parameters, and update the permissions if necessary.
+ * Returns SPCI_SUCCESS if the request was valid, or the relevant SPCI_ERROR if
+ * not.
+ */
+static struct spci_value spci_memory_send_validate(
+	struct vm *to, struct vm_locked from_locked,
+	struct spci_memory_region *memory_region, uint32_t memory_share_size,
+	uint32_t share_func, bool *clear,
+	spci_memory_access_permissions_t *permissions)
+{
+	struct spci_composite_memory_region *composite;
+	uint32_t receivers_size;
+	uint32_t constituents_size;
+	enum spci_data_access data_access;
+	enum spci_instruction_access instruction_access;
+
+	CHECK(clear != NULL);
+	CHECK(permissions != NULL);
+
+	/* The sender must match the message sender. */
+	if (memory_region->sender != from_locked.vm->id) {
+		dlog_verbose("Invalid sender %d.\n", memory_region->sender);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/* We only support a single recipient. */
+	if (memory_region->receiver_count != 1) {
+		dlog_verbose("Multiple recipients not supported.\n");
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/*
+	 * Ensure that the composite header is within the memory bounds and
+	 * doesn't overlap the first part of the message.
+	 */
+	receivers_size = sizeof(struct spci_memory_access) *
+			 memory_region->receiver_count;
+	if (memory_region->receivers[0].composite_memory_region_offset <
+		    sizeof(struct spci_memory_region) + receivers_size ||
+	    memory_region->receivers[0].composite_memory_region_offset +
+			    sizeof(struct spci_composite_memory_region) >=
+		    memory_share_size) {
+		dlog_verbose(
+			"Invalid composite memory region descriptor offset.\n");
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	composite = spci_memory_region_get_composite(memory_region, 0);
+
+	/*
+	 * Ensure the number of constituents are within the memory
+	 * bounds.
+	 */
+	constituents_size = sizeof(struct spci_memory_region_constituent) *
+			    composite->constituent_count;
+	if (memory_share_size !=
+	    memory_region->receivers[0].composite_memory_region_offset +
+		    sizeof(struct spci_composite_memory_region) +
+		    constituents_size) {
+		dlog_verbose("Invalid size %d or constituent offset %d.\n",
+			     memory_share_size,
+			     memory_region->receivers[0]
+				     .composite_memory_region_offset);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/* The recipient must match the message recipient. */
+	if (memory_region->receivers[0].receiver_permissions.receiver !=
+	    to->id) {
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	*clear = memory_region->flags & SPCI_MEMORY_REGION_FLAG_CLEAR;
+	/*
+	 * Clear is not allowed for memory sharing, as the sender still has
+	 * access to the memory.
+	 */
+	if (*clear && share_func == SPCI_MEM_SHARE_32) {
+		dlog_verbose("Memory can't be cleared while being shared.\n");
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/* No other flags are allowed/supported here. */
+	if (memory_region->flags & ~SPCI_MEMORY_REGION_FLAG_CLEAR) {
+		dlog_verbose("Invalid flags %#x.\n", memory_region->flags);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/* Check that the permissions are valid. */
+	*permissions =
+		memory_region->receivers[0].receiver_permissions.permissions;
+	data_access = spci_get_data_access_attr(*permissions);
+	instruction_access = spci_get_instruction_access_attr(*permissions);
+	if (data_access == SPCI_DATA_ACCESS_RESERVED ||
+	    instruction_access == SPCI_INSTRUCTION_ACCESS_RESERVED) {
+		dlog_verbose("Reserved value for receiver permissions %#x.\n",
+			     *permissions);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+	if (instruction_access != SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED) {
+		dlog_verbose(
+			"Invalid instruction access permissions %#x for "
+			"sending memory.\n",
+			*permissions);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+	if (share_func == SPCI_MEM_SHARE_32) {
+		if (data_access == SPCI_DATA_ACCESS_NOT_SPECIFIED) {
+			dlog_verbose(
+				"Invalid data access permissions %#x for "
+				"sharing memory.\n",
+				*permissions);
+			return spci_error(SPCI_INVALID_PARAMETERS);
+		}
+		/*
+		 * According to section 6.11.3 of the FF-A spec NX is required
+		 * for share operations (but must not be specified by the
+		 * sender) so set it in the copy that we store, ready to be
+		 * returned to the retriever.
+		 */
+		spci_set_instruction_access_attr(permissions,
+						 SPCI_INSTRUCTION_ACCESS_NX);
+		memory_region->receivers[0].receiver_permissions.permissions =
+			*permissions;
+	}
+	if (share_func == SPCI_MEM_LEND_32 &&
+	    data_access == SPCI_DATA_ACCESS_NOT_SPECIFIED) {
+		dlog_verbose(
+			"Invalid data access permissions %#x for lending "
+			"memory.\n",
+			*permissions);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+	if (share_func == SPCI_MEM_DONATE_32 &&
+	    data_access != SPCI_DATA_ACCESS_NOT_SPECIFIED) {
+		dlog_verbose(
+			"Invalid data access permissions %#x for donating "
+			"memory.\n",
+			*permissions);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	return (struct spci_value){.func = SPCI_SUCCESS_32};
+}
+
+/**
  * Validates a call to donate, lend or share memory and then updates the stage-2
  * page tables. Specifically, check if the message length and number of memory
  * region constituents match, and if the transition is valid for the type of
@@ -955,62 +1130,39 @@
 				   uint32_t memory_share_size,
 				   uint32_t share_func, struct mpool *page_pool)
 {
-	struct spci_memory_region_constituent *constituents =
-		spci_memory_region_get_constituents(memory_region);
-	uint32_t constituent_count = memory_region->constituent_count;
-	uint32_t attributes_size;
-	uint32_t constituents_size;
+	struct spci_composite_memory_region *composite;
 	bool clear;
+	spci_memory_access_permissions_t permissions;
 	struct spci_value ret;
 	spci_memory_handle_t handle;
 
 	/*
-	 * Ensure the number of constituents are within the memory
-	 * bounds.
+	 * If there is an error validating the `memory_region` then we need to
+	 * free it because we own it but we won't be storing it in a share state
+	 * after all.
 	 */
-	attributes_size = sizeof(struct spci_memory_region_attributes) *
-			  memory_region->attribute_count;
-	constituents_size = sizeof(struct spci_memory_region_constituent) *
-			    constituent_count;
-	if (memory_region->constituent_offset <
-		    sizeof(struct spci_memory_region) + attributes_size ||
-	    memory_share_size !=
-		    memory_region->constituent_offset + constituents_size) {
-		dlog_verbose("Invalid size %d or constituent offset %d.\n",
-			     memory_share_size,
-			     memory_region->constituent_offset);
+	ret = spci_memory_send_validate(to, from_locked, memory_region,
+					memory_share_size, share_func, &clear,
+					&permissions);
+	if (ret.func != SPCI_SUCCESS_32) {
 		mpool_free(page_pool, memory_region);
-		return spci_error(SPCI_INVALID_PARAMETERS);
+		return ret;
 	}
 
-	/* The sender must match the message sender. */
-	if (memory_region->sender != from_locked.vm->id) {
-		dlog_verbose("Invalid sender %d.\n", memory_region->sender);
-		mpool_free(page_pool, memory_region);
-		return spci_error(SPCI_INVALID_PARAMETERS);
-	}
-
-	/* We only support a single recipient. */
-	if (memory_region->attribute_count != 1) {
-		dlog_verbose("Multiple recipients not supported.\n");
-		mpool_free(page_pool, memory_region);
-		return spci_error(SPCI_NOT_SUPPORTED);
-	}
-
-	/* The recipient must match the message recipient. */
-	if (memory_region->attributes[0].receiver != to->id) {
-		mpool_free(page_pool, memory_region);
-		return spci_error(SPCI_INVALID_PARAMETERS);
-	}
-
-	clear = memory_region->flags & SPCI_MEMORY_REGION_FLAG_CLEAR;
-	/*
-	 * Clear is not allowed for memory sharing, as the sender still has
-	 * access to the memory.
-	 */
-	if (clear && share_func == SPCI_MEM_SHARE_32) {
-		dlog_verbose("Memory can't be cleared while being shared.\n");
-		return spci_error(SPCI_INVALID_PARAMETERS);
+	/* Set flag for share function, ready to be retrieved later. */
+	switch (share_func) {
+	case SPCI_MEM_SHARE_32:
+		memory_region->flags |=
+			SPCI_MEMORY_REGION_TRANSACTION_TYPE_SHARE;
+		break;
+	case SPCI_MEM_LEND_32:
+		memory_region->flags |=
+			SPCI_MEMORY_REGION_TRANSACTION_TYPE_LEND;
+		break;
+	case SPCI_MEM_DONATE_32:
+		memory_region->flags |=
+			SPCI_MEMORY_REGION_TRANSACTION_TYPE_DONATE;
+		break;
 	}
 
 	/*
@@ -1029,8 +1181,10 @@
 	dump_share_states();
 
 	/* Check that state is valid in sender page table and update. */
-	ret = spci_send_memory(from_locked, constituents, constituent_count,
-			       share_func, page_pool, clear);
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	ret = spci_send_memory(from_locked, composite->constituents,
+			       composite->constituent_count, share_func,
+			       permissions, page_pool, clear);
 	if (ret.func != SPCI_SUCCESS_32) {
 		if (to->id != HF_TEE_VM_ID) {
 			/* Free share state. */
@@ -1043,7 +1197,7 @@
 	}
 
 	if (to->id == HF_TEE_VM_ID) {
-		/* Return directly, no need to allocate share state. */
+		/* No share state allocated here so no handle to return. */
 		return (struct spci_value){.func = SPCI_SUCCESS_32};
 	}
 
@@ -1051,20 +1205,27 @@
 }
 
 struct spci_value spci_memory_retrieve(
-	struct vm_locked to_locked,
-	struct spci_memory_retrieve_request *retrieve_request,
+	struct vm_locked to_locked, struct spci_memory_region *retrieve_request,
 	uint32_t retrieve_request_size, struct mpool *page_pool)
 {
 	uint32_t expected_retrieve_request_size =
-		sizeof(struct spci_memory_retrieve_request) +
-		retrieve_request->retrieve_properties_count *
-			sizeof(struct spci_memory_retrieve_properties);
+		sizeof(struct spci_memory_region) +
+		retrieve_request->receiver_count *
+			sizeof(struct spci_memory_access);
 	spci_memory_handle_t handle = retrieve_request->handle;
+	spci_memory_region_flags_t transaction_type =
+		retrieve_request->flags &
+		SPCI_MEMORY_REGION_TRANSACTION_TYPE_MASK;
 	struct spci_memory_region *memory_region;
-	struct spci_memory_retrieve_properties *retrieve_properties;
+	spci_memory_access_permissions_t sent_permissions;
+	enum spci_data_access sent_data_access;
+	enum spci_instruction_access sent_instruction_access;
+	spci_memory_access_permissions_t requested_permissions;
+	enum spci_data_access requested_data_access;
+	enum spci_instruction_access requested_instruction_access;
+	spci_memory_access_permissions_t permissions;
 	uint32_t memory_to_attributes;
-	struct spci_memory_region_constituent *constituents;
-	uint32_t constituent_count;
+	struct spci_composite_memory_region *composite;
 	struct share_states_locked share_states;
 	struct spci_memory_share_state *share_state;
 	struct spci_value ret;
@@ -1080,6 +1241,15 @@
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
+	if (retrieve_request->receiver_count != 1) {
+		dlog_verbose(
+			"Multi-way memory sharing not supported (got %d "
+			"receivers descriptors on SPCI_MEM_RETRIEVE_REQ, "
+			"expected 1).\n",
+			retrieve_request->receiver_count);
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
 	share_states = share_states_lock();
 	if (!get_share_state(share_states, handle, &share_state)) {
 		dlog_verbose("Invalid handle %#x for SPCI_MEM_RETRIEVE_REQ.\n",
@@ -1088,19 +1258,28 @@
 		goto out;
 	}
 
-	if (retrieve_request->share_func != share_state->share_func) {
+	memory_region = share_state->memory_region;
+	CHECK(memory_region != NULL);
+
+	/*
+	 * Check that the transaction type expected by the receiver is correct,
+	 * if it has been specified.
+	 */
+	if (transaction_type !=
+		    SPCI_MEMORY_REGION_TRANSACTION_TYPE_UNSPECIFIED &&
+	    transaction_type != (memory_region->flags &
+				 SPCI_MEMORY_REGION_TRANSACTION_TYPE_MASK)) {
 		dlog_verbose(
 			"Incorrect transaction type %#x for "
 			"SPCI_MEM_RETRIEVE_REQ, expected %#x for handle %#x.\n",
-			retrieve_request->share_func, share_state->share_func,
+			transaction_type,
+			memory_region->flags &
+				SPCI_MEMORY_REGION_TRANSACTION_TYPE_MASK,
 			handle);
 		ret = spci_error(SPCI_INVALID_PARAMETERS);
 		goto out;
 	}
 
-	memory_region = share_state->memory_region;
-	CHECK(memory_region != NULL);
-
 	if (retrieve_request->sender != memory_region->sender) {
 		dlog_verbose(
 			"Incorrect sender ID %d for SPCI_MEM_RETRIEVE_REQ, "
@@ -1120,11 +1299,25 @@
 		goto out;
 	}
 
-	if (memory_region->attributes[0].receiver != to_locked.vm->id) {
+	if (retrieve_request->receivers[0].receiver_permissions.receiver !=
+	    to_locked.vm->id) {
+		dlog_verbose(
+			"Retrieve request receiver VM ID %d didn't match "
+			"caller of SPCI_MEM_RETRIEVE_REQ.\n",
+			retrieve_request->receivers[0]
+				.receiver_permissions.receiver);
+		ret = spci_error(SPCI_INVALID_PARAMETERS);
+		goto out;
+	}
+
+	if (memory_region->receivers[0].receiver_permissions.receiver !=
+	    to_locked.vm->id) {
 		dlog_verbose(
 			"Incorrect receiver VM ID %d for "
 			"SPCI_MEM_RETRIEVE_REQ, expected %d for handle %#x.\n",
-			to_locked.vm->id, memory_region->attributes[0].receiver,
+			to_locked.vm->id,
+			memory_region->receivers[0]
+				.receiver_permissions.receiver,
 			handle);
 		ret = spci_error(SPCI_INVALID_PARAMETERS);
 		goto out;
@@ -1137,64 +1330,97 @@
 		goto out;
 	}
 
-	if (retrieve_request->attribute_count != 0) {
-		dlog_verbose(
-			"Multi-way memory sharing not supported (got %d "
-			"attribute descriptors on SPCI_MEM_RETRIEVE_REQ, "
-			"expected 0).\n",
-			retrieve_request->attribute_count);
-		ret = spci_error(SPCI_NOT_SUPPORTED);
-		goto out;
-	}
-
-	if (retrieve_request->retrieve_properties_count != 1) {
-		dlog_verbose(
-			"Stream endpoints not supported (got %d retrieve "
-			"properties descriptors on SPCI_MEM_RETRIEVE_REQ, "
-			"expected 1).\n",
-			retrieve_request->retrieve_properties_count);
-		ret = spci_error(SPCI_INVALID_PARAMETERS);
-		goto out;
-	}
-
-	retrieve_properties =
-		spci_memory_retrieve_request_first_retrieve_properties(
-			retrieve_request);
-
-	if (retrieve_properties->attributes.receiver != to_locked.vm->id) {
-		dlog_verbose(
-			"Retrieve properties receiver VM ID %d didn't match "
-			"caller of SPCI_MEM_RETRIEVE_REQ.\n",
-			retrieve_properties->attributes.receiver);
-		ret = spci_error(SPCI_INVALID_PARAMETERS);
-		goto out;
-	}
-
-	if (retrieve_properties->page_count != memory_region->page_count) {
-		dlog_verbose(
-			"Incorrect page count %d for "
-			"SPCI_MEM_RETRIEVE_REQ, expected %d for handle %#x.\n",
-			retrieve_properties->page_count,
-			memory_region->page_count, handle);
-		ret = spci_error(SPCI_INVALID_PARAMETERS);
-		goto out;
-	}
-
-	if (retrieve_properties->constituent_count != 0) {
+	if (retrieve_request->receivers[0].composite_memory_region_offset !=
+	    0) {
 		dlog_verbose(
 			"Retriever specified address ranges not supported (got "
+			"offset"
 			"%d).\n",
-			retrieve_properties->constituent_count);
+			retrieve_request->receivers[0]
+				.composite_memory_region_offset);
 		ret = spci_error(SPCI_INVALID_PARAMETERS);
 		goto out;
 	}
 
-	memory_to_attributes = spci_memory_attrs_to_mode(
-		memory_region->attributes[0].memory_attributes);
+	/*
+	 * Check permissions from sender against permissions requested by
+	 * receiver.
+	 */
+	/* TODO: Check attributes too. */
+	sent_permissions =
+		memory_region->receivers[0].receiver_permissions.permissions;
+	sent_data_access = spci_get_data_access_attr(sent_permissions);
+	sent_instruction_access =
+		spci_get_instruction_access_attr(sent_permissions);
+	requested_permissions =
+		retrieve_request->receivers[0].receiver_permissions.permissions;
+	requested_data_access =
+		spci_get_data_access_attr(requested_permissions);
+	requested_instruction_access =
+		spci_get_instruction_access_attr(requested_permissions);
+	permissions = 0;
+	switch (sent_data_access) {
+	case SPCI_DATA_ACCESS_NOT_SPECIFIED:
+	case SPCI_DATA_ACCESS_RW:
+		if (requested_data_access == SPCI_DATA_ACCESS_NOT_SPECIFIED ||
+		    requested_data_access == SPCI_DATA_ACCESS_RW) {
+			spci_set_data_access_attr(&permissions,
+						  SPCI_DATA_ACCESS_RW);
+			break;
+		}
+		/* Intentional fall-through. */
+	case SPCI_DATA_ACCESS_RO:
+		if (requested_data_access == SPCI_DATA_ACCESS_NOT_SPECIFIED ||
+		    requested_data_access == SPCI_DATA_ACCESS_RO) {
+			spci_set_data_access_attr(&permissions,
+						  SPCI_DATA_ACCESS_RO);
+			break;
+		}
+		dlog_verbose(
+			"Invalid data access requested; sender specified "
+			"permissions %#x but receiver requested %#x.\n",
+			sent_permissions, requested_permissions);
+		ret = spci_error(SPCI_DENIED);
+		goto out;
+	case SPCI_DATA_ACCESS_RESERVED:
+		panic("Got unexpected SPCI_DATA_ACCESS_RESERVED. Should be "
+		      "checked before this point.");
+	}
+	switch (sent_instruction_access) {
+	case SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED:
+	case SPCI_INSTRUCTION_ACCESS_X:
+		if (requested_instruction_access ==
+			    SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED ||
+		    requested_instruction_access == SPCI_INSTRUCTION_ACCESS_X) {
+			spci_set_instruction_access_attr(
+				&permissions, SPCI_INSTRUCTION_ACCESS_X);
+			break;
+		}
+	case SPCI_INSTRUCTION_ACCESS_NX:
+		if (requested_instruction_access ==
+			    SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED ||
+		    requested_instruction_access ==
+			    SPCI_INSTRUCTION_ACCESS_NX) {
+			spci_set_instruction_access_attr(
+				&permissions, SPCI_INSTRUCTION_ACCESS_NX);
+			break;
+		}
+		dlog_verbose(
+			"Invalid instruction access requested; sender "
+			"specified "
+			"permissions %#x but receiver requested %#x.\n",
+			sent_permissions, requested_permissions);
+		ret = spci_error(SPCI_DENIED);
+		goto out;
+	case SPCI_INSTRUCTION_ACCESS_RESERVED:
+		panic("Got unexpected SPCI_INSTRUCTION_ACCESS_RESERVED. Should "
+		      "be checked before this point.");
+	}
+	memory_to_attributes = spci_memory_permissions_to_mode(permissions);
 
-	constituents = spci_memory_region_get_constituents(memory_region);
-	constituent_count = memory_region->constituent_count;
-	ret = spci_retrieve_memory(to_locked, constituents, constituent_count,
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	ret = spci_retrieve_memory(to_locked, composite->constituents,
+				   composite->constituent_count,
 				   memory_to_attributes,
 				   share_state->share_func, false, page_pool);
 	if (ret.func != SPCI_SUCCESS_32) {
@@ -1205,9 +1431,12 @@
 	 * Copy response to RX buffer of caller and deliver the message. This
 	 * must be done before the share_state is (possibly) freed.
 	 */
+	/* TODO: combine attributes from sender and request. */
 	response_size = spci_retrieved_memory_region_init(
-		to_locked.vm->mailbox.recv, HF_MAILBOX_SIZE, to_locked.vm->id,
-		constituents, constituent_count, memory_region->page_count);
+		to_locked.vm->mailbox.recv, HF_MAILBOX_SIZE,
+		memory_region->sender, memory_region->attributes,
+		memory_region->flags, handle, to_locked.vm->id, permissions,
+		composite->constituents, composite->constituent_count);
 	to_locked.vm->mailbox.recv_size = response_size;
 	to_locked.vm->mailbox.recv_sender = HF_HYPERVISOR_VM_ID;
 	to_locked.vm->mailbox.recv_func = SPCI_MEM_RETRIEVE_RESP_32;
@@ -1225,8 +1454,8 @@
 	}
 
 	ret = (struct spci_value){.func = SPCI_MEM_RETRIEVE_RESP_32,
-				  .arg3 = response_size,
-				  .arg4 = response_size};
+				  .arg1 = response_size,
+				  .arg2 = response_size};
 
 out:
 	share_states_unlock(&share_states);
@@ -1243,23 +1472,22 @@
 	struct spci_memory_share_state *share_state;
 	struct spci_memory_region *memory_region;
 	bool clear;
-	struct spci_memory_region_constituent *constituents;
-	uint32_t constituent_count;
+	struct spci_composite_memory_region *composite;
 	struct spci_value ret;
 
-	if (relinquish_request->endpoint_count != 0) {
+	if (relinquish_request->endpoint_count != 1) {
 		dlog_verbose(
-			"Stream endpoints not supported (got %d extra "
-			"endpoints on SPCI_MEM_RELINQUISH, expected 0).\n",
+			"Stream endpoints not supported (got %d endpoints on "
+			"SPCI_MEM_RELINQUISH, expected 1).\n",
 			relinquish_request->endpoint_count);
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
-	if (relinquish_request->sender != from_locked.vm->id) {
+	if (relinquish_request->endpoints[0] != from_locked.vm->id) {
 		dlog_verbose(
 			"VM ID %d in relinquish message doesn't match calling "
 			"VM ID %d.\n",
-			relinquish_request->sender, from_locked.vm->id);
+			relinquish_request->endpoints[0], from_locked.vm->id);
 		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
@@ -1276,12 +1504,14 @@
 	memory_region = share_state->memory_region;
 	CHECK(memory_region != NULL);
 
-	if (memory_region->attributes[0].receiver != from_locked.vm->id) {
+	if (memory_region->receivers[0].receiver_permissions.receiver !=
+	    from_locked.vm->id) {
 		dlog_verbose(
 			"VM ID %d tried to relinquish memory region with "
 			"handle %#x but receiver was %d.\n",
 			from_locked.vm->id, handle,
-			memory_region->attributes[0].receiver);
+			memory_region->receivers[0]
+				.receiver_permissions.receiver);
 		ret = spci_error(SPCI_INVALID_PARAMETERS);
 		goto out;
 	}
@@ -1307,10 +1537,10 @@
 		goto out;
 	}
 
-	constituents = spci_memory_region_get_constituents(memory_region);
-	constituent_count = memory_region->constituent_count;
-	ret = spci_relinquish_memory(from_locked, constituents,
-				     constituent_count, page_pool, clear);
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	ret = spci_relinquish_memory(from_locked, composite->constituents,
+				     composite->constituent_count, page_pool,
+				     clear);
 
 	if (ret.func == SPCI_SUCCESS_32) {
 		/*
@@ -1338,8 +1568,7 @@
 	struct share_states_locked share_states;
 	struct spci_memory_share_state *share_state;
 	struct spci_memory_region *memory_region;
-	struct spci_memory_region_constituent *constituents;
-	uint32_t constituent_count;
+	struct spci_composite_memory_region *composite;
 	uint32_t memory_to_attributes = MM_MODE_R | MM_MODE_W | MM_MODE_X;
 	struct spci_value ret;
 
@@ -1374,9 +1603,9 @@
 		goto out;
 	}
 
-	constituents = spci_memory_region_get_constituents(memory_region);
-	constituent_count = memory_region->constituent_count;
-	ret = spci_retrieve_memory(to_locked, constituents, constituent_count,
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	ret = spci_retrieve_memory(to_locked, composite->constituents,
+				   composite->constituent_count,
 				   memory_to_attributes, SPCI_MEM_RECLAIM_32,
 				   clear, page_pool);
 
diff --git a/test/inc/test/vmapi/spci.h b/test/inc/test/vmapi/spci.h
index 24e9fc5..bab7f81 100644
--- a/test/inc/test/vmapi/spci.h
+++ b/test/inc/test/vmapi/spci.h
@@ -36,7 +36,14 @@
 	spci_vm_id_t recipient,
 	struct spci_memory_region_constituent constituents[],
 	uint32_t constituent_count, spci_memory_region_flags_t flags,
-	enum spci_memory_access access);
+	enum spci_data_access send_data_access,
+	enum spci_data_access retrieve_data_access,
+	enum spci_instruction_access send_instruction_access,
+	enum spci_instruction_access retrieve_instruction_access);
 spci_vm_id_t retrieve_memory_from_message(void *recv_buf, void *send_buf,
 					  struct spci_value msg_ret,
 					  spci_memory_handle_t *handle);
+spci_vm_id_t retrieve_memory_from_message_expect_fail(void *recv_buf,
+						      void *send_buf,
+						      struct spci_value msg_ret,
+						      int32_t expected_error);
diff --git a/test/vmapi/common/spci.c b/test/vmapi/common/spci.c
index c3176b3..0bc3380 100644
--- a/test/vmapi/common/spci.c
+++ b/test/vmapi/common/spci.c
@@ -51,28 +51,30 @@
 	spci_vm_id_t recipient,
 	struct spci_memory_region_constituent constituents[],
 	uint32_t constituent_count, spci_memory_region_flags_t flags,
-	enum spci_memory_access access)
+	enum spci_data_access send_data_access,
+	enum spci_data_access retrieve_data_access,
+	enum spci_instruction_access send_instruction_access,
+	enum spci_instruction_access retrieve_instruction_access)
 {
 	uint32_t msg_size;
 	struct spci_value ret;
-	uint32_t page_count = 0;
-	uint32_t handle;
-	uint32_t i;
+	spci_memory_handle_t handle;
 
 	/* Send the memory. */
 	msg_size = spci_memory_region_init(
 		tx_buffer, sender, recipient, constituents, constituent_count,
-		0, flags, access, SPCI_MEMORY_NORMAL_MEM,
-		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+		0, flags, send_data_access, send_instruction_access,
+		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+		SPCI_MEMORY_OUTER_SHAREABLE);
 	switch (share_func) {
 	case SPCI_MEM_DONATE_32:
-		ret = spci_mem_donate(msg_size, msg_size, 0);
+		ret = spci_mem_donate(msg_size, msg_size);
 		break;
 	case SPCI_MEM_LEND_32:
-		ret = spci_mem_lend(msg_size, msg_size, 0);
+		ret = spci_mem_lend(msg_size, msg_size);
 		break;
 	case SPCI_MEM_SHARE_32:
-		ret = spci_mem_share(msg_size, msg_size, 0);
+		ret = spci_mem_share(msg_size, msg_size);
 		break;
 	default:
 		FAIL("Invalid share_func %#x.\n", share_func);
@@ -82,18 +84,14 @@
 	EXPECT_EQ(ret.func, SPCI_SUCCESS_32);
 	handle = spci_mem_success_handle(ret);
 
-	/* Count pages. */
-	for (i = 0; i < constituent_count; ++i) {
-		page_count += constituents[i].page_count;
-	}
-
 	/*
 	 * Send the appropriate retrieve request to the VM so that it can use it
 	 * to retrieve the memory.
 	 */
 	msg_size = spci_memory_retrieve_request_init(
-		tx_buffer, handle, sender, recipient, share_func, 0, page_count,
-		access, SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+		tx_buffer, handle, sender, recipient, 0, 0,
+		retrieve_data_access, retrieve_instruction_access,
+		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 		SPCI_MEMORY_OUTER_SHAREABLE);
 	EXPECT_EQ(spci_msg_send(sender, recipient, msg_size, 0).func,
 		  SPCI_SUCCESS_32);
@@ -102,7 +100,7 @@
 }
 
 /*
- * Use the retrieve request from the recieve buffer to retrieve a memory region
+ * Use the retrieve request from the receive buffer to retrieve a memory region
  * which has been sent to us. Returns the sender, and the handle via a return
  * parameter.
  */
@@ -112,7 +110,7 @@
 {
 	uint32_t msg_size;
 	struct spci_value ret;
-	struct spci_retrieved_memory_region *memory_region;
+	struct spci_memory_region *memory_region;
 	spci_vm_id_t sender;
 
 	EXPECT_EQ(msg_ret.func, SPCI_MSG_SEND_32);
@@ -120,16 +118,44 @@
 	sender = spci_msg_send_sender(msg_ret);
 
 	if (handle != NULL) {
-		struct spci_memory_retrieve_request *retrieve_request =
-			(struct spci_memory_retrieve_request *)recv_buf;
+		struct spci_memory_region *retrieve_request =
+			(struct spci_memory_region *)recv_buf;
 		*handle = retrieve_request->handle;
 	}
 	memcpy_s(send_buf, HF_MAILBOX_SIZE, recv_buf, msg_size);
 	spci_rx_release();
-	ret = spci_mem_retrieve_req(msg_size, msg_size, 0);
+	ret = spci_mem_retrieve_req(msg_size, msg_size);
 	EXPECT_EQ(ret.func, SPCI_MEM_RETRIEVE_RESP_32);
-	memory_region = (struct spci_retrieved_memory_region *)recv_buf;
+	memory_region = (struct spci_memory_region *)recv_buf;
 	EXPECT_EQ(memory_region->receiver_count, 1);
+	EXPECT_EQ(memory_region->receivers[0].receiver_permissions.receiver,
+		  hf_vm_get_id());
+
+	return sender;
+}
+
+/*
+ * Use the retrieve request from the receive buffer to retrieve a memory region
+ * which has been sent to us, expecting it to fail with the given error code.
+ * Returns the sender.
+ */
+spci_vm_id_t retrieve_memory_from_message_expect_fail(void *recv_buf,
+						      void *send_buf,
+						      struct spci_value msg_ret,
+						      int32_t expected_error)
+{
+	uint32_t msg_size;
+	struct spci_value ret;
+	spci_vm_id_t sender;
+
+	EXPECT_EQ(msg_ret.func, SPCI_MSG_SEND_32);
+	msg_size = spci_msg_send_size(msg_ret);
+	sender = spci_msg_send_sender(msg_ret);
+
+	memcpy_s(send_buf, HF_MAILBOX_SIZE, recv_buf, msg_size);
+	spci_rx_release();
+	ret = spci_mem_retrieve_req(msg_size, msg_size);
+	EXPECT_SPCI_ERROR(ret, expected_error);
 
 	return sender;
 }
diff --git a/test/vmapi/primary_with_secondaries/memory_sharing.c b/test/vmapi/primary_with_secondaries/memory_sharing.c
index 5050f11..f1a0aae 100644
--- a/test/vmapi/primary_with_secondaries/memory_sharing.c
+++ b/test/vmapi/primary_with_secondaries/memory_sharing.c
@@ -33,22 +33,26 @@
  */
 static void check_cannot_send_memory(
 	struct mailbox_buffers mb,
-	struct spci_value (*send_function)(uint32_t, uint32_t, uint32_t),
+	struct spci_value (*send_function)(uint32_t, uint32_t),
 	struct spci_memory_region_constituent constituents[],
 	int constituent_count, int32_t avoid_vm)
 
 {
-	enum spci_memory_access access[] = {SPCI_MEMORY_RO_NX, SPCI_MEMORY_RO_X,
-					    SPCI_MEMORY_RW_NX,
-					    SPCI_MEMORY_RW_X};
+	enum spci_data_access data_access[] = {
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RW, SPCI_DATA_ACCESS_RESERVED};
+	enum spci_instruction_access instruction_access[] = {
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX, SPCI_INSTRUCTION_ACCESS_X,
+		SPCI_INSTRUCTION_ACCESS_RESERVED};
 	enum spci_memory_cacheability cacheability[] = {
-		SPCI_MEMORY_CACHE_NON_CACHEABLE,
-		SPCI_MEMORY_CACHE_WRITE_THROUGH, SPCI_MEMORY_CACHE_WRITE_BACK};
+		SPCI_MEMORY_CACHE_RESERVED, SPCI_MEMORY_CACHE_NON_CACHEABLE,
+		SPCI_MEMORY_CACHE_RESERVED_1, SPCI_MEMORY_CACHE_WRITE_BACK};
 	enum spci_memory_cacheability device[] = {
 		SPCI_MEMORY_DEV_NGNRNE, SPCI_MEMORY_DEV_NGNRE,
 		SPCI_MEMORY_DEV_NGRE, SPCI_MEMORY_DEV_GRE};
 	enum spci_memory_shareability shareability[] = {
-		SPCI_MEMORY_SHARE_NON_SHAREABLE, SPCI_MEMORY_RESERVED,
+		SPCI_MEMORY_SHARE_NON_SHAREABLE, SPCI_MEMORY_SHARE_RESERVED,
 		SPCI_MEMORY_OUTER_SHAREABLE, SPCI_MEMORY_INNER_SHAREABLE};
 	uint32_t vms[] = {HF_PRIMARY_VM_ID, SERVICE_VM1, SERVICE_VM2};
 
@@ -56,45 +60,75 @@
 	size_t j = 0;
 	size_t k = 0;
 	size_t l = 0;
+	size_t m = 0;
 
 	for (i = 0; i < ARRAY_SIZE(vms); ++i) {
 		/* Optionally skip one VM as the send would succeed. */
 		if (vms[i] == avoid_vm) {
 			continue;
 		}
-		for (j = 0; j < ARRAY_SIZE(access); ++j) {
-			for (k = 0; k < ARRAY_SIZE(shareability); ++k) {
-				for (l = 0; l < ARRAY_SIZE(cacheability); ++l) {
-					uint32_t msg_size =
-						spci_memory_region_init(
-							mb.send,
-							HF_PRIMARY_VM_ID,
-							vms[i], constituents,
-							constituent_count, 0, 0,
-							access[j],
-							SPCI_MEMORY_NORMAL_MEM,
-							cacheability[l],
-							shareability[k]);
-					EXPECT_SPCI_ERROR(
-						send_function(msg_size,
-							      msg_size, 0),
-						SPCI_INVALID_PARAMETERS);
-				}
-				for (l = 0; l < ARRAY_SIZE(device); ++l) {
-					uint32_t msg_size =
-						spci_memory_region_init(
-							mb.send,
-							HF_PRIMARY_VM_ID,
-							vms[i], constituents,
-							constituent_count, 0, 0,
-							access[j],
-							SPCI_MEMORY_DEVICE_MEM,
-							device[l],
-							shareability[k]);
-					EXPECT_SPCI_ERROR(
-						send_function(msg_size,
-							      msg_size, 0),
-						SPCI_INVALID_PARAMETERS);
+		for (j = 0; j < ARRAY_SIZE(data_access); ++j) {
+			for (k = 0; k < ARRAY_SIZE(instruction_access); ++k) {
+				for (l = 0; l < ARRAY_SIZE(shareability); ++l) {
+					for (m = 0;
+					     m < ARRAY_SIZE(cacheability);
+					     ++m) {
+						uint32_t msg_size =
+							spci_memory_region_init(
+								mb.send,
+								HF_PRIMARY_VM_ID,
+								vms[i],
+								constituents,
+								constituent_count,
+								0, 0,
+								data_access[j],
+								instruction_access
+									[k],
+								SPCI_MEMORY_NORMAL_MEM,
+								cacheability[m],
+								shareability
+									[l]);
+						struct spci_value ret =
+							send_function(msg_size,
+								      msg_size);
+
+						EXPECT_EQ(ret.func,
+							  SPCI_ERROR_32);
+						EXPECT_TRUE(
+							ret.arg2 ==
+								SPCI_DENIED ||
+							ret.arg2 ==
+								SPCI_INVALID_PARAMETERS);
+					}
+					for (m = 0; m < ARRAY_SIZE(device);
+					     ++m) {
+						uint32_t msg_size =
+							spci_memory_region_init(
+								mb.send,
+								HF_PRIMARY_VM_ID,
+								vms[i],
+								constituents,
+								constituent_count,
+								0, 0,
+								data_access[j],
+								instruction_access
+									[k],
+								SPCI_MEMORY_DEVICE_MEM,
+								device[m],
+								shareability
+									[l]);
+						struct spci_value ret =
+							send_function(msg_size,
+								      msg_size);
+
+						EXPECT_EQ(ret.func,
+							  SPCI_ERROR_32);
+						EXPECT_TRUE(
+							ret.arg2 ==
+								SPCI_DENIED ||
+							ret.arg2 ==
+								SPCI_INVALID_PARAMETERS);
+					}
 				}
 			}
 		}
@@ -142,17 +176,21 @@
 	size_t i;
 	for (i = 0; i < ARRAY_SIZE(vms); ++i) {
 		uint32_t msg_size;
+		struct spci_value ret;
 		/* Optionally skip one VM as the donate would succeed. */
 		if (vms[i] == avoid_vm) {
 			continue;
 		}
 		msg_size = spci_memory_region_init(
 			mb.send, HF_PRIMARY_VM_ID, vms[i], constituents,
-			constituent_count, 0, 0, SPCI_MEMORY_RW_X,
+			constituent_count, 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+			SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
 			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
-				  SPCI_INVALID_PARAMETERS);
+		ret = spci_mem_donate(msg_size, msg_size);
+		EXPECT_EQ(ret.func, SPCI_ERROR_32);
+		EXPECT_TRUE(ret.arg2 == SPCI_DENIED ||
+			    ret.arg2 == SPCI_INVALID_PARAMETERS);
 	}
 }
 
@@ -167,9 +205,12 @@
 
 	size_t i;
 	for (i = 0; i < ARRAY_SIZE(vms); ++i) {
-		*(struct spci_mem_relinquish *)mb.send =
-			(struct spci_mem_relinquish){.handle = handle,
-						     .sender = vms[i]};
+		struct spci_mem_relinquish *relinquish_req =
+			(struct spci_mem_relinquish *)mb.send;
+
+		*relinquish_req = (struct spci_mem_relinquish){
+			.handle = handle, .endpoint_count = 1};
+		relinquish_req->endpoints[0] = vms[i];
 		EXPECT_SPCI_ERROR(spci_mem_relinquish(),
 				  SPCI_INVALID_PARAMETERS);
 	}
@@ -190,7 +231,7 @@
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "memory_increment", mb.send);
@@ -199,7 +240,9 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
@@ -229,7 +272,7 @@
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
@@ -239,7 +282,9 @@
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	/* Let the memory be returned. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -262,7 +307,7 @@
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)PAGE_SIZE, 1),
+		{.address = (uint64_t)PAGE_SIZE, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
@@ -292,14 +337,15 @@
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
-		spci_memory_region_constituent_init((uint64_t)pages + PAGE_SIZE,
-						    2),
+		{.address = (uint64_t)pages, .page_count = 1},
+		{.address = (uint64_t)pages + PAGE_SIZE, .page_count = 2},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 
@@ -333,14 +379,16 @@
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
-		spci_memory_region_constituent_init((uint64_t)pages + PAGE_SIZE,
-						    2),
+		{.address = (uint64_t)pages, .page_count = 1},
+		{.address = (uint64_t)pages + PAGE_SIZE, .page_count = 2},
 	};
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/*
 	 * Let the service access the memory, and try and fail to relinquish it.
@@ -358,7 +406,7 @@
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
@@ -368,7 +416,10 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be returned, and retrieve it. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -395,7 +446,7 @@
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
@@ -405,7 +456,9 @@
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be returned. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -430,7 +483,7 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
@@ -438,7 +491,9 @@
 	/* Lend the memory initially. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be returned. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -449,7 +504,9 @@
 	/* Lend the memory again after it has been returned. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Observe the service doesn't fault when accessing the memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -467,7 +524,7 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
@@ -476,7 +533,9 @@
 	/* Lend the memory initially. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be returned. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -487,7 +546,9 @@
 	/* Share the memory with a different VM after it has been returned. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -501,8 +562,8 @@
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
-	struct spci_retrieved_memory_region *memory_region;
-	struct spci_receiver_address_range *range;
+	struct spci_memory_region *memory_region;
+	struct spci_composite_memory_region *composite;
 	uint8_t *ptr;
 
 	SERVICE_SELECT(SERVICE_VM1, "give_memory_and_fault", mb.send);
@@ -513,11 +574,12 @@
 		  SERVICE_VM1);
 
 	/* Check the memory was cleared. */
-	memory_region = (struct spci_retrieved_memory_region *)mb.recv;
-	range = spci_retrieved_memory_region_first_receiver_range(
-		memory_region);
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[0]);
+	memory_region = (struct spci_memory_region *)mb.recv;
+	ASSERT_EQ(memory_region->receiver_count, 1);
+	ASSERT_NE(memory_region->receivers[0].composite_memory_region_offset,
+		  0);
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	ptr = (uint8_t *)composite->constituents[0].address;
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
@@ -535,8 +597,8 @@
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
-	struct spci_retrieved_memory_region *memory_region;
-	struct spci_receiver_address_range *range;
+	struct spci_memory_region *memory_region;
+	struct spci_composite_memory_region *composite;
 	uint8_t *ptr;
 
 	SERVICE_SELECT(SERVICE_VM1, "lend_memory_and_fault", mb.send);
@@ -547,11 +609,12 @@
 		  SERVICE_VM1);
 
 	/* Check the memory was cleared. */
-	memory_region = (struct spci_retrieved_memory_region *)mb.recv;
-	range = spci_retrieved_memory_region_first_receiver_range(
-		memory_region);
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[0]);
+	memory_region = (struct spci_memory_region *)mb.recv;
+	ASSERT_EQ(memory_region->receiver_count, 1);
+	ASSERT_NE(memory_region->receivers[0].composite_memory_region_offset,
+		  0);
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	ptr = (uint8_t *)composite->constituents[0].address;
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
@@ -570,7 +633,6 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
-	uint64_t address;
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_check_upper_bound", mb.send);
 	SERVICE_SELECT(SERVICE_VM2, "spci_check_upper_bound", mb.send);
@@ -580,9 +642,8 @@
 
 	/* Specify non-contiguous memory regions. */
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 2, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
+		{.address = (uint64_t)pages + PAGE_SIZE * 2, .page_count = 1},
 	};
 
 	/*
@@ -593,19 +654,18 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
 		  1);
 
 	/* Use different memory regions for verifying the second constituent. */
-	address = (uint64_t)pages + PAGE_SIZE * 1;
-	constituents[0].address_high = address << 32;
-	constituents[0].address_low = (uint32_t)address;
-	address = (uint64_t)pages + PAGE_SIZE * 3;
-	constituents[1].address_high = address << 32;
-	constituents[1].address_low = (uint32_t)address;
+	constituents[0].address = (uint64_t)pages + PAGE_SIZE * 1;
+	constituents[1].address = (uint64_t)pages + PAGE_SIZE * 3;
 
 	/*
 	 * Specify that we now want to test the second constituent of the
@@ -619,7 +679,10 @@
 	 */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM2, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -634,7 +697,6 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
-	uint64_t address;
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_check_lower_bound", mb.send);
 	SERVICE_SELECT(SERVICE_VM2, "spci_check_lower_bound", mb.send);
@@ -644,9 +706,8 @@
 
 	/* Specify non-contiguous memory regions. */
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 2, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
+		{.address = (uint64_t)pages + PAGE_SIZE * 2, .page_count = 1},
 	};
 
 	/*
@@ -657,19 +718,18 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
 		  1);
 
 	/* Use different memory regions for verifying the second constituent. */
-	address = (uint64_t)pages + PAGE_SIZE * 1;
-	constituents[0].address_high = address << 32;
-	constituents[0].address_low = (uint32_t)address;
-	address = (uint64_t)pages + PAGE_SIZE * 3;
-	constituents[1].address_high = address << 32;
-	constituents[1].address_low = (uint32_t)address;
+	constituents[0].address = (uint64_t)pages + PAGE_SIZE * 1;
+	constituents[1].address = (uint64_t)pages + PAGE_SIZE * 3;
 
 	/*
 	 * Specify that we now want to test the second constituent of the
@@ -683,7 +743,10 @@
 	 */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM2, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -707,12 +770,15 @@
 	memset_s(ptr, sizeof(pages), 'b', 1 * PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 
@@ -724,7 +790,10 @@
 	/* Share the memory with another VM. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -748,7 +817,7 @@
 	memset_s(ptr, sizeof(pages), 'b', 1 * PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	/* Set up VM2 to wait for message. */
@@ -758,7 +827,10 @@
 	/* Donate memory. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be sent from VM1 to VM2. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -796,13 +868,16 @@
 	memset_s(ptr, sizeof(pages), 'b', 1 * PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	/* Donate memory to VM1. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be received. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -844,16 +919,16 @@
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	msg_size = spci_memory_region_init(
 		mb.send, HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
 
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 }
 
@@ -869,15 +944,15 @@
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	msg_size = spci_memory_region_init(
 		mb.send, HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size, 0),
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 }
 
@@ -893,15 +968,15 @@
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	msg_size = spci_memory_region_init(
 		mb.send, HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size, 0),
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 }
 
@@ -921,38 +996,41 @@
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	/* Try invalid configurations. */
 	msg_size = spci_memory_region_init(
 		mb.send, SERVICE_VM1, HF_PRIMARY_VM_ID, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	msg_size = spci_memory_region_init(
 		mb.send, SERVICE_VM1, SERVICE_VM1, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	msg_size = spci_memory_region_init(
 		mb.send, SERVICE_VM2, SERVICE_VM1, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	/* Successfully donate to VM1. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Receive and return memory from VM1. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -982,27 +1060,30 @@
 				continue;
 			}
 			struct spci_memory_region_constituent constituents[] = {
-				spci_memory_region_constituent_init(
-					(uint64_t)pages + i, 1),
-				spci_memory_region_constituent_init(
-					(uint64_t)pages + PAGE_SIZE + j, 1),
+				{.address = (uint64_t)pages + i,
+				 .page_count = 1},
+				{.address = (uint64_t)pages + PAGE_SIZE + j,
+				 .page_count = 1},
 			};
 			uint32_t msg_size = spci_memory_region_init(
 				mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
 				constituents, ARRAY_SIZE(constituents), 0, 0,
-				SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+				SPCI_DATA_ACCESS_NOT_SPECIFIED,
+				SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+				SPCI_MEMORY_NORMAL_MEM,
 				SPCI_MEMORY_CACHE_WRITE_BACK,
 				SPCI_MEMORY_OUTER_SHAREABLE);
-			EXPECT_SPCI_ERROR(
-				spci_mem_donate(msg_size, msg_size, 0),
-				SPCI_INVALID_PARAMETERS);
+			EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
+					  SPCI_INVALID_PARAMETERS);
 			msg_size = spci_memory_region_init(
 				mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
 				constituents, ARRAY_SIZE(constituents), 0, 0,
-				SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+				SPCI_DATA_ACCESS_RW,
+				SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+				SPCI_MEMORY_NORMAL_MEM,
 				SPCI_MEMORY_CACHE_WRITE_BACK,
 				SPCI_MEMORY_OUTER_SHAREABLE);
-			EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size, 0),
+			EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size),
 					  SPCI_INVALID_PARAMETERS);
 		}
 	}
@@ -1024,22 +1105,24 @@
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	/* Check cannot swap VM IDs. */
 	msg_size = spci_memory_region_init(
 		mb.send, SERVICE_VM1, HF_PRIMARY_VM_ID, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size, 0),
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	/* Lend memory to VM1. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Receive and return memory from VM1. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1069,12 +1152,14 @@
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1091,7 +1176,9 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1103,32 +1190,35 @@
 }
 
 /**
- * Memory can be shared with executable permissions.
+ * Memory cannot be shared with executable permissions.
  * Check RO and RW permissions.
  */
-TEST(memory_sharing, share_relinquish_X_RW)
+TEST(memory_sharing, share_X_RW)
 {
 	spci_memory_handle_t handle;
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
 
-	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish_RW", mb.send);
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_share_fail", mb.send);
 
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
-	/* Let the memory be accessed. */
+	/* Let the secondary VM fail to retrieve the memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 	/* Ensure we still have access. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -1136,10 +1226,7 @@
 		ptr[i]++;
 	}
 
-	/* Let service write to and return memory. */
-	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
-	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
+	/* Reclaim the memory. */
 	EXPECT_EQ(spci_mem_reclaim(handle, 0).func, SPCI_SUCCESS_32);
 
 	/* Re-initialise the memory before giving it. */
@@ -1147,11 +1234,14 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
-	/* Let the memory be accessed. */
+	/* Let the secondary VM fail to retrieve the memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 	/* Ensure we still have access. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -1159,9 +1249,8 @@
 		ptr[i]++;
 	}
 
-	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
-		  1);
+	/* Reclaim the memory. */
+	EXPECT_EQ(spci_mem_reclaim(handle, 0).func, SPCI_SUCCESS_32);
 }
 
 /**
@@ -1181,12 +1270,14 @@
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_NX);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1208,7 +1299,9 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_NX);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1243,12 +1336,14 @@
 	memset_s(ptr, sizeof(pages) * 2, 'b', PAGE_SIZE * 2);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
+		{.address = (uint64_t)pages, .page_count = 2},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_NX);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	/* Let the memory be received, fail to be cleared, and then returned. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1282,12 +1377,14 @@
 	*ptr2 = 0xD65F03C0;
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Attempt to execute from memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1297,7 +1394,9 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_NX);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -1324,12 +1423,14 @@
 	*ptr2 = 0xD65F03C0;
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Attempt to execute from memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1339,7 +1440,9 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_NX);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -1363,13 +1466,15 @@
 	memset_s(ptr, sizeof(pages) * 2, 'b', PAGE_SIZE * 2);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
+		{.address = (uint64_t)pages, .page_count = 2},
 	};
 
 	/* Lend memory to VM1. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1378,26 +1483,25 @@
 	/* Ensure we can't donate any sub section of memory to another VM. */
 	constituents[0].page_count = 1;
 	for (int i = 1; i < PAGE_SIZE * 2; i++) {
-		uint64_t address = (uint64_t)pages + PAGE_SIZE;
-		constituents[0].address_high = address << 32;
-		constituents[0].address_low = (uint32_t)address;
+		constituents[0].address = (uint64_t)pages + PAGE_SIZE;
 		msg_size = spci_memory_region_init(
 			mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2, constituents,
-			ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
+			ARRAY_SIZE(constituents), 0, 0,
+			SPCI_DATA_ACCESS_NOT_SPECIFIED,
+			SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
 			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
-				  SPCI_INVALID_PARAMETERS);
+		EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
+				  SPCI_DENIED);
 	}
 
 	/* Ensure we can't donate to the only borrower. */
 	msg_size = spci_memory_region_init(
 		mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
-			  SPCI_INVALID_PARAMETERS);
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size), SPCI_DENIED);
 }
 
 /**
@@ -1417,14 +1521,15 @@
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE * 4);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 2, 2),
+		{.address = (uint64_t)pages, .page_count = 2},
+		{.address = (uint64_t)pages + PAGE_SIZE * 2, .page_count = 2},
 	};
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RO_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1437,26 +1542,25 @@
 	/* Ensure we can't donate any sub section of memory to another VM. */
 	constituents[0].page_count = 1;
 	for (int i = 1; i < PAGE_SIZE * 2; i++) {
-		uint64_t address = (uint64_t)pages + PAGE_SIZE;
-		constituents[0].address_high = address << 32;
-		constituents[0].address_low = (uint32_t)address;
+		constituents[0].address = (uint64_t)pages + PAGE_SIZE;
 		msg_size = spci_memory_region_init(
 			mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2, constituents,
-			ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
+			ARRAY_SIZE(constituents), 0, 0,
+			SPCI_DATA_ACCESS_NOT_SPECIFIED,
+			SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
 			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
-				  SPCI_INVALID_PARAMETERS);
+		EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
+				  SPCI_DENIED);
 	}
 
 	/* Ensure we can't donate to the only borrower. */
 	msg_size = spci_memory_region_init(
 		mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
-			  SPCI_INVALID_PARAMETERS);
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size), SPCI_DENIED);
 }
 
 /**
@@ -1477,15 +1581,16 @@
 	memset_s(ptr, sizeof(pages), 'b', PAGE_SIZE * 4);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 3, 1),
+		{.address = (uint64_t)pages, .page_count = 2},
+		{.address = (uint64_t)pages + PAGE_SIZE * 3, .page_count = 1},
 	};
 
 	/* Lend memory to VM1. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1505,8 +1610,7 @@
 
 	/* Now attempt to share only a portion of the same area of memory. */
 	struct spci_memory_region_constituent constituents_subsection[] = {
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 3, 1),
+		{.address = (uint64_t)pages + PAGE_SIZE * 3, .page_count = 1},
 	};
 	check_cannot_lend_memory(mb, constituents_subsection,
 				 ARRAY_SIZE(constituents_subsection), -1);
@@ -1517,16 +1621,15 @@
 	/* Attempt to lend again with different permissions. */
 	constituents[0].page_count = 1;
 	for (int i = 0; i < 2; i++) {
-		uint64_t address = (uint64_t)pages + i * PAGE_SIZE;
-		constituents[0].address_high = address << 32;
-		constituents[0].address_low = (uint32_t)address;
+		constituents[0].address = (uint64_t)pages + i * PAGE_SIZE;
 		msg_size = spci_memory_region_init(
 			mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2, constituents,
-			ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RO_X,
+			ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_RO,
+			SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
 			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size, 0),
-				  SPCI_INVALID_PARAMETERS);
+		EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size),
+				  SPCI_DENIED);
 	}
 }
 
@@ -1548,12 +1651,14 @@
 	memset_s(ptr, sizeof(pages) * 2, 'b', PAGE_SIZE * 2);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
+		{.address = (uint64_t)pages, .page_count = 2},
 	};
 
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_SHARE_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NX);
 
 	/* Let the memory be accessed. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -1576,16 +1681,15 @@
 	/* Attempt to share again with different permissions. */
 	constituents[0].page_count = 1;
 	for (int i = 0; i < 2; i++) {
-		uint64_t address = (uint64_t)pages + i * PAGE_SIZE;
-		constituents[0].address_high = address << 32;
-		constituents[0].address_low = (uint32_t)address;
+		constituents[0].address = (uint64_t)pages + i * PAGE_SIZE;
 		msg_size = spci_memory_region_init(
 			mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2, constituents,
-			ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RO_X,
+			ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_RO,
+			SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
 			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size, 0),
-				  SPCI_INVALID_PARAMETERS);
+		EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size),
+				  SPCI_DENIED);
 	}
 }
 
@@ -1605,14 +1709,16 @@
 	memset_s(ptr, sizeof(pages) * 2, 'b', PAGE_SIZE * 2);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
+		{.address = (uint64_t)pages, .page_count = 2},
 	};
 
 	/* Lend memory with clear flag. */
 	handle = send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
 		constituents, ARRAY_SIZE(constituents),
-		SPCI_MEMORY_REGION_FLAG_CLEAR, SPCI_MEMORY_RO_X);
+		SPCI_MEMORY_REGION_FLAG_CLEAR, SPCI_DATA_ACCESS_RO,
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 	/* Take it back again. */
 	spci_mem_reclaim(handle, 0);
 
@@ -1638,15 +1744,16 @@
 	memset_s(ptr, sizeof(pages) * 2, 'b', PAGE_SIZE * 2);
 
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 2),
+		{.address = (uint64_t)pages, .page_count = 2},
 	};
 
 	msg_size = spci_memory_region_init(
 		mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1, constituents,
 		ARRAY_SIZE(constituents), 0, SPCI_MEMORY_REGION_FLAG_CLEAR,
-		SPCI_MEMORY_RO_X, SPCI_MEMORY_NORMAL_MEM,
-		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size, 0),
+		SPCI_DATA_ACCESS_RO, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+		SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	/* Check that it has not been cleared. */
@@ -1663,7 +1770,6 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
-	uint64_t address;
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_check_upper_bound", mb.send);
 	SERVICE_SELECT(SERVICE_VM2, "spci_check_upper_bound", mb.send);
@@ -1673,9 +1779,8 @@
 
 	/* Specify non-contiguous memory regions. */
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 2, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
+		{.address = (uint64_t)pages + PAGE_SIZE * 2, .page_count = 1},
 	};
 
 	/*
@@ -1686,19 +1791,17 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
 		  1);
 
 	/* Use different memory regions for verifying the second constituent. */
-	address = (uint64_t)pages + PAGE_SIZE * 1;
-	constituents[0].address_high = address << 32;
-	constituents[0].address_low = (uint32_t)address;
-	address = (uint64_t)pages + PAGE_SIZE * 3;
-	constituents[1].address_high = address << 32;
-	constituents[1].address_low = (uint32_t)address;
+	constituents[0].address = (uint64_t)pages + PAGE_SIZE * 1;
+	constituents[1].address = (uint64_t)pages + PAGE_SIZE * 3;
 
 	/*
 	 * Specify that we now want to test the second constituent of the
@@ -1712,7 +1815,9 @@
 	 */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM2, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
@@ -1727,7 +1832,6 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = pages;
-	uint64_t address;
 
 	SERVICE_SELECT(SERVICE_VM1, "spci_check_lower_bound", mb.send);
 	SERVICE_SELECT(SERVICE_VM2, "spci_check_lower_bound", mb.send);
@@ -1737,9 +1841,8 @@
 
 	/* Specify non-contiguous memory regions. */
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)pages, 1),
-		spci_memory_region_constituent_init(
-			(uint64_t)pages + PAGE_SIZE * 2, 1),
+		{.address = (uint64_t)pages, .page_count = 1},
+		{.address = (uint64_t)pages + PAGE_SIZE * 2, .page_count = 1},
 	};
 
 	/*
@@ -1750,19 +1853,17 @@
 
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM1,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
 		  1);
 
 	/* Use different memory regions for verifying the second constituent. */
-	address = (uint64_t)pages + PAGE_SIZE * 1;
-	constituents[0].address_high = address << 32;
-	constituents[0].address_low = (uint32_t)address;
-	address = (uint64_t)pages + PAGE_SIZE * 3;
-	constituents[1].address_high = address << 32;
-	constituents[1].address_low = (uint32_t)address;
+	constituents[0].address = (uint64_t)pages + PAGE_SIZE * 1;
+	constituents[1].address = (uint64_t)pages + PAGE_SIZE * 3;
 
 	/*
 	 * Specify that we now want to test the second constituent of the
@@ -1776,7 +1877,9 @@
 	 */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, mb.send, HF_PRIMARY_VM_ID, SERVICE_VM2,
-		constituents, ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X);
+		constituents, ARRAY_SIZE(constituents), 0, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	run_res = spci_run(SERVICE_VM2, 0);
 	EXPECT_EQ(exception_handler_receive_exception_count(&run_res, mb.recv),
diff --git a/test/vmapi/primary_with_secondaries/services/memory.c b/test/vmapi/primary_with_secondaries/services/memory.c
index 0a1c561..2c07835 100644
--- a/test/vmapi/primary_with_secondaries/services/memory.c
+++ b/test/vmapi/primary_with_secondaries/services/memory.c
@@ -16,6 +16,7 @@
 
 #include "hf/arch/vm/interrupts.h"
 
+#include "hf/check.h"
 #include "hf/mm.h"
 #include "hf/std.h"
 
@@ -39,14 +40,16 @@
 		struct spci_value ret = spci_msg_wait();
 		spci_vm_id_t sender = retrieve_memory_from_message(
 			recv_buf, send_buf, ret, NULL);
-		struct spci_retrieved_memory_region *memory_region =
-			(struct spci_retrieved_memory_region *)recv_buf;
-		struct spci_receiver_address_range *range =
-			spci_retrieved_memory_region_first_receiver_range(
-				memory_region);
-		uint8_t *ptr =
-			(uint8_t *)spci_memory_region_constituent_get_address(
-				&range->constituents[0]);
+		struct spci_memory_region *memory_region =
+			(struct spci_memory_region *)recv_buf;
+		struct spci_composite_memory_region *composite =
+			spci_memory_region_get_composite(memory_region, 0);
+		uint8_t *ptr = (uint8_t *)composite->constituents[0].address;
+
+		ASSERT_EQ(memory_region->receiver_count, 1);
+		ASSERT_NE(memory_region->receivers[0]
+				  .composite_memory_region_offset,
+			  0);
 
 		/* Allow the memory to be populated. */
 		EXPECT_EQ(spci_yield().func, SPCI_SUCCESS_32);
@@ -66,14 +69,16 @@
 {
 	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)&page, 1),
+		{.address = (uint64_t)&page, .page_count = 1},
 	};
 
 	/* Give memory to the primary. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, send_buf, hf_vm_get_id(), HF_PRIMARY_VM_ID,
 		constituents, ARRAY_SIZE(constituents),
-		SPCI_MEMORY_REGION_FLAG_CLEAR, SPCI_MEMORY_RW_X);
+		SPCI_MEMORY_REGION_FLAG_CLEAR, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	exception_setup(NULL, exception_handler_yield_data_abort);
 
@@ -87,14 +92,16 @@
 {
 	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init((uint64_t)&page, 1),
+		{.address = (uint64_t)&page, .page_count = 1},
 	};
 
 	/* Lend memory to the primary. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_LEND_32, send_buf, hf_vm_get_id(), HF_PRIMARY_VM_ID,
 		constituents, ARRAY_SIZE(constituents),
-		SPCI_MEMORY_REGION_FLAG_CLEAR, SPCI_MEMORY_RW_X);
+		SPCI_MEMORY_REGION_FLAG_CLEAR, SPCI_DATA_ACCESS_RW,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	exception_setup(NULL, exception_handler_yield_data_abort);
 
@@ -116,13 +123,12 @@
 
 	spci_vm_id_t sender =
 		retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	struct spci_retrieved_memory_region *memory_region =
-		(struct spci_retrieved_memory_region *)recv_buf;
-	struct spci_receiver_address_range *range =
-		spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[0]);
+	struct spci_memory_region *memory_region =
+		(struct spci_memory_region *)recv_buf;
+	struct spci_composite_memory_region *composite =
+		spci_memory_region_get_composite(memory_region, 0);
+
+	ptr = (uint8_t *)composite->constituents[0].address;
 
 	/* Check that one has access to the shared region. */
 	for (i = 0; i < PAGE_SIZE; ++i) {
@@ -132,8 +138,10 @@
 	/* Give the memory back and notify the sender. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, send_buf, hf_vm_get_id(), sender,
-		range->constituents, range->constituent_count, 0,
-		SPCI_MEMORY_RW_X);
+		composite->constituents, composite->constituent_count, 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 	/*
@@ -150,8 +158,8 @@
  */
 TEST_SERVICE(spci_check_upper_bound)
 {
-	struct spci_retrieved_memory_region *memory_region;
-	struct spci_receiver_address_range *range;
+	struct spci_memory_region *memory_region;
+	struct spci_composite_memory_region *composite;
 	uint8_t *ptr;
 	uint8_t index;
 
@@ -162,15 +170,12 @@
 	exception_setup(NULL, exception_handler_yield_data_abort);
 
 	retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	memory_region = (struct spci_retrieved_memory_region *)recv_buf;
-	range = spci_retrieved_memory_region_first_receiver_range(
-		memory_region);
+	memory_region = (struct spci_memory_region *)recv_buf;
+	composite = spci_memory_region_get_composite(memory_region, 0);
 
 	/* Choose which constituent we want to test. */
-	index = *(uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[0]);
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[index]);
+	index = *(uint8_t *)composite->constituents[0].address;
+	ptr = (uint8_t *)composite->constituents[index].address;
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 	/*
@@ -187,8 +192,8 @@
  */
 TEST_SERVICE(spci_check_lower_bound)
 {
-	struct spci_retrieved_memory_region *memory_region;
-	struct spci_receiver_address_range *range;
+	struct spci_memory_region *memory_region;
+	struct spci_composite_memory_region *composite;
 	uint8_t *ptr;
 	uint8_t index;
 
@@ -199,15 +204,12 @@
 	exception_setup(NULL, exception_handler_yield_data_abort);
 
 	retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	memory_region = (struct spci_retrieved_memory_region *)recv_buf;
-	range = spci_retrieved_memory_region_first_receiver_range(
-		memory_region);
+	memory_region = (struct spci_memory_region *)recv_buf;
+	composite = spci_memory_region_get_composite(memory_region, 0);
 
 	/* Choose which constituent we want to test. */
-	index = *(uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[0]);
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[index]);
+	index = *(uint8_t *)composite->constituents[0].address;
+	ptr = (uint8_t *)composite->constituents[index].address;
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 	/*
@@ -231,23 +233,23 @@
 	struct spci_value ret = spci_msg_wait();
 	spci_vm_id_t sender =
 		retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	struct spci_retrieved_memory_region *memory_region =
-		(struct spci_retrieved_memory_region *)recv_buf;
-	struct spci_receiver_address_range *range =
-		spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
+	struct spci_memory_region *memory_region =
+		(struct spci_memory_region *)recv_buf;
+	struct spci_composite_memory_region *composite =
+		spci_memory_region_get_composite(memory_region, 0);
 
 	ASSERT_EQ(sender, HF_PRIMARY_VM_ID);
 	exception_setup(NULL, exception_handler_yield_data_abort);
 
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&range->constituents[0]);
+	ptr = (uint8_t *)composite->constituents[0].address;
 
 	/* Donate memory to next VM. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, send_buf, hf_vm_get_id(), SERVICE_VM2,
-		range->constituents, range->constituent_count, 0,
-		SPCI_MEMORY_RW_X);
+		composite->constituents, composite->constituent_count, 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 	/* Ensure that we are unable to modify memory any more. */
@@ -268,13 +270,12 @@
 	struct spci_value ret = spci_msg_wait();
 	spci_vm_id_t sender =
 		retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	struct spci_retrieved_memory_region *memory_region =
-		(struct spci_retrieved_memory_region *)recv_buf;
-	struct spci_receiver_address_range *range =
-		spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
+	struct spci_memory_region *memory_region =
+		(struct spci_memory_region *)recv_buf;
+	struct spci_composite_memory_region *composite =
+		spci_memory_region_get_composite(memory_region, 0);
 	struct spci_memory_region_constituent constituent =
-		range->constituents[0];
+		composite->constituents[0];
 
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
@@ -282,17 +283,19 @@
 	spci_yield();
 
 	/* Give the memory back and notify the sender. */
-	send_memory_and_retrieve_request(SPCI_MEM_DONATE_32, send_buf,
-					 hf_vm_get_id(), sender, &constituent,
-					 1, 0, SPCI_MEMORY_RW_X);
+	send_memory_and_retrieve_request(
+		SPCI_MEM_DONATE_32, send_buf, hf_vm_get_id(), sender,
+		&constituent, 1, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Attempt to donate the memory to another VM. */
 	msg_size = spci_memory_region_init(
 		send_buf, hf_vm_get_id(), SERVICE_VM2, &constituent, 1, 0, 0,
-		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
 		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
-			  SPCI_INVALID_PARAMETERS);
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size), SPCI_DENIED);
 
 	spci_yield();
 }
@@ -308,16 +311,14 @@
 
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
-		struct spci_retrieved_memory_region *memory_region;
-		struct spci_receiver_address_range *range;
+		struct spci_memory_region *memory_region;
+		struct spci_composite_memory_region *composite;
 		uint8_t *ptr;
 
 		retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-		memory_region = (struct spci_retrieved_memory_region *)recv_buf;
-		range = spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
-		ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-			&range->constituents[0]);
+		memory_region = (struct spci_memory_region *)recv_buf;
+		composite = spci_memory_region_get_composite(memory_region, 0);
+		ptr = (uint8_t *)composite->constituents[0].address;
 
 		EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 		ptr[0] = 'd';
@@ -341,26 +342,28 @@
 	struct spci_value ret = spci_msg_wait();
 	spci_vm_id_t sender =
 		retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	struct spci_retrieved_memory_region *memory_region =
-		(struct spci_retrieved_memory_region *)recv_buf;
-	struct spci_receiver_address_range *range =
-		spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
+	struct spci_memory_region *memory_region =
+		(struct spci_memory_region *)recv_buf;
+	struct spci_composite_memory_region *composite =
+		spci_memory_region_get_composite(memory_region, 0);
 
 	/* Give the memory back and notify the sender. */
 	send_memory_and_retrieve_request(
 		SPCI_MEM_DONATE_32, send_buf, hf_vm_get_id(), sender,
-		range->constituents, range->constituent_count, 0,
-		SPCI_MEMORY_RW_X);
+		composite->constituents, composite->constituent_count, 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED, SPCI_DATA_ACCESS_RW,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_X);
 
 	/* Fail to donate the memory from the primary to VM2. */
 	msg_size = spci_memory_region_init(
-		send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2, range->constituents,
-		range->constituent_count, 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
+		send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2,
+		composite->constituents, composite->constituent_count, 0, 0,
+		SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
-	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size, 0),
+	EXPECT_SPCI_ERROR(spci_mem_donate(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 	spci_yield();
 }
@@ -384,19 +387,19 @@
 		struct spci_value ret = spci_msg_wait();
 		spci_vm_id_t sender = retrieve_memory_from_message(
 			recv_buf, send_buf, ret, &handle);
-		struct spci_retrieved_memory_region *memory_region =
-			(struct spci_retrieved_memory_region *)recv_buf;
-		struct spci_receiver_address_range *range =
-			spci_retrieved_memory_region_first_receiver_range(
-				memory_region);
+		struct spci_memory_region *memory_region =
+			(struct spci_memory_region *)recv_buf;
+		struct spci_composite_memory_region *composite =
+			spci_memory_region_get_composite(memory_region, 0);
 		struct spci_memory_region_constituent *constituents =
-			range->constituents;
+			composite->constituents;
 
-		ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-			&constituents[0]);
+		/* ASSERT_TRUE isn't enough for clang-analyze. */
+		CHECK(composite != NULL);
+
+		ptr = (uint8_t *)constituents[0].address;
 		count = constituents[0].page_count;
-		ptr2 = (uint8_t *)spci_memory_region_constituent_get_address(
-			&constituents[1]);
+		ptr2 = (uint8_t *)constituents[1].address;
 		count2 = constituents[1].page_count;
 		/* Relevant information read, mailbox can be cleared. */
 		EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
@@ -410,9 +413,7 @@
 		}
 
 		/* Give the memory back and notify the sender. */
-		*(struct spci_mem_relinquish *)send_buf =
-			(struct spci_mem_relinquish){.handle = handle,
-						     .sender = hf_vm_get_id()};
+		spci_mem_relinquish_init(send_buf, handle, 0, hf_vm_get_id());
 		EXPECT_EQ(spci_mem_relinquish().func, SPCI_SUCCESS_32);
 		EXPECT_EQ(spci_msg_send(hf_vm_get_id(), sender, 0, 0).func,
 			  SPCI_SUCCESS_32);
@@ -433,8 +434,8 @@
 	for (;;) {
 		size_t i;
 		spci_memory_handle_t handle;
-		struct spci_retrieved_memory_region *memory_region;
-		struct spci_receiver_address_range *range;
+		struct spci_memory_region *memory_region;
+		struct spci_composite_memory_region *composite;
 		uint8_t *ptr;
 
 		void *recv_buf = SERVICE_RECV_BUFFER();
@@ -442,12 +443,10 @@
 		struct spci_value ret = spci_msg_wait();
 
 		retrieve_memory_from_message(recv_buf, send_buf, ret, &handle);
-		memory_region = (struct spci_retrieved_memory_region *)recv_buf;
-		range = spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
+		memory_region = (struct spci_memory_region *)recv_buf;
+		composite = spci_memory_region_get_composite(memory_region, 0);
 
-		ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-			&range->constituents[0]);
+		ptr = (uint8_t *)composite->constituents[0].address;
 
 		/* Check that we have access to the shared region. */
 		for (i = 0; i < PAGE_SIZE; ++i) {
@@ -458,9 +457,7 @@
 		 * Attempt to relinquish the memory, which should fail because
 		 * it was donated not lent.
 		 */
-		*(struct spci_mem_relinquish *)send_buf =
-			(struct spci_mem_relinquish){.handle = handle,
-						     .sender = hf_vm_get_id()};
+		spci_mem_relinquish_init(send_buf, handle, 0, hf_vm_get_id());
 		EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 		EXPECT_SPCI_ERROR(spci_mem_relinquish(),
 				  SPCI_INVALID_PARAMETERS);
@@ -498,18 +495,14 @@
 		EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
 		/* Trying to relinquish the memory and clear it should fail. */
-		*(struct spci_mem_relinquish *)send_buf =
-			(struct spci_mem_relinquish){
-				.handle = handle,
-				.sender = hf_vm_get_id(),
-				.flags = SPCI_MEMORY_REGION_FLAG_CLEAR};
+		spci_mem_relinquish_init(send_buf, handle,
+					 SPCI_MEMORY_REGION_FLAG_CLEAR,
+					 hf_vm_get_id());
 		EXPECT_SPCI_ERROR(spci_mem_relinquish(),
 				  SPCI_INVALID_PARAMETERS);
 
 		/* Give the memory back and notify the sender. */
-		*(struct spci_mem_relinquish *)send_buf =
-			(struct spci_mem_relinquish){.handle = handle,
-						     .sender = hf_vm_get_id()};
+		spci_mem_relinquish_init(send_buf, handle, 0, hf_vm_get_id());
 		EXPECT_EQ(spci_mem_relinquish().func, SPCI_SUCCESS_32);
 		EXPECT_EQ(spci_msg_send(hf_vm_get_id(), sender, 0, 0).func,
 			  SPCI_SUCCESS_32);
@@ -529,36 +522,36 @@
 	struct spci_value ret = spci_msg_wait();
 	spci_vm_id_t sender =
 		retrieve_memory_from_message(recv_buf, send_buf, ret, &handle);
-	struct spci_retrieved_memory_region *memory_region =
-		(struct spci_retrieved_memory_region *)recv_buf;
-	struct spci_receiver_address_range *range =
-		spci_retrieved_memory_region_first_receiver_range(
-			memory_region);
+	struct spci_memory_region *memory_region =
+		(struct spci_memory_region *)recv_buf;
+	struct spci_composite_memory_region *composite =
+		spci_memory_region_get_composite(memory_region, 0);
 
 	/* Give the memory back and notify the sender. */
-	*(struct spci_mem_relinquish *)send_buf = (struct spci_mem_relinquish){
-		.handle = handle, .sender = hf_vm_get_id()};
+	spci_mem_relinquish_init(send_buf, handle, 0, hf_vm_get_id());
 	EXPECT_EQ(spci_mem_relinquish().func, SPCI_SUCCESS_32);
 	EXPECT_EQ(spci_msg_send(hf_vm_get_id(), sender, 0, 0).func,
 		  SPCI_SUCCESS_32);
 
 	/* Ensure we cannot lend from the primary to another secondary. */
 	msg_size = spci_memory_region_init(
-		send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2, range->constituents,
-		range->constituent_count, 0, 0, SPCI_MEMORY_RW_X,
+		send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2,
+		composite->constituents, composite->constituent_count, 0, 0,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_X,
 		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 		SPCI_MEMORY_OUTER_SHAREABLE);
-	EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size, 0),
+	EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	/* Ensure we cannot share from the primary to another secondary. */
 	msg_size = spci_memory_region_init(
-		send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2, range->constituents,
-		range->constituent_count, 0, 0, SPCI_MEMORY_RW_X,
+		send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2,
+		composite->constituents, composite->constituent_count, 0, 0,
+		SPCI_DATA_ACCESS_RW, SPCI_INSTRUCTION_ACCESS_X,
 		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 		SPCI_MEMORY_OUTER_SHAREABLE);
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
-	EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size, 0),
+	EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size),
 			  SPCI_INVALID_PARAMETERS);
 
 	spci_yield();
@@ -578,16 +571,18 @@
 		struct spci_value ret = spci_msg_wait();
 		spci_vm_id_t sender = retrieve_memory_from_message(
 			recv_buf, send_buf, ret, &handle);
-		struct spci_retrieved_memory_region *memory_region =
-			(struct spci_retrieved_memory_region *)recv_buf;
-		struct spci_receiver_address_range *range =
-			spci_retrieved_memory_region_first_receiver_range(
-				memory_region);
-		struct spci_memory_region_constituent *constituents =
-			range->constituents;
-		uint64_t *ptr =
-			(uint64_t *)spci_memory_region_constituent_get_address(
-				&constituents[0]);
+		struct spci_memory_region *memory_region =
+			(struct spci_memory_region *)recv_buf;
+		struct spci_composite_memory_region *composite =
+			spci_memory_region_get_composite(memory_region, 0);
+		struct spci_memory_region_constituent *constituents;
+		uint64_t *ptr;
+
+		/* ASSERT_TRUE isn't enough for clang-analyze. */
+		CHECK(composite != NULL);
+
+		constituents = composite->constituents;
+		ptr = (uint64_t *)constituents[0].address;
 
 		EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
@@ -600,9 +595,7 @@
 		__asm__ volatile("blr %0" ::"r"(ptr));
 
 		/* Release the memory again. */
-		*(struct spci_mem_relinquish *)send_buf =
-			(struct spci_mem_relinquish){.handle = handle,
-						     .sender = hf_vm_get_id()};
+		spci_mem_relinquish_init(send_buf, handle, 0, hf_vm_get_id());
 		EXPECT_EQ(spci_mem_relinquish().func, SPCI_SUCCESS_32);
 		EXPECT_EQ(spci_msg_send(hf_vm_get_id(), sender, 0, 0).func,
 			  SPCI_SUCCESS_32);
@@ -610,6 +603,24 @@
 }
 
 /**
+ * Attempt to retrieve a shared page but expect to fail.
+ */
+TEST_SERVICE(spci_memory_share_fail)
+{
+	for (;;) {
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
+		struct spci_value ret = spci_msg_wait();
+		spci_vm_id_t sender = retrieve_memory_from_message_expect_fail(
+			recv_buf, send_buf, ret, SPCI_DENIED);
+
+		/* Return control to primary. */
+		EXPECT_EQ(spci_msg_send(hf_vm_get_id(), sender, 0, 0).func,
+			  SPCI_SUCCESS_32);
+	}
+}
+
+/**
  * Attempt to read and write to a shared page.
  */
 TEST_SERVICE(spci_memory_lend_relinquish_RW)
@@ -626,18 +637,16 @@
 		struct spci_value ret = spci_msg_wait();
 		spci_vm_id_t sender = retrieve_memory_from_message(
 			recv_buf, send_buf, ret, &handle);
-		struct spci_retrieved_memory_region *memory_region =
-			(struct spci_retrieved_memory_region *)recv_buf;
-		struct spci_receiver_address_range *range =
-			spci_retrieved_memory_region_first_receiver_range(
-				memory_region);
+		struct spci_memory_region *memory_region =
+			(struct spci_memory_region *)recv_buf;
+		struct spci_composite_memory_region *composite =
+			spci_memory_region_get_composite(memory_region, 0);
 		struct spci_memory_region_constituent constituent_copy =
-			range->constituents[0];
+			composite->constituents[0];
 
 		EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
-		ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-			&constituent_copy);
+		ptr = (uint8_t *)constituent_copy.address;
 
 		/* Check that we have read access. */
 		for (i = 0; i < PAGE_SIZE; ++i) {
@@ -653,9 +662,7 @@
 		}
 
 		/* Give the memory back and notify the sender. */
-		*(struct spci_mem_relinquish *)send_buf =
-			(struct spci_mem_relinquish){.handle = handle,
-						     .sender = hf_vm_get_id()};
+		spci_mem_relinquish_init(send_buf, handle, 0, hf_vm_get_id());
 		EXPECT_EQ(spci_mem_relinquish().func, SPCI_SUCCESS_32);
 		EXPECT_EQ(spci_msg_send(hf_vm_get_id(), sender, 0, 0).func,
 			  SPCI_SUCCESS_32);
@@ -671,20 +678,18 @@
 
 	void *recv_buf = SERVICE_RECV_BUFFER();
 	void *send_buf = SERVICE_SEND_BUFFER();
-	struct spci_retrieved_memory_region *memory_region;
-	struct spci_receiver_address_range *range;
+	struct spci_memory_region *memory_region;
+	struct spci_composite_memory_region *composite;
 	struct spci_memory_region_constituent constituent_copy;
 
 	retrieve_memory_from_message(recv_buf, send_buf, ret, NULL);
-	memory_region = (struct spci_retrieved_memory_region *)recv_buf;
-	range = spci_retrieved_memory_region_first_receiver_range(
-		memory_region);
-	constituent_copy = range->constituents[0];
+	memory_region = (struct spci_memory_region *)recv_buf;
+	composite = spci_memory_region_get_composite(memory_region, 0);
+	constituent_copy = composite->constituents[0];
 
 	EXPECT_EQ(spci_rx_release().func, SPCI_SUCCESS_32);
 
-	ptr = (uint8_t *)spci_memory_region_constituent_get_address(
-		&constituent_copy);
+	ptr = (uint8_t *)constituent_copy.address;
 
 	/* Check that we have read access. */
 	for (i = 0; i < PAGE_SIZE; ++i) {
@@ -697,24 +702,24 @@
 	}
 
 	for (i = 1; i < PAGE_SIZE * 2; i++) {
-		uint64_t address = (uint64_t)ptr + i;
-		constituent_copy.address_high = address << 32;
-		constituent_copy.address_low = (uint32_t)address;
+		constituent_copy.address = (uint64_t)ptr + i;
 
 		/* Fail to lend or share the memory from the primary. */
 		msg_size = spci_memory_region_init(
 			send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2,
-			&constituent_copy, 1, 0, 0, SPCI_MEMORY_RW_X,
-			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+			&constituent_copy, 1, 0, 0, SPCI_DATA_ACCESS_RW,
+			SPCI_INSTRUCTION_ACCESS_X, SPCI_MEMORY_NORMAL_MEM,
+			SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size, 0),
+		EXPECT_SPCI_ERROR(spci_mem_lend(msg_size, msg_size),
 				  SPCI_INVALID_PARAMETERS);
 		msg_size = spci_memory_region_init(
 			send_buf, HF_PRIMARY_VM_ID, SERVICE_VM2,
-			&constituent_copy, 1, 0, 0, SPCI_MEMORY_RW_X,
-			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+			&constituent_copy, 1, 0, 0, SPCI_DATA_ACCESS_RW,
+			SPCI_INSTRUCTION_ACCESS_X, SPCI_MEMORY_NORMAL_MEM,
+			SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size, 0),
+		EXPECT_SPCI_ERROR(spci_mem_share(msg_size, msg_size),
 				  SPCI_INVALID_PARAMETERS);
 	}
 
diff --git a/test/vmapi/primary_with_secondaries/services/unmapped.c b/test/vmapi/primary_with_secondaries/services/unmapped.c
index b4a07a4..30d9f07 100644
--- a/test/vmapi/primary_with_secondaries/services/unmapped.c
+++ b/test/vmapi/primary_with_secondaries/services/unmapped.c
@@ -41,17 +41,16 @@
 	void *send_buf = SERVICE_SEND_BUFFER();
 	/* Give some memory to the primary VM so that it's unmapped. */
 	struct spci_memory_region_constituent constituents[] = {
-		spci_memory_region_constituent_init(
-			(uint64_t)(&pages[PAGE_SIZE]), 1),
+		{.address = (uint64_t)(&pages[PAGE_SIZE]), .page_count = 1},
 	};
 	uint32_t msg_size = spci_memory_region_init(
 		send_buf, hf_vm_get_id(), HF_PRIMARY_VM_ID, constituents,
-		ARRAY_SIZE(constituents), 0, 0, SPCI_MEMORY_RW_X,
-		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
-		SPCI_MEMORY_OUTER_SHAREABLE);
+		ARRAY_SIZE(constituents), 0, 0, SPCI_DATA_ACCESS_NOT_SPECIFIED,
+		SPCI_INSTRUCTION_ACCESS_NOT_SPECIFIED, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
 	exception_setup(NULL, exception_handler_yield_data_abort);
 
-	EXPECT_EQ(spci_mem_donate(msg_size, msg_size, 0).func, SPCI_SUCCESS_32);
+	EXPECT_EQ(spci_mem_donate(msg_size, msg_size).func, SPCI_SUCCESS_32);
 
 	*(volatile uint64_t *)(&pages[PAGE_SIZE - 6]);
 	FAIL("Exception not generated by invalid access.");
diff --git a/vmlib/spci.c b/vmlib/spci.c
index 55347cf..c404e2f 100644
--- a/vmlib/spci.c
+++ b/vmlib/spci.c
@@ -24,19 +24,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 
-/* Linux doesn't have a checked memcpy, so just use the unchecked version. */
-void memcpy_s(void *dest, size_t destsz, const void *src, size_t count)
-{
-	memcpy(dest, src, count);
-}
-
-/*
- * Use macro from Linux because we can't include Hafnium internal headers here.
- */
-#ifndef align_up
-#define align_up(v, a) ALIGN((v), (a))
-#endif
-
 #else
 #include "hf/std.h"
 #endif
@@ -46,127 +33,156 @@
  * information to it. Returns the length in bytes occupied by the data copied to
  * `memory_region` (attributes, constituents and memory region header size).
  */
+static uint32_t spci_memory_region_init_internal(
+	struct spci_memory_region *memory_region, spci_vm_id_t sender,
+	spci_memory_attributes_t attributes, spci_memory_region_flags_t flags,
+	spci_memory_handle_t handle, uint32_t tag, spci_vm_id_t receiver,
+	spci_memory_access_permissions_t permissions,
+	const struct spci_memory_region_constituent constituents[],
+	uint32_t constituent_count)
+{
+	struct spci_composite_memory_region *composite_memory_region;
+	uint32_t index;
+	uint32_t constituents_length =
+		constituent_count *
+		sizeof(struct spci_memory_region_constituent);
+
+	memory_region->sender = sender;
+	memory_region->attributes = attributes;
+	memory_region->reserved_0 = 0;
+	memory_region->flags = flags;
+	memory_region->handle = handle;
+	memory_region->tag = tag;
+	memory_region->reserved_1 = 0;
+	memory_region->receiver_count = 1;
+	memory_region->receivers[0].receiver_permissions.receiver = receiver;
+	memory_region->receivers[0].receiver_permissions.permissions =
+		permissions;
+	memory_region->receivers[0].receiver_permissions.flags = 0;
+	/*
+	 * Note that `sizeof(struct_spci_memory_region)` and `sizeof(struct
+	 * spci_memory_access)` must both be multiples of 16 (as verified by the
+	 * asserts in `spci_memory.c`, so it is guaranteed that the offset we
+	 * calculate here is aligned to a 64-bit boundary and so 64-bit values
+	 * can be copied without alignment faults.
+	 */
+	memory_region->receivers[0].composite_memory_region_offset =
+		sizeof(struct spci_memory_region) +
+		memory_region->receiver_count *
+			sizeof(struct spci_memory_access);
+	memory_region->receivers[0].reserved_0 = 0;
+
+	composite_memory_region =
+		spci_memory_region_get_composite(memory_region, 0);
+
+	composite_memory_region->page_count = 0;
+	composite_memory_region->constituent_count = constituent_count;
+	composite_memory_region->reserved_0 = 0;
+
+	for (index = 0; index < constituent_count; index++) {
+		composite_memory_region->constituents[index] =
+			constituents[index];
+		composite_memory_region->page_count +=
+			constituents[index].page_count;
+	}
+
+	/*
+	 * TODO: Add assert ensuring that the specified message
+	 * length is not greater than SPCI_MSG_PAYLOAD_MAX.
+	 */
+
+	return memory_region->receivers[0].composite_memory_region_offset +
+	       sizeof(struct spci_composite_memory_region) +
+	       constituents_length;
+}
+
+/**
+ * Initialises the given `spci_memory_region` and copies the constituent
+ * information to it. Returns the length in bytes occupied by the data copied to
+ * `memory_region` (attributes, constituents and memory region header size).
+ */
 uint32_t spci_memory_region_init(
 	struct spci_memory_region *memory_region, spci_vm_id_t sender,
 	spci_vm_id_t receiver,
 	const struct spci_memory_region_constituent constituents[],
 	uint32_t constituent_count, uint32_t tag,
-	spci_memory_region_flags_t flags, enum spci_memory_access access,
+	spci_memory_region_flags_t flags, enum spci_data_access data_access,
+	enum spci_instruction_access instruction_access,
 	enum spci_memory_type type, enum spci_memory_cacheability cacheability,
 	enum spci_memory_shareability shareability)
 {
-	uint32_t constituents_length =
-		constituent_count *
-		sizeof(struct spci_memory_region_constituent);
-	uint32_t index;
-	struct spci_memory_region_constituent *region_constituents;
-	uint16_t attributes = 0;
+	spci_memory_access_permissions_t permissions = 0;
+	spci_memory_attributes_t attributes = 0;
+
+	/* Set memory region's permissions. */
+	spci_set_data_access_attr(&permissions, data_access);
+	spci_set_instruction_access_attr(&permissions, instruction_access);
 
 	/* Set memory region's page attributes. */
-	spci_set_memory_access_attr(&attributes, access);
 	spci_set_memory_type_attr(&attributes, type);
 	spci_set_memory_cacheability_attr(&attributes, cacheability);
 	spci_set_memory_shareability_attr(&attributes, shareability);
 
-	memory_region->tag = tag;
-	memory_region->flags = flags;
-	memory_region->sender = sender;
-	memory_region->reserved_0 = 0;
-	memory_region->reserved_1 = 0;
-	memory_region->page_count = 0;
-	memory_region->constituent_count = constituent_count;
-	memory_region->attribute_count = 1;
-	memory_region->attributes[0].receiver = receiver;
-	memory_region->attributes[0].memory_attributes = attributes;
-	memory_region->attributes[0].reserved_0 = 0;
-	memory_region->attributes[0].reserved_1 = 0;
-
-	/*
-	 * Constituent offset must be aligned to a 32-bit boundary so that
-	 * 32-bit values can be copied without alignment faults.
-	 */
-	memory_region->constituent_offset = align_up(
-		sizeof(struct spci_memory_region) +
-			memory_region->attribute_count *
-				sizeof(struct spci_memory_region_attributes),
-		4);
-	region_constituents =
-		spci_memory_region_get_constituents(memory_region);
-
-	for (index = 0; index < constituent_count; index++) {
-		region_constituents[index] = constituents[index];
-		memory_region->page_count += constituents[index].page_count;
-	}
-
-	/*
-	 * TODO: Add assert ensuring that the specified message
-	 * length is not greater than SPCI_MSG_PAYLOAD_MAX.
-	 */
-
-	return memory_region->constituent_offset + constituents_length;
+	return spci_memory_region_init_internal(
+		memory_region, sender, attributes, flags, 0, tag, receiver,
+		permissions, constituents, constituent_count);
 }
 
 uint32_t spci_memory_retrieve_request_init(
-	struct spci_memory_retrieve_request *request,
-	spci_memory_handle_t handle, spci_vm_id_t sender, spci_vm_id_t receiver,
-	uint32_t share_func, uint32_t tag, uint32_t page_count,
-	enum spci_memory_access access, enum spci_memory_type type,
-	enum spci_memory_cacheability cacheability,
+	struct spci_memory_region *memory_region, spci_memory_handle_t handle,
+	spci_vm_id_t sender, spci_vm_id_t receiver, uint32_t tag,
+	spci_memory_region_flags_t flags, enum spci_data_access data_access,
+	enum spci_instruction_access instruction_access,
+	enum spci_memory_type type, enum spci_memory_cacheability cacheability,
 	enum spci_memory_shareability shareability)
 {
-	struct spci_memory_retrieve_properties *retrieve_properties =
-		spci_memory_retrieve_request_first_retrieve_properties(request);
-	uint16_t attributes = 0;
+	spci_memory_access_permissions_t permissions = 0;
+	spci_memory_attributes_t attributes = 0;
+
+	/* Set memory region's permissions. */
+	spci_set_data_access_attr(&permissions, data_access);
+	spci_set_instruction_access_attr(&permissions, instruction_access);
 
 	/* Set memory region's page attributes. */
-	spci_set_memory_access_attr(&attributes, access);
 	spci_set_memory_type_attr(&attributes, type);
 	spci_set_memory_cacheability_attr(&attributes, cacheability);
 	spci_set_memory_shareability_attr(&attributes, shareability);
 
-	request->reserved_0 = 0;
-	request->reserved_1 = 0;
-	request->handle = handle;
-	request->sender = sender;
-	request->share_func = share_func;
-	request->tag = tag;
-	request->attribute_count = 0;
-	request->attribute_offset = 0;
-	request->retrieve_properties_count = 1;
+	memory_region->sender = sender;
+	memory_region->attributes = attributes;
+	memory_region->reserved_0 = 0;
+	memory_region->flags = flags;
+	memory_region->reserved_1 = 0;
+	memory_region->handle = handle;
+	memory_region->tag = tag;
+	memory_region->receiver_count = 1;
+	memory_region->receivers[0].receiver_permissions.receiver = receiver;
+	memory_region->receivers[0].receiver_permissions.permissions =
+		permissions;
+	memory_region->receivers[0].receiver_permissions.flags = 0;
+	/*
+	 * Offset 0 in this case means that the hypervisor should allocate the
+	 * address ranges. This is the only configuration supported by Hafnium,
+	 * as it enforces 1:1 mappings in the stage 2 page tables.
+	 */
+	memory_region->receivers[0].composite_memory_region_offset = 0;
+	memory_region->receivers[0].reserved_0 = 0;
 
-	retrieve_properties->attributes.receiver = receiver;
-	retrieve_properties->attributes.memory_attributes = attributes;
-	retrieve_properties->page_count = page_count;
-	retrieve_properties->constituent_count = 0;
-	retrieve_properties->reserved = 0;
-
-	return sizeof(struct spci_memory_retrieve_request) +
-	       sizeof(struct spci_memory_retrieve_properties);
+	return sizeof(struct spci_memory_region) +
+	       memory_region->receiver_count *
+		       sizeof(struct spci_memory_access);
 }
 
 uint32_t spci_retrieved_memory_region_init(
-	struct spci_retrieved_memory_region *response, size_t response_max_size,
-	spci_vm_id_t receiver,
+	struct spci_memory_region *response, size_t response_max_size,
+	spci_vm_id_t sender, spci_memory_attributes_t attributes,
+	spci_memory_region_flags_t flags, spci_memory_handle_t handle,
+	spci_vm_id_t receiver, spci_memory_access_permissions_t permissions,
 	const struct spci_memory_region_constituent constituents[],
-	uint32_t constituent_count, uint32_t page_count)
+	uint32_t constituent_count)
 {
-	struct spci_receiver_address_range *response_range =
-		spci_retrieved_memory_region_first_receiver_range(response);
-
-	response->receiver_count = 1;
-	response_range->receiver = receiver;
-	response_range->page_count = page_count;
-	response_range->constituent_count = constituent_count;
-	memcpy_s(response_range->constituents,
-		 response_max_size -
-			 sizeof(struct spci_retrieved_memory_region) -
-			 sizeof(struct spci_receiver_address_range),
-		 constituents,
-		 constituent_count *
-			 sizeof(struct spci_memory_region_constituent));
-
-	return sizeof(struct spci_retrieved_memory_region) +
-	       sizeof(struct spci_receiver_address_range) +
-	       constituent_count *
-		       sizeof(struct spci_memory_region_constituent);
+	/* TODO: Check against response_max_size first. */
+	return spci_memory_region_init_internal(
+		response, sender, attributes, flags, handle, 0, receiver,
+		permissions, constituents, constituent_count);
 }