genprotimg: use pv_ namespace for our Buffer implementation

Use `pv_` namespace for our Buffer implementation so a symbol clash with other
libraries is less likely.

Fixes: https://github.com/ibm-s390-linux/s390-tools/issues/109
Reviewed-by: Jan Hoeppner <hoeppner@linux.ibm.com>
Signed-off-by: Marc Hartmayer <mhartmay@linux.ibm.com>
Signed-off-by: Jan Höppner <hoeppner@linux.ibm.com>

genprotimg/src/pv/pv_comp.c

@@ -73,12 +73,12 @@ PvComponent *pv_component_new_file(PvComponentType type, const gchar *path,
 	return pv_component_new(type, size, DATA_FILE, (void **)&file, err);
 }
 
-PvComponent *pv_component_new_buf(PvComponentType type, const Buffer *buf,
+PvComponent *pv_component_new_buf(PvComponentType type, const PvBuffer *buf,
 				  GError **err)
 {
 	g_assert(buf);
 
-	g_autoptr(Buffer) dup_buf = buffer_dup(buf, FALSE);
+	g_autoptr(PvBuffer) dup_buf = pv_buffer_dup(buf, FALSE);
 	return pv_component_new(type, buf->size, DATA_BUFFER, (void **)&dup_buf,
 				err);
 }
@@ -90,7 +90,7 @@ void pv_component_free(PvComponent *component)
 
 	switch ((PvComponentDataType)component->d_type) {
 	case DATA_BUFFER:
-		buffer_clear(&component->buf);
+		pv_buffer_clear(&component->buf);
 		break;
 	case DATA_FILE:
 		comp_file_free(component->file);
@@ -162,21 +162,21 @@ gint pv_component_align_and_encrypt(PvComponent *component, const gchar *tmp_pat
 
 	switch ((PvComponentDataType)component->d_type) {
 	case DATA_BUFFER: {
-		g_autoptr(Buffer) enc_buf = NULL;
+		g_autoptr(PvBuffer) enc_buf = NULL;
 
 		if (!(IS_PAGE_ALIGNED(pv_component_size(component)))) {
-			g_autoptr(Buffer) new = NULL;
+			g_autoptr(PvBuffer) new = NULL;
 
 			/* create a page aligned copy */
-			new = buffer_dup(component->buf, TRUE);
-			buffer_clear(&component->buf);
+			new = pv_buffer_dup(component->buf, TRUE);
+			pv_buffer_clear(&component->buf);
 			component->buf = g_steal_pointer(&new);
 		}
 		enc_buf = encrypt_buf(parms, component->buf, err);
 		if (!enc_buf)
 			return -1;
 
-		buffer_clear(&component->buf);
+		pv_buffer_clear(&component->buf);
 		component->buf = g_steal_pointer(&enc_buf);
 		return 0;
 	}
@@ -220,10 +220,10 @@ gint pv_component_align(PvComponent *component, const gchar *tmp_path,
 
 	switch (component->d_type) {
 	case DATA_BUFFER: {
-		g_autoptr(Buffer) buf = NULL;
+		g_autoptr(PvBuffer) buf = NULL;
 
-		buf = buffer_dup(component->buf, TRUE);
-		buffer_clear(&component->buf);
+		buf = pv_buffer_dup(component->buf, TRUE);
+		pv_buffer_clear(&component->buf);
 		component->buf = g_steal_pointer(&buf);
 		return 0;
 	} break;
@@ -301,7 +301,7 @@ int64_t pv_component_update_pld(const PvComponent *comp, EVP_MD_CTX *ctx,
 
 	switch (comp->d_type) {
 	case DATA_BUFFER: {
-		const Buffer *buf = comp->buf;
+		const PvBuffer *buf = comp->buf;
 
 		g_assert(buf->size <= INT64_MAX);
 		g_assert(buf->size == size);
@@ -425,7 +425,7 @@ gint pv_component_write(const PvComponent *component, FILE *f, GError **err)
 
 	switch (component->d_type) {
 	case DATA_BUFFER: {
-		const Buffer *buf = component->buf;
+		const PvBuffer *buf = component->buf;
 
 		if (seek_and_write_buffer(f, buf, offset, err) < 0)
 			return -1;

genprotimg/src/pv/pv_comp.h

@@ -41,7 +41,7 @@ typedef struct {
 	gint d_type; /* PvComponentDataType */
 	union {
 		struct comp_file *file;
-		Buffer *buf;
+		PvBuffer *buf;
 		void *data;
 	};
 	uint64_t src_addr;
@@ -51,7 +51,7 @@ typedef struct {
 
 PvComponent *pv_component_new_file(PvComponentType type, const gchar *path,
 				   GError **err);
-PvComponent *pv_component_new_buf(PvComponentType type, const Buffer *buf,
+PvComponent *pv_component_new_buf(PvComponentType type, const PvBuffer *buf,
 				  GError **err);
 void pv_component_free(PvComponent *component);
 gint pv_component_type(const PvComponent *component);

genprotimg/src/pv/pv_comps.c

@@ -210,13 +210,13 @@ GSList *pv_img_comps_get_comps(const PvImgComps *comps)
 	return comps->comps;
 }
 
-gint pv_img_comps_finalize(PvImgComps *comps, Buffer **pld_digest,
-			   Buffer **ald_digest, Buffer **tld_digest,
+gint pv_img_comps_finalize(PvImgComps *comps, PvBuffer **pld_digest,
+			   PvBuffer **ald_digest, PvBuffer **tld_digest,
 			   uint64_t *nep, GError **err)
 {
-	g_autoptr(Buffer) tmp_pld_digest = NULL;
-	g_autoptr(Buffer) tmp_ald_digest = NULL;
-	g_autoptr(Buffer) tmp_tld_digest = NULL;
+	g_autoptr(PvBuffer) tmp_pld_digest = NULL;
+	g_autoptr(PvBuffer) tmp_ald_digest = NULL;
+	g_autoptr(PvBuffer) tmp_tld_digest = NULL;
 
 	comps->finalized = TRUE;
 	for (GSList *iterator = comps->comps; iterator; iterator = iterator->next) {

genprotimg/src/pv/pv_comps.h

@@ -32,8 +32,8 @@ gint pv_img_comps_add_component(PvImgComps *comps, PvComponent **comp,
 				GError **err);
 PvComponent *pv_img_comps_get_nth_comp(PvImgComps *comps, guint n);
 gint pv_img_comps_set_offset(PvImgComps *comps, gsize offset, GError **err);
-gint pv_img_comps_finalize(PvImgComps *comps, Buffer **pld_digest,
-			   Buffer **ald_digest, Buffer **tld_digest,
+gint pv_img_comps_finalize(PvImgComps *comps, PvBuffer **pld_digest,
+			   PvBuffer **ald_digest, PvBuffer **tld_digest,
 			   uint64_t *nep, GError **err);
 void pv_img_comps_free(PvImgComps *comps);
 

genprotimg/src/pv/pv_hdr.c

@@ -76,17 +76,17 @@ uint64_t pv_hdr_get_nks(const PvHdr *hdr)
 }
 
 /* In-place modification of ``buf`` */
-static gint pv_hdr_encrypt(const PvHdr *hdr, const PvImage *img, Buffer *buf,
+static gint pv_hdr_encrypt(const PvHdr *hdr, const PvImage *img, PvBuffer *buf,
 			   GError **err)
 {
 	uint32_t hdr_len = pv_hdr_size(hdr);
 	uint32_t aad_len = pv_hdr_aad_size(hdr);
 	guint tag_len = pv_hdr_tag_size(hdr);
 	uint32_t enc_len = pv_hdr_enc_size_casted(hdr);
-	const Buffer aad_part = { .data = buf->data, .size = aad_len };
-	Buffer enc_part = { .data = (uint8_t *)buf->data + aad_len,
+	const PvBuffer aad_part = { .data = buf->data, .size = aad_len };
+	PvBuffer enc_part = { .data = (uint8_t *)buf->data + aad_len,
 			    .size = enc_len };
-	Buffer tag_part = { .data = (uint8_t *)buf->data + hdr_len - tag_len,
+	PvBuffer tag_part = { .data = (uint8_t *)buf->data + hdr_len - tag_len,
 			    .size = tag_len };
 	struct cipher_parms parms;
 	int64_t c_len;
@@ -119,9 +119,9 @@ static gint pv_hdr_aad_init(PvHdr *hdr, const PvImage *img, GError **err)
 	g_autofree union ecdh_pub_key *cust_pub_key = NULL;
 	struct pv_hdr_key_slot *hdr_slot = hdr->slots;
 	struct pv_hdr_head *head = &hdr->head;
-	g_autoptr(Buffer) pld = NULL;
-	g_autoptr(Buffer) ald = NULL;
-	g_autoptr(Buffer) tld = NULL;
+	g_autoptr(PvBuffer) pld = NULL;
+	g_autoptr(PvBuffer) ald = NULL;
+	g_autoptr(PvBuffer) tld = NULL;
 	uint64_t nep = 0;
 
 	g_assert(sizeof(head->iv) == img->gcm_iv->size);
@@ -250,7 +250,7 @@ PvHdr *pv_hdr_new(const PvImage *img, GError **err)
 	return g_steal_pointer(&ret);
 }
 
-static void pv_hdr_memcpy(const PvHdr *hdr, const Buffer *dst)
+static void pv_hdr_memcpy(const PvHdr *hdr, const PvBuffer *dst)
 {
 	uint64_t nks = pv_hdr_get_nks(hdr);
 	uint8_t *data;
@@ -270,13 +270,13 @@ static void pv_hdr_memcpy(const PvHdr *hdr, const Buffer *dst)
 	}
 }
 
-Buffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img,
-			 enum PvCryptoMode mode, GError **err)
+PvBuffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img,
+			   enum PvCryptoMode mode, GError **err)
 {
 	uint32_t hdr_size = pv_hdr_size(hdr);
-	g_autoptr(Buffer) ret = NULL;
+	g_autoptr(PvBuffer) ret = NULL;
 
-	ret = buffer_alloc(hdr_size);
+	ret = pv_buffer_alloc(hdr_size);
 	pv_hdr_memcpy(hdr, ret);
 
 	if (mode == PV_ENCRYPT) {

genprotimg/src/pv/pv_hdr.h

@@ -23,8 +23,8 @@
 PvHdr *pv_hdr_new(const PvImage *img, GError **err);
 void pv_hdr_free(PvHdr *hdr);
 G_GNUC_UNUSED gboolean pv_hdr_uses_encryption(const PvHdr *hdr);
-Buffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img,
-			 enum PvCryptoMode mode, GError **err);
+PvBuffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img,
+			   enum PvCryptoMode mode, GError **err);
 uint32_t pv_hdr_size(const PvHdr *hdr);
 uint32_t pv_hdr_aad_size(const PvHdr *hdr);
 uint64_t pv_hdr_enc_size(const PvHdr *hdr);

genprotimg/src/pv/pv_image.c

@@ -56,7 +56,7 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp,
 				     GError **err)
 {
 	struct cipher_parms parms = { 0 };
-	g_autoptr(Buffer) tweak = NULL;
+	g_autoptr(PvBuffer) tweak = NULL;
 	prepare_func func = NULL;
 	void *opaque = NULL;
 	gint rc;
@@ -76,7 +76,7 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp,
 				EVP_CIPHER_iv_length(cipher));
 		g_assert(img->xts_key->size <= UINT_MAX);
 
-		tweak = buffer_alloc(sizeof(comp->tweak.data));
+		tweak = pv_buffer_alloc(sizeof(comp->tweak.data));
 		memcpy(tweak->data, comp->tweak.data, tweak->size);
 		func = pv_component_align_and_encrypt;
 		parms.cipher = cipher;
@@ -93,11 +93,11 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp,
 	return 0;
 }
 
-static Buffer *pv_img_read_key(const gchar *path, guint key_size,
-			       GError **err)
+static PvBuffer *pv_img_read_key(const gchar *path, guint key_size,
+				 GError **err)
 {
-	g_autoptr(Buffer) tmp_ret = NULL;
-	Buffer *ret = NULL;
+	g_autoptr(PvBuffer) tmp_ret = NULL;
+	PvBuffer *ret = NULL;
 	gsize bytes_read;
 	FILE *f = NULL;
 	gsize size;
@@ -116,7 +116,7 @@ static Buffer *pv_img_read_key(const gchar *path, guint key_size,
 	if (!f)
 		return NULL;
 
-	tmp_ret = buffer_alloc(size);
+	tmp_ret = pv_buffer_alloc(size);
 	if (file_read(f, tmp_ret->data, 1, tmp_ret->size, &bytes_read, err) < 0)
 		goto err;
 
@@ -160,8 +160,8 @@ static HostKeyList *pv_img_get_host_keys(GSList *host_keys_with_path, gint nid,
 	return g_steal_pointer(&ret);
 }
 
-static Buffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path,
-			      GError **err)
+static PvBuffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path,
+				GError **err)
 {
 	gint key_len = EVP_CIPHER_key_length(cipher);
 
@@ -173,8 +173,8 @@ static Buffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path,
 	return generate_aes_key((guint)key_len, err);
 }
 
-static Buffer *pv_img_get_iv(const EVP_CIPHER *cipher, const gchar *path,
-			     GError **err)
+static PvBuffer *pv_img_get_iv(const EVP_CIPHER *cipher, const gchar *path,
+			       GError **err)
 {
 	gint iv_len = EVP_CIPHER_iv_length(cipher);
 
@@ -485,23 +485,23 @@ static void pv_hdr_key_slot_free(PvHdrKeySlot *slot)
 WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(PvHdrKeySlot, pv_hdr_key_slot_free)
 
 static PvHdrKeySlot *pv_hdr_key_slot_new(const EVP_CIPHER *gcm_cipher,
-					 const Buffer *cust_root_key,
+					 const PvBuffer *cust_root_key,
 					 EVP_PKEY *cust_key, EVP_PKEY *host_key,
 					 GError **err)
 {
 	g_autoptr(PvHdrKeySlot) ret = g_new0(PvHdrKeySlot, 1);
 	g_autofree union ecdh_pub_key *pub = NULL;
-	g_autoptr(Buffer) exchange_key = NULL;
-	g_autoptr(Buffer) digest_key = NULL;
-	g_autoptr(Buffer) iv = NULL;
-	Buffer pub_buf;
+	g_autoptr(PvBuffer) exchange_key = NULL;
+	g_autoptr(PvBuffer) digest_key = NULL;
+	g_autoptr(PvBuffer) iv = NULL;
+	PvBuffer pub_buf;
 	/* No AAD data is used */
-	Buffer aad = { .data = NULL, .size = 0 };
+	PvBuffer aad = { .data = NULL, .size = 0 };
 	/* Set the output buffers for the encrypted data and the
 	 * generated GCM tag
 	 */
-	Buffer enc = { .data = ret->wrapped_key, .size = sizeof(ret->wrapped_key) };
-	Buffer tag = { .data = ret->tag, .size = sizeof(ret->tag) };
+	PvBuffer enc = { .data = ret->wrapped_key, .size = sizeof(ret->wrapped_key) };
+	PvBuffer tag = { .data = ret->tag, .size = sizeof(ret->tag) };
 	struct cipher_parms parms;
 	int64_t c_len = 0;
 
@@ -530,7 +530,7 @@ static PvHdrKeySlot *pv_hdr_key_slot_new(const EVP_CIPHER *gcm_cipher,
 	g_assert(exchange_key->size == (guint)EVP_CIPHER_key_length(gcm_cipher));
 
 	/* create zero IV */
-	iv = buffer_alloc((guint)EVP_CIPHER_iv_length(gcm_cipher));
+	iv = pv_buffer_alloc((guint)EVP_CIPHER_iv_length(gcm_cipher));
 	parms.iv_or_tweak = iv;
 	parms.key = exchange_key;
 	parms.cipher = gcm_cipher;
@@ -637,13 +637,13 @@ void pv_img_free(PvImage *img)
 	g_slist_free_full(img->key_slots, (GDestroyNotify)pv_hdr_key_slot_free);
 	g_slist_free_full(img->host_pub_keys, (GDestroyNotify)EVP_PKEY_free);
 	EVP_PKEY_free(img->cust_pub_priv_key);
-	buffer_clear(&img->stage3a);
+	pv_buffer_clear(&img->stage3a);
 	pv_img_comps_free(img->comps);
 	g_free(img->tmp_dir);
-	buffer_free(img->xts_key);
-	buffer_free(img->cust_root_key);
-	buffer_free(img->gcm_iv);
-	buffer_free(img->cust_comm_key);
+	pv_buffer_free(img->xts_key);
+	pv_buffer_free(img->cust_root_key);
+	pv_buffer_free(img->gcm_iv);
+	pv_buffer_free(img->cust_comm_key);
 	g_free(img);
 }
 
@@ -684,13 +684,13 @@ gint pv_img_add_component(PvImage *img, const PvArg *arg, GError **err)
 	return 0;
 }
 
-gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, Buffer **pld, Buffer **ald,
-				 Buffer **tld, uint64_t *nep, GError **err)
+gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, PvBuffer **pld, PvBuffer **ald,
+				 PvBuffer **tld, uint64_t *nep, GError **err)
 {
 	return pv_img_comps_finalize(img->comps, pld, ald, tld, nep, err);
 }
 
-static gint pv_img_build_stage3b(PvImage *img, Buffer *stage3b, GError **err)
+static gint pv_img_build_stage3b(PvImage *img, PvBuffer *stage3b, GError **err)
 {
 	g_autofree struct stage3b_args *args = NULL;
 
@@ -708,7 +708,7 @@ static gint pv_img_build_stage3b(PvImage *img, Buffer *stage3b, GError **err)
 gint pv_img_add_stage3b_comp(PvImage *img, const gchar *path, GError **err)
 {
 	g_autoptr(PvComponent) comp = NULL;
-	g_autoptr(Buffer) stage3b = NULL;
+	g_autoptr(PvBuffer) stage3b = NULL;
 
 	stage3b = stage3b_getblob(path, err);
 	if (!stage3b)
@@ -825,7 +825,7 @@ static gint get_stage3a_data_size(const PvImage *img, gsize *data_size,
 
 gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err)
 {
-	g_autoptr(Buffer) stage3a = NULL;
+	g_autoptr(PvBuffer) stage3a = NULL;
 	gsize bin_size, data_size = 0;
 
 	if (get_stage3a_data_size(img, &data_size, err) < 0)
@@ -845,8 +845,8 @@ gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err)
 }
 
 /* Creates the PV IPIB and sets the stage3a arguments */
-static gint pv_img_build_stage3a(Buffer *stage3a, gsize stage3a_bin_size,
-				 GSList *comps, const Buffer *hdr, GError **err)
+static gint pv_img_build_stage3a(PvBuffer *stage3a, gsize stage3a_bin_size,
+				 GSList *comps, const PvBuffer *hdr, GError **err)
 {
 	g_autofree struct ipl_parameter_block *ipib = NULL;
 
@@ -866,9 +866,9 @@ static gint pv_img_build_stage3a(Buffer *stage3a, gsize stage3a_bin_size,
 }
 
 /* Creates the actual PV header (serialized and AES-GCM encrypted) */
-static Buffer *pv_img_create_pv_hdr(PvImage *img, GError **err)
+static PvBuffer *pv_img_create_pv_hdr(PvImage *img, GError **err)
 {
-	g_autoptr(Buffer) hdr_buf = NULL;
+	g_autoptr(PvBuffer) hdr_buf = NULL;
 	g_autoptr(PvHdr) hdr = NULL;
 
 	hdr = pv_hdr_new(img, err);
@@ -887,7 +887,7 @@ static Buffer *pv_img_create_pv_hdr(PvImage *img, GError **err)
  */
 gint pv_img_finalize(PvImage *pv, const gchar *stage3b_path, GError **err)
 {
-	g_autoptr(Buffer) hdr = NULL;
+	g_autoptr(PvBuffer) hdr = NULL;
 
 	/* load stage3b template into memory and add it to the list of
 	 * components. This must be done before calling

genprotimg/src/pv/pv_image.h

@@ -25,7 +25,7 @@
 
 typedef struct {
 	gchar *tmp_dir; /* directory used for temporary files */
-	Buffer *stage3a; /* stage3a containing IPIB and PV header */
+	PvBuffer *stage3a; /* stage3a containing IPIB and PV header */
 	gsize stage3a_bin_size; /* size of stage3a.bin */
 	struct psw_t stage3a_psw; /* (short) PSW that is written to
 				   * location 0 of the created image
@@ -35,15 +35,15 @@ typedef struct {
 	GSList *host_pub_keys; /* public host keys */
 	gint nid; /* Elliptic Curve used for the key derivation */
 	/* keys and cipher used for the AES-GCM encryption */
-	Buffer *cust_root_key;
-	Buffer *gcm_iv;
+	PvBuffer *cust_root_key;
+	PvBuffer *gcm_iv;
 	const EVP_CIPHER *gcm_cipher;
 	/* Information for the IPIB and PV header */
 	uint64_t pcf;
 	uint64_t scf;
-	Buffer *cust_comm_key;
+	PvBuffer *cust_comm_key;
 	const EVP_CIPHER *cust_comm_cipher;
-	Buffer *xts_key;
+	PvBuffer *xts_key;
 	const EVP_CIPHER *xts_cipher;
 	GSList *key_slots;
 	GSList *optional_items;
@@ -54,8 +54,8 @@ PvImage *pv_img_new(PvArgs *args, const gchar *stage3a_path, GError **err);
 void pv_img_free(PvImage *img);
 gint pv_img_add_component(PvImage *img, const PvArg *arg, GError **err);
 gint pv_img_finalize(PvImage *img, const gchar *stage3b_path, GError **err);
-gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, Buffer **pld, Buffer **ald,
-				 Buffer **tld, uint64_t *nep, GError **err);
+gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, PvBuffer **pld, PvBuffer **ald,
+				 PvBuffer **tld, uint64_t *nep, GError **err);
 gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err);
 const PvComponent *pv_img_get_stage3b_comp(const PvImage *img, GError **err);
 gint pv_img_add_stage3b_comp(PvImage *img, const gchar *path, GError **err);

genprotimg/src/pv/pv_ipib.c

@@ -35,7 +35,7 @@ uint64_t pv_ipib_get_size(uint32_t num_comp)
 }
 
 static gint pv_ipib_init(IplParameterBlock *ipib, GSList *comps,
-			 const Buffer *hdr)
+			 const PvBuffer *hdr)
 {
 	g_assert(sizeof(struct ipl_pl_hdr) <= UINT32_MAX);
 	g_assert(sizeof(struct ipl_pb0_pv_comp) <= UINT32_MAX);
@@ -100,7 +100,7 @@ static gint pv_ipib_init(IplParameterBlock *ipib, GSList *comps,
 	return 0;
 }
 
-IplParameterBlock *pv_ipib_new(GSList *comps, const Buffer *hdr, GError **err)
+IplParameterBlock *pv_ipib_new(GSList *comps, const PvBuffer *hdr, GError **err)
 {
 	uint64_t ipib_size = pv_ipib_get_size(g_slist_length(comps));
 	g_autoptr(IplParameterBlock) ret = NULL;

genprotimg/src/pv/pv_ipib.h

@@ -19,7 +19,7 @@
 typedef struct ipl_parameter_block IplParameterBlock;
 
 uint64_t pv_ipib_get_size(uint32_t num_comp);
-IplParameterBlock *pv_ipib_new(GSList *comps, const Buffer *hdr, GError **err);
+IplParameterBlock *pv_ipib_new(GSList *comps, const PvBuffer *hdr, GError **err);
 void pv_ipib_free(IplParameterBlock *ipib);
 
 WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(IplParameterBlock, pv_ipib_free)

genprotimg/src/pv/pv_stage3.c

@@ -24,12 +24,12 @@
 	((struct stage3a_args *)((uint64_t)data_ptr + loader_size - \
 				 sizeof(struct stage3a_args)))
 
-static Buffer *loader_getblob(const gchar *filename, gsize *loader_size,
-			      gsize args_size, gsize data_size,
-			      gboolean data_aligned, GError **err)
+static PvBuffer *loader_getblob(const gchar *filename, gsize *loader_size,
+				gsize args_size, gsize data_size,
+				gboolean data_aligned, GError **err)
 {
 	g_autoptr(GMappedFile) mapped_file = NULL;
-	g_autoptr(Buffer) ret = NULL;
+	g_autoptr(PvBuffer) ret = NULL;
 	gsize size, tmp_loader_size;
 	gchar *loader_data;
 
@@ -60,7 +60,7 @@ static Buffer *loader_getblob(const gchar *filename, gsize *loader_size,
 	size = (data_aligned ? PAGE_ALIGN(tmp_loader_size) : tmp_loader_size) +
 	       data_size;
 
-	ret = buffer_alloc(size);
+	ret = pv_buffer_alloc(size);
 
 	/* copy the loader "template" */
 	memcpy(ret->data, loader_data, tmp_loader_size);
@@ -71,8 +71,8 @@ static Buffer *loader_getblob(const gchar *filename, gsize *loader_size,
 	return g_steal_pointer(&ret);
 }
 
-Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size,
-			gsize data_size, GError **err)
+PvBuffer *stage3a_getblob(const gchar *filename, gsize *loader_size,
+			  gsize data_size, GError **err)
 {
 	return loader_getblob(filename, loader_size,
 			      sizeof(struct stage3a_args), data_size, TRUE,
@@ -83,8 +83,8 @@ Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size,
 /* Set the right offsets and sizes in the stage3a template + add
  * the IPIB block with the PV header
  */
-static gint stage3a_set_data(Buffer *loader, gsize loader_size,
-			     const Buffer *hdr, struct ipl_parameter_block *ipib,
+static gint stage3a_set_data(PvBuffer *loader, gsize loader_size,
+			     const PvBuffer *hdr, struct ipl_parameter_block *ipib,
 			     GError **err)
 {
 	uint32_t ipib_size = GUINT32_FROM_BE(ipib->hdr.len);
@@ -126,15 +126,15 @@ static gint stage3a_set_data(Buffer *loader, gsize loader_size,
 	return 0;
 }
 
-gint build_stage3a(Buffer *loader, gsize loader_size, const Buffer *hdr,
+gint build_stage3a(PvBuffer *loader, gsize loader_size, const PvBuffer *hdr,
 		   struct ipl_parameter_block *ipib, GError **err)
 {
 	return stage3a_set_data(loader, loader_size, hdr, ipib, err);
 }
 
-Buffer *stage3b_getblob(const gchar *filename, GError **err)
+PvBuffer *stage3b_getblob(const gchar *filename, GError **err)
 {
-	g_autoptr(Buffer) ret = NULL;
+	g_autoptr(PvBuffer) ret = NULL;
 	gsize rb_size;
 
 	ret = loader_getblob(filename, &rb_size, sizeof(struct stage3b_args), 0,
@@ -146,7 +146,7 @@ Buffer *stage3b_getblob(const gchar *filename, GError **err)
 	return g_steal_pointer(&ret);
 }
 
-void build_stage3b(Buffer *stage3b, const struct stage3b_args *args)
+void build_stage3b(PvBuffer *stage3b, const struct stage3b_args *args)
 {
 	g_assert(stage3b->size > sizeof(*args));
 

genprotimg/src/pv/pv_stage3.h

@@ -19,12 +19,12 @@
 #include "boot/stage3b.h"
 #include "utils/buffer.h"
 
-Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size,
-			gsize data_size, GError **err);
-gint build_stage3a(Buffer *dc, gsize dc_size, const Buffer *hdr,
+PvBuffer *stage3a_getblob(const gchar *filename, gsize *loader_size,
+			  gsize data_size, GError **err);
+gint build_stage3a(PvBuffer *dc, gsize dc_size, const PvBuffer *hdr,
 		   struct ipl_parameter_block *ipib, GError **err);
-Buffer *stage3b_getblob(const gchar *filename, GError **err);
-void build_stage3b(Buffer *stage3b, const struct stage3b_args *args);
+PvBuffer *stage3b_getblob(const gchar *filename, GError **err);
+void build_stage3b(PvBuffer *stage3b, const struct stage3b_args *args);
 void memblob_init(struct memblob *arg, uint64_t src, uint64_t size);
 
 #endif