| /* |
| * Copyright (c) 2013, Google, Inc. All rights reserved |
| * Copyright (c) 2014, Travis Geiselbrecht |
| * |
| * Use of this source code is governed by a MIT-style |
| * license that can be found in the LICENSE file or at |
| * https://opensource.org/licenses/MIT |
| */ |
| #include <lib/ptable.h> |
| #include <lk/debug.h> |
| #include <lk/trace.h> |
| #include <assert.h> |
| #include <lk/err.h> |
| #include <string.h> |
| #include <malloc.h> |
| #include <stdlib.h> |
| #include <lk/list.h> |
| #include <lib/bio.h> |
| #include <lib/cksum.h> |
| #include <lk/init.h> |
| #include <lk/console_cmd.h> |
| |
| #define LOCAL_TRACE 0 |
| |
| #define PTABLE_MAGIC '1BTP' |
| #define PTABLE_MIN_ENTRIES 16 |
| #define PTABLE_PART_NAME "ptable" |
| |
| struct ptable_header { |
| uint32_t magic; |
| uint32_t crc32; /* (total ptable according to total_length, 0 where crc field is) */ |
| uint32_t generation; /* incremented by one every time its saved */ |
| uint32_t total_length; /* valid length of table, only covers entries that are used */ |
| }; |
| |
| struct ptable_mem_entry { |
| struct list_node node; |
| struct ptable_entry entry; |
| }; |
| |
| static struct ptable_state { |
| bdev_t *bdev; |
| uint32_t gen; |
| struct list_node list; |
| } ptable; |
| |
| #define PTABLE_HEADER_NUM_ENTRIES(header) (((header).total_length - sizeof(struct ptable_header)) / sizeof(struct ptable_entry)) |
| #define BAIL(__err) do { err = __err; goto bailout; } while (0) |
| |
| static inline size_t ptable_length(size_t entry_cnt) { |
| return sizeof(struct ptable_header) + (sizeof(struct ptable_entry) * entry_cnt); |
| } |
| |
| static status_t validate_entry(const struct ptable_entry *entry) { |
| if (entry->offset > entry->offset + entry->length) |
| return ERR_GENERIC; |
| if (entry->offset + entry->length > (uint64_t)ptable.bdev->total_size) |
| return ERR_GENERIC; |
| |
| uint i; |
| for (i = 0; i < sizeof(entry->name); i++) |
| if (entry->name[i] == 0) |
| break; |
| |
| if (!i || (i >= sizeof(entry->name))) |
| return ERR_GENERIC; |
| |
| return NO_ERROR; |
| } |
| |
| static status_t ptable_write(void) { |
| uint8_t *buf = NULL; |
| bdev_t *bdev = NULL; |
| ssize_t err = ERR_GENERIC; |
| |
| if (!ptable_found_valid()) |
| return ERR_NOT_MOUNTED; |
| |
| bdev = bio_open(PTABLE_PART_NAME); |
| if (!bdev) |
| return ERR_BAD_STATE; |
| |
| /* count the number of entries in the list and calculate the total size */ |
| size_t count = 0; |
| struct list_node *node; |
| list_for_every(&ptable.list, node) { |
| count++; |
| } |
| LTRACEF("%u entries\n", count); |
| size_t total_length = sizeof(struct ptable_header) + sizeof(struct ptable_entry) * count; |
| |
| /* can we fit our partition table in our ptable subdevice? */ |
| if (total_length > bdev->total_size) |
| BAIL(ERR_TOO_BIG); |
| |
| /* allocate a buffer to hold it */ |
| buf = malloc(total_length); |
| if (!buf) |
| BAIL(ERR_NO_MEMORY); |
| |
| /* fill in a default header */ |
| struct ptable_header *header = (struct ptable_header *)buf; |
| header->magic = PTABLE_MAGIC; |
| header->crc32 = 0; |
| header->generation = ptable.gen++; |
| header->total_length = total_length; |
| |
| /* start the crc calculation */ |
| header->crc32 = crc32(0, (void *)header, sizeof(*header)); |
| |
| /* start by writing the entries */ |
| size_t off = sizeof(struct ptable_header); |
| struct ptable_mem_entry *mentry; |
| list_for_every_entry(&ptable.list, mentry, struct ptable_mem_entry, node) { |
| const struct ptable_entry *entry = &mentry->entry; |
| |
| memcpy(buf + off, entry, sizeof(struct ptable_entry)); |
| |
| /* update the header */ |
| header->crc32 = crc32(header->crc32, (void *)entry, sizeof(struct ptable_entry)); |
| |
| off += sizeof(struct ptable_entry); |
| } |
| |
| /* write it to the block device. If the device has an erase geometry, start |
| * by erasing the partition. |
| */ |
| if (bdev->geometry_count && bdev->geometry) { |
| /* This is a subdevice, it should have a homogeneous erase geometry */ |
| DEBUG_ASSERT(1 == bdev->geometry_count); |
| |
| err = bio_erase(bdev, 0, bdev->total_size); |
| if (err != (ssize_t)bdev->total_size) { |
| LTRACEF("error %d erasing device\n", (int)err); |
| BAIL(ERR_IO); |
| } |
| } |
| |
| err = bio_write(bdev, buf, 0, total_length); |
| if (err < (ssize_t)total_length) { |
| LTRACEF("error %d writing data to device\n", (int)err); |
| BAIL(ERR_IO); |
| } |
| |
| LTRACEF("wrote ptable:\n"); |
| if (LOCAL_TRACE) |
| hexdump(buf, total_length); |
| |
| err = NO_ERROR; |
| |
| bailout: |
| if (bdev) |
| bio_close(bdev); |
| |
| free(buf); |
| |
| return err; |
| } |
| |
| static void ptable_init(uint level) { |
| memset(&ptable, 0, sizeof(ptable)); |
| list_initialize(&ptable.list); |
| } |
| |
| LK_INIT_HOOK(ptable, &ptable_init, LK_INIT_LEVEL_THREADING); |
| |
| static void ptable_unpublish(struct ptable_mem_entry *mentry) { |
| if (mentry) { |
| bdev_t *bdev; |
| |
| bdev = bio_open((char *)mentry->entry.name); |
| if (bdev) { |
| bio_unregister_device(bdev); |
| bio_close(bdev); |
| } |
| |
| if (list_in_list(&mentry->node)) |
| list_delete(&mentry->node); |
| |
| free(mentry); |
| } |
| } |
| |
| static void ptable_reset(void) { |
| /* walk through the partition list, clearing any entries */ |
| struct ptable_mem_entry *mentry; |
| struct ptable_mem_entry *temp; |
| list_for_every_entry_safe(&ptable.list, mentry, temp, struct ptable_mem_entry, node) { |
| ptable_unpublish(mentry); |
| } |
| |
| /* release our reference to our primary device */ |
| if (NULL != ptable.bdev) |
| bio_close(ptable.bdev); |
| |
| /* Reset initialize our bookkeeping */ |
| ptable_init(LK_INIT_LEVEL_THREADING); |
| } |
| |
| static void ptable_push_entry (struct ptable_mem_entry *mentry) { |
| DEBUG_ASSERT (mentry); |
| |
| // iterator for the list |
| struct ptable_mem_entry *it_mentry; |
| |
| // The ptable list must be ordered by offset, so let's find the correct |
| // spot for this entry |
| list_for_every_entry(&ptable.list, it_mentry, struct ptable_mem_entry, node) { |
| if (it_mentry->entry.offset > mentry->entry.offset) { |
| // push the entry and we are done ! |
| list_add_before(&it_mentry->node, &mentry->node); |
| // All done |
| return; |
| } |
| } |
| |
| // if we exist the loop, that means that the |
| // entry has not been added, let add it at the tail |
| list_add_tail(&ptable.list, &mentry->node); |
| } |
| |
| static status_t ptable_publish(const struct ptable_entry *entry) { |
| status_t err; |
| struct ptable_mem_entry *mentry = NULL; |
| |
| DEBUG_ASSERT(entry && ptable.bdev); |
| size_t block_mask = ((size_t)0x01 << ptable.bdev->block_shift) - 1; |
| |
| err = validate_entry(entry); |
| if (err < 0) { |
| LTRACEF("entry failed valid check\n"); |
| BAIL(ERR_NOT_FOUND); |
| } |
| |
| // Make sure the partition does not already exist. |
| const char *part_name = (const char *)entry->name; |
| err = ptable_find(part_name, 0); |
| if (err >= 0) { |
| LTRACEF("entry \"%s\" already exists\n", part_name); |
| BAIL(ERR_ALREADY_EXISTS); |
| } |
| |
| // make sure that the partition is aligned properly |
| if ((entry->offset & block_mask) || (entry->length & block_mask)) { |
| LTRACEF("Entry in parition (\"%s\") is misaligned " |
| "(off 0x%llx len 0x%llx blockmask 0x%zx\n", |
| part_name, entry->offset, entry->length, block_mask); |
| BAIL(ERR_BAD_STATE); |
| } |
| |
| // make sure that length is non-zero and does not wrap |
| if ((entry->offset + entry->length) <= entry->offset) { |
| LTRACEF("Bad offset/length 0x%llx/0x%llx\n", entry->offset, entry->length); |
| BAIL(ERR_INVALID_ARGS); |
| } |
| |
| // make sure entry can fit in the device |
| if ((entry->offset + entry->length) > (uint64_t)ptable.bdev->total_size) { |
| LTRACEF("outside of device\n"); |
| BAIL(ERR_INVALID_ARGS); |
| } |
| |
| /* create an in-memory copy and attempt to publish a subdevice for the |
| * partition |
| */ |
| mentry = calloc(1, sizeof(struct ptable_mem_entry)); |
| if (!mentry) { |
| LTRACEF("Out of memory\n"); |
| BAIL(ERR_NO_MEMORY); |
| } |
| |
| memcpy(&mentry->entry, entry, sizeof(struct ptable_entry)); |
| err = bio_publish_subdevice(ptable.bdev->name, part_name, |
| entry->offset >> ptable.bdev->block_shift, |
| entry->length >> ptable.bdev->block_shift); |
| if (err < 0) { |
| LTRACEF("Failed to publish subdevice for \"%s\"\n", part_name); |
| goto bailout; |
| } |
| |
| err = NO_ERROR; |
| |
| bailout: |
| /* If we failed to publish, clean up whatever we may have allocated. |
| * Otherwise, put our new entry on the in-memory list. |
| */ |
| if (err < 0) { |
| ptable_unpublish(mentry); |
| } else { |
| ptable_push_entry (mentry); |
| } |
| |
| return err; |
| } |
| |
| static off_t ptable_adjust_request_for_erase_geometry(uint64_t region_start, |
| uint64_t region_len, |
| uint64_t *plength, |
| bool alloc_end) { |
| DEBUG_ASSERT(plength && ptable.bdev); |
| |
| LTRACEF("[0x%llx, 0x%llx) len 0x%llx%s\n", |
| region_start, region_start + region_len, *plength, alloc_end ? " (alloc end)" : ""); |
| |
| uint64_t block_mask = ((uint64_t)0x1 << ptable.bdev->block_shift) - 1; |
| DEBUG_ASSERT(!(*plength & block_mask)); |
| DEBUG_ASSERT(!(region_start & block_mask)); |
| DEBUG_ASSERT(!(region_len & block_mask)); |
| |
| uint64_t region_end = region_start + region_len; |
| DEBUG_ASSERT(region_end >= region_start); |
| |
| // Can we fit in the region at all? |
| if (*plength > region_len) { |
| LTRACEF("Request too large for region (0x%llx > 0x%llx)\n", *plength, region_len); |
| return ERR_TOO_BIG; |
| } |
| |
| // If our block device does not have an erase geometry to obey, then great! |
| // No special modifications to the request are needed. Just determine the |
| // offset based on if we are allocating from the start or the end. |
| if (!ptable.bdev->geometry_count || !ptable.bdev->geometry) { |
| off_t ret = alloc_end ? (region_start + region_len - *plength) : region_start; |
| LTRACEF("No geometry; allocating at [0x%llx, 0x%llx)\n", ret, ret + *plength); |
| return ret; |
| } |
| |
| // Intersect each of the erase regions with the region being proposed and |
| // see if we can fit the allocation request in the intersection, after |
| // adjusting the intersection and requested length to multiples of and |
| // aligned to the erase block size. Test the geometries back-to-front |
| // instead of front-to-back if alloc_end has been reqeusted. |
| for (size_t i = 0; i < ptable.bdev->geometry_count; ++i) { |
| size_t geo_index = alloc_end ? (ptable.bdev->geometry_count - i - 1) : i; |
| const bio_erase_geometry_info_t *geo = ptable.bdev->geometry + geo_index; |
| uint64_t erase_mask = ((uint64_t)0x1 << geo->erase_shift) - 1; |
| |
| LTRACEF("Considering erase region [0x%llx, 0x%llx) (erase size 0x%zx)\n", |
| geo->start, geo->start + geo->size, geo->erase_size); |
| |
| // If the erase region and the allocation region do not intersect at |
| // all, just move on to the next region. |
| if (!bio_does_overlap(region_start, region_len, geo->start, geo->size)) { |
| LTRACEF("No overlap...\n"); |
| continue; |
| } |
| |
| // Compute the intersection of the request region with the erase region. |
| uint64_t erase_end = geo->start + geo->size; |
| uint64_t rstart = MAX(region_start, (uint64_t)geo->start); |
| uint64_t rend = MIN(region_end, erase_end); |
| |
| // Align to erase unit boundaries. Move the start of the intersected |
| // region up and the end of the intersected region down. |
| rstart = (rstart + erase_mask) & ~erase_mask; |
| rend = rend & ~erase_mask; |
| |
| // Round the requested length up to a multiple of the erase unit. |
| uint64_t length = (*plength + erase_mask) & ~erase_mask; |
| |
| LTRACEF("Trimmed and aligned request [0x%llx, 0x%llx) len 0x%llx%s\n", |
| rstart, rend, length, alloc_end ? " (alloc end)" : ""); |
| |
| // Is there enough space in the aligned intersection to hold the |
| // request? |
| uint64_t tmp = rstart + length; |
| if ((tmp < rstart) || (rend < tmp)) { |
| LTRACEF("Not enough space\n"); |
| continue; |
| } |
| |
| // Yay! We found space for this allocation! Adjust the requested |
| // length and return the approprate offset based on whether we want to |
| // allocate from the start or the end. |
| off_t ret; |
| *plength = length; |
| ret = alloc_end ? (rend - length) : rstart; |
| LTRACEF("Allocating at [0x%llx, 0x%llx) (erase_size 0x%zx)\n", |
| ret, ret + *plength, geo->erase_size); |
| return ret; |
| } |
| |
| // Looks like we didn't find a place to put this allocation. |
| LTRACEF("No location found!\n"); |
| return ERR_INVALID_ARGS; |
| } |
| |
| static off_t ptable_allocate(uint64_t *plength, uint flags) { |
| DEBUG_ASSERT(plength); |
| |
| if (!ptable.bdev) |
| return ERR_BAD_STATE; |
| |
| LTRACEF("length 0x%llx, flags 0x%x\n", *plength, flags); |
| |
| uint64_t block_mask = ((uint64_t)0x1 << ptable.bdev->block_shift) - 1; |
| uint64_t length = (*plength + block_mask) & ~block_mask; |
| off_t offset = ERR_NOT_FOUND; |
| bool alloc_end = 0 != (flags & FLASH_PTABLE_ALLOC_END); |
| |
| if (list_is_empty(&ptable.list)) { |
| /* If the ptable is empty, then we have the entire device to use for |
| * allocation. Apply the erase geometry and return the result. |
| */ |
| offset = ptable_adjust_request_for_erase_geometry(0, |
| ptable.bdev->total_size, |
| &length, |
| alloc_end); |
| goto done; |
| } |
| |
| const struct ptable_entry *lastentry = NULL; |
| struct ptable_mem_entry *mentry; |
| uint64_t region_start; |
| uint64_t region_len; |
| uint64_t test_len; |
| off_t test_offset; |
| |
| list_for_every_entry(&ptable.list, mentry, struct ptable_mem_entry, node) { |
| const struct ptable_entry *entry = &mentry->entry; |
| |
| // Figure out the region we are testing, then adjust the request |
| // based on the device erase geometry. |
| region_start = lastentry ? (lastentry->offset + lastentry->length): 0; |
| region_len = entry->offset - region_start; |
| DEBUG_ASSERT((int64_t)region_len >= 0); |
| |
| LTRACEF("Considering region [0x%llx, 0x%llx) between \"%s\" and \"%s\"\n", |
| region_start, |
| region_start + region_len, |
| lastentry ? (char *)lastentry->name : "<device start>", |
| entry->name); |
| lastentry = entry; |
| |
| // Don't bother with the region if it is of zero length |
| if (!region_len) |
| continue; |
| |
| test_len = length; |
| test_offset = ptable_adjust_request_for_erase_geometry(region_start, |
| region_len, |
| &test_len, |
| alloc_end); |
| |
| // If this region was no good, move onto the next one. |
| if (test_offset < 0) |
| continue; |
| |
| // We found a possible answer, go ahead and record it. If we are |
| // allocating from the front, then we are finished. If we are |
| // attempting to allocate from the back, keep looking to see if |
| // there are other (better) answers. |
| offset = test_offset; |
| length = test_len; |
| if (!alloc_end) |
| goto done; |
| } |
| |
| /* still looking... the final region to test goes from the end of the previous |
| * region to the end of the device. |
| */ |
| DEBUG_ASSERT(lastentry); /* should always have a valid tail */ |
| |
| region_start = lastentry->offset + lastentry->length; |
| region_len = ptable.bdev->total_size - region_start; |
| DEBUG_ASSERT((int64_t)region_len >= 0); |
| |
| if (region_len) { |
| LTRACEF("Considering region [0x%llx, 0x%llx) between \"%s\" and \"%s\"\n", |
| region_start, |
| region_start + region_len, |
| lastentry->name, |
| "<device end>"); |
| test_len = length; |
| test_offset = ptable_adjust_request_for_erase_geometry(region_start, |
| region_len, |
| &test_len, |
| alloc_end); |
| if (test_offset >= 0) { |
| offset = test_offset; |
| length = test_len; |
| } |
| } |
| |
| done: |
| if (offset < 0) { |
| LTRACEF("Failed to find a suitable region of at least length %llu (err %lld)\n", |
| *plength, offset); |
| } else { |
| LTRACEF("Found region for %lld byte request @[%lld, %lld)\n", |
| *plength, offset, offset + length); |
| *plength = length; |
| } |
| |
| return offset; |
| } |
| |
| static status_t ptable_allocate_at(off_t _offset, uint64_t *plength) { |
| if (!ptable.bdev) |
| return ERR_BAD_STATE; |
| |
| if ((_offset < 0) || !plength) |
| return ERR_INVALID_ARGS; |
| |
| /* to make life easier, get our offset into unsigned */ |
| uint64_t offset = (uint64_t)_offset; |
| |
| /* Make certain the request was aligned to a program block boundary, and |
| * adjust the length to be a multiple of program blocks in size. |
| */ |
| uint64_t block_mask = ((uint64_t)0x1 << ptable.bdev->block_shift) - 1; |
| if (offset & block_mask) |
| return ERR_INVALID_ARGS; |
| |
| *plength = (*plength + block_mask) & ~block_mask; |
| |
| /* Make sure the request is contained within the extent of the device |
| * itself. |
| */ |
| if (!bio_contains_range(0, ptable.bdev->total_size, offset, *plength)) |
| return ERR_INVALID_ARGS; |
| |
| /* Adjust the request base on the erase geometry. If the offset needs to |
| * move to accomadate the erase geometry, we cannot satisfy this request. |
| */ |
| uint64_t new_offset = ptable_adjust_request_for_erase_geometry(offset, |
| ptable.bdev->total_size - offset, |
| plength, |
| false); |
| if (new_offset != offset) |
| return ERR_INVALID_ARGS; |
| |
| /* Finally, check the adjusted request against all of the existing |
| * partitions. The final region may not overlap an of the existing |
| * partitions. |
| */ |
| struct ptable_mem_entry *mentry; |
| list_for_every_entry(&ptable.list, mentry, struct ptable_mem_entry, node) { |
| const struct ptable_entry *entry = &mentry->entry; |
| |
| if (bio_does_overlap(offset, *plength, entry->offset, entry->length)) |
| return ERR_NOT_FOUND; |
| } |
| |
| // Success. |
| return NO_ERROR; |
| } |
| |
| status_t ptable_scan(const char *bdev_name, uint64_t offset) { |
| ssize_t err; |
| DEBUG_ASSERT(bdev_name); |
| |
| ptable_reset(); |
| |
| /* Open a reference to the main block device */ |
| ptable.bdev = bio_open(bdev_name); |
| if (NULL == ptable.bdev) { |
| LTRACEF("Failed to find device \"%s\"", bdev_name); |
| BAIL(ERR_NOT_FOUND); |
| } |
| |
| /* validate the header */ |
| struct ptable_header header; |
| |
| err = bio_read(ptable.bdev, &header, offset, sizeof(header)); |
| if (err < (ssize_t)sizeof(header)) { |
| LTRACEF("failed to read partition table header @%llu (%ld)\n", offset, err); |
| goto bailout; |
| } |
| |
| if (LOCAL_TRACE) |
| hexdump(&header, sizeof(struct ptable_header)); |
| |
| if (header.magic != PTABLE_MAGIC) { |
| LTRACEF("failed magic test\n"); |
| BAIL(ERR_NOT_FOUND); |
| } |
| if (header.total_length < sizeof(struct ptable_header)) { |
| LTRACEF("total length too short\n"); |
| BAIL(ERR_NOT_FOUND); |
| } |
| if (header.total_length > ptable.bdev->block_size) { |
| LTRACEF("total length too long\n"); |
| BAIL(ERR_NOT_FOUND); |
| } |
| if (((header.total_length - sizeof(struct ptable_header)) % sizeof(struct ptable_entry)) != 0) { |
| LTRACEF("total length not multiple of header + multiple of entry size\n"); |
| BAIL(ERR_NOT_FOUND); |
| } |
| |
| /* start a crc check by calculating the header */ |
| uint32_t crc; |
| uint32_t saved_crc = header.crc32; |
| header.crc32 = 0; |
| crc = crc32(0, (void *)&header, sizeof(header)); |
| header.crc32 = saved_crc; |
| bool found_ptable = false; |
| |
| /* read the entries into memory */ |
| off_t off = offset + sizeof(struct ptable_header); |
| for (uint i = 0; i < PTABLE_HEADER_NUM_ENTRIES(header); i++) { |
| struct ptable_entry entry; |
| |
| /* read the next entry off the device */ |
| err = bio_read(ptable.bdev, &entry, off, sizeof(entry)); |
| if (err < 0) { |
| LTRACEF("failed to read entry\n"); |
| goto bailout; |
| } |
| |
| LTRACEF("looking at entry:\n"); |
| if (LOCAL_TRACE) |
| hexdump(&entry, sizeof(entry)); |
| |
| /* Attempt to publish the entry */ |
| err = ptable_publish(&entry); |
| if (err < 0) { |
| goto bailout; |
| } |
| |
| /* If this was the "ptable" entry, was it in the right place? */ |
| if (!strncmp((char *)entry.name, PTABLE_PART_NAME, sizeof(entry.name))) { |
| found_ptable = true; |
| |
| if (entry.offset != offset) { |
| LTRACEF("\"ptable\" in the wrong location! (expected %lld got %lld)\n", |
| offset, entry.offset); |
| BAIL(ERR_BAD_STATE); |
| } |
| } |
| |
| /* append the crc */ |
| crc = crc32(crc, (void *)&entry, sizeof(entry)); |
| |
| /* Move on to the next entry */ |
| off += sizeof(struct ptable_entry); |
| } |
| |
| if (header.crc32 != crc) { |
| LTRACEF("failed crc check at the end (0x%08x != 0x%08x)\n", header.crc32, crc); |
| BAIL(ERR_CRC_FAIL); |
| } |
| |
| if (!found_ptable) { |
| LTRACEF("\"ptable\" partition not found\n"); |
| BAIL(ERR_NOT_FOUND); |
| } |
| |
| err = NO_ERROR; |
| |
| bailout: |
| if (err < 0) |
| ptable_reset(); |
| |
| return (status_t)err; |
| } |
| |
| bool ptable_found_valid(void) { |
| return (NULL != ptable.bdev); |
| } |
| |
| bdev_t *ptable_get_device(void) { |
| return ptable.bdev; |
| } |
| |
| status_t ptable_find(const char *name, struct ptable_entry *_entry) { |
| struct ptable_mem_entry *mentry; |
| list_for_every_entry(&ptable.list, mentry, struct ptable_mem_entry, node) { |
| const struct ptable_entry *entry = &mentry->entry; |
| if (strcmp(name, (void *)entry->name) == 0) { |
| /* copy the entry to the passed in pointer */ |
| if (_entry) { |
| memcpy(_entry, entry, sizeof(struct ptable_entry)); |
| } |
| |
| return NO_ERROR; |
| } |
| } |
| |
| return ERR_NOT_FOUND; |
| } |
| |
| status_t ptable_create_default(const char *bdev_name, uint64_t offset) { |
| DEBUG_ASSERT(bdev_name); |
| |
| /* Reset the system */ |
| ptable_reset(); |
| ptable.bdev = bio_open(bdev_name); |
| if (!ptable.bdev) { |
| LTRACEF("Failed to open \"%s\"\n", bdev_name); |
| return ERR_NOT_FOUND; |
| } |
| |
| /* See if we can put the partition table partition at the requested |
| * location, and determine the size needed based on program block size and |
| * erase block geometry. |
| */ |
| uint64_t len = ptable_length(PTABLE_MIN_ENTRIES); |
| status_t err = ptable_allocate_at(offset, &len); |
| if (err < 0) { |
| LTRACEF("Failed to allocate partition of len 0x%llx @ 0x%llx (err %d)\n", |
| len, offset, err); |
| goto bailout; |
| } |
| |
| /* Publish the ptable partition */ |
| struct ptable_entry ptable_entry; |
| memset(&ptable_entry, 0, sizeof(ptable_entry)); |
| ptable_entry.offset = offset; |
| ptable_entry.length = len; |
| ptable_entry.flags = 0; |
| strlcpy((char *)ptable_entry.name, PTABLE_PART_NAME, sizeof(ptable_entry.name)); |
| err = ptable_publish(&ptable_entry); |
| if (err < 0) { |
| LTRACEF("Failed to publish ptable partition\n"); |
| goto bailout; |
| } |
| |
| /* Commit the partition table to storage */ |
| err = ptable_write(); |
| if (err < 0) { |
| LTRACEF("Failed to commit ptable\n"); |
| goto bailout; |
| } |
| |
| bailout: |
| /* if we failed, reset the system. */ |
| if (err < 0) |
| ptable_reset(); |
| |
| return err; |
| } |
| |
| status_t ptable_remove(const char *name) { |
| DEBUG_ASSERT(ptable.bdev); |
| |
| LTRACEF("name %s\n", name); |
| |
| if (!ptable_found_valid()) |
| return ERR_NOT_MOUNTED; |
| |
| if (!name) |
| return ERR_INVALID_ARGS; |
| |
| if (!strcmp(name, "ptable")) |
| return ERR_NOT_ALLOWED; |
| |
| bool found = false; |
| struct ptable_mem_entry *mentry; |
| list_for_every_entry(&ptable.list, mentry, struct ptable_mem_entry, node) { |
| const struct ptable_entry *entry = &mentry->entry; |
| if (strcmp(name, (void *)entry->name) == 0) { |
| ptable_unpublish(mentry); |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) |
| return ERR_NOT_FOUND; |
| |
| /* rewrite the page table */ |
| status_t err = ptable_write(); |
| return err; |
| } |
| |
| status_t ptable_add(const char *name, uint64_t min_len, uint32_t flags) { |
| LTRACEF("name %s min_len 0x%llx flags 0x%x\n", name, min_len, flags); |
| |
| if (!ptable_found_valid()) |
| return ERR_NOT_MOUNTED; |
| |
| /* see if the name is valid */ |
| if (strlen(name) > MAX_FLASH_PTABLE_NAME_LEN - 1) { |
| LTRACEF("Name too long\n"); |
| return ERR_INVALID_ARGS; |
| } |
| |
| // Find a place for the requested partition, adjust the length as needed |
| off_t part_loc = ptable_allocate(&min_len, flags); |
| if (part_loc < 0) { |
| LTRACEF("Failed to usable find location.\n"); |
| return (status_t)part_loc; |
| } |
| |
| /* Attempt to publish the partition */ |
| struct ptable_entry ptable_entry; |
| memset(&ptable_entry, 0, sizeof(ptable_entry)); |
| ptable_entry.offset = part_loc; |
| ptable_entry.length = min_len; |
| ptable_entry.flags = 0; |
| strlcpy((char *)ptable_entry.name, name, sizeof(ptable_entry.name)); |
| status_t err = ptable_publish(&ptable_entry); |
| if (err < 0) { |
| LTRACEF("Failed to publish\n"); |
| return err; |
| } |
| |
| /* Commit the partition table */ |
| err = ptable_write(); |
| if (err < 0) { |
| LTRACEF("Failed to commit ptable\n"); |
| } |
| |
| return err; |
| } |
| |
| void ptable_dump(void) { |
| int i = 0; |
| struct ptable_mem_entry *mentry; |
| list_for_every_entry(&ptable.list, mentry, struct ptable_mem_entry, node) { |
| const struct ptable_entry *entry = &mentry->entry; |
| |
| printf("%d: %16s off 0x%016llx len 0x%016llx flags 0x%08x\n", |
| i, entry->name, entry->offset, entry->length, entry->flags); |
| i++; |
| } |
| } |
| |
| static int cmd_ptable(int argc, const console_cmd_args *argv) { |
| if (argc < 2) { |
| notenoughargs: |
| printf("not enough arguments\n"); |
| usage: |
| printf("usage: %s scan <bio_device> <offset>\n", argv[0].str); |
| printf("usage: %s default <bio_device> <offset>\n", argv[0].str); |
| printf("usage: %s list\n", argv[0].str); |
| printf("usage: %s add <name> <length> <flags>\n", argv[0].str); |
| printf("usage: %s remove <name>\n", argv[0].str); |
| printf("usage: %s alloc <len>\n", argv[0].str); |
| printf("usage: %s allocend <len>\n", argv[0].str); |
| printf("usage: %s write\n", argv[0].str); |
| return -1; |
| } |
| |
| status_t err; |
| if (!strcmp(argv[1].str, "scan")) { |
| if (argc < 4) goto notenoughargs; |
| err = ptable_scan(argv[2].str, argv[3].u); |
| printf("ptable_scan returns %d\n", err); |
| } else if (!strcmp(argv[1].str, "default")) { |
| if (argc < 4) goto notenoughargs; |
| err = ptable_create_default(argv[2].str, argv[3].u); |
| printf("ptable_create_default returns %d\n", err); |
| } else if (!strcmp(argv[1].str, "list")) { |
| ptable_dump(); |
| } else if (!strcmp(argv[1].str, "nuke")) { |
| bdev_t *ptable_dev = bio_open(PTABLE_PART_NAME); |
| |
| if (ptable_dev) { |
| err = bio_erase(ptable_dev, 0, ptable_dev->total_size); |
| if (err < 0) { |
| printf("ptable nuke failed (err %d)\n", err); |
| } else { |
| printf("ptable nuke OK\n"); |
| } |
| bio_close(ptable_dev); |
| } else { |
| printf("Failed to find ptable device\n"); |
| } |
| } else if (!strcmp(argv[1].str, "add")) { |
| if (argc < 5) goto notenoughargs; |
| err = ptable_add(argv[2].str, argv[3].u, argv[4].u); |
| if (err < NO_ERROR) |
| printf("ptable_add returns err %d\n", err); |
| } else if (!strcmp(argv[1].str, "remove")) { |
| if (argc < 3) goto notenoughargs; |
| ptable_remove(argv[2].str); |
| } else if (!strcmp(argv[1].str, "alloc") || |
| !strcmp(argv[1].str, "allocend")) { |
| if (argc < 3) goto notenoughargs; |
| |
| uint flags = !strcmp(argv[1].str, "allocend") ? FLASH_PTABLE_ALLOC_END : 0; |
| uint64_t len = argv[2].u; |
| off_t off = ptable_allocate(&len, flags); |
| |
| if (off < 0) { |
| printf("%s of 0x%lx failed (err %lld)\n", |
| argv[1].str, argv[2].u, off); |
| } else { |
| printf("%s of 0x%lx gives [0x%llx, 0x%llx)\n", |
| argv[1].str, argv[2].u, off, off + len); |
| } |
| } else if (!strcmp(argv[1].str, "write")) { |
| printf("ptable_write result %d\n", ptable_write()); |
| } else { |
| goto usage; |
| } |
| |
| return 0; |
| } |
| |
| STATIC_COMMAND_START |
| STATIC_COMMAND("ptable", "commands for manipulating the flash partition table", &cmd_ptable) |
| STATIC_COMMAND_END(ptable); |
