fdisk_create_disklabel ()

int
fdisk_create_disklabel (struct fdisk_context *cxt,
                        const char *name);

Creates a new disk label of type name . If name is NULL, then it will create a default system label type, either SUN or DOS. The function automaticaly switches the current label driver to name . The function fdisk_get_label() returns the current label driver.

The function modifies in-memory data only.

fdisk_list_disklabel ()

int
fdisk_list_disklabel (struct fdisk_context *cxt);

Lists details about disklabel, but no partitions.

This function uses libfdisk ASK interface to print data. The details about partitions table are printed by FDISK_ASKTYPE_INFO.

fdisk_locate_disklabel ()

int
fdisk_locate_disklabel (struct fdisk_context *cxt,
                        int n,
                        const char **name,
                        uint64_t *offset,
                        size_t *size);

Locate disklabel and returns info about n item of the label. For example GPT is composed from two items, PMBR and GPT, n=0 return offset to PMBR and n=1 return offset to GPT. For more details see 'D' expert fdisk command.

fdisk_reorder_partitions ()

int
fdisk_reorder_partitions (struct fdisk_context *cxt);

Sort partitions according to the partition start sector.

fdisk_set_disklabel_id ()

int
fdisk_set_disklabel_id (struct fdisk_context *cxt);

fdisk_set_partition_type ()

int
fdisk_set_partition_type (struct fdisk_context *cxt,
                          size_t partnum,
                          struct fdisk_parttype *t);

fdisk_toggle_partition_flag ()

int
fdisk_toggle_partition_flag (struct fdisk_context *cxt,
                             size_t partnum,
                             unsigned long  flag);

fdisk_verify_disklabel ()

int
fdisk_verify_disklabel (struct fdisk_context *cxt);

Verifies the partition table.

fdisk_write_disklabel ()

int
fdisk_write_disklabel (struct fdisk_context *cxt);

Write in-memory changes to disk. Be careful!

fdisk_get_disklabel_id ()

int
fdisk_get_disklabel_id (struct fdisk_context *cxt,
                        char **id);

fdisk_get_label ()

struct fdisk_label *
fdisk_get_label (struct fdisk_context *cxt,
                 const char *name);

If no name specified then returns the current context label.

The label is allocated and maintained within the context cxt. There is nothing like reference counting for labels, you cannot delallocate the label.

fdisk_get_nlabels ()

size_t
fdisk_get_nlabels (struct fdisk_context *cxt);

fdisk_next_label ()

int
fdisk_next_label (struct fdisk_context *cxt,
                  struct fdisk_label **lb);

1
2
3
4
5
6
7

// print all supported labels
struct fdisk_context *cxt = fdisk_new_context();
struct fdisk_label *lb = NULL;

while (fdisk_next_label(cxt, &lb) == 0)
    print("label name: %s\n", fdisk_label_get_name(lb));
fdisk_unref_context(cxt);

fdisk_get_npartitions ()

size_t
fdisk_get_npartitions (struct fdisk_context *cxt);

The maximal number of the partitions depends on disklabel and does not have to describe the real limit of PT.

For example the limit for MBR without extend partition is 4, with extended partition it's unlimited (so the function returns the current number of all partitions in this case).

And for example for GPT it depends on space allocated on disk for array of entry records (usually 128).

It's fine to use fdisk_get_npartitions() in loops, but don't forget that partition may be unused (see fdisk_is_partition_used()).

1
2
3
4
5
6
7
8

struct fdisk_partition *pa = NULL;
size_t i, nmax = fdisk_get_npartitions(cxt);

for (i = 0; i < nmax; i++) {
    if (!fdisk_is_partition_used(cxt, i))
        continue;
    ... do something ...
}

Note that the recommended way to list partitions is to use fdisk_get_partitions() and struct fdisk_table than ask disk driver for each individual partitions.

fdisk_field_get_id ()

int
fdisk_field_get_id (const struct fdisk_field *field);

fdisk_field_get_name ()

const char *
fdisk_field_get_name (const struct fdisk_field *field);

fdisk_field_get_width ()

double
fdisk_field_get_width (const struct fdisk_field *field);

fdisk_field_is_number ()

int
fdisk_field_is_number (const struct fdisk_field *field);

fdisk_is_label()

#define fdisk_is_label(c, x) fdisk_is_labeltype(c, FDISK_DISKLABEL_ ## x)

fdisk_label_get_field ()

const struct fdisk_field *
fdisk_label_get_field (const struct fdisk_label *lb,
                       int id);

The field struct describes data stored in struct fdisk_partition. The info about data is usable for example to generate human readable output (e.g. fdisk 'p'rint command). See fdisk_partition_to_string() and fdisk code.

fdisk_label_get_field_by_name ()

const struct fdisk_field *
fdisk_label_get_field_by_name (const struct fdisk_label *lb,
                               const char *name);

fdisk_label_get_fields_ids ()

int
fdisk_label_get_fields_ids (const struct fdisk_label *lb,
                            struct fdisk_context *cxt,
                            int **ids,
                            size_t *nids);

This function returns the default fields for the label.

Note that the set of the default fields depends on fdisk_enable_details() function. If the details are enabled then this function usually returns more fields.

fdisk_label_get_name ()

const char *
fdisk_label_get_name (const struct fdisk_label *lb);

fdisk_label_get_nparttypes ()

size_t
fdisk_label_get_nparttypes (const struct fdisk_label *lb);

fdisk_label_get_parttype ()

struct fdisk_parttype *
fdisk_label_get_parttype (const struct fdisk_label *lb,
                          size_t n);

fdisk_label_get_parttype_from_code ()

struct fdisk_parttype *
fdisk_label_get_parttype_from_code (const struct fdisk_label *lb,
                                    unsigned int code);

Search for partition type in label-specific table. The result is pointer to static array of label types.

fdisk_label_get_parttype_from_string ()

struct fdisk_parttype *
fdisk_label_get_parttype_from_string (const struct fdisk_label *lb,
                                      const char *str);

Search for partition type in label-specific table. The result is pointer to static array of label types.

fdisk_label_get_type ()

int
fdisk_label_get_type (const struct fdisk_label *lb);

fdisk_label_has_code_parttypes ()

int
fdisk_label_has_code_parttypes (const struct fdisk_label *lb);

fdisk_label_is_changed ()

int
fdisk_label_is_changed (const struct fdisk_label *lb);

fdisk_label_is_disabled ()

int
fdisk_label_is_disabled (const struct fdisk_label *lb);

fdisk_label_parse_parttype ()

struct fdisk_parttype *
fdisk_label_parse_parttype (const struct fdisk_label *lb,
                            const char *str);

Parses partition type from str according to the label. Thefunction returns a pointer to static table of the partition types, or newly allocated partition type for unknown types (see fdisk_parttype_is_unknown(). It's safe to call fdisk_unref_parttype() for all results.

fdisk_label_require_geometry ()

int
fdisk_label_require_geometry (const struct fdisk_label *lb);

fdisk_label_set_changed ()

void
fdisk_label_set_changed (struct fdisk_label *lb,
                         int changed);

Marks in-memory data as changed, to force fdisk_write_disklabel() to write to device. This should be unnecessar by default, the library keeps track about changes.

fdisk_label_set_disabled ()

void
fdisk_label_set_disabled (struct fdisk_label *lb,
                          int disabled);

Mark label as disabled, then libfdisk is going to ignore the label when probe device for labels.

struct fdisk_field

struct fdisk_field;

Output field description.

struct fdisk_label

struct fdisk_label;

Disk label specific driver and setting.