diff --git a/libpldm/bios_table.c b/libpldm/bios_table.c
index e8b6607..a1db7eb 100644
--- a/libpldm/bios_table.c
+++ b/libpldm/bios_table.c
@@ -21,6 +21,11 @@
 			return PLDM_ERROR_INVALID_DATA;                        \
 	} while (0)
 
+static bool attribute_is_readonly(uint8_t attr_type)
+{
+	return (attr_type & 0x80);
+}
+
 #define BUFFER_SIZE_EXPECT(current_size, expected_size)                        \
 	do {                                                                   \
 		if (current_size < expected_size)                              \
@@ -739,13 +744,14 @@
 	return size;
 }
 
-void pldm_bios_table_append_pad_checksum(void *table, size_t size,
-					 size_t size_without_pad)
+size_t pldm_bios_table_append_pad_checksum(void *table, size_t size,
+					   size_t size_without_pad)
 {
 
 	size_t pad_checksum_size =
 	    pldm_bios_table_pad_checksum_size(size_without_pad);
-	assert(size >= (size_without_pad + pad_checksum_size));
+	size_t total_length = size_without_pad + pad_checksum_size;
+	assert(size >= total_length);
 
 	uint8_t *table_end = (uint8_t *)table + size_without_pad;
 	size_t pad_size = pad_size_get(size_without_pad);
@@ -753,6 +759,8 @@
 
 	uint32_t checksum = crc32(table, size_without_pad + pad_size);
 	checksum_append(table_end, checksum);
+
+	return total_length;
 }
 
 struct pldm_bios_table_iter {
@@ -902,3 +910,53 @@
 	    table, length, PLDM_BIOS_ATTR_VAL_TABLE,
 	    attr_value_table_handle_equal, &handle);
 }
+
+int pldm_bios_table_attr_value_copy_and_update(
+    const void *src_table, size_t src_length, void *dest_table,
+    size_t *dest_length, const void *entry, size_t entry_length)
+{
+	struct pldm_bios_table_iter *iter = pldm_bios_table_iter_create(
+	    src_table, src_length, PLDM_BIOS_ATTR_VAL_TABLE);
+
+	int rc = PLDM_SUCCESS;
+	const struct pldm_bios_attr_val_table_entry *tmp;
+	size_t buffer_length = *dest_length, copied_length = 0, length = 0;
+	while (!pldm_bios_table_iter_is_end(iter)) {
+		tmp = pldm_bios_table_iter_attr_value_entry_value(iter);
+		length = attr_value_table_entry_length(tmp);
+
+		/* we need the tmp's entry_length here, iter_next will calculate
+		 * it too, use current_pos directly to avoid calculating it
+		 * twice */
+		iter->current_pos += length;
+		if (tmp->attr_handle ==
+		    ((const struct pldm_bios_attr_val_table_entry *)entry)
+			->attr_handle) {
+			if (attribute_is_readonly(tmp->attr_type)) {
+				rc = PLDM_ERROR_INVALID_DATA;
+				goto out;
+			}
+			length = entry_length;
+			tmp = entry;
+		}
+		if (copied_length + length > buffer_length) {
+			rc = PLDM_ERROR_INVALID_LENGTH;
+			goto out;
+		}
+		memcpy((uint8_t *)dest_table + copied_length, tmp, length);
+		copied_length += length;
+	}
+
+	size_t pad_checksum_size =
+	    pldm_bios_table_pad_checksum_size(copied_length);
+	if ((pad_checksum_size + copied_length) > buffer_length) {
+		rc = PLDM_ERROR_INVALID_LENGTH;
+		goto out;
+	}
+
+	*dest_length = pldm_bios_table_append_pad_checksum(
+	    dest_table, buffer_length, copied_length);
+out:
+	pldm_bios_table_iter_free(iter);
+	return rc;
+}
diff --git a/libpldm/bios_table.h b/libpldm/bios_table.h
index 8715bc7..262f423 100644
--- a/libpldm/bios_table.h
+++ b/libpldm/bios_table.h
@@ -552,9 +552,26 @@
  *  @param[in,out] table - Pointer to a buffer of a bios table
  *  @param[in] size - Size of the buffer of a bios table
  *  @param[in] size_without_pad - Table size without pad and checksum
+ *  @return Total size of the table
  */
-void pldm_bios_table_append_pad_checksum(void *table, size_t size,
-					 size_t size_without_pad);
+size_t pldm_bios_table_append_pad_checksum(void *table, size_t size,
+					   size_t size_without_pad);
+
+/** @brief Build a new table and update an entry
+ *  @param[in] src_table - Pointer to the source table
+ *  @param[in] src_length - Size of the source table
+ *  @param[out] dest_table - Pointer to the buffer of destination table
+ *  @param[in,out] dest_length - Buffer size of the destination table as input
+ *                               parameter and will be assigned the length of
+ *                               the new table, if the function returns
+ * 				 PLDM_SUCCESS
+ *  @param[in] entry - Pointer to an entry
+ *  @param[in] entry_length - Size of the entry
+ *  @return pldm_completion_codes
+ */
+int pldm_bios_table_attr_value_copy_and_update(
+    const void *src_table, size_t src_length, void *dest_table,
+    size_t *dest_length, const void *entry, size_t entry_length);
 
 #ifdef __cplusplus
 }
diff --git a/test/libpldm_bios_table_test.cpp b/test/libpldm_bios_table_test.cpp
index f1e0e56..5ab1dfe 100644
--- a/test/libpldm_bios_table_test.cpp
+++ b/test/libpldm_bios_table_test.cpp
@@ -1,3 +1,4 @@
+#include <endian.h>
 #include <string.h>
 
 #include <cstring>
@@ -7,6 +8,7 @@
 #include "libpldm/base.h"
 #include "libpldm/bios.h"
 #include "libpldm/bios_table.h"
+#include "libpldm/utils.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -18,7 +20,11 @@
 {
     auto padSize = ((table.size() % 4) ? (4 - table.size() % 4) : 0);
     table.insert(table.end(), padSize, 0);
-    table.insert(table.end(), sizeof(uint32_t) /*checksum*/, 0);
+    uint32_t checksum = crc32(table.data(), table.size());
+    checksum = htole32(checksum);
+    uint8_t a[4];
+    std::memcpy(a, &checksum, sizeof(checksum));
+    table.insert(table.end(), std::begin(a), std::end(a));
 }
 
 template <typename First, typename... Rest>
@@ -667,6 +673,94 @@
                  "entry_length != NULL");
 }
 
+TEST(AttrValTable, CopyAndUpdateTest)
+{
+    std::vector<uint8_t> enumEntry{
+        0, 0, /* attr handle */
+        0,    /* attr type */
+        2,    /* number of current value */
+        0,    /* current value string handle index */
+        1,    /* current value string handle index */
+    };
+    std::vector<uint8_t> stringEntry{
+        1,   0,        /* attr handle */
+        1,             /* attr type */
+        3,   0,        /* current string length */
+        'a', 'b', 'c', /* defaut value string handle index */
+    };
+    std::vector<uint8_t> integerEntry{
+        2,  0,                   /* attr handle */
+        3,                       /* attr type */
+        10, 0, 0, 0, 0, 0, 0, 0, /* current value */
+    };
+
+    Table srcTable;
+    buildTable(srcTable, enumEntry, stringEntry, integerEntry);
+
+    std::vector<uint8_t> stringEntry1{
+        1,   0,        /* attr handle */
+        1,             /* attr type */
+        3,   0,        /* current string length */
+        'd', 'e', 'f', /* defaut value string handle index */
+    };
+
+    Table expectTable;
+    buildTable(expectTable, enumEntry, stringEntry1, integerEntry);
+    Table destTable(expectTable.size() + 10);
+    auto destLength = destTable.size();
+    auto rc = pldm_bios_table_attr_value_copy_and_update(
+        srcTable.data(), srcTable.size(), destTable.data(), &destLength,
+        stringEntry1.data(), stringEntry1.size());
+
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+    EXPECT_EQ(destLength, expectTable.size());
+    destTable.resize(destLength);
+    EXPECT_THAT(destTable, ElementsAreArray(expectTable));
+
+    std::vector<uint8_t> stringEntry2{
+        1,   0,                  /* attr handle */
+        1,                       /* attr type */
+        5,   0,                  /* current string length */
+        'd', 'e', 'f', 'a', 'b', /* defaut value string handle index */
+    };
+    expectTable.resize(0);
+    buildTable(expectTable, enumEntry, stringEntry2, integerEntry);
+    destTable.resize(expectTable.size() + 10);
+    destLength = destTable.size();
+    rc = pldm_bios_table_attr_value_copy_and_update(
+        srcTable.data(), srcTable.size(), destTable.data(), &destLength,
+        stringEntry2.data(), stringEntry2.size());
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+    EXPECT_EQ(destLength, expectTable.size());
+    destTable.resize(destLength);
+    EXPECT_THAT(destTable, ElementsAreArray(expectTable));
+
+    std::vector<uint8_t> stringEntry3{
+        1,   0, /* attr handle */
+        1,      /* attr type */
+        1,   0, /* current string length */
+        'd',    /* defaut value string handle index */
+    };
+    expectTable.resize(0);
+    buildTable(expectTable, enumEntry, stringEntry3, integerEntry);
+    destTable.resize(expectTable.size() + 10);
+    destLength = destTable.size();
+    rc = pldm_bios_table_attr_value_copy_and_update(
+        srcTable.data(), srcTable.size(), destTable.data(), &destLength,
+        stringEntry3.data(), stringEntry3.size());
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+    EXPECT_EQ(destLength, expectTable.size());
+    destTable.resize(destLength);
+    EXPECT_THAT(destTable, ElementsAreArray(expectTable));
+
+    destTable.resize(expectTable.size() - 1);
+    destLength = destTable.size();
+    rc = pldm_bios_table_attr_value_copy_and_update(
+        srcTable.data(), srcTable.size(), destTable.data(), &destLength,
+        stringEntry3.data(), stringEntry3.size());
+    EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+}
+
 TEST(StringTable, EntryEncodeTest)
 {
     std::vector<uint8_t> stringEntry{