Changeset a2aa81cb in mainline for uspace/app


Ignore:
Timestamp:
2013-05-30T11:52:31Z (13 years ago)
Author:
Dominik Taborsky (AT DOT) <brembyseznamcz>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
44c4886, 469739f
Parents:
622a50b
Message:

API changes, bug fixing

Location:
uspace/app/hdisk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hdisk/common.h

    r622a50b ra2aa81cb  
    3939#include <libgpt.h>
    4040
    41 union table_data {
    42         mbr_table_t     mbr;
    43         gpt_table_t     gpt;
     41union label_data {
     42        mbr_label_t     *mbr;
     43        gpt_label_t     *gpt;
    4444};
    4545

  • uspace/app/hdisk/func_gpt.c

    r622a50b ra2aa81cb  
    4343static int set_gpt_partition(tinput_t *, gpt_part_t *);
    4444
    45 int add_gpt_part(tinput_t * in, union table_data * data)
     45int add_gpt_part(tinput_t * in, union label_data * data)
    4646{
    47         gpt_part_t * p = gpt_alloc_partition(data->gpt.parts);
     47        gpt_part_t * p = gpt_alloc_partition(data->gpt->parts);
    4848        if (p == NULL) {
    4949                return ENOMEM;
    … …  
    5353}
    5454
    55 int delete_gpt_part(tinput_t * in, union table_data * data)
     55int delete_gpt_part(tinput_t * in, union label_data * data)
    5656{
    5757        size_t idx;
    … …  
    6060        idx = get_input_size_t(in);
    6161
    62         if (gpt_remove_partition(data->gpt.parts, idx) == -1) {
     62        if (gpt_remove_partition(data->gpt->parts, idx) == -1) {
    6363                printf("Warning: running low on memory, not resizing...\n");
    6464        }
    … …  
    6767}
    6868
    69 int new_gpt_table(tinput_t * in, union table_data * data)
     69int destroy_gpt_label(union label_data *data)
    7070{
    71         data->gpt.gpt = gpt_alloc_gpt_header();
    72         data->gpt.parts = gpt_alloc_partitions();
    7371        return EOK;
    7472}
    7573
    76 int print_gpt_parts(union table_data * data)
     74int new_gpt_label(union label_data *data)
     75{
     76        data->gpt->gpt = gpt_alloc_gpt_header();
     77        data->gpt->parts = gpt_alloc_partitions();
     78        return EOK;
     79}
     80
     81int print_gpt_parts(union label_data *data)
    7782{
    7883        //int rc;
    … …  
    8287        size_t i = 0;
    8388       
    84         gpt_part_foreach(data->gpt.parts, iter) {
     89        gpt_part_foreach(data->gpt->parts, iter) {
    8590                //printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
    8691                //              iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
    … …  
    95100}
    96101
    97 int write_gpt_parts(service_id_t dev_handle, union table_data * data)
     102int read_gpt_parts(service_id_t dev_handle, union label_data *data)
     103{
     104        return EOK;
     105}
     106
     107int write_gpt_parts(service_id_t dev_handle, union label_data * data)
    98108{
    99109        int rc;
    100110
    101         rc = gpt_write_partitions(data->gpt.parts, data->gpt.gpt, dev_handle);
     111        rc = gpt_write_partitions(data->gpt->parts, data->gpt->gpt, dev_handle);
    102112        if (rc != EOK) {
    103113                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    … …  
    105115        }
    106116
    107         rc = gpt_write_gpt_header(data->gpt.gpt, dev_handle);
     117        rc = gpt_write_gpt_header(data->gpt->gpt, dev_handle);
    108118        if (rc != EOK) {
    109119                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    … …  
    114124}
    115125
    116 int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
     126int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union label_data * data)
    117127{
    118128        printf("Not implemented.\n");

  • uspace/app/hdisk/func_gpt.h

    r622a50b ra2aa81cb  
    4242#include "common.h"
    4343
    44 extern int add_gpt_part(tinput_t * in, union table_data * data);
    45 extern int delete_gpt_part(tinput_t * in, union table_data * data);
    46 extern int new_gpt_table(tinput_t *, union table_data *);
    47 extern int print_gpt_parts(union table_data * data);
    48 extern int write_gpt_parts(service_id_t dev_handle, union table_data * data);
    49 extern int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data);
     44extern int add_gpt_part(tinput_t *, union label_data *);
     45extern int delete_gpt_part(tinput_t *, union label_data *);
     46extern int destroy_gpt_label(union label_data *);
     47extern int new_gpt_label(union label_data *);
     48extern int print_gpt_parts(union label_data *);
     49extern int read_gpt_parts(service_id_t, union label_data *);
     50extern int write_gpt_parts(service_id_t, union label_data *);
     51extern int extra_gpt_funcs(tinput_t *, service_id_t, union label_data *);
    5052
    5153#endif

  • uspace/app/hdisk/func_mbr.c

    r622a50b ra2aa81cb  
    4141#include "input.h"
    4242
    43 static int set_mbr_partition(tinput_t * in, mbr_part_t * p);
    44 
    45 
    46 int add_mbr_part(tinput_t * in, union table_data * data)
     43static int set_mbr_partition(tinput_t *in, mbr_part_t *p);
     44
     45int add_mbr_part(tinput_t *in, union label_data *data)
    4746{
    4847        int rc;
    4948       
    50         mbr_part_t * part = mbr_alloc_partition();
     49        mbr_part_t *part = mbr_alloc_partition();
    5150
    5251        set_mbr_partition(in, part);
    5352
    54         rc = mbr_add_partition(data->mbr.parts, part);
     53        rc = mbr_add_partition(data->mbr, part);
    5554        if (rc != EOK) {
    5655                printf("Error adding partition.\n");
    5756        }
    5857       
    59        
    60         return rc;
    61 }
    62 
    63 int delete_mbr_part(tinput_t * in, union table_data * data)
     58        return EOK;
     59}
     60
     61int delete_mbr_part(tinput_t *in, union label_data *data)
    6462{
    6563        int rc;
    … …  
    7270                return errno;
    7371       
    74         rc = mbr_remove_partition(data->mbr.parts, idx);
     72        rc = mbr_remove_partition(data->mbr, idx);
    7573        if(rc != EOK) {
    7674                printf("Error: something.\n");
    … …  
    8078}
    8179
    82 int new_mbr_table(tinput_t * in, union table_data * data)
    83 {
    84         data->mbr.mbr = mbr_alloc_mbr();
    85         data->mbr.parts = mbr_alloc_partitions();
    86         return EOK;
     80int destroy_mbr_label(union label_data *data)
     81{
     82        mbr_free_label(data->mbr);
     83        return EOK;
     84}
     85
     86int new_mbr_label(union label_data *data)
     87{
     88        data->mbr = mbr_alloc_label();
     89        if (data->mbr == NULL)
     90                return ENOMEM;
     91        else
     92                return EOK;
    8793}
    8894
    8995/** Print current partition scheme */
    90 int print_mbr_parts(union table_data * data)
     96int print_mbr_parts(union label_data *data)
    9197{
    9298        int num = 0;
    … …  
    96102        printf("\t\t%10s  %10s %10s %10s %7s\n", "Bootable:", "Start:", "End:", "Length:", "Type:");
    97103       
    98         mbr_part_t * it;
    99         mbr_part_foreach(data->mbr.parts, it) {
     104        mbr_part_t *it;
     105        mbr_part_foreach(data->mbr->parts, it) {
    100106                if (it->type == PT_UNUSED)
    101107                        continue;
    … …  
    117123}
    118124
    119 int write_mbr_parts(service_id_t dev_handle, union table_data * data)
    120 {
    121         int rc = mbr_write_partitions(data->mbr.parts, data->mbr.mbr, dev_handle);
     125int read_mbr_parts(service_id_t dev_handle, union label_data *data)
     126{
     127        int rc;
     128        printf("mbr\n");
     129        rc = mbr_read_mbr(data->mbr, dev_handle);
     130        if (rc != EOK)
     131                return rc;
     132        printf("ismbr\n");
     133        if (!mbr_is_mbr(data->mbr))
     134                return EINVAL;
     135        printf("parts\n");
     136        rc = mbr_read_partitions(data->mbr);
     137        if (rc != EOK)
     138                return rc;
     139        printf("end\n");
     140        return EOK;
     141}
     142
     143int write_mbr_parts(service_id_t dev_handle, union label_data *data)
     144{
     145        int rc = mbr_write_partitions(data->mbr, dev_handle);
    122146        if (rc != EOK) {
    123147                printf("Error occured during writing: ERR: %d: %s\n", rc, str_error(rc));
    … …  
    127151}
    128152
    129 int extra_mbr_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
     153int extra_mbr_funcs(tinput_t *in, service_id_t dev_handle, union label_data *data)
    130154{
    131155        printf("Not implemented.\n");
    … …  
    133157}
    134158
    135 static int set_mbr_partition(tinput_t * in, mbr_part_t * p)
     159static int set_mbr_partition(tinput_t *in, mbr_part_t *p)
    136160{
    137161        int c;
    … …  
    159183                return errno;
    160184
    161         ///TODO: there can only be one bootable partition; let's do it just like fdisk
     185        ///TODO: there can only be one boolabel partition; let's do it just like fdisk
    162186        printf("Bootable? (y/n): ");
    163187        c = getchar();

  • uspace/app/hdisk/func_mbr.h

    r622a50b ra2aa81cb  
    4242#include "common.h"
    4343
    44 extern int add_mbr_part(tinput_t * in, union table_data * data);
    45 extern int delete_mbr_part(tinput_t * in, union table_data * data);
    46 extern int new_mbr_table(tinput_t *, union table_data *);
    47 extern int print_mbr_parts(union table_data * data);
    48 extern int write_mbr_parts(service_id_t dev_handle, union table_data * data);
    49 extern int extra_mbr_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data);
     44extern int add_mbr_part(tinput_t *, union label_data *);
     45extern int delete_mbr_part(tinput_t *, union label_data *);
     46extern int destroy_mbr_label(union label_data *);
     47extern int new_mbr_label(union label_data *);
     48extern int print_mbr_parts(union label_data *);
     49extern int read_mbr_parts(service_id_t, union label_data *);
     50extern int write_mbr_parts(service_id_t, union label_data *);
     51extern int extra_mbr_funcs(tinput_t *, service_id_t, union label_data *);
    5052
    5153#endif

  • uspace/app/hdisk/func_none.c

    r622a50b ra2aa81cb  
    4040static void not_implemented(void);
    4141
    42 int add_none_part(tinput_t * in, union table_data * data)
     42
     43int add_none_part(tinput_t *in, union label_data *data)
    4344{
    4445        not_implemented();
    … …  
    4647}
    4748
    48 int delete_none_part(tinput_t * in, union table_data * data)
     49int delete_none_part(tinput_t *in, union label_data *data)
    4950{
    5051        not_implemented();
    … …  
    5253}
    5354
    54 int new_none_table(tinput_t * in, union table_data * data)
     55int destroy_none_label(union label_data *data)
    5556{
    5657        not_implemented();
    … …  
    5859}
    5960
    60 int print_none_parts(union table_data * data)
     61int new_none_label(union label_data *data)
    6162{
    6263        not_implemented();
    … …  
    6465}
    6566
    66 int write_none_parts(service_id_t dev_handle, union table_data * data)
     67int print_none_parts(union label_data *data)
    6768{
    6869        not_implemented();
    … …  
    7071}
    7172
    72 int extra_none_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
     73int read_none_parts(service_id_t dev_handle, union label_data *data)
     74{
     75        not_implemented();
     76        return EOK;
     77}
     78
     79int write_none_parts(service_id_t dev_handle, union label_data *data)
     80{
     81        not_implemented();
     82        return EOK;
     83}
     84
     85int extra_none_funcs(tinput_t *in, service_id_t dev_handle, union label_data *data)
    7386{
    7487        not_implemented();

  • uspace/app/hdisk/func_none.h

    r622a50b ra2aa81cb  
    4141#include "common.h"
    4242
    43 extern int add_none_part(tinput_t * in, union table_data * data);
    44 extern int delete_none_part(tinput_t * in, union table_data * data);
    45 extern int new_none_table(tinput_t *, union table_data *);
    46 extern int print_none_parts(union table_data * data);
    47 extern int write_none_parts(service_id_t dev_handle, union table_data * data);
    48 extern int extra_none_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data);
     43extern int add_none_part(tinput_t *, union label_data *);
     44extern int delete_none_part(tinput_t *, union label_data *);
     45extern int destroy_none_label(union label_data *);
     46extern int new_none_label(union label_data *);
     47extern int print_none_parts(union label_data *);
     48extern int read_none_parts(service_id_t, union label_data *);
     49extern int write_none_parts(service_id_t, union label_data *);
     50extern int extra_none_funcs(tinput_t *, service_id_t, union label_data *);
    4951
    5052#endif

  • uspace/app/hdisk/hdisk.c

    r622a50b ra2aa81cb  
    5353#include "func_none.h"
    5454
    55 int interact(service_id_t dev_handle);
     55int interact(service_id_t);
    5656void print_help(void);
    57 void select_table_format(tinput_t * in);
    58 void fill_table_funcs(void);
    59 void free_table(void);
    60 
    61 static table_t table;
     57void select_label_format(tinput_t *);
     58void fill_label_funcs(void);
     59void free_label(void);
     60int try_read(service_id_t);
     61
     62int construct_none_label(void);
     63
     64int construct_mbr_label(void);
     65int try_read_mbr(service_id_t);
     66
     67int construct_gpt_label(void);
     68int try_read_gpt(service_id_t);
     69
     70
     71static label_t label;
    6272
    6373int main(int argc, char ** argv)
    6474{
    6575        if (argc == 1) {
    66                 printf("I'd like to have an argument, please.\n");
    67                 return 1;
    68         }
    69 
     76                printf("Missing argument. Please specify a device to operate on.\n");
     77                return -1;
     78        }
     79       
    7080        int rc;
    7181        service_id_t dev_handle;
    72 
     82       
    7383        rc = loc_service_get_id(argv[1], &dev_handle, IPC_FLAG_BLOCKING);
    7484        if (rc != EOK) {
    … …  
    7686                return -1;
    7787        }
    78 
    79         init_table();
    80 
     88       
     89        printf("Init.\n");
     90        init_label();
     91       
     92        /*
    8193        mbr_t * mbr = mbr_read_mbr(dev_handle);
    8294        if(mbr == NULL) {
    … …  
    8799
    88100        if(mbr_is_mbr(mbr)) {
    89                 table.layout = LYT_MBR;
    90                 set_table_mbr(mbr);
     101                label.layout = LYT_MBR;
     102                set_label_mbr(mbr);
    91103                mbr_partitions_t * parts = mbr_read_partitions(mbr);
    92104                if(parts == NULL) {
    … …  
    95107                        parts = mbr_alloc_partitions();
    96108                }
    97                 set_table_mbr_parts(parts);
    98                 fill_table_funcs();
     109                set_label_mbr_parts(parts);
     110                fill_label_funcs();
    99111                goto interact;
    100112        }
    101113       
    102114       
    103         mbr_free_mbr(mbr);
     115        mbr_free_mbr(mbr);*/
     116       
     117        printf("Try MBR.\n");
     118        rc = try_read_mbr(dev_handle);
     119        if (rc == EOK)
     120                goto interact;
     121       
     122        /*
    104123        gpt_t * gpt = gpt_read_gpt_header(dev_handle);
    105124       
    106125        if(gpt != NULL) {
    107                 table.layout = LYT_GPT;
    108                 set_table_gpt(gpt);
     126                label.layout = LYT_GPT;
     127                set_label_gpt(gpt);
    109128               
    110129                gpt_partitions_t * parts = gpt_read_partitions(gpt);
    … …  
    115134                        parts = gpt_alloc_partitions();
    116135                }
    117                 set_table_gpt_parts(parts);
    118                 fill_table_funcs();
     136                set_label_gpt_parts(parts);
     137                fill_label_funcs();
    119138                goto interact;
    120139        }
    121         printf("No partition table recognized. Create a new one.\n");
    122         table.layout = LYT_NONE;
     140        */
     141       
     142        printf("Try GPT.\n");
     143        rc = try_read_gpt(dev_handle);
     144        if (rc == EOK)
     145                goto interact;
     146       
     147        printf("No label recognized. Create a new one.\n");
     148        label.layout = LYT_NONE;
    123149       
    124150interact:
     151        printf("interact.\n");
    125152        rc = interact(dev_handle);
    126153       
    127         free_table();
     154        free_label();
    128155       
    129156        return rc;
    … …  
    152179                switch(input) {
    153180                        case 'a':
    154                                 table.add_part(in, &table.data);
     181                                label.add_part(in, &label.data);
     182                                break;
     183                        case 'b':
     184                                label.add_part(in, &label.data);
    155185                                break;
    156186                        case 'd':
    157                                 table.delete_part(in, &table.data);
     187                                label.delete_part(in, &label.data);
    158188                                break;
    159189                        case 'e':
    160                                 table.extra_funcs(in, dev_handle, &table.data);
     190                                label.extra_funcs(in, dev_handle, &label.data);
    161191                                break;
    162192                        case 'f':
    163                                 free_table();
    164                                 select_table_format(in);
     193                                free_label();
     194                                select_label_format(in);
    165195                                break;
    166196                        case 'h':
    … …  
    168198                                break;
    169199                        case 'n':
    170                                 free_table();
    171                                 table.new_table(in, &table.data);
     200                                free_label();
     201                                label.new_label(&label.data);
    172202                                break;
    173203                        case 'p':
    174                                 table.print_parts(&table.data);
     204                                label.print_parts(&label.data);
    175205                                break;
    176206                        case 'q':
    … …  
    178208                                goto end;
    179209                        case 'w':
    180                                 table.write_parts(dev_handle, &table.data);
     210                                label.write_parts(dev_handle, &label.data);
    181211                                break;
    182212                        default:
    … …  
    197227                "\t 'a' \t\t Add partition.\n"
    198228                "\t 'd' \t\t Delete partition.\n"
    199                 "\t 'e' \t\t Extra functions (per table format).\n"
    200                 "\t 'f' \t\t Switch the format of the partition table."
     229                "\t 'e' \t\t Extra functions (per label format).\n"
     230                "\t 'f' \t\t Switch the format of the partition label."
    201231                "\t 'h' \t\t Prints help. See help for more.\n"
    202                 "\t 'n' \t\t Create new table (discarding the old one).\n"
    203                 "\t 'p' \t\t Prints the table contents.\n"
    204                 "\t 'w' \t\t Write table to disk.\n"
     232                "\t 'l' \t\t Set alignment.\n"
     233                "\t 'n' \t\t Create new label (discarding the old one).\n"
     234                "\t 'p' \t\t Prints label contents.\n"
     235                "\t 'w' \t\t Write label to disk.\n"
    205236                "\t 'q' \t\t Quit.\n"
    206237                );
    … …  
    208239}
    209240
    210 void select_table_format(tinput_t * in)
     241void select_label_format(tinput_t * in)
    211242{
    212243        printf("Available formats are: \n"
    … …  
    218249        switch(val) {
    219250                case 0:
    220                         table.layout = LYT_NONE;
    221                         fill_table_funcs();
     251                        free_label();
     252                        label.layout = LYT_NONE;
     253                        fill_label_funcs();
    222254                        break;
    223255                case 1:
    224                         table.layout = LYT_MBR;
    225                         fill_table_funcs();
     256                        free_label();
     257                        label.layout = LYT_MBR;
     258                        fill_label_funcs();
    226259                        break;
    227260                case 2:
    228                         table.layout = LYT_GPT;
    229                         fill_table_funcs();
    230                         break;
    231         }
    232 }
    233 
    234 void fill_table_funcs(void)
    235 {
    236         switch(table.layout) {
     261                        free_label();
     262                        label.layout = LYT_GPT;
     263                        fill_label_funcs();
     264                        break;
     265        }
     266}
     267
     268void fill_label_funcs(void)
     269{
     270        switch(label.layout) {
    237271                case LYT_MBR:
    238                         table.add_part = add_mbr_part;
    239                         table.delete_part = delete_mbr_part;
    240                         table.new_table = new_mbr_table;
    241                         table.print_parts = print_mbr_parts;
    242                         table.write_parts = write_mbr_parts;
    243                         table.extra_funcs = extra_mbr_funcs;
     272                        construct_mbr_label();
    244273                        break;
    245274                case LYT_GPT:
    246                         table.add_part = add_gpt_part;
    247                         table.delete_part = delete_gpt_part;
    248                         table.new_table = new_gpt_table;
    249                         table.print_parts = print_gpt_parts;
    250                         table.write_parts = write_gpt_parts;
    251                         table.extra_funcs = extra_gpt_funcs;
     275                        construct_gpt_label();
    252276                        break;
    253277                default:
    254                         table.add_part = add_none_part;
    255                         table.delete_part = delete_none_part;
    256                         table.new_table = new_none_table;
    257                         table.print_parts = print_none_parts;
    258                         table.write_parts = write_none_parts;
    259                         table.extra_funcs = extra_none_funcs;
    260                         break;
    261         }
    262 }
    263 
    264 void free_table(void)
    265 {
    266         switch(table.layout) {
     278                        construct_none_label();
     279                        break;
     280        }
     281}
     282
     283void free_label(void)
     284{
     285        /*
     286        switch(label.layout) {
    267287                case LYT_MBR:
    268                         if (table.data.mbr.parts != NULL) {
    269                                 mbr_free_partitions(table.data.mbr.parts);
    270                                 table.data.mbr.parts = NULL;
    271                         }
    272                         if (table.data.mbr.mbr != NULL) {
    273                                 mbr_free_mbr(table.data.mbr.mbr);
    274                                 table.data.mbr.mbr = NULL;
    275                         }
     288                        destroy_mbr_label(&label);
    276289                        break;
    277290                case LYT_GPT:
    278                         if (table.data.gpt.parts != NULL) {
    279                                 gpt_free_partitions(table.data.gpt.parts);
    280                                 table.data.gpt.parts = NULL;
    281                         }
    282                         if (table.data.gpt.gpt != NULL) {
    283                                 gpt_free_gpt(table.data.gpt.gpt);
    284                                 table.data.gpt.gpt = NULL;
    285                         }
     291                        destroy_gpt_label(&label);
    286292                        break;
    287293                default:
    288294                        break;
    289295        }
    290 }
    291 
    292 
    293 
     296        */
     297       
     298        label.destroy_label(&label.data);
     299}
     300
     301int try_read(service_id_t dev_handle)
     302{
     303        fill_label_funcs();
     304        printf("read_parts\n");
     305        return label.read_parts(dev_handle, &label.data);
     306}
     307
     308int construct_none_label()
     309{
     310        label.add_part      = add_none_part;
     311        label.delete_part   = delete_none_part;
     312        label.destroy_label = destroy_none_label;
     313        label.new_label     = new_none_label;
     314        label.print_parts   = print_none_parts;
     315        label.read_parts    = read_none_parts;
     316        label.write_parts   = write_none_parts;
     317        label.extra_funcs   = extra_none_funcs;
     318       
     319        return EOK;
     320}
     321
     322int construct_mbr_label()
     323{
     324        label.add_part      = add_mbr_part;
     325        label.delete_part   = delete_mbr_part;
     326        label.destroy_label = destroy_mbr_label;
     327        label.new_label     = new_mbr_label;
     328        label.print_parts   = print_mbr_parts;
     329        label.read_parts    = read_mbr_parts;
     330        label.write_parts   = write_mbr_parts;
     331        label.extra_funcs   = extra_mbr_funcs;
     332       
     333        return label.new_label(&label.data);
     334}
     335
     336int try_read_mbr(service_id_t dev_handle)
     337{
     338        label.layout = LYT_MBR;
     339        return try_read(dev_handle);
     340}
     341
     342int construct_gpt_label()
     343{
     344        label.add_part    = add_gpt_part;
     345        label.delete_part = delete_gpt_part;
     346        label.new_label   = new_gpt_label;
     347        label.print_parts = print_gpt_parts;
     348        label.read_parts  = read_gpt_parts;
     349        label.write_parts = write_gpt_parts;
     350        label.extra_funcs = extra_gpt_funcs;
     351       
     352        return label.new_label(&label.data);
     353}
     354
     355int try_read_gpt(service_id_t dev_handle)
     356{
     357        label.layout = LYT_GPT;
     358        return try_read(dev_handle);
     359}
     360
     361
     362
     363
     364
     365
     366
     367
     368
     369
     370
     371
     372
     373
     374
     375
     376
     377
     378
     379
     380
     381
     382
     383
     384
     385

  • uspace/app/hdisk/hdisk.h

    r622a50b ra2aa81cb  
    3939        LYT_MBR,
    4040        LYT_GPT,
    41 } LAYOUTS;
     41} layouts_t;
    4242
    43 typedef struct table {
    44         LAYOUTS layout;
    45         union table_data data;
    46         int (* add_part)(tinput_t *, union table_data *);
    47         int (* delete_part)(tinput_t *, union table_data *);
    48         int (* new_table)(tinput_t *, union table_data *);
    49         int (* print_parts)();
    50         int (* write_parts)(service_id_t, union table_data *);
    51         int (* extra_funcs)(tinput_t *, service_id_t, union table_data *);
    52 } table_t;
     43typedef struct label {
     44        layouts_t layout;
     45        union label_data data;
     46        int (* add_part)     (tinput_t *,   union label_data *);
     47        int (* delete_part)  (tinput_t *,   union label_data *);
     48        int (* destroy_label)(              union label_data *);
     49        int (* new_label)    (              union label_data *);
     50        int (* print_parts)  (              union label_data *);
     51        int (* read_parts)   (service_id_t, union label_data *);
     52        int (* write_parts)  (service_id_t, union label_data *);
     53        int (* extra_funcs)  (tinput_t *, service_id_t, union label_data *);
     54} label_t;
    5355
    54 #define init_table() \
    55         table.layout = LYT_NONE
     56#define init_label() \
     57        label.layout = LYT_NONE
    5658
    57 #define set_table_mbr(m) \
    58         table.data.mbr.mbr = (m)
    59 
    60 #define set_table_mbr_parts(p) \
    61         table.data.mbr.parts = (p)
    62 
    63 #define set_table_gpt(g) \
    64         table.data.gpt.gpt = (g)
    65 
    66 #define set_table_gpt_parts(p) \
    67         table.data.gpt.parts = (p)
Note: See TracChangeset for help on using the changeset viewer.