Changeset 30440ed in mainline for uspace/lib/gpt

Timestamp:

2013-04-08T23:15:42Z (12 years ago)

Author:

Dominik Taborsky (AT DOT) <brembyseznamcz>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

256cbfe

Parents:

271e24a

Message:

save progress

Location:

uspace/lib/gpt

Files:

• global.c (added)
• libgpt.c (modified) (12 diffs)
• libgpt.h (modified) (4 diffs)

uspace/lib/gpt/libgpt.c

@@ -117 +117 @@
  * 
  * @return                              0 on success, libblock error code otherwise
+ * 
+ * Note: Firstly write partitions (if changed), then gpt header.
  */
 int gpt_write_gpt_header(gpt_t * gpt, service_id_t dev_handle)
@@ -167 +169 @@
         unsigned int i;
         gpt_partitions_t * res;
-        uint32_t num_ent = uint32_t_le2host(gpt->raw_data->num_entries);
+        uint32_t fill = uint32_t_le2host(gpt->raw_data->fillries);
         uint32_t ent_size = uint32_t_le2host(gpt->raw_data->entry_size);
         uint64_t ent_lba = uint64_t_le2host(gpt->raw_data->entry_lba);
         
-        res = alloc_part_array(num_ent);
+        res = alloc_part_array(fill);
         if (res == NULL) {
                 //errno = ENOMEM; // already set in alloc_part_array()
@@ -204 +206 @@
          * will always read just sizeof(gpt_entry_t) bytes - hopefully they
          * don't break backward compatibility) */
-        for (i = 0; i < num_ent; ++i) {
+        for (i = 0; i < fill; ++i) {
                 //FIXME: this does bypass cache...
                 rc = block_read_bytes_direct(gpt->device, pos, sizeof(gpt_entry_t), res->part_array + i);
@@ -223 +225 @@
          * on all of the partition entry array.
          */
-        uint32_t crc = compute_crc32((uint8_t *) res->part_array, res->num_ent * sizeof(gpt_entry_t));
+        uint32_t crc = compute_crc32((uint8_t *) res->part_array, res->fill * sizeof(gpt_entry_t));
         
         if(uint32_t_le2host(gpt->raw_data->pe_array_crc32) != crc)
@@ -247 +249 @@
         size_t b_size;
         
-        gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->num_ent * gpt->raw_data->entry_size);
+        gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->fill * gpt->raw_data->entry_size);
         
         rc = block_get_bsize(dev_handle, &b_size);
@@ -259 +261 @@
         /* Write to main GPT partition array location */
         rc = block_write_direct(dev_handle, uint64_t_le2host(gpt->raw_data->entry_lba), 
-                        nearest_larger_int((uint64_t_le2host(gpt->raw_data->entry_size) * parts->num_ent) / b_size), 
+                        nearest_larger_int((uint64_t_le2host(gpt->raw_data->entry_size) * parts->fill) / b_size), 
                         parts->part_array);
         if (rc != EOK)
@@ -277 +279 @@
         
         
-        gpt_write_gpt_header(gpt, dev_handle);
-        
-        return 0;
-        
-}
-
-gpt_partitions_t * gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition)
-{
-        
+        return gpt_write_gpt_header(gpt, dev_handle);
+}
+
+/** Alloc new partition
+ * 
+ * @param parts         partition table to carry new partition
+ * 
+ * @return                      returns pointer to the new partition or NULL on ENOMEM
+ * 
+ * Note: use either gpt_alloc_partition or gpt_add_partition. The first
+ * returns a pointer to write your data to, the second copies the data 
+ * (and does not free the memory).
+ */
+gpt_part_t * gpt_alloc_partition(gpt_partitions_t * parts)
+{
+        if (parts->fill == parts->arr_size) {
+                if (extend_part_array(parts) == -1)
+                        return NULL;
+        }
+        
+        return parts->part_array + parts->fill++;
+}
+
+/** Copy partition into partition array
+ * 
+ * @param parts                 target partition array
+ * @param partition             source partition to copy
+ * 
+ * @return                              -1 on error, 0 otherwise
+ * 
+ * Note: use either gpt_alloc_partition or gpt_add_partition. The first
+ * returns a pointer to write your data to, the second copies the data 
+ * (and does not free the memory).
+ */
+int gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition)
+{
+        if (parts->fill == parts->arr_size) {
+                if (extend_part_array(parts) == -1)
+                        return -1;
+        }
         extend_part_array(parts);
         return parts;
 }
 
-gpt_partitions_t * gpt_remove_partition(gpt_partitions_t * parts, size_t idx)
-{
-        reduce_part_array(parts);
-        return parts;
+/** Remove partition from array
+ * 
+ * @param idx           index of the partition to remove
+ * 
+ * @return                      -1 on error, 0 otherwise
+ * 
+ * Note: even if it fails, the partition still gets removed. Only
+ * reducing the array failed.
+ */
+int gpt_remove_partition(gpt_partitions_t * parts, size_t idx)
+{
+        if (idx != parts->fill - 1) {
+                memcpy(parts->part_array + idx, parts->part_array + fill - 1, sizeof(gpt_entry_t));
+                parts->fill -= 1;
+        }
+        
+        if (parts->fill < (parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
+                if (reduce_part_array(parts) == -1)
+                        return -1;
+        }
+        
+        return 0;
 }
 
@@ -311 +362 @@
         free(parts->part_array);
         free(parts);
+}
+
+/** Get partition type by linear search
+ * (hopefully this doesn't get slow)
+ */
+size_t gpt_get_part_type(gpt_part_t * p)
+{
+        size_t i;
+        for (i = 0; gpt_ptypes[i].guid != NULL; i++) {
+                if (memcmp(p->raw_data.part_type, gpt_ptypes[i].guid, 16) == 0) {
+                        break;
+                }
+        }
+        return i;
 }
 
@@ -343 +408 @@
 }
 
+char * gpt_get_part_name(gpt_entry_t * p)
+{
+        return p->raw_data.part_name;
+}
+
 /** Copy partition name */
 void gpt_set_part_name(gpt_entry_t * p, char * name[], size_t length)
 {
+        if (length >= 72)
+                length = 71;
+        
         memcpy(p->part_name, name, length);
+        p->part_name[length] = '\0';
+}
+
+/** Get partition attribute */
+extern bool gpt_get_flag(gpt_part_t * p, GPT_ATTR flag)
+{
+        return (p->raw_data.attributes & (((uint64_t) 1) << flag)) ? 1 : 0;
+}
+
+/** Set partition attribute */
+extern void gpt_set_flag(gpt_part_t * p, GPT_ATTR flag, bool value)
+{
+        uint64_t attr = p->raw_data.attributes;
+
+        if (value)
+                attr = attr | (((uint64_t) 1) << flag);
+        else
+                attr = attr ^ (attr & (((uint64_t) 1) << flag));
+
+        p->raw_data.attributes = attr;
 }
 
@@ -405 +498 @@
         }
         
-        res->num_ent = num;
+        res->fill = num;
         res->arr_size = size;
         
@@ -420 +513 @@
         }
         
-        memcpy(tmp, p->part_array, p->num_ent);
+        memcpy(tmp, p->part_array, p->fill);
         free(p->part_array);
         p->part_array = tmp;
@@ -438 +531 @@
                 }
                 
-                memcpy(tmp, p->part_array, p->num_ent < nsize ? p->num_ent : nsize);
+                memcpy(tmp, p->part_array, p->fill < nsize ? p->fill  : nsize);
                 free(p->part_array);
                 p->part_array = tmp;

uspace/lib/gpt/libgpt.h

@@ -49 +49 @@
 /** Basic number of GPT partition entries */
 #define GPT_BASE_PART_NUM (GPT_MIN_PART_NUM)
+/** How much fill we ignore before resizing partition array */
+#define GPT_IGNORE_FILL_NUM 10
 
 /** GPT header signature ("EFI PART" in ASCII) */
 extern const uint8_t efi_signature[8];
+
+typedef enum {
+        AT_REQ_PART = 0,
+        AT_NO_BLOCK_IO,
+        AT_LEGACY_BOOT,
+        AT_UNDEFINED,
+        AT_SPECIFIC = 48
+} GPT_ATTR;
 
 /** GPT header
@@ -68 +78 @@
         uint8_t disk_guid[16];
         uint64_t entry_lba;
-        uint32_t num_entries;
+        uint32_t fillries;
         uint32_t entry_size;
         uint32_t pe_array_crc32;
@@ -105 +115 @@
 typedef struct gpt_parts {
         /** Number of entries */
-        unsigned int num_ent;
+        size_t fill;
         /** Size of the array */
-        unsigned int arr_size;
+        size_t arr_size;
         /** Resizable partition array */
         gpt_entry_t * part_array;
@@ -132 +142 @@
 extern gpt_partitions_t * gpt_read_partitions(gpt_t * gpt);
 extern int                                gpt_write_partitions(gpt_partitions_t * parts, gpt_t * header, service_id_t dev_handle);
-extern gpt_partitions_t * gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition);
-extern gpt_partitions_t * gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
-extern void                       gpt_set_part_type(gpt_part_t * p, int type);
+extern gpt_part_t *               gpt_alloc_partition(gpt_partitions_t * parts);
+extern int                                gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition);
+extern int                                gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
+extern size_t                     gpt_get_part_type(gpt_part_t * p);
+extern void                       gpt_set_part_type(gpt_part_t * p, size_t type);
+extern char *                     gpt_get_part_name(gpt_entry_t * p);
 extern void                       gpt_set_part_name(gpt_entry_t * p, char * name[], size_t length);
+extern bool                               gpt_get_flag(gpt_part_t * p, GPT_ATTR flag);
+extern void                               gpt_set_flag(gpt_part_t * p, GPT_ATTR flag, bool value);
+
+#define gpt_foreach(parts, i, iterator) \
+                for(size_t i = 0, gpt_part_t * iterator = parts->part_array;
+                    i < parts->fill; i++, iterator++)
 
 extern void gpt_free_gpt(gpt_t * gpt);