Changes in / [c9f61150:9bda5d90] in mainline


Ignore:
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • tools/toolchain.sh

    rc9f61150 r9bda5d90  
    5353EOF
    5454
    55 BINUTILS_VERSION="2.23.1"
     55BINUTILS_VERSION="2.22"
    5656BINUTILS_RELEASE=""
    57 GCC_VERSION="4.8.0"
    58 GDB_VERSION="7.5.1"
     57#GCC_VERSION="4.7.2"
     58GCC_VERSION="4.7.3"
     59#GCC_VERSION="4.8.0"
     60GDB_VERSION="7.5"
    5961
    6062BASEDIR="`pwd`"
    … …  
    7173        HEADER="$2"
    7274        BODY="$3"
    73        
     75
    7476        FNAME="/tmp/conftest-$$"
    75        
     77
    7678        echo "#include ${HEADER}" > "${FNAME}.c"
    7779        echo >> "${FNAME}.c"
    … …  
    8183        echo "  return 0;" >> "${FNAME}.c"
    8284        echo "}" >> "${FNAME}.c"
    83        
     85
    8486        cc -c -o "${FNAME}.o" "${FNAME}.c" 2> "${FNAME}.log"
    8587        RC="$?"
    86        
     88
    8789        if [ "$RC" -ne "0" ] ; then
    8890                echo " ${DEPENDENCY} not found, too old or compiler error."
    … …  
    113115                echo
    114116                echo "Script failed: $2"
    115                
     117
    116118                exit 1
    117119        fi
    … …  
    121123        FILE="$1"
    122124        SUM="$2"
    123        
     125
    124126        COMPUTED="`md5sum "${FILE}" | cut -d' ' -f1`"
    125127        if [ "${SUM}" != "${COMPUTED}" ] ; then
    126128                echo
    127129                echo "Checksum of ${FILE} does not match."
    128                
     130
    129131                exit 2
    130132        fi
    … …  
    156158        echo "defined, /usr/local/cross will be used by default."
    157159        echo
    158        
     160
    159161        exit 3
    160162}
    … …  
    166168show_countdown() {
    167169        TM="$1"
    168        
     170
    169171        if [ "${TM}" -eq 0 ] ; then
    170172                echo
    171173                return 0
    172174        fi
    173        
     175
    174176        echo -n "${TM} "
    175177        change_title "${TM}"
    176178        sleep 1
    177        
     179
    178180        TM="`expr "${TM}" - 1`"
    179181        show_countdown "${TM}"
    … …  
    211213        FILE="$2"
    212214        CHECKSUM="$3"
    213        
     215
    214216        if [ ! -f "${FILE}" ]; then
    215217                change_title "Downloading ${FILE}"
    … …  
    217219                check_error $? "Error downloading ${FILE}."
    218220        fi
    219        
     221
    220222        check_md5 "${FILE}" "${CHECKSUM}"
    221223}
    … …  
    223225source_check() {
    224226        FILE="$1"
    225        
     227
    226228        if [ ! -f "${FILE}" ]; then
    227229                echo
    228230                echo "File ${FILE} not found."
    229                
     231
    230232                exit 4
    231233        fi
    … …  
    234236cleanup_dir() {
    235237        DIR="$1"
    236        
     238
    237239        if [ -d "${DIR}" ]; then
    238240                change_title "Removing ${DIR}"
    … …  
    245247        DIR="$1"
    246248        DESC="$2"
    247        
     249
    248250        change_title "Creating ${DESC}"
    249251        echo ">>> Creating ${DESC}"
    250        
     252
    251253        mkdir -p "${DIR}"
    252254        test -d "${DIR}"
    … …  
    257259        FILE="$1"
    258260        DESC="$2"
    259        
     261
    260262        change_title "Unpacking ${DESC}"
    261263        echo " >>> Unpacking ${DESC}"
    262        
     264
    263265        tar -xjf "${FILE}"
    264266        check_error $? "Error unpacking ${DESC}."
    … …  
    269271        check_dependecies
    270272        show_countdown 10
    271        
     273
    272274        BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
    273275        GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
    274276        GDB_SOURCE="ftp://ftp.gnu.org/gnu/gdb/"
    275        
    276         download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "33adb18c3048d057ac58d07a3f1adb38"
    277         download_fetch "${GCC_SOURCE}" "${GCC}" "e6040024eb9e761c3bea348d1fa5abb0"
    278         download_fetch "${GDB_SOURCE}" "${GDB}" "3f48f468b24447cf24820054ff6e85b1"
     277
     278        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "ee0f10756c84979622b992a4a61ea3f5"
     279        download_fetch "${GCC_SOURCE}" "${GCC}" "cc308a0891e778cfda7a151ab8a6e762"
     280        download_fetch "${GDB_SOURCE}" "${GDB}" "24a6779a9fe0260667710de1b082ef61"
    279281}
    280282
    … …  
    282284        PLATFORM="$1"
    283285        TARGET="$2"
    284        
     286
    285287        WORKDIR="${BASEDIR}/${PLATFORM}"
    286288        BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
    … …  
    288290        OBJDIR="${WORKDIR}/gcc-obj"
    289291        GDBDIR="${WORKDIR}/gdb-${GDB_VERSION}"
    290        
     292
    291293        if [ -z "${CROSS_PREFIX}" ] ; then
    292294                CROSS_PREFIX="/usr/local/cross"
    293295        fi
    294        
     296
    295297        PREFIX="${CROSS_PREFIX}/${PLATFORM}"
    296        
     298
    297299        echo ">>> Downloading tarballs"
    298         source_check "${BASEDIR}/${BINUTILS}"
     300        #source_check "${BASEDIR}/${BINUTILS}"
    299301        source_check "${BASEDIR}/${GCC}"
    300         source_check "${BASEDIR}/${GDB}"
    301        
     302        #source_check "${BASEDIR}/${GDB}"
     303
    302304        echo ">>> Removing previous content"
    303         cleanup_dir "${PREFIX}"
    304         cleanup_dir "${WORKDIR}"
    305        
     305        #cleanup_dir "${PREFIX}"
     306        #cleanup_dir "${WORKDIR}"
     307
    306308        create_dir "${PREFIX}" "destination directory"
    307309        create_dir "${OBJDIR}" "GCC object directory"
    308        
     310
    309311        echo ">>> Unpacking tarballs"
    310312        cd "${WORKDIR}"
    311313        check_error $? "Change directory failed."
    312        
    313         unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
     314
     315        #unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
    314316        unpack_tarball "${BASEDIR}/${GCC}" "GCC"
    315         unpack_tarball "${BASEDIR}/${GDB}" "GDB"
    316        
    317         echo ">>> Processing binutils (${PLATFORM})"
    318         cd "${BINUTILSDIR}"
    319         check_error $? "Change directory failed."
    320        
    321         change_title "binutils: configure (${PLATFORM})"
    322         CFLAGS=-Wno-error ./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --disable-nls --disable-werror
    323         check_error $? "Error configuring binutils."
    324        
    325         change_title "binutils: make (${PLATFORM})"
    326         make all install
    327         check_error $? "Error compiling/installing binutils."
    328        
     317        #unpack_tarball "${BASEDIR}/${GDB}" "GDB"
     318
     319        #echo ">>> Processing binutils (${PLATFORM})"
     320        #cd "${BINUTILSDIR}"
     321        #check_error $? "Change directory failed."
     322
     323        #change_title "binutils: configure (${PLATFORM})"
     324        #CFLAGS=-Wno-error ./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --disable-nls --disable-werror
     325        #check_error $? "Error configuring binutils."
     326
     327        #change_title "binutils: make (${PLATFORM})"
     328        #make all install
     329        #check_error $? "Error compiling/installing binutils."
     330
    329331        echo ">>> Processing GCC (${PLATFORM})"
    330332        cd "${OBJDIR}"
    331333        check_error $? "Change directory failed."
    332        
     334
    333335        change_title "GCC: configure (${PLATFORM})"
    334336        "${GCCDIR}/configure" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c,objc,c++,obj-c++ --disable-multilib --disable-libgcj --without-headers --disable-shared --enable-lto --disable-werror
    335337        check_error $? "Error configuring GCC."
    336        
     338
    337339        change_title "GCC: make (${PLATFORM})"
    338340        PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
    339341        check_error $? "Error compiling/installing GCC."
    340        
    341         echo ">>> Processing GDB (${PLATFORM})"
    342         cd "${GDBDIR}"
    343         check_error $? "Change directory failed."
    344        
    345         change_title "GDB: configure (${PLATFORM})"
    346         ./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-"
    347         check_error $? "Error configuring GDB."
    348        
    349         change_title "GDB: make (${PLATFORM})"
    350         make all install
    351         check_error $? "Error compiling/installing GDB."
    352        
     342
     343        #echo ">>> Processing GDB (${PLATFORM})"
     344        #cd "${GDBDIR}"
     345        #check_error $? "Change directory failed."
     346
     347        #change_title "GDB: configure (${PLATFORM})"
     348        #./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-"
     349        #check_error $? "Error configuring GDB."
     350
     351        #change_title "GDB: make (${PLATFORM})"
     352        #make all install
     353        #check_error $? "Error compiling/installing GDB."
     354
    353355        cd "${BASEDIR}"
    354356        check_error $? "Change directory failed."
    355        
     357
    356358        echo ">>> Cleaning up"
    357359        cleanup_dir "${WORKDIR}"
    358        
     360
    359361        echo
    360362        echo ">>> Cross-compiler for ${TARGET} installed."
    … …  
    367369case "$1" in
    368370        "amd64")
    369                 prepare
     371                #prepare
    370372                build_target "amd64" "amd64-linux-gnu"
    371373                ;;
    … …  
    375377                ;;
    376378        "ia32")
    377                 prepare
     379                #prepare
    378380                build_target "ia32" "i686-pc-linux-gnu"
    379381                ;;
    … …  
    438440                build_target "arm32" "arm-linux-gnueabi" &
    439441                wait
    440                
     442
    441443                build_target "ia32" "i686-pc-linux-gnu" &
    442444                build_target "ia64" "ia64-pc-linux-gnu" &
    443445                wait
    444                
     446
    445447                build_target "mips32" "mipsel-linux-gnu" &
    446448                build_target "mips32eb" "mips-linux-gnu" &
    447449                wait
    448                
     450
    449451                build_target "mips64" "mips64el-linux-gnu" &
    450452                build_target "ppc32" "ppc-linux-gnu" &
    451453                wait
    452                
     454
    453455                build_target "ppc64" "ppc64-linux-gnu" &
    454456                build_target "sparc64" "sparc64-linux-gnu" &

  • uspace/app/hdisk/common.h

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

  • uspace/app/hdisk/func_gpt.c

    rc9f61150 r9bda5d90  
    4343static int set_gpt_partition(tinput_t *, gpt_part_t *);
    4444
    45 int add_gpt_part(tinput_t * in, union label_data * data)
     45int add_gpt_part(tinput_t * in, union table_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 label_data * data)
     55int delete_gpt_part(tinput_t * in, union table_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 destroy_gpt_label(union label_data *data)
     69int new_gpt_table(tinput_t * in, union table_data * data)
    7070{
     71        data->gpt.gpt = gpt_alloc_gpt_header();
     72        data->gpt.parts = gpt_alloc_partitions();
    7173        return EOK;
    7274}
    7375
    74 int 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 
    81 int print_gpt_parts(union label_data *data)
     76int print_gpt_parts(union table_data * data)
    8277{
    8378        //int rc;
    … …  
    8782        size_t i = 0;
    8883       
    89         gpt_part_foreach(data->gpt->parts, iter) {
     84        gpt_part_foreach(data->gpt.parts, iter) {
    9085                //printf("\t%10u %10u %10u %3d\n", iter->start_addr, iter->start_addr + iter->length,
    9186                //              iter->length, gpt_get_part_type(iter), gpt_get_part_name(iter));
    … …  
    10095}
    10196
    102 int read_gpt_parts(service_id_t dev_handle, union label_data *data)
    103 {
    104         return EOK;
    105 }
    106 
    107 int write_gpt_parts(service_id_t dev_handle, union label_data * data)
     97int write_gpt_parts(service_id_t dev_handle, union table_data * data)
    10898{
    10999        int rc;
    110100
    111         rc = gpt_write_partitions(data->gpt->parts, data->gpt->gpt, dev_handle);
     101        rc = gpt_write_partitions(data->gpt.parts, data->gpt.gpt, dev_handle);
    112102        if (rc != EOK) {
    113103                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    … …  
    115105        }
    116106
    117         rc = gpt_write_gpt_header(data->gpt->gpt, dev_handle);
     107        rc = gpt_write_gpt_header(data->gpt.gpt, dev_handle);
    118108        if (rc != EOK) {
    119109                printf("Error: Writing partitions failed: %d (%s)\n", rc, str_error(rc));
    … …  
    124114}
    125115
    126 int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union label_data * data)
     116int extra_gpt_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
    127117{
    128118        printf("Not implemented.\n");

  • uspace/app/hdisk/func_gpt.h

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

  • uspace/app/hdisk/func_mbr.c

    rc9f61150 r9bda5d90  
    4141#include "input.h"
    4242
    43 static int set_mbr_partition(tinput_t *in, mbr_part_t *p);
    44 
    45 int add_mbr_part(tinput_t *in, union label_data *data)
     43static int set_mbr_partition(tinput_t * in, mbr_part_t * p);
     44
     45
     46int add_mbr_part(tinput_t * in, union table_data * data)
    4647{
    4748        int rc;
    4849       
    49         mbr_part_t *part = mbr_alloc_partition();
     50        mbr_part_t * part = mbr_alloc_partition();
    5051
    5152        set_mbr_partition(in, part);
    5253
    53         rc = mbr_add_partition(data->mbr, part);
     54        rc = mbr_add_partition(data->mbr.parts, part);
    5455        if (rc != EOK) {
    5556                printf("Error adding partition.\n");
    5657        }
    5758       
    58         return EOK;
    59 }
    60 
    61 int delete_mbr_part(tinput_t *in, union label_data *data)
     59       
     60        return rc;
     61}
     62
     63int delete_mbr_part(tinput_t * in, union table_data * data)
    6264{
    6365        int rc;
    … …  
    7072                return errno;
    7173       
    72         rc = mbr_remove_partition(data->mbr, idx);
     74        rc = mbr_remove_partition(data->mbr.parts, idx);
    7375        if(rc != EOK) {
    7476                printf("Error: something.\n");
    … …  
    7880}
    7981
    80 int destroy_mbr_label(union label_data *data)
    81 {
    82         mbr_free_label(data->mbr);
    83         return EOK;
    84 }
    85 
    86 int 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;
     82int 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;
    9387}
    9488
    9589/** Print current partition scheme */
    96 int print_mbr_parts(union label_data *data)
     90int print_mbr_parts(union table_data * data)
    9791{
    9892        int num = 0;
    … …  
    10296        printf("\t\t%10s  %10s %10s %10s %7s\n", "Bootable:", "Start:", "End:", "Length:", "Type:");
    10397       
    104         mbr_part_t *it;
    105         mbr_part_foreach(data->mbr->parts, it) {
     98        mbr_part_t * it;
     99        mbr_part_foreach(data->mbr.parts, it) {
    106100                if (it->type == PT_UNUSED)
    107101                        continue;
    … …  
    123117}
    124118
    125 int 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 
    143 int write_mbr_parts(service_id_t dev_handle, union label_data *data)
    144 {
    145         int rc = mbr_write_partitions(data->mbr, dev_handle);
     119int 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);
    146122        if (rc != EOK) {
    147123                printf("Error occured during writing: ERR: %d: %s\n", rc, str_error(rc));
    … …  
    151127}
    152128
    153 int extra_mbr_funcs(tinput_t *in, service_id_t dev_handle, union label_data *data)
     129int extra_mbr_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
    154130{
    155131        printf("Not implemented.\n");
    … …  
    157133}
    158134
    159 static int set_mbr_partition(tinput_t *in, mbr_part_t *p)
     135static int set_mbr_partition(tinput_t * in, mbr_part_t * p)
    160136{
    161137        int c;
    … …  
    183159                return errno;
    184160
    185         ///TODO: there can only be one boolabel partition; let's do it just like fdisk
     161        ///TODO: there can only be one bootable partition; let's do it just like fdisk
    186162        printf("Bootable? (y/n): ");
    187163        c = getchar();

  • uspace/app/hdisk/func_mbr.h

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

  • uspace/app/hdisk/func_none.c

    rc9f61150 r9bda5d90  
    4040static void not_implemented(void);
    4141
    42 
    43 int add_none_part(tinput_t *in, union label_data *data)
     42int add_none_part(tinput_t * in, union table_data * data)
    4443{
    4544        not_implemented();
    … …  
    4746}
    4847
    49 int delete_none_part(tinput_t *in, union label_data *data)
     48int delete_none_part(tinput_t * in, union table_data * data)
    5049{
    5150        not_implemented();
    … …  
    5352}
    5453
    55 int destroy_none_label(union label_data *data)
     54int new_none_table(tinput_t * in, union table_data * data)
    5655{
    5756        not_implemented();
    … …  
    5958}
    6059
    61 int new_none_label(union label_data *data)
     60int print_none_parts(union table_data * data)
    6261{
    6362        not_implemented();
    … …  
    6564}
    6665
    67 int print_none_parts(union label_data *data)
     66int write_none_parts(service_id_t dev_handle, union table_data * data)
    6867{
    6968        not_implemented();
    … …  
    7170}
    7271
    73 int read_none_parts(service_id_t dev_handle, union label_data *data)
    74 {
    75         not_implemented();
    76         return EOK;
    77 }
    78 
    79 int write_none_parts(service_id_t dev_handle, union label_data *data)
    80 {
    81         not_implemented();
    82         return EOK;
    83 }
    84 
    85 int extra_none_funcs(tinput_t *in, service_id_t dev_handle, union label_data *data)
     72int extra_none_funcs(tinput_t * in, service_id_t dev_handle, union table_data * data)
    8673{
    8774        not_implemented();

  • uspace/app/hdisk/func_none.h

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

  • uspace/app/hdisk/hdisk.c

    rc9f61150 r9bda5d90  
    5353#include "func_none.h"
    5454
    55 int interact(service_id_t);
     55int interact(service_id_t dev_handle);
    5656void print_help(void);
    57 void select_label_format(tinput_t *);
    58 void fill_label_funcs(void);
    59 void free_label(void);
    60 int try_read(service_id_t);
    61 
    62 int construct_none_label(void);
    63 
    64 int construct_mbr_label(void);
    65 int try_read_mbr(service_id_t);
    66 
    67 int construct_gpt_label(void);
    68 int try_read_gpt(service_id_t);
    69 
    70 
    71 static label_t label;
     57void select_table_format(tinput_t * in);
     58void fill_table_funcs(void);
     59void free_table(void);
     60
     61static table_t table;
    7262
    7363int main(int argc, char ** argv)
    7464{
    7565        if (argc == 1) {
    76                 printf("Missing argument. Please specify a device to operate on.\n");
    77                 return -1;
    78         }
    79        
     66                printf("I'd like to have an argument, please.\n");
     67                return 1;
     68        }
     69
    8070        int rc;
    8171        service_id_t dev_handle;
    82        
     72
    8373        rc = loc_service_get_id(argv[1], &dev_handle, IPC_FLAG_BLOCKING);
    8474        if (rc != EOK) {
    … …  
    8676                return -1;
    8777        }
    88        
    89         printf("Init.\n");
    90         init_label();
    91        
    92         /*
     78
     79        init_table();
     80
    9381        mbr_t * mbr = mbr_read_mbr(dev_handle);
    9482        if(mbr == NULL) {
    … …  
    9987
    10088        if(mbr_is_mbr(mbr)) {
    101                 label.layout = LYT_MBR;
    102                 set_label_mbr(mbr);
     89                table.layout = LYT_MBR;
     90                set_table_mbr(mbr);
    10391                mbr_partitions_t * parts = mbr_read_partitions(mbr);
    10492                if(parts == NULL) {
    … …  
    10795                        parts = mbr_alloc_partitions();
    10896                }
    109                 set_label_mbr_parts(parts);
    110                 fill_label_funcs();
     97                set_table_mbr_parts(parts);
     98                fill_table_funcs();
    11199                goto interact;
    112100        }
    113101       
    114102       
    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         /*
     103        mbr_free_mbr(mbr);
    123104        gpt_t * gpt = gpt_read_gpt_header(dev_handle);
    124105       
    125106        if(gpt != NULL) {
    126                 label.layout = LYT_GPT;
    127                 set_label_gpt(gpt);
     107                table.layout = LYT_GPT;
     108                set_table_gpt(gpt);
    128109               
    129110                gpt_partitions_t * parts = gpt_read_partitions(gpt);
    … …  
    134115                        parts = gpt_alloc_partitions();
    135116                }
    136                 set_label_gpt_parts(parts);
    137                 fill_label_funcs();
     117                set_table_gpt_parts(parts);
     118                fill_table_funcs();
    138119                goto interact;
    139120        }
    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;
     121        printf("No partition table recognized. Create a new one.\n");
     122        table.layout = LYT_NONE;
    149123       
    150124interact:
    151         printf("interact.\n");
    152125        rc = interact(dev_handle);
    153126       
    154         free_label();
     127        free_table();
    155128       
    156129        return rc;
    … …  
    179152                switch(input) {
    180153                        case 'a':
    181                                 label.add_part(in, &label.data);
    182                                 break;
    183                         case 'b':
    184                                 label.add_part(in, &label.data);
     154                                table.add_part(in, &table.data);
    185155                                break;
    186156                        case 'd':
    187                                 label.delete_part(in, &label.data);
     157                                table.delete_part(in, &table.data);
    188158                                break;
    189159                        case 'e':
    190                                 label.extra_funcs(in, dev_handle, &label.data);
     160                                table.extra_funcs(in, dev_handle, &table.data);
    191161                                break;
    192162                        case 'f':
    193                                 free_label();
    194                                 select_label_format(in);
     163                                free_table();
     164                                select_table_format(in);
    195165                                break;
    196166                        case 'h':
    … …  
    198168                                break;
    199169                        case 'n':
    200                                 free_label();
    201                                 label.new_label(&label.data);
     170                                free_table();
     171                                table.new_table(in, &table.data);
    202172                                break;
    203173                        case 'p':
    204                                 label.print_parts(&label.data);
     174                                table.print_parts(&table.data);
    205175                                break;
    206176                        case 'q':
    … …  
    208178                                goto end;
    209179                        case 'w':
    210                                 label.write_parts(dev_handle, &label.data);
     180                                table.write_parts(dev_handle, &table.data);
    211181                                break;
    212182                        default:
    … …  
    227197                "\t 'a' \t\t Add partition.\n"
    228198                "\t 'd' \t\t Delete partition.\n"
    229                 "\t 'e' \t\t Extra functions (per label format).\n"
    230                 "\t 'f' \t\t Switch the format of the partition label."
     199                "\t 'e' \t\t Extra functions (per table format).\n"
     200                "\t 'f' \t\t Switch the format of the partition table."
    231201                "\t 'h' \t\t Prints help. See help for more.\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"
     202                "\t 'n' \t\t Create new partition 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"
    236205                "\t 'q' \t\t Quit.\n"
    237206                );
    … …  
    239208}
    240209
    241 void select_label_format(tinput_t * in)
     210void select_table_format(tinput_t * in)
    242211{
    243212        printf("Available formats are: \n"
    … …  
    249218        switch(val) {
    250219                case 0:
    251                         free_label();
    252                         label.layout = LYT_NONE;
    253                         fill_label_funcs();
     220                        table.layout = LYT_NONE;
     221                        fill_table_funcs();
    254222                        break;
    255223                case 1:
    256                         free_label();
    257                         label.layout = LYT_MBR;
    258                         fill_label_funcs();
     224                        table.layout = LYT_MBR;
     225                        fill_table_funcs();
    259226                        break;
    260227                case 2:
    261                         free_label();
    262                         label.layout = LYT_GPT;
    263                         fill_label_funcs();
    264                         break;
    265         }
    266 }
    267 
    268 void fill_label_funcs(void)
    269 {
    270         switch(label.layout) {
     228                        table.layout = LYT_GPT;
     229                        fill_table_funcs();
     230                        break;
     231        }
     232}
     233
     234void fill_table_funcs(void)
     235{
     236        switch(table.layout) {
    271237                case LYT_MBR:
    272                         construct_mbr_label();
     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;
    273244                        break;
    274245                case LYT_GPT:
    275                         construct_gpt_label();
     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;
    276252                        break;
    277253                default:
    278                         construct_none_label();
    279                         break;
    280         }
    281 }
    282 
    283 void free_label(void)
    284 {
    285         /*
    286         switch(label.layout) {
     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
     264void free_table(void)
     265{
     266        switch(table.layout) {
    287267                case LYT_MBR:
    288                         destroy_mbr_label(&label);
     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                        }
    289276                        break;
    290277                case LYT_GPT:
    291                         destroy_gpt_label(&label);
     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                        }
    292286                        break;
    293287                default:
    294288                        break;
    295289        }
    296         */
    297        
    298         label.destroy_label(&label.data);
    299 }
    300 
    301 int 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 
    308 int 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 
    322 int 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 
    336 int try_read_mbr(service_id_t dev_handle)
    337 {
    338         label.layout = LYT_MBR;
    339         return try_read(dev_handle);
    340 }
    341 
    342 int 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 
    355 int 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 
     290}
     291
     292
     293

  • uspace/app/hdisk/hdisk.h

    rc9f61150 r9bda5d90  
    3939        LYT_MBR,
    4040        LYT_GPT,
    41 } layouts_t;
     41} LAYOUTS;
    4242
    43 typedef 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;
     43typedef 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;
    5553
    56 #define init_label() \
    57         label.layout = LYT_NONE
     54#define init_table() \
     55        table.layout = LYT_NONE
    5856
     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)

  • uspace/lib/gpt/libgpt.h

    rc9f61150 r9bda5d90  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
    3  * Copyright (c) 2011, 2012, 2013 Dominik Taborsky
     2 * Copyright (c) 2009 Jiri Svoboda, 2011, 2012, 2013 Dominik Taborsky
    43 * All rights reserved.
    54 *
    … …  
    130129        gpt_t * gpt;
    131130        gpt_partitions_t * parts;
    132 } gpt_label_t;
     131} gpt_table_t;
    133132
    134133struct partition_type {
    … …  
    142141extern gpt_t * gpt_alloc_gpt_header(void);
    143142extern gpt_t * gpt_read_gpt_header(service_id_t dev_handle);
    144 extern int     gpt_write_gpt_header(gpt_t * header, service_id_t dev_handle);
     143extern int gpt_write_gpt_header(gpt_t * header, service_id_t dev_handle);
    145144
    146 extern gpt_partitions_t * gpt_alloc_partitions(void);
    147 extern gpt_partitions_t * gpt_read_partitions(gpt_t * gpt);
    148 extern int             gpt_write_partitions(gpt_partitions_t * parts, gpt_t * header, service_id_t dev_handle);
    149 extern gpt_part_t *    gpt_alloc_partition (gpt_partitions_t * parts);
    150 extern int             gpt_add_partition   (gpt_partitions_t * parts, gpt_part_t * partition);
    151 extern int             gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
     145extern gpt_partitions_t *       gpt_alloc_partitions(void);
     146extern gpt_partitions_t *       gpt_read_partitions     (gpt_t * gpt);
     147extern int                                      gpt_write_partitions    (gpt_partitions_t * parts, gpt_t * header, service_id_t dev_handle);
     148extern gpt_part_t *                     gpt_alloc_partition             (gpt_partitions_t * parts);
     149extern int                                      gpt_add_partition       (gpt_partitions_t * parts, gpt_part_t * partition);
     150extern int                                      gpt_remove_partition(gpt_partitions_t * parts, size_t idx);
    152151
    153 extern size_t          gpt_get_part_type(gpt_part_t * p);
    154 extern void            gpt_set_part_type(gpt_part_t * p, size_t type);
    155 extern void            gpt_set_start_lba(gpt_part_t * p, uint64_t start);
    156 extern uint64_t        gpt_get_start_lba(gpt_part_t * p);
    157 extern void            gpt_set_end_lba  (gpt_part_t * p, uint64_t end);
    158 extern uint64_t        gpt_get_end_lba  (gpt_part_t * p);
    159 extern unsigned char * gpt_get_part_name(gpt_part_t * p);
    160 extern void            gpt_set_part_name(gpt_part_t * p, char * name[], size_t length);
    161 extern bool            gpt_get_flag     (gpt_part_t * p, GPT_ATTR flag);
    162 extern void            gpt_set_flag     (gpt_part_t * p, GPT_ATTR flag, bool value);
     152extern size_t                           gpt_get_part_type       (gpt_part_t * p);
     153extern void                             gpt_set_part_type       (gpt_part_t * p, size_t type);
     154extern void                                     gpt_set_start_lba       (gpt_part_t * p, uint64_t start);
     155extern uint64_t                         gpt_get_start_lba       (gpt_part_t * p);
     156extern void                                     gpt_set_end_lba         (gpt_part_t * p, uint64_t end);
     157extern uint64_t                         gpt_get_end_lba         (gpt_part_t * p);
     158extern unsigned char *          gpt_get_part_name       (gpt_part_t * p);
     159extern void                             gpt_set_part_name       (gpt_part_t * p, char * name[], size_t length);
     160extern bool                                     gpt_get_flag            (gpt_part_t * p, GPT_ATTR flag);
     161extern void                                     gpt_set_flag            (gpt_part_t * p, GPT_ATTR flag, bool value);
    163162
    164163

  • uspace/lib/mbr/libmbr.c

    rc9f61150 r9bda5d90  
    4646
    4747static br_block_t * alloc_br(void);
    48 static int decode_part(pt_entry_t *, mbr_part_t *, uint32_t);
    49 static int decode_logical(mbr_label_t *, mbr_part_t *);
    50 static void encode_part(mbr_part_t *, pt_entry_t *, uint32_t, bool);
    51 static int check_overlap(mbr_part_t *, mbr_part_t *);
    52 static int check_encaps(mbr_part_t *, mbr_part_t *);
    53 static int check_preceeds(mbr_part_t *, mbr_part_t *);
    54 
    55 /** Allocate and initialize mbr_label_t structure */
    56 mbr_label_t * mbr_alloc_label(void)
    57 {
    58         mbr_label_t *label = malloc(sizeof(mbr_label_t));
    59         if (label == NULL)
    60                 return NULL;
    61        
    62         label->mbr = NULL;
    63         label->parts = NULL;
    64         label->device = 0;
    65        
    66         return label;
    67 }
    68 
    69 /** Free mbr_label_t structure */
    70 void mbr_free_label(mbr_label_t *label)
    71 {
    72         if (label->mbr != NULL)
    73                 mbr_free_mbr(label->mbr);
    74        
    75         if (label->parts != NULL)
    76                 mbr_free_partitions(label->parts);
    77        
    78         free(label);
    79 }
     48static int decode_part(pt_entry_t * src, mbr_part_t * trgt, uint32_t base);
     49static int decode_logical(mbr_t * mbr, mbr_partitions_t * p, mbr_part_t * ext);
     50static void encode_part(mbr_part_t * src, pt_entry_t * trgt, uint32_t base, bool ebr);
     51static int check_overlap(mbr_part_t * p1, mbr_part_t * p2);
     52static int check_encaps(mbr_part_t * inner, mbr_part_t * outer);
     53static int check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee);
    8054
    8155/** Allocate memory for mbr_t */
    … …  
    8660
    8761/** Read MBR from specific device
    88  * @param   label       label to write data to
    89  * @param   dev_handle  device to read MBR from
    90  *
    91  * @return                              EOK on success, error code on error
    92  */
    93 int mbr_read_mbr(mbr_label_t *label, service_id_t dev_handle)
    94 {
    95         if (label == NULL)
    96                 return EINVAL;
    97        
     62 * @param       dev_handle      device to read MBR from
     63 *
     64 * @return                              mbr record on success, NULL on error
     65 */
     66mbr_t * mbr_read_mbr(service_id_t dev_handle)
     67{
    9868        int rc;
    99        
    100         if (label->mbr == NULL) {
    101                 label->mbr = mbr_alloc_mbr();
    102                 if (label->mbr == NULL) {
    103                         return ENOMEM;
    104                 }
     69
     70        mbr_t * mbr = malloc(sizeof(mbr_t));
     71        if (mbr == NULL) {
     72                return NULL;
    10573        }
    10674
    10775        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
    108         if (rc != EOK)
    109                 return rc;
    110 
    111         rc = block_read_direct(dev_handle, 0, 1, &(label->mbr->raw_data));
     76        if (rc != EOK) {
     77                free(mbr);
     78                return NULL;
     79        }
     80
     81        rc = block_read_direct(dev_handle, 0, 1, &(mbr->raw_data));
     82        if (rc != EOK) {
     83                free(mbr);
     84                block_fini(dev_handle);
     85                return NULL;
     86        }
     87
    11288        block_fini(dev_handle);
    113         if (rc != EOK)
    114                 return rc;
    115 
    116         label->device = dev_handle;
    117 
    118         return EOK;
     89
     90        mbr->device = dev_handle;
     91
     92        return mbr;
    11993}
    12094
    12195/** Write mbr to disk
    122  * @param label                 MBR to be written
     96 * @param mbr                   MBR to be written
    12397 * @param dev_handle    device handle to write MBR to (may be different
    12498 *                                                      from the device in 'mbr')
    … …  
    126100 * @return                              0 on success, otherwise libblock error code
    127101 */
    128 int mbr_write_mbr(mbr_label_t *label, service_id_t dev_handle)
     102int mbr_write_mbr(mbr_t * mbr, service_id_t dev_handle)
    129103{
    130104        int rc;
    … …  
    135109        }
    136110
    137         rc = block_write_direct(dev_handle, 0, 1, &(label->mbr->raw_data));
     111        rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
    138112        block_fini(dev_handle);
    139113        if (rc != EOK) {
    … …  
    141115        }
    142116
    143         return EOK;
     117        return 0;
    144118}
    145119
    … …  
    150124 * @return                      1 if MBR, 0 if GPT
    151125 */
    152 int mbr_is_mbr(mbr_label_t *label)
    153 {
    154         return (label->mbr->raw_data.pte[0].ptype != PT_GPT) ? 1 : 0;
    155 }
    156 
    157 /** Parse partitions from MBR, freeing previous partitions if any
    158  * NOTE: it is assumed mbr_read_mbr(label) was called before.
    159  * @param label  MBR to be parsed
    160  *
    161  * @return       linked list of partitions or NULL on error
    162  */
    163 int mbr_read_partitions(mbr_label_t *label)
    164 {
    165         if (label == NULL || label->mbr == NULL)
    166                 return EINVAL;
    167        
    168         int rc, rc_ext;
    169         unsigned int i;
    170         mbr_part_t *p;
    171         mbr_part_t *ext = NULL;
    172         //mbr_partitions_t *parts;
    173         printf("check\n");
    174         if (label->parts != NULL)
    175                 mbr_free_partitions(label->parts);
    176         printf("check2\n");
    177         label->parts = mbr_alloc_partitions();
    178         if (label->parts == NULL) {
    179                 return ENOMEM;
    180         }
    181         printf("primary\n");
    182         /* Generate the primary partitions */
     126int mbr_is_mbr(mbr_t * mbr)
     127{
     128        return (mbr->raw_data.pte[0].ptype != PT_GPT) ? 1 : 0;
     129}
     130
     131/** Parse partitions from MBR
     132 * @param mbr   MBR to be parsed
     133 *
     134 * @return              linked list of partitions or NULL on error
     135 */
     136mbr_partitions_t * mbr_read_partitions(mbr_t * mbr)
     137{
     138        int rc, i, rc_ext;
     139        mbr_part_t * p;
     140        mbr_part_t * ext = NULL;
     141        mbr_partitions_t * parts;
     142       
     143        if (mbr == NULL)
     144                return NULL;
     145       
     146        parts = mbr_alloc_partitions();
     147        if (parts == NULL) {
     148                return NULL;
     149        }
     150
     151        // Generate the primary partitions
    183152        for (i = 0; i < N_PRIMARY; ++i) {
    184                 if (label->mbr->raw_data.pte[i].ptype == PT_UNUSED)
     153                if (mbr->raw_data.pte[i].ptype == PT_UNUSED)
    185154                        continue;
    186                 printf("pcheck1\n");
     155               
    187156                p = mbr_alloc_partition();
    188157                if (p == NULL) {
    189158                        printf(LIBMBR_NAME ": Error on memory allocation.\n");
    190                         mbr_free_partitions(label->parts);
    191                         return ENOMEM;
    192                 }
    193                 printf("pcheck2\n");
    194                 rc_ext = decode_part(&(label->mbr->raw_data.pte[i]), p, 0);
     159                        mbr_free_partitions(parts);
     160                        return NULL;
     161                }
     162               
     163                rc_ext = decode_part(&(mbr->raw_data.pte[i]), p, 0);
    195164                mbr_set_flag(p, ST_LOGIC, false);
    196                 rc = mbr_add_partition(label, p);
     165                rc = mbr_add_partition(parts, p);
    197166                if (rc != ERR_OK) {
    198167                        printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \
    199                                LIBMBR_NAME ": MBR is invalid.\n", rc);
    200                         mbr_free_partitions(label->parts);
    201                         return EINVAL;
    202                 }
    203                 printf("pcheck3\n");
     168                                   LIBMBR_NAME ": Partition list may be incomplete.\n", rc);
     169                        return NULL;
     170                }
     171               
    204172                if (rc_ext) {
    205173                        ext = p;
    206                         label->parts->l_extended = list_nth(&(label->parts->list), i);
    207                 }
    208                 printf("pcheck4\n");
    209         }
    210         printf("logical\n");
    211         /* Fill in the primary partitions and generate logical ones, if any */
    212         rc = decode_logical(label, ext);
     174                        parts->l_extended = list_last(&(parts->list));
     175                }
     176        }
     177       
     178        // Fill in the primary partitions and generate logical ones, if any
     179        rc = decode_logical(mbr, parts, ext);
    213180        if (rc != EOK) {
    214181                printf(LIBMBR_NAME ": Error occured during decoding the MBR.\n" \
    215182                           LIBMBR_NAME ": Partition list may be incomplete.\n");
    216                 return rc;
    217         }
    218         printf("finish\n");
    219         return EOK;
     183        }
     184       
     185        return parts;
    220186}
    221187
    222188/** Write MBR and partitions to device
    223  * @param label        label to write
    224  * @param dev_handle   device to write the data to
    225  *
    226  * @return             returns EOK on succes, specific error code otherwise
    227  */
    228 int mbr_write_partitions(mbr_label_t *label, service_id_t dev_handle)
     189 * @param parts                 partition list to be written
     190 * @param mbr                   MBR to be written with 'parts' partitions
     191 * @param dev_handle    device to write the data to
     192 *
     193 * @return                              returns EOK on succes, specific error code otherwise
     194 */
     195int mbr_write_partitions(mbr_partitions_t * parts, mbr_t * mbr, service_id_t dev_handle)
    229196{
    230197        int i = 0;
    231198        int rc;
    232         mbr_part_t *p;
    233         mbr_part_t *ext = (label->parts->l_extended == NULL) ? NULL
    234                                         : list_get_instance(label->parts->l_extended, mbr_part_t, link);
     199        mbr_part_t * p;
     200        mbr_part_t * ext = (parts->l_extended == NULL) ? NULL
     201                                        : list_get_instance(parts->l_extended, mbr_part_t, link);
    235202       
    236203        rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
    … …  
    240207        }
    241208       
    242         link_t *l = label->parts->list.head.next;
    243        
    244         /* Encoding primary partitions */
    245         for (i = 0; i < label->parts->n_primary; i++) {
    246                 p = list_get_instance(l, mbr_part_t, link);     
    247                 encode_part(p, &(label->mbr->raw_data.pte[i]), 0, false);
     209        link_t * l = parts->list.head.next;
     210       
     211        // Encoding primary partitions
     212        for (i = 0; i < parts->n_primary; i++) {
     213                p = list_get_instance(l, mbr_part_t, link);
     214                encode_part(p, &(mbr->raw_data.pte[i]), 0, false);
    248215                l = l->next;
    249216        }
    250217       
    251         /* Writing MBR */
    252         rc = block_write_direct(dev_handle, 0, 1, &(label->mbr->raw_data));
     218        // Writing MBR
     219        rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
    253220        if (rc != EOK) {
    254221                printf(LIBMBR_NAME ": Error while writing MBR : %d - %s.\n", rc, str_error(rc));
    … …  
    267234         * as much power over it as you can get. Thanks. */
    268235       
    269         /* Encoding and writing first logical partition */
    270         if (l != &(label->parts->list.head)) {
     236        // Encoding and writing first logical partition
     237        if (l != &(parts->list.head)) {
    271238                p = list_get_instance(l, mbr_part_t, link);
    272239                p->ebr_addr = base;
    … …  
    289256        prev_p = p;
    290257       
    291         /* Encoding and writing logical partitions */
    292         while (l != &(label->parts->list.head)) {
     258        // Encoding and writing logical partitions
     259        while (l != &(parts->list.head)) {
    293260                p = list_get_instance(l, mbr_part_t, link);
    294261               
    … …  
    319286        }
    320287       
    321         /* write the last EBR */
     288        // write the last EBR
    322289        encode_part(NULL, &(prev_p->ebr->pte[1]), 0, false);
    323290        rc = block_write_direct(dev_handle, prev_p->ebr_addr, 1, prev_p->ebr);
    … …  
    338305mbr_part_t * mbr_alloc_partition(void)
    339306{
    340         mbr_part_t *p = malloc(sizeof(mbr_part_t));
     307        mbr_part_t * p = malloc(sizeof(mbr_part_t));
    341308        if (p == NULL) {
    342309                return NULL;
    … …  
    345312        link_initialize(&(p->link));
    346313        p->ebr = NULL;
    347         p->type = PT_UNUSED;
     314        p->type = 0;
    348315        p->status = 0;
    349316        p->start_addr = 0;
    350317        p->length = 0;
    351318        p->ebr_addr = 0;
    352        
     319
    353320        return p;
    354321}
    … …  
    357324mbr_partitions_t * mbr_alloc_partitions(void)
    358325{
    359         mbr_partitions_t *parts = malloc(sizeof(mbr_partitions_t));
     326        mbr_partitions_t * parts = malloc(sizeof(mbr_partitions_t));
    360327        if (parts == NULL) {
    361328                return NULL;
    362329        }
    363        
     330
    364331        list_initialize(&(parts->list));
    365332        parts->n_primary = 0;
    366333        parts->n_logical = 0;
    367334        parts->l_extended = NULL;
    368        
    369         /* add blank primary partitions */
    370         int i;
    371         mbr_part_t *p;
    372         for (i = 0; i < N_PRIMARY; ++i) {
    373                 p = mbr_alloc_partition();
    374                 if (p == NULL) {
    375                         mbr_free_partitions(parts);
    376                         return NULL;
    377                 }
    378                 list_append(&(p->link), &(parts->list));
    379         }
    380        
    381335
    382336        return parts;
    … …  
    386340 *      Performs checks, sorts the list.
    387341 *
    388  * @param label                 label to add to
     342 * @param parts                 partition list to add to
    389343 * @param p                             partition to add
    390344 *
    391345 * @return                              ERR_OK (0) on success, other MBR_ERR_VAL otherwise
    392346 */
    393 mbr_err_val mbr_add_partition(mbr_label_t *label, mbr_part_t *p)
    394 {
    395         int rc;
    396         mbr_partitions_t *parts = label->parts;
    397        
    398         aoff64_t nblocks;
    399         printf("add1.\n");
    400         rc = block_init(EXCHANGE_ATOMIC, label->device, 512);
    401         if (rc != EOK) {
    402                 printf(LIBMBR_NAME ": Error while getting number of blocks: %d - %s.\n", rc, str_error(rc));
    403                 return ERR_LIBBLOCK;
    404         }
    405         printf("add2.\n");
    406         rc = block_get_nblocks(label->device, &nblocks);
    407         block_fini(label->device);
    408         if (rc != EOK) {
    409                 printf(LIBMBR_NAME ": Error while getting number of blocks: %d - %s.\n", rc, str_error(rc));
    410                 return ERR_LIBBLOCK;
    411         }
    412         printf("add3.\n");
    413         if (mbr_get_flag(p, ST_LOGIC)) {
    414                 /* adding logical partition */
    415                
    416                 /* is there any extended partition? */
     347MBR_ERR_VAL mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * p)
     348{
     349        if (mbr_get_flag(p, ST_LOGIC)) { // adding logical part
     350                // is there any extended partition?
    417351                if (parts->l_extended == NULL)
    418352                        return ERR_NO_EXTENDED;
    419353               
    420                 /* is the logical partition inside the extended one? */
    421                 mbr_part_t *ext = list_get_instance(parts->l_extended, mbr_part_t, link);
     354                // is the logical partition inside the extended one?
     355                mbr_part_t * ext = list_get_instance(parts->l_extended, mbr_part_t, link);
    422356                if (!check_encaps(p, ext))
    423357                        return ERR_OUT_BOUNDS;
    424358               
    425                 /* find a place for the new partition in a sorted linked list */
    426                 //mbr_part_t *last = list_get_instance(list_last(&(parts->list)), mbr_part_t, link);
    427                 mbr_part_t *iter;
    428                 //uint32_t ebr_space = 1;
     359                // find a place for the new partition in a sorted linked list
     360                mbr_part_t * last = list_get_instance(list_last(&(parts->list)), mbr_part_t, link);
     361                mbr_part_t * iter;
     362                uint32_t ebr_space = 1;
    429363                mbr_part_foreach(parts, iter) {
    430364                        if (mbr_get_flag(iter, ST_LOGIC)) {
    … …  
    432366                                        return ERR_OVERLAP;
    433367                                if (check_preceeds(iter, p)) {
    434                                         /* checking if there's at least one sector of space preceeding */
    435                                         if ((iter->start_addr + iter->length) >= p->start_addr - 1)
    436                                                 return ERR_NO_EBR;
    437                                 } else {
    438                                         /* checking if there's at least one sector of space following (for following partitions's EBR) */
    439                                         if ((p->start_addr + p->length) >= iter->start_addr - 1)
    440                                                 return ERR_NO_EBR;
    441                                 }
     368                                        last = iter;
     369                                        ebr_space = p->start_addr - (last->start_addr + last->length);
     370                                } else
     371                                        break;
    442372                        }
    443373                }
    444374               
    445                 /* alloc EBR if it's not already there */
     375                // checking if there's at least one sector of space preceeding
     376                if (ebr_space < 1)
     377                        return ERR_NO_EBR;
     378               
     379                // checking if there's at least one sector of space following (for following partitions's EBR)
     380                if (last->link.next != &(parts->list.head)) {
     381                        if (list_get_instance(&(last->link.next), mbr_part_t, link)->start_addr <= p->start_addr + p->length + 1)
     382                                return ERR_NO_EBR;
     383                }
     384               
     385                // alloc EBR if it's not already there
    446386                if (p->ebr == NULL) {
    447387                        p->ebr = alloc_br();
    … …  
    451391                }
    452392               
    453                 /* add it */
    454                 list_append(&(p->link), &(parts->list));
     393                // add it
     394                list_insert_after(&(p->link), &(last->link));
    455395                parts->n_logical += 1;
    456         } else {
    457                 /* adding primary */
    458                
     396        } else { // adding primary
    459397                if (parts->n_primary == 4) {
    460398                        return ERR_PRIMARY_FULL;
    461399                }
    462400               
    463                 /* Check if partition makes space for MBR itself. */
    464                 if (p->start_addr == 0 || ((aoff64_t) p->start_addr) + p->length >= nblocks) {
     401                // TODO: should we check if it's inside the drive's upper boundary?
     402                if (p->start_addr == 0) {
    465403                        return ERR_OUT_BOUNDS;
    466404                }
    467                 printf("add4.\n");
    468                 /* if it's extended, is there any other one? */
     405               
     406                // if it's extended, is there any other one?
    469407                if ((p->type == PT_EXTENDED || p->type == PT_EXTENDED_LBA) && parts->l_extended != NULL) {
    470408                        return ERR_EXTENDED_PRESENT;
    471409                }
    472                 printf("add5.\n");
    473                 /* find a place and add it */
    474                 mbr_part_t *iter;
    475                 mbr_part_t *empty = NULL;
    476                 mbr_part_foreach(parts, iter) {
    477                         printf("type: %x\n", iter->type);
    478                         if (iter->type == PT_UNUSED) {
    479                                 if (empty == NULL)
    480                                         empty = iter;
    481                         } else if (check_overlap(p, iter))
    482                                 return ERR_OVERLAP;
    483                 }
    484                 printf("add6. %p, %p\n", empty, p);
    485                 list_insert_after(&(p->link), &(empty->link));
    486                 printf("add6.1.\n");
    487                 list_remove(&(empty->link));
    488                 printf("add6.2.\n");
    489                 free(empty);
    490                 printf("add7.\n");
     410               
     411                // find a place and add it
     412                if (list_empty(&(parts->list))) {
     413                        list_append(&(p->link), &(parts->list));
     414                } else {
     415                        mbr_part_t * iter;
     416                        mbr_part_foreach(parts, iter) {
     417                                if (mbr_get_flag(iter, ST_LOGIC)) {
     418                                        list_insert_before(&(p->link), &(iter->link));
     419                                        break;
     420                                } else if (check_overlap(p, iter))
     421                                        return ERR_OVERLAP;
     422                        }
     423                        if (iter == list_get_instance(&(parts->list.head.prev), mbr_part_t, link))
     424                                list_append(&(p->link), &(parts->list));
     425                }
    491426                parts->n_primary += 1;
    492427               
    … …  
    494429                        parts->l_extended = &(p->link);
    495430        }
    496         printf("add8.\n");
     431
    497432        return ERR_OK;
    498433}
    … …  
    500435/** Remove partition
    501436 *      Removes partition by index, indexed from zero. When removing extended
    502  *  partition, all logical partitions get removed as well.
     437 * partition, all logical partitions get removed as well.
    503438 *
    504  * @param label                 label to remove from
     439 * @param parts                 partition list to remove from
    505440 * @param idx                   index of the partition to remove
    506441 *
    507442 * @return                              EOK on success, EINVAL if idx invalid
    508443 */
    509 int mbr_remove_partition(mbr_label_t *label, size_t idx)
    510 {
    511         link_t *l = list_nth(&(label->parts->list), idx);
     444int mbr_remove_partition(mbr_partitions_t * parts, size_t idx)
     445{
     446        link_t * l = list_nth(&(parts->list), idx);
    512447        if (l == NULL)
    513448                return EINVAL;
    514449       
    515         mbr_part_t *p;
    516        
    517         /* If we're removing an extended partition, remove all logical as well */
    518         if (l == label->parts->l_extended) {
    519                 label->parts->l_extended = NULL;
    520                
    521                 link_t *it = l->next;
    522                 link_t *next_it;
    523                 while (it != &(label->parts->list.head)) {
     450        mbr_part_t * p;
     451       
     452        /* TODO: if it is extended partition, should we also remove all logical?
     453         * If we don't, we break the consistency of the list. If we do,
     454         * the user will have to input them all over again. So yes. */
     455        if (l == parts->l_extended) {
     456                parts->l_extended = NULL;
     457               
     458                link_t * it = l->next;
     459                link_t * next_it;
     460                while (it != &(parts->list.head)) {
    524461                        next_it = it->next;
    525462                       
    … …  
    527464                        if (mbr_get_flag(p, ST_LOGIC)) {
    528465                                list_remove(it);
    529                                 label->parts->n_logical -= 1;
     466                                parts->n_logical -= 1;
    530467                                mbr_free_partition(p);
    531468                        }
    … …  
    536473        }
    537474       
    538         /* Remove the partition itself */
     475        list_remove(l);
     476       
    539477        p = list_get_instance(l, mbr_part_t, link);
    540         if (mbr_get_flag(p, ST_LOGIC)) {
    541                 label->parts->n_logical -= 1;
    542                 list_remove(l);
    543                 mbr_free_partition(p);
    544         } else {
    545                 /* Cannot remove primary - it would break ordering, just zero it */
    546                 label->parts->n_primary -= 1;
    547                 p->type = 0;
    548                 p->status = 0;
    549                 p->start_addr = 0;
    550                 p->length = 0;
    551                 p->ebr_addr = 0;
    552         }
     478        if (mbr_get_flag(p, ST_LOGIC))
     479                parts->n_logical -= 1;
     480        else
     481                parts->n_primary -= 1;
     482       
     483       
     484        mbr_free_partition(p);
    553485       
    554486        return EOK;
    … …  
    556488
    557489/** mbr_part_t destructor */
    558 void mbr_free_partition(mbr_part_t *p)
     490void mbr_free_partition(mbr_part_t * p)
    559491{
    560492        if (p->ebr != NULL)
    … …  
    564496
    565497/** Get flag bool value */
    566 int mbr_get_flag(mbr_part_t *p, MBR_FLAGS flag)
     498int mbr_get_flag(mbr_part_t * p, MBR_FLAGS flag)
    567499{
    568500        return (p->status & (1 << flag)) ? 1 : 0;
    … …  
    570502
    571503/** Set a specifig status flag to a value */
    572 void mbr_set_flag(mbr_part_t *p, MBR_FLAGS flag, bool value)
     504void mbr_set_flag(mbr_part_t * p, MBR_FLAGS flag, bool value)
    573505{
    574506        uint8_t status = p->status;
    … …  
    590522
    591523/** Just a wrapper for free() */
    592 void mbr_free_mbr(mbr_t *mbr)
     524void mbr_free_mbr(mbr_t * mbr)
    593525{
    594526        free(mbr);
    … …  
    599531 * @param parts         partition list to be freed
    600532 */
    601 void mbr_free_partitions(mbr_partitions_t *parts)
     533void mbr_free_partitions(mbr_partitions_t * parts)
    602534{
    603535        list_foreach_safe(parts->list, cur_link, next) {
    604                 mbr_part_t *p = list_get_instance(cur_link, mbr_part_t, link);
     536                mbr_part_t * p = list_get_instance(cur_link, mbr_part_t, link);
     537                list_remove(cur_link);
    605538                mbr_free_partition(p);
    606539        }
    … …  
    611544// Internal functions follow //
    612545
    613 static br_block_t *alloc_br()
    614 {
    615         br_block_t *br = malloc(sizeof(br_block_t));
     546static br_block_t * alloc_br()
     547{
     548        br_block_t * br = malloc(sizeof(br_block_t));
    616549        if (br == NULL)
    617550                return NULL;
    … …  
    626559 * @return              returns 1, if extended partition, 0 otherwise
    627560 * */
    628 static int decode_part(pt_entry_t *src, mbr_part_t *trgt, uint32_t base)
     561static int decode_part(pt_entry_t * src, mbr_part_t * trgt, uint32_t base)
    629562{
    630563        trgt->type = src->ptype;
    631564
    632565        /* Checking only 0x80; otherwise writing will fix to 0x00 */
    633         trgt->status = (trgt->status & 0xFF00) | src->status;
     566        //trgt->bootable = (src->status == B_ACTIVE) ? true : false;
     567        mbr_set_flag(trgt, ST_BOOT, (src->status == B_ACTIVE) ? true : false);
    634568
    635569        trgt->start_addr = uint32_t_le2host(src->first_lba) + base;
    … …  
    640574
    641575/** Parse MBR contents to mbr_part_t list */
    642 static int decode_logical(mbr_label_t *label, mbr_part_t * ext)
     576static int decode_logical(mbr_t * mbr, mbr_partitions_t * parts, mbr_part_t * ext)
    643577{
    644578        int rc;
    645         mbr_part_t *p;
     579        mbr_part_t * p;
     580
     581        if (mbr == NULL || parts == NULL)
     582                return EINVAL;
     583
    646584
    647585        if (ext == NULL)
    648586                return EOK;
    649587
     588
    650589        uint32_t base = ext->start_addr;
    651590        uint32_t addr = base;
    652         br_block_t *ebr;
    653        
    654         rc = block_init(EXCHANGE_ATOMIC, label->device, 512);
     591        br_block_t * ebr;
     592       
     593        rc = block_init(EXCHANGE_ATOMIC, mbr->device, 512);
    655594        if (rc != EOK)
    656595                return rc;
    … …  
    662601        }
    663602       
    664         rc = block_read_direct(label->device, addr, 1, ebr);
     603        rc = block_read_direct(mbr->device, addr, 1, ebr);
    665604        if (rc != EOK) {
    666605                goto free_ebr_end;
    … …  
    687626        p->ebr = ebr;
    688627        p->ebr_addr = addr;
    689         rc = mbr_add_partition(label, p);
     628        rc = mbr_add_partition(parts, p);
    690629        if (rc != ERR_OK)
    691630                return EINVAL;
    … …  
    700639                }
    701640               
    702                 rc = block_read_direct(label->device, addr, 1, ebr);
     641                rc = block_read_direct(mbr->device, addr, 1, ebr);
    703642                if (rc != EOK) {
    704643                        goto free_ebr_end;
    … …  
    721660                p->ebr = ebr;
    722661                p->ebr_addr = addr;
    723                 rc = mbr_add_partition(label, p);
     662                rc = mbr_add_partition(parts, p);
    724663                if (rc != ERR_OK)
    725664                        return EINVAL;
    … …  
    735674       
    736675end:
    737         block_fini(label->device);
     676        block_fini(mbr->device);
    738677       
    739678        return rc;
    … …  
    744683{
    745684        if (src != NULL) {
    746                 //trgt->status = mbr_get_flag(src, ST_BOOT) ? B_ACTIVE : B_INACTIVE;
    747                 trgt->status = (uint8_t) (src->status & 0xFF);
    748                 /* ingoring CHS */
    749                 trgt->first_chs[0] = 0xFE;
    750                 trgt->first_chs[1] = 0xFF;
    751                 trgt->first_chs[2] = 0xFF;
    752                 trgt->last_chs[0] = 0xFE;
    753                 trgt->last_chs[1] = 0xFF;
    754                 trgt->last_chs[2] = 0xFF;
     685                trgt->status = mbr_get_flag(src, ST_BOOT) ? B_ACTIVE : B_INACTIVE;
    755686                if (ebr) {      // encoding reference to EBR
    756687                        trgt->ptype = PT_EXTENDED_LBA;

  • uspace/lib/mbr/libmbr.h

    rc9f61150 r9bda5d90  
    11/*
    2  * Copyright (c) 2009 Jiri Svoboda
    32 * Copyright (c) 2011, 2012, 2013 Dominik Taborsky
    43 * All rights reserved.
    … …  
    7473
    7574typedef enum {
    76         /** Other flags unknown - saving previous state */
    7775        /** Bootability */
    78         ST_BOOT = 7,
     76        ST_BOOT = 0,
    7977        /** Logical partition, 0 = primary, 1 = logical*/
    80         ST_LOGIC = 8
     78        ST_LOGIC = 1
    8179} MBR_FLAGS;
    8280
    … …  
    103101        /** Partition overlapping */
    104102        ERR_OVERLAP,
    105         /** Partition out of bounds */
     103        /** Logical partition out of bounds */
    106104        ERR_OUT_BOUNDS,
    107105        /** No space left for EBR */
    … …  
    109107        /** Out of memory */
    110108        ERR_NOMEM,
    111         /** Libblock error */
    112         ERR_LIBBLOCK,
    113 } mbr_err_val;
     109} MBR_ERR_VAL;
    114110
    115111
    … …  
    147143        /** Raw access to data */
    148144        br_block_t raw_data;
     145        /** Device where the data are from */
     146        service_id_t device;
    149147} mbr_t;
    150148
    … …  
    157155        uint8_t type;
    158156        /** Flags */
    159         uint16_t status;
     157        uint8_t status;
    160158        /** Address of first block */
    161159        uint32_t start_addr;
    … …  
    181179
    182180/** Both header and partition list */
    183 typedef struct mbr_label {
    184         /** MBR header */
     181typedef struct mbr_table {
    185182        mbr_t * mbr;
    186         /** Partition list */
    187183        mbr_partitions_t * parts;
    188         /** Device where the data are from (or for) */
    189         service_id_t device;
    190 } mbr_label_t;
    191 
    192 /* Alloc complete label structure */
    193 extern mbr_label_t * mbr_alloc_label(void);
    194 
    195 /* Read/Write MBR header.
     184} mbr_table_t;
     185
     186/** Read/Write MBR header.
    196187 * WARNING: when changing both header and partitions, write first header,
    197188 * then partitions. The MBR headers' raw_data is NOT updated to follow
    198189 * partition changes. */
    199190extern mbr_t * mbr_alloc_mbr(void);
    200 extern int mbr_read_mbr(mbr_label_t *, service_id_t);
    201 extern int mbr_write_mbr(mbr_label_t *, service_id_t);
    202 extern int mbr_is_mbr(mbr_label_t *);
    203 
    204 /* Read/Write/Set MBR partitions.
     191extern mbr_t * mbr_read_mbr(service_id_t dev_handle);
     192extern int mbr_write_mbr(mbr_t * mbr, service_id_t dev_handle);
     193extern int mbr_is_mbr(mbr_t * mbr);
     194
     195/** Read/Write/Set MBR partitions.
    205196 * NOTE: Writing partitions writes the complete header as well. */
    206 extern int mbr_read_partitions(mbr_label_t *);
    207 extern int          mbr_write_partitions(mbr_label_t *, service_id_t);
    208 extern mbr_part_t * mbr_alloc_partition(void);
     197extern mbr_partitions_t * mbr_read_partitions(mbr_t * mbr);
     198extern int                      mbr_write_partitions(mbr_partitions_t * parts, mbr_t * mbr, service_id_t dev_handle);
     199extern mbr_part_t *     mbr_alloc_partition(void);
    209200extern mbr_partitions_t * mbr_alloc_partitions(void);
    210 extern mbr_err_val  mbr_add_partition(mbr_label_t *, mbr_part_t *);
    211 extern int          mbr_remove_partition(mbr_label_t *, size_t);
    212 extern int          mbr_get_flag(mbr_part_t *, MBR_FLAGS);
    213 extern void         mbr_set_flag(mbr_part_t *, MBR_FLAGS, bool);
    214 extern uint32_t     mbr_get_next_aligned(uint32_t, unsigned int);
     201extern MBR_ERR_VAL      mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * partition);
     202extern int                      mbr_remove_partition(mbr_partitions_t * parts, size_t idx);
     203extern int                      mbr_get_flag(mbr_part_t * p, MBR_FLAGS flag);
     204extern void                     mbr_set_flag(mbr_part_t * p, MBR_FLAGS flag, bool value);
     205extern uint32_t         mbr_get_next_aligned(uint32_t addr, unsigned int alignment);
    215206
    216207#define mbr_part_foreach(parts, iterator)       \
    217         for (iterator  = list_get_instance((parts)->list.head.next, mbr_part_t, link); \
    218              iterator != list_get_instance(&((parts)->list.head), mbr_part_t, link); \
    219              iterator  = list_get_instance(iterator->link.next, mbr_part_t, link))
    220 
    221 
    222 /* free() wrapper functions. */
    223 extern void mbr_free_label(mbr_label_t *);
    224 extern void mbr_free_mbr(mbr_t *);
    225 extern void mbr_free_partition(mbr_part_t *);
    226 extern void mbr_free_partitions(mbr_partitions_t *);
     208                        for (iterator  = list_get_instance((parts)->list.head.next, mbr_part_t, link); \
     209                                 iterator != list_get_instance(&((parts)->list.head), mbr_part_t, link); \
     210                                 iterator  = list_get_instance(iterator->link.next, mbr_part_t, link))
     211
     212
     213/** free() wrapper functions. */
     214extern void mbr_free_mbr(mbr_t * mbr);
     215extern void mbr_free_partition(mbr_part_t * p);
     216extern void mbr_free_partitions(mbr_partitions_t * parts);
    227217
    228218#endif
Note: See TracChangeset for help on using the changeset viewer.