ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

module/bdev_gpt: remove spdk prefix from static/internal functions.

Browse Source 
Signed-off-by: Seth Howell <seth.howell@intel.com>
Change-Id: Ibbe4a0fff51ca901aedaca62f424cb67a52100d0
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/2324
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Community-CI: Mellanox Build Bot
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Aleksey Marchuk <alexeymar@mellanox.com>
This commit is contained in:
Seth Howell 2020-05-10 00:22:54 -07:00 committed by Tomasz Zawadzki
parent f3eccec5c7
commit 1d2faf6d2b
4 changed files with 63 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
module/bdev/gpt/gpt.c
View File

@ -45,7 +45,7 @@
#define SPDK_MAX_NUM_PARTITION_ENTRIES 128 #define SPDK_MAX_NUM_PARTITION_ENTRIES 128
static uint64_t static uint64_t
spdk_gpt_get_expected_head_lba(struct spdk_gpt *gpt) gpt_get_expected_head_lba(struct spdk_gpt *gpt)
{ {
switch (gpt->parse_phase) { switch (gpt->parse_phase) {
case SPDK_GPT_PARSE_PHASE_PRIMARY: case SPDK_GPT_PARSE_PHASE_PRIMARY:
@ -59,7 +59,7 @@ spdk_gpt_get_expected_head_lba(struct spdk_gpt *gpt)
} }
static struct spdk_gpt_header * static struct spdk_gpt_header *
spdk_gpt_get_header_buf(struct spdk_gpt *gpt) gpt_get_header_buf(struct spdk_gpt *gpt)
{ {
switch (gpt->parse_phase) { switch (gpt->parse_phase) {
case SPDK_GPT_PARSE_PHASE_PRIMARY: case SPDK_GPT_PARSE_PHASE_PRIMARY:
@ -75,8 +75,8 @@ spdk_gpt_get_header_buf(struct spdk_gpt *gpt)
} }
static struct spdk_gpt_partition_entry * static struct spdk_gpt_partition_entry *
spdk_gpt_get_partitions_buf(struct spdk_gpt *gpt, uint64_t total_partition_size, gpt_get_partitions_buf(struct spdk_gpt *gpt, uint64_t total_partition_size,
uint64_t partition_start_lba) uint64_t partition_start_lba)
{ {
uint64_t secondary_total_size; uint64_t secondary_total_size;
@ -104,7 +104,7 @@ spdk_gpt_get_partitions_buf(struct spdk_gpt *gpt, uint64_t total_partition_size,
} }
static int static int
spdk_gpt_read_partitions(struct spdk_gpt *gpt) gpt_read_partitions(struct spdk_gpt *gpt)
{ {
uint32_t total_partition_size, num_partition_entries, partition_entry_size; uint32_t total_partition_size, num_partition_entries, partition_entry_size;
uint64_t partition_start_lba; uint64_t partition_start_lba;
@ -127,7 +127,7 @@ spdk_gpt_read_partitions(struct spdk_gpt *gpt)
total_partition_size = num_partition_entries * partition_entry_size; total_partition_size = num_partition_entries * partition_entry_size;
partition_start_lba = from_le64(&head->partition_entry_lba); partition_start_lba = from_le64(&head->partition_entry_lba);
gpt->partitions = spdk_gpt_get_partitions_buf(gpt, total_partition_size, gpt->partitions = gpt_get_partitions_buf(gpt, total_partition_size,
partition_start_lba); partition_start_lba);
if (!gpt->partitions) { if (!gpt->partitions) {
SPDK_ERRLOG("Failed to get gpt partitions buf\n"); SPDK_ERRLOG("Failed to get gpt partitions buf\n");
@ -146,7 +146,7 @@ spdk_gpt_read_partitions(struct spdk_gpt *gpt)
} }
static int static int
spdk_gpt_lba_range_check(struct spdk_gpt_header *head, uint64_t lba_end) gpt_lba_range_check(struct spdk_gpt_header *head, uint64_t lba_end)
{ {
uint64_t usable_lba_start, usable_lba_end; uint64_t usable_lba_start, usable_lba_end;
@ -175,14 +175,14 @@ spdk_gpt_lba_range_check(struct spdk_gpt_header *head, uint64_t lba_end)
} }
static int static int
spdk_gpt_read_header(struct spdk_gpt *gpt) gpt_read_header(struct spdk_gpt *gpt)
{ {
uint32_t head_size; uint32_t head_size;
uint32_t new_crc, original_crc; uint32_t new_crc, original_crc;
uint64_t my_lba, head_lba; uint64_t my_lba, head_lba;
struct spdk_gpt_header *head; struct spdk_gpt_header *head;
head = spdk_gpt_get_header_buf(gpt); head = gpt_get_header_buf(gpt);
if (!head) { if (!head) {
SPDK_ERRLOG("Failed to get gpt header buf\n"); SPDK_ERRLOG("Failed to get gpt header buf\n");
return -1; return -1;
@ -213,7 +213,7 @@ spdk_gpt_read_header(struct spdk_gpt *gpt)
return -1; return -1;
} }
head_lba = spdk_gpt_get_expected_head_lba(gpt); head_lba = gpt_get_expected_head_lba(gpt);
my_lba = from_le64(&head->my_lba); my_lba = from_le64(&head->my_lba);
if (my_lba != head_lba) { if (my_lba != head_lba) {
SPDK_ERRLOG("head my_lba(%" PRIu64 ") != expected(%" PRIu64 ")\n", SPDK_ERRLOG("head my_lba(%" PRIu64 ") != expected(%" PRIu64 ")\n",
@ -221,7 +221,7 @@ spdk_gpt_read_header(struct spdk_gpt *gpt)
return -1; return -1;
} }
if (spdk_gpt_lba_range_check(head, gpt->lba_end)) { if (gpt_lba_range_check(head, gpt->lba_end)) {
SPDK_ERRLOG("lba range check error\n"); SPDK_ERRLOG("lba range check error\n");
return -1; return -1;
} }
@ -231,7 +231,7 @@ spdk_gpt_read_header(struct spdk_gpt *gpt)
} }
static int static int
spdk_gpt_check_mbr(struct spdk_gpt *gpt) gpt_check_mbr(struct spdk_gpt *gpt)
{ {
int i, primary_partition = 0; int i, primary_partition = 0;
uint32_t total_lba_size = 0, ret = 0, expected_start_lba; uint32_t total_lba_size = 0, ret = 0, expected_start_lba;
@ -279,7 +279,7 @@ spdk_gpt_check_mbr(struct spdk_gpt *gpt)
} }
int int
spdk_gpt_parse_mbr(struct spdk_gpt *gpt) gpt_parse_mbr(struct spdk_gpt *gpt)
{ {
int rc; int rc;
@ -288,7 +288,7 @@ spdk_gpt_parse_mbr(struct spdk_gpt *gpt)
return -1; return -1;
} }
rc = spdk_gpt_check_mbr(gpt); rc = gpt_check_mbr(gpt);
if (rc) { if (rc) {
SPDK_DEBUGLOG(SPDK_LOG_GPT_PARSE, "Failed to detect gpt in MBR\n"); SPDK_DEBUGLOG(SPDK_LOG_GPT_PARSE, "Failed to detect gpt in MBR\n");
return rc; return rc;
@ -298,17 +298,17 @@ spdk_gpt_parse_mbr(struct spdk_gpt *gpt)
} }
int int
spdk_gpt_parse_partition_table(struct spdk_gpt *gpt) gpt_parse_partition_table(struct spdk_gpt *gpt)
{ {
int rc; int rc;
rc = spdk_gpt_read_header(gpt); rc = gpt_read_header(gpt);
if (rc) { if (rc) {
SPDK_ERRLOG("Failed to read gpt header\n"); SPDK_ERRLOG("Failed to read gpt header\n");
return rc; return rc;
} }
rc = spdk_gpt_read_partitions(gpt); rc = gpt_read_partitions(gpt);
if (rc) { if (rc) {
SPDK_ERRLOG("Failed to read gpt partitions\n"); SPDK_ERRLOG("Failed to read gpt partitions\n");
return rc; return rc;

4
module/bdev/gpt/gpt.h
View File

@ -64,7 +64,7 @@ struct spdk_gpt {
struct spdk_gpt_partition_entry *partitions; struct spdk_gpt_partition_entry *partitions;
}; };
int spdk_gpt_parse_mbr(struct spdk_gpt *gpt); int gpt_parse_mbr(struct spdk_gpt *gpt);
int spdk_gpt_parse_partition_table(struct spdk_gpt *gpt); int gpt_parse_partition_table(struct spdk_gpt *gpt);
#endif /* SPDK_INTERNAL_GPT_H */ #endif /* SPDK_INTERNAL_GPT_H */

26
module/bdev/gpt/vbdev_gpt.c
View File

@ -93,7 +93,7 @@ struct gpt_io {
static bool g_gpt_disabled; static bool g_gpt_disabled;
static void static void
spdk_gpt_base_free(void *ctx) gpt_base_free(void *ctx)
{ {
struct gpt_base *gpt_base = ctx; struct gpt_base *gpt_base = ctx;
@ -102,7 +102,7 @@ spdk_gpt_base_free(void *ctx)
} }
static void static void
spdk_gpt_base_bdev_hotremove_cb(void *_part_base) gpt_base_bdev_hotremove_cb(void *_part_base)
{ {
struct spdk_bdev_part_base *part_base = _part_base; struct spdk_bdev_part_base *part_base = _part_base;
struct gpt_base *gpt_base = spdk_bdev_part_base_get_ctx(part_base); struct gpt_base *gpt_base = spdk_bdev_part_base_get_ctx(part_base);
@ -121,7 +121,7 @@ static struct spdk_bdev_fn_table vbdev_gpt_fn_table = {
}; };
static struct gpt_base * static struct gpt_base *
spdk_gpt_base_bdev_init(struct spdk_bdev *bdev) gpt_base_bdev_init(struct spdk_bdev *bdev)
{ {
struct gpt_base *gpt_base; struct gpt_base *gpt_base;
struct spdk_gpt *gpt; struct spdk_gpt *gpt;
@ -134,9 +134,9 @@ spdk_gpt_base_bdev_init(struct spdk_bdev *bdev)
TAILQ_INIT(&gpt_base->parts); TAILQ_INIT(&gpt_base->parts);
gpt_base->part_base = spdk_bdev_part_base_construct(bdev, gpt_base->part_base = spdk_bdev_part_base_construct(bdev,
spdk_gpt_base_bdev_hotremove_cb, gpt_base_bdev_hotremove_cb,
&gpt_if, &vbdev_gpt_fn_table, &gpt_if, &vbdev_gpt_fn_table,
&gpt_base->parts, spdk_gpt_base_free, gpt_base, &gpt_base->parts, gpt_base_free, gpt_base,
sizeof(struct gpt_channel), NULL, NULL); sizeof(struct gpt_channel), NULL, NULL);
if (!gpt_base->part_base) { if (!gpt_base->part_base) {
free(gpt_base); free(gpt_base);
@ -367,7 +367,7 @@ vbdev_gpt_create_bdevs(struct gpt_base *gpt_base)
} }
static void static void
spdk_gpt_read_secondary_table_complete(struct spdk_bdev_io *bdev_io, bool status, void *arg) gpt_read_secondary_table_complete(struct spdk_bdev_io *bdev_io, bool status, void *arg)
{ {
struct gpt_base *gpt_base = (struct gpt_base *)arg; struct gpt_base *gpt_base = (struct gpt_base *)arg;
struct spdk_bdev *bdev = spdk_bdev_part_base_get_bdev(gpt_base->part_base); struct spdk_bdev *bdev = spdk_bdev_part_base_get_bdev(gpt_base->part_base);
@ -383,7 +383,7 @@ spdk_gpt_read_secondary_table_complete(struct spdk_bdev_io *bdev_io, bool status
goto end; goto end;
} }
rc = spdk_gpt_parse_partition_table(&gpt_base->gpt); rc = gpt_parse_partition_table(&gpt_base->gpt);
if (rc) { if (rc) {
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse secondary partition table\n"); SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse secondary partition table\n");
goto end; goto end;
@ -422,12 +422,12 @@ vbdev_gpt_read_secondary_table(struct gpt_base *gpt_base)
secondary_offset = gpt->total_sectors * gpt->sector_size - gpt->buf_size; secondary_offset = gpt->total_sectors * gpt->sector_size - gpt->buf_size;
return spdk_bdev_read(part_base_desc, gpt_base->ch, gpt_base->gpt.buf, secondary_offset, return spdk_bdev_read(part_base_desc, gpt_base->ch, gpt_base->gpt.buf, secondary_offset,
gpt_base->gpt.buf_size, spdk_gpt_read_secondary_table_complete, gpt_base->gpt.buf_size, gpt_read_secondary_table_complete,
gpt_base); gpt_base);
} }
static void static void
spdk_gpt_bdev_complete(struct spdk_bdev_io *bdev_io, bool status, void *arg) gpt_bdev_complete(struct spdk_bdev_io *bdev_io, bool status, void *arg)
{ {
struct gpt_base *gpt_base = (struct gpt_base *)arg; struct gpt_base *gpt_base = (struct gpt_base *)arg;
struct spdk_bdev *bdev = spdk_bdev_part_base_get_bdev(gpt_base->part_base); struct spdk_bdev *bdev = spdk_bdev_part_base_get_bdev(gpt_base->part_base);
@ -441,13 +441,13 @@ spdk_gpt_bdev_complete(struct spdk_bdev_io *bdev_io, bool status, void *arg)
goto end; goto end;
} }
rc = spdk_gpt_parse_mbr(&gpt_base->gpt); rc = gpt_parse_mbr(&gpt_base->gpt);
if (rc) { if (rc) {
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse mbr\n"); SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse mbr\n");
goto end; goto end;
} }
rc = spdk_gpt_parse_partition_table(&gpt_base->gpt); rc = gpt_parse_partition_table(&gpt_base->gpt);
if (rc) { if (rc) {
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse primary partition table\n"); SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse primary partition table\n");
rc = vbdev_gpt_read_secondary_table(gpt_base); rc = vbdev_gpt_read_secondary_table(gpt_base);
@ -490,7 +490,7 @@ vbdev_gpt_read_gpt(struct spdk_bdev *bdev)
struct spdk_bdev_desc *part_base_desc; struct spdk_bdev_desc *part_base_desc;
int rc; int rc;
gpt_base = spdk_gpt_base_bdev_init(bdev); gpt_base = gpt_base_bdev_init(bdev);
if (!gpt_base) { if (!gpt_base) {
SPDK_ERRLOG("Cannot allocated gpt_base\n"); SPDK_ERRLOG("Cannot allocated gpt_base\n");
return -1; return -1;
@ -505,7 +505,7 @@ vbdev_gpt_read_gpt(struct spdk_bdev *bdev)
} }
rc = spdk_bdev_read(part_base_desc, gpt_base->ch, gpt_base->gpt.buf, 0, rc = spdk_bdev_read(part_base_desc, gpt_base->ch, gpt_base->gpt.buf, 0,
gpt_base->gpt.buf_size, spdk_gpt_bdev_complete, gpt_base); gpt_base->gpt.buf_size, gpt_bdev_complete, gpt_base);
if (rc < 0) { if (rc < 0) {
spdk_put_io_channel(gpt_base->ch); spdk_put_io_channel(gpt_base->ch);
spdk_bdev_part_base_free(gpt_base->part_base); spdk_bdev_part_base_free(gpt_base->part_base);

62
test/unit/lib/bdev/gpt/gpt.c/gpt_ut.c
View File

@ -46,40 +46,40 @@ test_check_mbr(void)
int re; int re;
/* Set gpt is NULL */ /* Set gpt is NULL */
re = spdk_gpt_parse_mbr(NULL); re = gpt_parse_mbr(NULL);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set gpt->buf is NULL */ /* Set gpt->buf is NULL */
gpt = calloc(1, sizeof(*gpt)); gpt = calloc(1, sizeof(*gpt));
SPDK_CU_ASSERT_FATAL(gpt != NULL); SPDK_CU_ASSERT_FATAL(gpt != NULL);
re = spdk_gpt_parse_mbr(gpt); re = gpt_parse_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set *gpt is "aaa...", all are mismatch include mbr_signature */ /* Set *gpt is "aaa...", all are mismatch include mbr_signature */
memset(a, 'a', sizeof(a)); memset(a, 'a', sizeof(a));
gpt->buf = &a[0]; gpt->buf = &a[0];
re = spdk_gpt_check_mbr(gpt); re = gpt_check_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set mbr->mbr_signature matched, start lba mismatch */ /* Set mbr->mbr_signature matched, start lba mismatch */
mbr = (struct spdk_mbr *)gpt->buf; mbr = (struct spdk_mbr *)gpt->buf;
mbr->mbr_signature = 0xAA55; mbr->mbr_signature = 0xAA55;
re = spdk_gpt_check_mbr(gpt); re = gpt_check_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set mbr->partitions[0].start lba matched, os_type mismatch */ /* Set mbr->partitions[0].start lba matched, os_type mismatch */
mbr->partitions[0].start_lba = 1; mbr->partitions[0].start_lba = 1;
re = spdk_gpt_check_mbr(gpt); re = gpt_check_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set mbr->partitions[0].os_type matched, size_lba mismatch */ /* Set mbr->partitions[0].os_type matched, size_lba mismatch */
mbr->partitions[0].os_type = 0xEE; mbr->partitions[0].os_type = 0xEE;
re = spdk_gpt_check_mbr(gpt); re = gpt_check_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set mbr->partitions[0].size_lba matched, passing case */ /* Set mbr->partitions[0].size_lba matched, passing case */
mbr->partitions[0].size_lba = 0xFFFFFFFF; mbr->partitions[0].size_lba = 0xFFFFFFFF;
re = spdk_gpt_check_mbr(gpt); re = gpt_check_mbr(gpt);
CU_ASSERT(re == 0); CU_ASSERT(re == 0);
free(gpt); free(gpt);
@ -93,7 +93,7 @@ test_read_header(void)
unsigned char a[SPDK_GPT_BUFFER_SIZE]; unsigned char a[SPDK_GPT_BUFFER_SIZE];
int re; int re;
/* spdk_gpt_read_header(NULL) does not exist, NULL is filtered out in spdk_gpt_parse_mbr() */ /* gpt_read_header(NULL) does not exist, NULL is filtered out in gpt_parse_mbr() */
gpt = calloc(1, sizeof(*gpt)); gpt = calloc(1, sizeof(*gpt));
SPDK_CU_ASSERT_FATAL(gpt != NULL); SPDK_CU_ASSERT_FATAL(gpt != NULL);
gpt->parse_phase = SPDK_GPT_PARSE_PHASE_PRIMARY; gpt->parse_phase = SPDK_GPT_PARSE_PHASE_PRIMARY;
@ -108,18 +108,18 @@ test_read_header(void)
gpt->sector_size = 512; gpt->sector_size = 512;
head = (struct spdk_gpt_header *)(gpt->buf + GPT_PRIMARY_PARTITION_TABLE_LBA * gpt->sector_size); head = (struct spdk_gpt_header *)(gpt->buf + GPT_PRIMARY_PARTITION_TABLE_LBA * gpt->sector_size);
to_le32(&head->header_size, 0x258); to_le32(&head->header_size, 0x258);
re = spdk_gpt_read_header(gpt); re = gpt_read_header(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set head->header_size matched, header_crc32 mismatch */ /* Set head->header_size matched, header_crc32 mismatch */
head->header_size = sizeof(*head); head->header_size = sizeof(*head);
to_le32(&head->header_crc32, 0x22D18C80); to_le32(&head->header_crc32, 0x22D18C80);
re = spdk_gpt_read_header(gpt); re = gpt_read_header(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set head->header_crc32 matched, gpt_signature mismatch */ /* Set head->header_crc32 matched, gpt_signature mismatch */
to_le32(&head->header_crc32, 0xC5B2117E); to_le32(&head->header_crc32, 0xC5B2117E);
re = spdk_gpt_read_header(gpt); re = gpt_read_header(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set head->gpt_signature matched, head->my_lba mismatch */ /* Set head->gpt_signature matched, head->my_lba mismatch */
@ -132,13 +132,13 @@ test_read_header(void)
head->gpt_signature[5] = 'A'; head->gpt_signature[5] = 'A';
head->gpt_signature[6] = 'R'; head->gpt_signature[6] = 'R';
head->gpt_signature[7] = 'T'; head->gpt_signature[7] = 'T';
re = spdk_gpt_read_header(gpt); re = gpt_read_header(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set head->my_lba matched, lba_end usable_lba mismatch */ /* Set head->my_lba matched, lba_end usable_lba mismatch */
to_le32(&head->header_crc32, 0xB3CDB2D2); to_le32(&head->header_crc32, 0xB3CDB2D2);
to_le64(&head->my_lba, 0x1); to_le64(&head->my_lba, 0x1);
re = spdk_gpt_read_header(gpt); re = gpt_read_header(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set gpt->lba_end usable_lba matched, passing case */ /* Set gpt->lba_end usable_lba matched, passing case */
@ -147,7 +147,7 @@ test_read_header(void)
to_le64(&gpt->lba_end, 0x2E935FFE); to_le64(&gpt->lba_end, 0x2E935FFE);
to_le64(&head->first_usable_lba, 0xA); to_le64(&head->first_usable_lba, 0xA);
to_le64(&head->last_usable_lba, 0xF4240); to_le64(&head->last_usable_lba, 0xF4240);
re = spdk_gpt_read_header(gpt); re = gpt_read_header(gpt);
CU_ASSERT(re == 0); CU_ASSERT(re == 0);
free(gpt); free(gpt);
@ -161,7 +161,7 @@ test_read_partitions(void)
unsigned char a[SPDK_GPT_BUFFER_SIZE]; unsigned char a[SPDK_GPT_BUFFER_SIZE];
int re; int re;
/* spdk_gpt_read_partitions(NULL) does not exist, NULL is filtered out in spdk_gpt_parse_mbr() */ /* gpt_read_partitions(NULL) does not exist, NULL is filtered out in gpt_parse_mbr() */
gpt = calloc(1, sizeof(*gpt)); gpt = calloc(1, sizeof(*gpt));
SPDK_CU_ASSERT_FATAL(gpt != NULL); SPDK_CU_ASSERT_FATAL(gpt != NULL);
gpt->parse_phase = SPDK_GPT_PARSE_PHASE_PRIMARY; gpt->parse_phase = SPDK_GPT_PARSE_PHASE_PRIMARY;
@ -177,35 +177,35 @@ test_read_partitions(void)
head = (struct spdk_gpt_header *)(gpt->buf + GPT_PRIMARY_PARTITION_TABLE_LBA * gpt->sector_size); head = (struct spdk_gpt_header *)(gpt->buf + GPT_PRIMARY_PARTITION_TABLE_LBA * gpt->sector_size);
gpt->header = head; gpt->header = head;
to_le32(&head->num_partition_entries, 0x100); to_le32(&head->num_partition_entries, 0x100);
re = spdk_gpt_read_partitions(gpt); re = gpt_read_partitions(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set num_partition_entries within Max value, size_of_partition_entry mismatch */ /* Set num_partition_entries within Max value, size_of_partition_entry mismatch */
to_le32(&head->header_crc32, 0x573857BE); to_le32(&head->header_crc32, 0x573857BE);
to_le32(&head->num_partition_entries, 0x40); to_le32(&head->num_partition_entries, 0x40);
to_le32(&head->size_of_partition_entry, 0x0); to_le32(&head->size_of_partition_entry, 0x0);
re = spdk_gpt_read_partitions(gpt); re = gpt_read_partitions(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set size_of_partition_entry matched, partition_entry_lba mismatch */ /* Set size_of_partition_entry matched, partition_entry_lba mismatch */
to_le32(&head->header_crc32, 0x5279B712); to_le32(&head->header_crc32, 0x5279B712);
to_le32(&head->size_of_partition_entry, 0x80); to_le32(&head->size_of_partition_entry, 0x80);
to_le64(&head->partition_entry_lba, 0x64); to_le64(&head->partition_entry_lba, 0x64);
re = spdk_gpt_read_partitions(gpt); re = gpt_read_partitions(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set partition_entry_lba matched, partition_entry_array_crc32 mismatch */ /* Set partition_entry_lba matched, partition_entry_array_crc32 mismatch */
to_le32(&head->header_crc32, 0xEC093B43); to_le32(&head->header_crc32, 0xEC093B43);
to_le64(&head->partition_entry_lba, 0x20); to_le64(&head->partition_entry_lba, 0x20);
to_le32(&head->partition_entry_array_crc32, 0x0); to_le32(&head->partition_entry_array_crc32, 0x0);
re = spdk_gpt_read_partitions(gpt); re = gpt_read_partitions(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set partition_entry_array_crc32 matched, passing case */ /* Set partition_entry_array_crc32 matched, passing case */
to_le32(&head->header_crc32, 0xE1A08822); to_le32(&head->header_crc32, 0xE1A08822);
to_le32(&head->partition_entry_array_crc32, 0xEBEE44FB); to_le32(&head->partition_entry_array_crc32, 0xEBEE44FB);
to_le32(&head->num_partition_entries, 0x80); to_le32(&head->num_partition_entries, 0x80);
re = spdk_gpt_read_partitions(gpt); re = gpt_read_partitions(gpt);
CU_ASSERT(re == 0); CU_ASSERT(re == 0);
free(gpt); free(gpt);
@ -221,7 +221,7 @@ test_parse_mbr_and_primary(void)
int re; int re;
/* Set gpt is NULL */ /* Set gpt is NULL */
re = spdk_gpt_parse_mbr(NULL); re = gpt_parse_mbr(NULL);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set gpt->buf is NULL */ /* Set gpt->buf is NULL */
@ -229,14 +229,14 @@ test_parse_mbr_and_primary(void)
SPDK_CU_ASSERT_FATAL(gpt != NULL); SPDK_CU_ASSERT_FATAL(gpt != NULL);
gpt->parse_phase = SPDK_GPT_PARSE_PHASE_PRIMARY; gpt->parse_phase = SPDK_GPT_PARSE_PHASE_PRIMARY;
gpt->sector_size = 512; gpt->sector_size = 512;
re = spdk_gpt_parse_mbr(gpt); re = gpt_parse_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set *gpt is "aaa...", check_mbr failed */ /* Set *gpt is "aaa...", check_mbr failed */
memset(a, 'a', sizeof(a)); memset(a, 'a', sizeof(a));
gpt->buf = &a[0]; gpt->buf = &a[0];
gpt->buf_size = sizeof(a); gpt->buf_size = sizeof(a);
re = spdk_gpt_parse_mbr(gpt); re = gpt_parse_mbr(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set check_mbr passed */ /* Set check_mbr passed */
@ -245,11 +245,11 @@ test_parse_mbr_and_primary(void)
mbr->partitions[0].start_lba = 1; mbr->partitions[0].start_lba = 1;
mbr->partitions[0].os_type = 0xEE; mbr->partitions[0].os_type = 0xEE;
mbr->partitions[0].size_lba = 0xFFFFFFFF; mbr->partitions[0].size_lba = 0xFFFFFFFF;
re = spdk_gpt_parse_mbr(gpt); re = gpt_parse_mbr(gpt);
CU_ASSERT(re == 0); CU_ASSERT(re == 0);
/* Expect read_header failed */ /* Expect read_header failed */
re = spdk_gpt_parse_partition_table(gpt); re = gpt_parse_partition_table(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set read_header passed, read_partitions failed */ /* Set read_header passed, read_partitions failed */
@ -269,7 +269,7 @@ test_parse_mbr_and_primary(void)
to_le64(&gpt->lba_end, 0x2E935FFE); to_le64(&gpt->lba_end, 0x2E935FFE);
to_le64(&head->first_usable_lba, 0xA); to_le64(&head->first_usable_lba, 0xA);
to_le64(&head->last_usable_lba, 0xF4240); to_le64(&head->last_usable_lba, 0xF4240);
re = spdk_gpt_parse_partition_table(gpt); re = gpt_parse_partition_table(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set read_partitions passed, all passed */ /* Set read_partitions passed, all passed */
@ -278,7 +278,7 @@ test_parse_mbr_and_primary(void)
to_le32(&head->header_crc32, 0x845A09AA); to_le32(&head->header_crc32, 0x845A09AA);
to_le32(&head->partition_entry_array_crc32, 0xEBEE44FB); to_le32(&head->partition_entry_array_crc32, 0xEBEE44FB);
to_le32(&head->num_partition_entries, 0x80); to_le32(&head->num_partition_entries, 0x80);
re = spdk_gpt_parse_partition_table(gpt); re = gpt_parse_partition_table(gpt);
CU_ASSERT(re == 0); CU_ASSERT(re == 0);
free(gpt); free(gpt);
@ -292,7 +292,7 @@ test_parse_secondary(void)
unsigned char a[SPDK_GPT_BUFFER_SIZE]; unsigned char a[SPDK_GPT_BUFFER_SIZE];
int re; int re;
/* spdk_gpt_parse_partition_table(NULL) does not exist, NULL is filtered out in spdk_gpt_parse_mbr() */ /* gpt_parse_partition_table(NULL) does not exist, NULL is filtered out in gpt_parse_mbr() */
gpt = calloc(1, sizeof(*gpt)); gpt = calloc(1, sizeof(*gpt));
SPDK_CU_ASSERT_FATAL(gpt != NULL); SPDK_CU_ASSERT_FATAL(gpt != NULL);
gpt->parse_phase = SPDK_GPT_PARSE_PHASE_SECONDARY; gpt->parse_phase = SPDK_GPT_PARSE_PHASE_SECONDARY;
@ -302,7 +302,7 @@ test_parse_secondary(void)
memset(a, 'a', sizeof(a)); memset(a, 'a', sizeof(a));
gpt->buf = &a[0]; gpt->buf = &a[0];
gpt->buf_size = sizeof(a); gpt->buf_size = sizeof(a);
re = spdk_gpt_parse_partition_table(gpt); re = gpt_parse_partition_table(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set read_header passed, read_partitions failed */ /* Set read_header passed, read_partitions failed */
@ -323,7 +323,7 @@ test_parse_secondary(void)
to_le64(&gpt->total_sectors, 0x6400000); to_le64(&gpt->total_sectors, 0x6400000);
to_le64(&head->first_usable_lba, 0xA); to_le64(&head->first_usable_lba, 0xA);
to_le64(&head->last_usable_lba, 0x63FFFDE); to_le64(&head->last_usable_lba, 0x63FFFDE);
re = spdk_gpt_parse_partition_table(gpt); re = gpt_parse_partition_table(gpt);
CU_ASSERT(re == -1); CU_ASSERT(re == -1);
/* Set read_partitions passed, all passed */ /* Set read_partitions passed, all passed */
@ -332,7 +332,7 @@ test_parse_secondary(void)
to_le32(&head->header_crc32, 0x204129E8); to_le32(&head->header_crc32, 0x204129E8);
to_le32(&head->partition_entry_array_crc32, 0xEBEE44FB); to_le32(&head->partition_entry_array_crc32, 0xEBEE44FB);
to_le32(&head->num_partition_entries, 0x80); to_le32(&head->num_partition_entries, 0x80);
re = spdk_gpt_parse_partition_table(gpt); re = gpt_parse_partition_table(gpt);
CU_ASSERT(re == 0); CU_ASSERT(re == 0);
free(gpt); free(gpt);