Changes in / [cb328ab:469739f] in mainline


Ignore:
Location:
uspace/lib
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/gpt/libgpt.c

    rcb328ab r469739f  
    5656static int reduce_part_array(gpt_partitions_t * p);
    5757static long long nearest_larger_int(double a);
    58 
    59 
    60 /** Allocate memory for gpt label */
    61 gpt_label_t * gpt_alloc_label(void)
    62 {
    63         gpt_label_t *label = malloc(sizeof(gpt_label_t));
    64         if (label == NULL)
    65                 return NULL;
    66        
    67         label->gpt = NULL;
    68         label->parts = NULL;
    69         label->device = 0;
    70        
    71         return label;
    72 }
    73 
    74 /** Free gpt_label_t structure */
    75 void gpt_free_label(gpt_label_t *label)
    76 {
    77         if (label->gpt != NULL)
    78                 gpt_free_gpt(label->gpt);
    79        
    80         if (label->parts != NULL)
    81                 gpt_free_partitions(label->parts);
    82        
    83         free(label);
    84 }
     58static int gpt_memcmp(const void * a, const void * b, size_t len);
    8559
    8660/** Allocate memory for gpt header */
    87 gpt_t * gpt_alloc_header(size_t size)
    88 {
    89         gpt_t *gpt = malloc(sizeof(gpt_t));
    90         if (gpt == NULL)
    91                 return NULL;
    92        
    93         // We might need only sizeof(gpt_header_t),
    94         // but we should follow specs and have
    95         // zeroes through all the rest of the block
    96         size_t final_size = size > sizeof(gpt_header_t) ? size : sizeof(gpt_header_t);
    97         gpt->header = malloc(final_size);
    98         if (gpt->header == NULL) {
    99                 free(gpt);
    100                 return NULL;
    101         }
    102        
    103         memset(gpt->header, 0, final_size);
    104        
    105         return gpt;
    106 }
    107 
    108 /** free() GPT header including gpt->header_lba */
    109 void gpt_free_gpt(gpt_t *gpt)
    110 {
    111         free(gpt->header);
    112         free(gpt);
     61gpt_t * gpt_alloc_gpt_header(void)
     62{
     63        return malloc(sizeof(gpt_t));
    11364}
    11465
    11566/** Read GPT from specific device
    116  * @param label        label structure to fill
    117  * @param dev_handle   device to read GPT from
    118  *
    119  * @return             EOK on success, errorcode on error
    120  */
    121 int gpt_read_header(gpt_label_t *label, service_id_t dev_handle)
     67 * @param       dev_handle      device to read GPT from
     68 *
     69 * @return                              GPT record on success, NULL on error
     70 */
     71gpt_t * gpt_read_gpt_header(service_id_t dev_handle)
    12272{
    12373        int rc;
    … …  
    12676        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
    12777        if (rc != EOK)
    128                 return rc;
     78                return NULL;
    12979       
    13080        rc = block_get_bsize(dev_handle, &b_size);
    131         if (rc != EOK)
    132                 return rc;
     81        if (rc != EOK) {
     82                errno = rc;
     83                return NULL;
     84        }
    13385       
    134         if (label->gpt == NULL) {
    135                 label->gpt = gpt_alloc_header(b_size);
    136                 if (label->gpt == NULL)
    137                         return ENOMEM;
     86        gpt_t * gpt = malloc(sizeof(gpt_t));
     87        if (gpt == NULL) {
     88                errno = ENOMEM;
     89                return NULL;
     90        }
     91
     92        gpt->raw_data = malloc(b_size); // We might need only sizeof(gpt_header_t),
     93        if (gpt == NULL) {                              // but we should follow specs and have
     94                free(gpt);                                      // zeroes through all the rest of the block
     95                errno = ENOMEM;
     96                return NULL;
    13897        }
    13998       
    140         rc = load_and_check_header(dev_handle, GPT_HDR_BA, b_size, label->gpt->header);
     99       
     100        rc = load_and_check_header(dev_handle, GPT_HDR_BA, b_size, gpt->raw_data);
    141101        if (rc == EBADCHECKSUM || rc == EINVAL) {
    142102                aoff64_t n_blocks;
    143103                rc = block_get_nblocks(dev_handle, &n_blocks);
    144                 if (rc != EOK)
     104                if (rc != EOK) {
     105                        errno = rc;
    145106                        goto fail;
    146 
    147                 rc = load_and_check_header(dev_handle, n_blocks - 1, b_size, label->gpt->header);
    148                 if (rc == EBADCHECKSUM || rc == EINVAL)
     107                }
     108
     109                rc = load_and_check_header(dev_handle, n_blocks - 1, b_size, gpt->raw_data);
     110                if (rc == EBADCHECKSUM || rc == EINVAL) {
     111                        errno = rc;
    149112                        goto fail;
     113                }
    150114        }
    151115       
    152         label->device = dev_handle;
     116        gpt->device = dev_handle;
    153117        block_fini(dev_handle);
    154         return EOK;
     118        return gpt;
    155119       
    156120fail:
    157121        block_fini(dev_handle);
    158         gpt_free_gpt(label->gpt);
    159         label->gpt = NULL;
    160         return rc;
     122        gpt_free_gpt(gpt);
     123        return NULL;
    161124}
    162125
    163126/** Write GPT header to device
    164  * @param label        GPT label header to be written
    165  * @param dev_handle   device handle to write the data to
    166  *
    167  * @return             EOK on success, libblock error code otherwise
    168  *
    169  * Note: Firstly write partitions (if modified), then gpt header.
    170  */
    171 int gpt_write_header(gpt_label_t *label, service_id_t dev_handle)
     127 * @param header                GPT header to be written
     128 * @param dev_handle    device handle to write the data to
     129 *
     130 * @return                              0 on success, libblock error code otherwise
     131 *
     132 * Note: Firstly write partitions (if changed), then gpt header.
     133 */
     134int gpt_write_gpt_header(gpt_t * gpt, service_id_t dev_handle)
    172135{
    173136        int rc;
    174137        size_t b_size;
    175138
    176         label->gpt->header->header_crc32 = 0;
    177         label->gpt->header->header_crc32 = compute_crc32((uint8_t *) label->gpt->header,
    178                                         uint32_t_le2host(label->gpt->header->header_size));
     139        gpt->raw_data->header_crc32 = 0;
     140        gpt->raw_data->header_crc32 = compute_crc32((uint8_t *) gpt->raw_data,
     141                                        uint32_t_le2host(gpt->raw_data->header_size));
    179142
    180143        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
    … …  
    187150
    188151        /* Write to main GPT header location */
    189         rc = block_write_direct(dev_handle, GPT_HDR_BA, GPT_HDR_BS, label->gpt->header);
    190         if (rc != EOK) {
     152        rc = block_write_direct(dev_handle, GPT_HDR_BA, GPT_HDR_BS, gpt->raw_data);
     153        if (rc != EOK)
    191154                block_fini(dev_handle);
    192155                return rc;
    193         }
    194156
    195157        aoff64_t n_blocks;
    196158        rc = block_get_nblocks(dev_handle, &n_blocks);
    197         if (rc != EOK) {
    198                 block_fini(dev_handle);
    199                 return rc;
    200         }
     159        if (rc != EOK)
     160                return rc;
    201161
    202162        /* Write to backup GPT header location */
    203163        //FIXME: those idiots thought it would be cool to have these fields in reverse order...
    204         rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, label->gpt->header);
     164        rc = block_write_direct(dev_handle, n_blocks - 1, GPT_HDR_BS, gpt->raw_data);
    205165        block_fini(dev_handle);
    206166        if (rc != EOK)
    … …  
    211171
    212172/** Alloc partition array */
    213 gpt_partitions_t * gpt_alloc_partitions()
     173gpt_partitions_t *      gpt_alloc_partitions()
    214174{
    215175        return alloc_part_array(128);
    … …  
    217177
    218178/** Parse partitions from GPT
    219  * @param label   GPT label to be parsed
    220  *
    221  * @return        EOK on success, errorcode otherwise
    222  */
    223 int gpt_read_partitions(gpt_label_t *label)
     179 * @param gpt   GPT to be parsed
     180 *
     181 * @return              partition linked list pointer or NULL on error
     182 *                              error code is stored in errno
     183 */
     184gpt_partitions_t * gpt_read_partitions(gpt_t * gpt)
    224185{
    225186        int rc;
    226187        unsigned int i;
    227         uint32_t fill = uint32_t_le2host(label->gpt->header->fillries);
    228         uint32_t ent_size = uint32_t_le2host(label->gpt->header->entry_size);
    229         uint64_t ent_lba = uint64_t_le2host(label->gpt->header->entry_lba);
    230        
    231         if (label->parts == NULL) {
    232                 label->parts = alloc_part_array(fill);
    233                 if (label->parts == NULL) {
    234                         return ENOMEM;
    235                 }
     188        gpt_partitions_t * res;
     189        uint32_t fill = uint32_t_le2host(gpt->raw_data->fillries);
     190        uint32_t ent_size = uint32_t_le2host(gpt->raw_data->entry_size);
     191        uint64_t ent_lba = uint64_t_le2host(gpt->raw_data->entry_lba);
     192
     193        res = alloc_part_array(fill);
     194        if (res == NULL) {
     195                //errno = ENOMEM; // already set in alloc_part_array()
     196                return NULL;
    236197        }
    237198
    … …  
    239200         *  - we don't need more bytes
    240201         *  - the size of GPT partition entry can be different to 128 bytes */
    241         rc = block_init(EXCHANGE_SERIALIZE, label->device, sizeof(gpt_entry_t));
    242         if (rc != EOK)
    243                 goto fail;
     202        rc = block_init(EXCHANGE_SERIALIZE, gpt->device, sizeof(gpt_entry_t));
     203        if (rc != EOK) {
     204                gpt_free_partitions(res);
     205                errno = rc;
     206                return NULL;
     207        }
    244208
    245209        size_t block_size;
    246         rc = block_get_bsize(label->device, &block_size);
    247         if (rc != EOK)
    248                 goto fail;
     210        rc = block_get_bsize(gpt->device, &block_size);
     211        if (rc != EOK) {
     212                gpt_free_partitions(res);
     213                errno = rc;
     214                return NULL;
     215        }
    249216
    250217        //size_t bufpos = 0;
    … …  
    259226        for (i = 0; i < fill; ++i) {
    260227                //FIXME: this does bypass cache...
    261                 rc = block_read_bytes_direct(label->device, pos, sizeof(gpt_entry_t), label->parts->part_array + i);
     228                rc = block_read_bytes_direct(gpt->device, pos, sizeof(gpt_entry_t), res->part_array + i);
    262229                //FIXME: but seqread() is just too complex...
    263230                //rc = block_seqread(gpt->device, &bufpos, &buflen, &pos, res->part_array[i], sizeof(gpt_entry_t));
    264231                pos += ent_size;
    265232
    266                 if (rc != EOK)
    267                         goto fail;
     233                if (rc != EOK) {
     234                        gpt_free_partitions(res);
     235                        errno = rc;
     236                        return NULL;
     237                }
    268238        }
    269239
    … …  
    273243         * on all of the partition entry array.
    274244         */
    275         uint32_t crc = compute_crc32((uint8_t *) label->parts->part_array, label->parts->fill * sizeof(gpt_entry_t));
    276 
    277         if(uint32_t_le2host(label->gpt->header->pe_array_crc32) != crc)
     245        uint32_t crc = compute_crc32((uint8_t *) res->part_array, res->fill * sizeof(gpt_entry_t));
     246
     247        if(uint32_t_le2host(gpt->raw_data->pe_array_crc32) != crc)
    278248        {
    279                 rc = EBADCHECKSUM;
    280                 goto fail;
    281         }
    282 
    283         return EOK;
    284        
    285 fail:
    286         gpt_free_partitions(label->parts);
    287         label->parts = NULL;
    288         return rc;
     249                gpt_free_partitions(res);
     250                errno = EBADCHECKSUM;
     251                return NULL;
     252        }
     253
     254        return res;
    289255}
    290256
    291257/** Write GPT and partitions to device
    292  * @param label        label to write
    293  * @param dev_handle   device to write the data to
    294  *
    295  * @return             returns EOK on succes, errorcode otherwise
    296  */
    297 int gpt_write_partitions(gpt_label_t *label, service_id_t dev_handle)
     258 * @param parts                 partition list to be written
     259 * @param header                GPT header belonging to the 'parts' partitions
     260 * @param dev_handle    device to write the data to
     261 *
     262 * @return                              returns EOK on succes, specific error code otherwise
     263 */
     264int gpt_write_partitions(gpt_partitions_t * parts, gpt_t * gpt, service_id_t dev_handle)
    298265{
    299266        int rc;
    300267        size_t b_size;
    301         uint32_t e_size = uint32_t_le2host(label->gpt->header->entry_size);
    302 
    303         label->gpt->header->pe_array_crc32 = compute_crc32(
    304                                        (uint8_t *) label->parts->part_array,
    305                                        label->parts->fill * e_size);
    306        
    307         /* comm_size of 4096 is ignored */
    308         rc = block_init(EXCHANGE_ATOMIC, dev_handle, 4096);
     268
     269        gpt->raw_data->pe_array_crc32 = compute_crc32((uint8_t *) parts->part_array, parts->fill * gpt->raw_data->entry_size);
     270
     271        rc = block_init(EXCHANGE_ATOMIC, dev_handle, b_size);
    309272        if (rc != EOK)
    310273                return rc;
    … …  
    312275        rc = block_get_bsize(dev_handle, &b_size);
    313276        if (rc != EOK)
    314                 goto fail;
     277                return rc;
    315278
    316279        /* Write to main GPT partition array location */
    317         rc = block_write_direct(dev_handle, uint64_t_le2host(label->gpt->header->entry_lba),
    318                         nearest_larger_int((uint64_t_le2host(label->gpt->header->entry_size) * label->parts->fill) / b_size),
    319                         label->parts->part_array);
    320         if (rc != EOK)
    321                 goto fail;
     280        rc = block_write_direct(dev_handle, uint64_t_le2host(gpt->raw_data->entry_lba),
     281                        nearest_larger_int((uint64_t_le2host(gpt->raw_data->entry_size) * parts->fill) / b_size),
     282                        parts->part_array);
     283        if (rc != EOK)
     284                block_fini(dev_handle);
     285                return rc;
    322286
    323287        aoff64_t n_blocks;
    324288        rc = block_get_nblocks(dev_handle, &n_blocks);
    325289        if (rc != EOK)
    326                 goto fail;
     290                return rc;
    327291
    328292        /* Write to backup GPT partition array location */
    … …  
    330294        block_fini(dev_handle);
    331295        if (rc != EOK)
    332                 goto fail;
    333 
    334 
    335         return gpt_write_header(label, dev_handle);
    336        
    337 fail:
    338         block_fini(dev_handle);
    339         return rc;
     296                return rc;
     297
     298
     299        return gpt_write_gpt_header(gpt, dev_handle);
    340300}
    341301
    342302/** Alloc new partition
    343303 *
    344  * @return        returns pointer to the new partition or NULL
    345  *
    346  * Note: use either gpt_alloc_partition or gpt_get_partition.
    347  * This returns a memory block (zero-filled) and needs gpt_add_partition()
    348  * to be called to insert it into a partition array.
    349  * Requires you to call gpt_free_partition after use.
    350  */
    351 gpt_part_t * gpt_alloc_partition(void)
    352 {
    353         gpt_part_t *p = malloc(sizeof(gpt_part_t));
    354         if (p == NULL)
    355                 return NULL;
    356        
    357         memset(p, 0, sizeof(gpt_part_t));
    358        
    359         return p;
    360 }
    361 
    362 /** Alloc new partition already inside the label
    363  *
    364  * @param label   label to carry new partition
    365  *
    366  * @return        returns pointer to the new partition or NULL on ENOMEM
    367  *
    368  * Note: use either gpt_alloc_partition or gpt_get_partition.
    369  * This one return a pointer to a structure already inside the array, so
    370  * there's no need to call gpt_add_partition().
    371  * This is the one you will usually want.
    372  */
    373 gpt_part_t * gpt_get_partition(gpt_label_t *label)
    374 {
    375         if (label->parts->fill == label->parts->arr_size) {
    376                 if (extend_part_array(label->parts) == -1)
     304 * @param parts         partition table to carry new partition
     305 *
     306 * @return                      returns pointer to the new partition or NULL on ENOMEM
     307 *
     308 * Note: use either gpt_alloc_partition or gpt_add_partition. The first
     309 * returns a pointer to write your data to, the second copies the data
     310 * (and does not free the memory).
     311 */
     312gpt_part_t * gpt_alloc_partition(gpt_partitions_t * parts)
     313{
     314        if (parts->fill == parts->arr_size) {
     315                if (extend_part_array(parts) == -1)
    377316                        return NULL;
    378317        }
    379318
    380         return label->parts->part_array + label->parts->fill++;
     319        return parts->part_array + parts->fill++;
    381320}
    382321
    383322/** Copy partition into partition array
    384323 *
    385  * @param parts                 target label
     324 * @param parts                 target partition array
    386325 * @param partition             source partition to copy
    387326 *
    388327 * @return                              -1 on error, 0 otherwise
    389328 *
    390  * Note: for use with gpt_alloc_partition() only. You will get
    391  * duplicates with gpt_get_partition().
    392  */
    393 int gpt_add_partition(gpt_label_t *label, gpt_part_t *partition)
    394 {
    395         if (label->parts->fill == label->parts->arr_size) {
    396                 if (extend_part_array(label->parts) == -1)
     329 * Note: use either gpt_alloc_partition or gpt_add_partition. The first
     330 * returns a pointer to write your data to, the second copies the data
     331 * (and does not free the memory).
     332 */
     333int gpt_add_partition(gpt_partitions_t * parts, gpt_part_t * partition)
     334{
     335        if (parts->fill == parts->arr_size) {
     336                if (extend_part_array(parts) == -1)
    397337                        return ENOMEM;
    398338        }
    399        
    400         memcpy(label->parts->part_array + label->parts->fill++,
    401                partition, sizeof(gpt_part_t));
    402        
    403         return EOK;
     339        extend_part_array(parts);
     340        return EOK;;
    404341}
    405342
    406343/** Remove partition from array
    407  * @param label   label to remove from
    408  * @param idx     index of the partition to remove
    409  *
    410  * @return        EOK on success, ENOMEM on array reduction failure
     344 *
     345 * @param idx           index of the partition to remove
     346 *
     347 * @return                      -1 on error, 0 otherwise
    411348 *
    412349 * Note: even if it fails, the partition still gets removed. Only
    413350 * reducing the array failed.
    414351 */
    415 int gpt_remove_partition(gpt_label_t *label, size_t idx)
    416 {
    417         if (idx != label->parts->fill - 1) {
    418                 memmove(label->parts->part_array + idx,
    419                         label->parts->part_array + idx + 1,
    420                         (label->parts->fill - 1) * sizeof(gpt_entry_t));
    421                 label->parts->fill -= 1;
    422         }
    423        
    424         /* FIXME: This probably shouldn't be here, but instead
    425          * in reduce_part_array() or similar */
    426         if (label->parts->fill < (label->parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
    427                 if (reduce_part_array(label->parts) == ENOMEM)
    428                         return ENOMEM;
    429         }
    430 
    431         return EOK;
     352int gpt_remove_partition(gpt_partitions_t * parts, size_t idx)
     353{
     354        if (idx != parts->fill - 1) {
     355                memcpy(parts->part_array + idx, parts->part_array + parts->fill - 1, sizeof(gpt_entry_t));
     356                parts->fill -= 1;
     357        }
     358
     359        if (parts->fill < (parts->arr_size / 2) - GPT_IGNORE_FILL_NUM) {
     360                if (reduce_part_array(parts) == -1)
     361                        return -1;
     362        }
     363
     364        return 0;
     365}
     366
     367/** free() GPT header including gpt->header_lba */
     368void gpt_free_gpt(gpt_t * gpt)
     369{
     370        free(gpt->raw_data);
     371        free(gpt);
    432372}
    433373
    … …  
    449389        size_t i;
    450390        for (i = 0; gpt_ptypes[i].guid != NULL; i++) {
    451                 if (bcmp(p->part_type, gpt_ptypes[i].guid, 16) == 0) {
     391                if (gpt_memcmp(p->part_type, gpt_ptypes[i].guid, 16) == 0) {
    452392                        break;
    453393                }
    … …  
    509449}
    510450
    511 /** Get partition name */
     451
    512452unsigned char * gpt_get_part_name(gpt_part_t * p)
    513453{
    … …  
    621561        if(p->arr_size > GPT_MIN_PART_NUM) {
    622562                unsigned int nsize = p->arr_size / 2;
    623                 nsize = nsize > GPT_MIN_PART_NUM ? nsize : GPT_MIN_PART_NUM;
    624563                gpt_entry_t * tmp = malloc(nsize * sizeof(gpt_entry_t));
    625                 if(tmp == NULL)
    626                         return ENOMEM;
     564                if(tmp == NULL) {
     565                        errno = ENOMEM;
     566                        return -1;
     567                }
    627568
    628569                memcpy(tmp, p->part_array, p->fill < nsize ? p->fill  : nsize);
    … …  
    645586}
    646587
    647 
    648 
    649 
    650 
    651 
     588static int gpt_memcmp(const void * a, const void * b, size_t len)
     589{
     590        size_t i;
     591        int diff;
     592        const unsigned char * x = a;
     593        const unsigned char * y = b;
     594
     595        for (i = 0; i < len; i++) {
     596                diff = (int)*(x++) - (int)*(y++);
     597                if (diff != 0) {
     598                        return diff;
     599                }
     600        }
     601        return 0;
     602}
     603
     604
     605
     606

  • uspace/lib/gpt/libgpt.h

    rcb328ab r469739f  
    8686typedef struct {
    8787        /** Raw header. Has more bytes alloced than sizeof(gpt_header_t)!
    88          * See gpt_alloc_header() to know why. */
    89         gpt_header_t *header;
     88         * See gpt_read_gpt_header() to know why. */
     89        gpt_header_t * raw_data;
     90        /** Device where the data are from */
     91        service_id_t device;
     92        /** Linked list of partitions (initially NULL) */
    9093} gpt_t;
    9194
    … …  
    120123        size_t arr_size;
    121124        /** Resizable partition array */
    122         gpt_entry_t *part_array;
     125        gpt_entry_t * part_array;
    123126} gpt_partitions_t;
    124127
    125128
    126129typedef struct gpt_table {
    127         gpt_t *gpt;
    128         gpt_partitions_t *parts;
    129         service_id_t device;
     130        gpt_t * gpt;
     131        gpt_partitions_t * parts;
    130132} gpt_label_t;
    131133
    132134struct partition_type {
    133         const char *desc;
    134         const char *guid;
     135        const char * desc;
     136        const char * guid;
    135137};
    136138
    137139extern const struct partition_type gpt_ptypes[];
    138140
    139 extern gpt_label_t * gpt_alloc_label(void);
    140 extern void gpt_free_label(gpt_label_t *);
    141141
    142 extern gpt_t * gpt_alloc_header(size_t);
    143 extern int     gpt_read_header(gpt_label_t *, service_id_t);
    144 extern int     gpt_write_header(gpt_label_t *, service_id_t);
     142extern gpt_t * gpt_alloc_gpt_header(void);
     143extern gpt_t * gpt_read_gpt_header(service_id_t dev_handle);
     144extern int     gpt_write_gpt_header(gpt_t * header, service_id_t dev_handle);
    145145
    146146extern gpt_partitions_t * gpt_alloc_partitions(void);
    147 extern int             gpt_read_partitions (gpt_label_t *);
    148 extern int             gpt_write_partitions(gpt_label_t *, service_id_t);
    149 extern gpt_part_t *    gpt_alloc_partition (void);
    150 extern gpt_part_t *    gpt_get_partition   (gpt_label_t *);
    151 extern int             gpt_add_partition   (gpt_label_t *, gpt_part_t *);
    152 extern int             gpt_remove_partition(gpt_label_t *, size_t);
     147extern gpt_partitions_t * gpt_read_partitions(gpt_t * gpt);
     148extern int             gpt_write_partitions(gpt_partitions_t * parts, gpt_t * header, service_id_t dev_handle);
     149extern gpt_part_t *    gpt_alloc_partition (gpt_partitions_t * parts);
     150extern int             gpt_add_partition   (gpt_partitions_t * parts, gpt_part_t * partition);
     151extern int             gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
    153152
    154 extern size_t          gpt_get_part_type(gpt_part_t *);
    155 extern void            gpt_set_part_type(gpt_part_t *, size_t);
    156 extern void            gpt_set_start_lba(gpt_part_t *, uint64_t);
    157 extern uint64_t        gpt_get_start_lba(gpt_part_t *);
    158 extern void            gpt_set_end_lba  (gpt_part_t *, uint64_t);
    159 extern uint64_t        gpt_get_end_lba  (gpt_part_t *);
    160 extern unsigned char * gpt_get_part_name(gpt_part_t *);
    161 extern void            gpt_set_part_name(gpt_part_t *, char *[], size_t);
    162 extern bool            gpt_get_flag     (gpt_part_t *, GPT_ATTR);
    163 extern void            gpt_set_flag     (gpt_part_t *, GPT_ATTR, bool);
     153extern size_t          gpt_get_part_type(gpt_part_t * p);
     154extern void            gpt_set_part_type(gpt_part_t * p, size_t type);
     155extern void            gpt_set_start_lba(gpt_part_t * p, uint64_t start);
     156extern uint64_t        gpt_get_start_lba(gpt_part_t * p);
     157extern void            gpt_set_end_lba  (gpt_part_t * p, uint64_t end);
     158extern uint64_t        gpt_get_end_lba  (gpt_part_t * p);
     159extern unsigned char * gpt_get_part_name(gpt_part_t * p);
     160extern void            gpt_set_part_name(gpt_part_t * p, char * name[], size_t length);
     161extern bool            gpt_get_flag     (gpt_part_t * p, GPT_ATTR flag);
     162extern void            gpt_set_flag     (gpt_part_t * p, GPT_ATTR flag, bool value);
    164163
    165164
    … …  
    169168                    iterator < (parts)->part_array + (parts)->fill; ++iterator)
    170169
    171 extern void gpt_free_gpt(gpt_t *);
    172 extern void gpt_free_partitions(gpt_partitions_t *);
     170extern void gpt_free_gpt(gpt_t * gpt);
     171extern void gpt_free_partitions(gpt_partitions_t * parts);
    173172
    174173#endif

  • uspace/lib/mbr/libmbr.c

    rcb328ab r469739f  
    9292 */
    9393int mbr_read_mbr(mbr_label_t *label, service_id_t dev_handle)
    94 {       
     94{
     95        if (label == NULL)
     96                return EINVAL;
     97       
    9598        int rc;
    9699       
Note: See TracChangeset for help on using the changeset viewer.