libfdisk/src/libfdisk.h.in

   1 /*
   2  * libfdisk.h - libfdisk API
   3  *
   4  * Copyright (C) 2012-2014 Karel Zak <kzak@redhat.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <https://gnu.org/licenses/>.
  18  */
  19
  20 #ifndef _LIBFDISK_H
  21 #define _LIBFDISK_H
  22
  23 #ifdef __cplusplus
  24 extern "C" {
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdarg.h>
  29 #include <stdint.h>
  30 #include <sys/types.h>
  31
  32 /**
  33  * LIBFDISK_VERSION:
  34  *
  35  * Library version string
  36  */
  37 #define LIBFDISK_VERSION   "@LIBFDISK_VERSION@"
  38
  39 #define LIBFDISK_MAJOR_VERSION   @LIBFDISK_MAJOR_VERSION@
  40 #define LIBFDISK_MINOR_VERSION   @LIBFDISK_MINOR_VERSION@
  41 #define LIBFDISK_PATCH_VERSION   @LIBFDISK_PATCH_VERSION@
  42
  43 /**
  44  * fdisk_context:
  45  *
  46  * Basic library handler.
  47  */
  48 struct fdisk_context;
  49
  50 /**
  51  * fdisk_label:
  52  *
  53  * Disk label specific driver and setting.
  54  */
  55 struct fdisk_label;
  56
  57 /**
  58  * fdisk_parttype:
  59  *
  60  * Partition type.
  61  */
  62 struct fdisk_parttype;
  63
  64 /**
  65  * fdisk_partition:
  66  *
  67  * Partition abstraction (and template).
  68  */
  69 struct fdisk_partition;
  70
  71 /**
  72  * fdisk_ask:
  73  *
  74  * Ask API handler for dialogs with users.
  75  */
  76 struct fdisk_ask;
  77
  78 /**
  79  * fdisk_iter:
  80  *
  81  * Unified iterator.
  82  */
  83 struct fdisk_iter;
  84
  85 /**
  86  * fdisk_table:
  87  *
  88  * Container for fdisk_partition objects
  89  */
  90 struct fdisk_table;
  91
  92 /**
  93  * fdisk_field
  94  *
  95  * Output field description.
  96  */
  97 struct fdisk_field;
  98
  99 /**
 100  * fdisk_script
 101  *
 102  * library handler for sfdisk compatible scripts and dumps
 103  */
 104 struct fdisk_script;
 105
 106 /**
 107  * fdisk_sector_t
 108  *
 109  * LBA addresses type
 110  */
 111 typedef uint64_t fdisk_sector_t;
 112
 113 /**
 114  * fdisk_labeltype:
 115  * @FDISK_DISKLABEL_DOS: MBR label type
 116  * @FDISK_DISKLABEL_SUN: SUN label type
 117  * @FDISK_DISKLABEL_SGI: SGI label type
 118  * @FDISK_DISKLABEL_BSD: BSD label type
 119  * @FDISK_DISKLABEL_GPT: UEFI GPT type
 120  *
 121  * Supported partition table types (labels)
 122  */
 123 enum fdisk_labeltype {
 124         FDISK_DISKLABEL_DOS = (1 << 1),         /* MBR label type */
 125         FDISK_DISKLABEL_SUN = (1 << 2),         /* SUN label type */
 126         FDISK_DISKLABEL_SGI = (1 << 3),         /* SGI label type */
 127         FDISK_DISKLABEL_BSD = (1 << 4),         /* BSD label t ype */
 128         FDISK_DISKLABEL_GPT = (1 << 5)          /* UEFI GPT type */
 129 };
 130
 131 /**
 132  * fdisk_labelitem:
 133  *
 134  * library handler for label specific information. See
 135  * generic FDISK_LABELITEM_* and label specific {GPT,MBR,..}_LABELITEM_*.
 136  */
 137 struct fdisk_labelitem;
 138
 139 /**
 140  * fdisk_asktype:
 141  * @FDISK_ASKTYPE_NONE: undefined type
 142  * @FDISK_ASKTYPE_NUMBER: ask for number
 143  * @FDISK_ASKTYPE_OFFSET:  ask for offset
 144  * @FDISK_ASKTYPE_WARN:  print warning message and errno
 145  * @FDISK_ASKTYPE_WARNX: print warning message
 146  * @FDISK_ASKTYPE_INFO: print info message
 147  * @FDISK_ASKTYPE_YESNO: ask Yes/No question
 148  * @FDISK_ASKTYPE_STRING: ask for string
 149  * @FDISK_ASKTYPE_MENU: ask for menu item
 150  *
 151  * Ask API dialog types
 152  */
 153 enum fdisk_asktype {
 154         FDISK_ASKTYPE_NONE = 0,
 155         FDISK_ASKTYPE_NUMBER,
 156         FDISK_ASKTYPE_OFFSET,
 157         FDISK_ASKTYPE_WARN,
 158         FDISK_ASKTYPE_WARNX,
 159         FDISK_ASKTYPE_INFO,
 160         FDISK_ASKTYPE_YESNO,
 161         FDISK_ASKTYPE_STRING,
 162         FDISK_ASKTYPE_MENU
 163 };
 164
 165 /* init.c */
 166 extern void fdisk_init_debug(int mask);
 167
 168 /* version.c */
 169 extern int fdisk_parse_version_string(const char *ver_string);
 170 extern int fdisk_get_library_version(const char **ver_string);
 171 extern int fdisk_get_library_features(const char ***features);
 172
 173 /* context.h */
 174
 175 #define FDISK_PLURAL    0
 176 #define FDISK_SINGULAR  1
 177
 178 struct fdisk_context *fdisk_new_context(void);
 179 struct fdisk_context *fdisk_new_nested_context(struct fdisk_context *parent, const char *name);
 180 void fdisk_unref_context(struct fdisk_context *cxt);
 181 void fdisk_ref_context(struct fdisk_context *cxt);
 182
 183 struct fdisk_context *fdisk_get_parent(struct fdisk_context *cxt);
 184 size_t fdisk_get_npartitions(struct fdisk_context *cxt);
 185
 186 struct fdisk_label *fdisk_get_label(struct fdisk_context *cxt, const char *name);
 187 int fdisk_next_label(struct fdisk_context *cxt, struct fdisk_label **lb);
 188 size_t fdisk_get_nlabels(struct fdisk_context *cxt);
 189
 190 int fdisk_has_label(struct fdisk_context *cxt);
 191 int fdisk_is_labeltype(struct fdisk_context *cxt, enum fdisk_labeltype id);
 192 #define fdisk_is_label(c, x) fdisk_is_labeltype(c, FDISK_DISKLABEL_ ## x)
 193
 194
 195 int fdisk_assign_device(struct fdisk_context *cxt,
 196                         const char *fname, int readonly);
 197 int fdisk_assign_device_by_fd(struct fdisk_context *cxt, int fd,
 198                         const char *fname, int readonly);
 199 int fdisk_deassign_device(struct fdisk_context *cxt, int nosync);
 200 int fdisk_reassign_device(struct fdisk_context *cxt);
 201
 202 int fdisk_is_readonly(struct fdisk_context *cxt);
 203 int fdisk_is_regfile(struct fdisk_context *cxt);
 204 int fdisk_device_is_used(struct fdisk_context *cxt);
 205
 206 int fdisk_disable_dialogs(struct fdisk_context *cxt, int disable);
 207 int fdisk_has_dialogs(struct fdisk_context *cxt);
 208
 209 int fdisk_enable_details(struct fdisk_context *cxt, int enable);
 210 int fdisk_is_details(struct fdisk_context *cxt);
 211
 212 int fdisk_enable_listonly(struct fdisk_context *cxt, int enable);
 213 int fdisk_is_listonly(struct fdisk_context *cxt);
 214
 215 int fdisk_enable_wipe(struct fdisk_context *cxt, int enable);
 216 int fdisk_has_wipe(struct fdisk_context *cxt);
 217 const char *fdisk_get_collision(struct fdisk_context *cxt);
 218 int fdisk_is_ptcollision(struct fdisk_context *cxt);
 219
 220 int fdisk_set_unit(struct fdisk_context *cxt, const char *str);
 221 const char *fdisk_get_unit(struct fdisk_context *cxt, int n);
 222 int fdisk_use_cylinders(struct fdisk_context *cxt);
 223 unsigned int fdisk_get_units_per_sector(struct fdisk_context *cxt);
 224
 225 unsigned long fdisk_get_optimal_iosize(struct fdisk_context *cxt);
 226 unsigned long fdisk_get_minimal_iosize(struct fdisk_context *cxt);
 227 unsigned long fdisk_get_physector_size(struct fdisk_context *cxt);
 228 unsigned long fdisk_get_sector_size(struct fdisk_context *cxt);
 229 unsigned long fdisk_get_alignment_offset(struct fdisk_context *cxt);
 230 unsigned long fdisk_get_grain_size(struct fdisk_context *cxt);
 231 fdisk_sector_t fdisk_get_first_lba(struct fdisk_context *cxt);
 232 fdisk_sector_t fdisk_set_first_lba(struct fdisk_context *cxt, fdisk_sector_t lba);
 233 fdisk_sector_t fdisk_get_last_lba(struct fdisk_context *cxt);
 234 fdisk_sector_t fdisk_set_last_lba(struct fdisk_context *cxt, fdisk_sector_t lba);
 235 fdisk_sector_t fdisk_get_nsectors(struct fdisk_context *cxt);
 236
 237 const char *fdisk_get_devname(struct fdisk_context *cxt);
 238 int fdisk_get_devfd(struct fdisk_context *cxt);
 239 dev_t fdisk_get_devno(struct fdisk_context *cxt);
 240 const char *fdisk_get_devmodel(struct fdisk_context *cxt);
 241
 242
 243 unsigned int fdisk_get_geom_heads(struct fdisk_context *cxt);
 244 fdisk_sector_t fdisk_get_geom_sectors(struct fdisk_context *cxt);
 245 fdisk_sector_t fdisk_get_geom_cylinders(struct fdisk_context *cxt);
 246
 247 enum {
 248         FDISK_SIZEUNIT_HUMAN    = 0,    /* default, human readable {M,G,P,...} */
 249         FDISK_SIZEUNIT_BYTES            /* bytes */
 250 };
 251 int fdisk_set_size_unit(struct fdisk_context *cxt, int unit);
 252 int fdisk_get_size_unit(struct fdisk_context *cxt);
 253
 254 int fdisk_has_protected_bootbits(struct fdisk_context *cxt);
 255 int fdisk_enable_bootbits_protection(struct fdisk_context *cxt, int enable);
 256
 257 /* parttype.c */
 258 struct fdisk_parttype *fdisk_new_parttype(void);
 259 void fdisk_ref_parttype(struct fdisk_parttype *t);
 260 void fdisk_unref_parttype(struct fdisk_parttype *t);
 261 int fdisk_parttype_set_name(struct fdisk_parttype *t, const char *str);
 262 int fdisk_parttype_set_typestr(struct fdisk_parttype *t, const char *str);
 263 int fdisk_parttype_set_code(struct fdisk_parttype *t, int code);
 264 size_t fdisk_label_get_nparttypes(const struct fdisk_label *lb);
 265 struct fdisk_parttype *fdisk_label_get_parttype(const struct fdisk_label *lb, size_t n);
 266 int fdisk_label_get_parttype_shortcut(
 267                                 const struct fdisk_label *lb, size_t n,
 268                                 const char **typestr,
 269                                 const char **shortcut,
 270                                 const char **alias);
 271 int fdisk_label_has_code_parttypes(const struct fdisk_label *lb);
 272 int fdisk_label_has_parttypes_shortcuts(const struct fdisk_label *lb);
 273 struct fdisk_parttype *fdisk_label_get_parttype_from_code(
 274                                 const struct fdisk_label *lb,
 275                                 unsigned int code);
 276 struct fdisk_parttype *fdisk_label_get_parttype_from_string(
 277                                 const struct fdisk_label *lb,
 278                                 const char *str);
 279 struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int code,
 280                                                   const char *typestr);
 281 struct fdisk_parttype *fdisk_copy_parttype(const struct fdisk_parttype *type);
 282 struct fdisk_parttype *fdisk_label_parse_parttype(
 283                                 const struct fdisk_label *lb,
 284                                 const char *str);
 285 struct fdisk_parttype *fdisk_label_advparse_parttype(
 286                                 const struct fdisk_label *lb,
 287                                 const char *str,
 288                                 int flags);
 289
 290 /**
 291  * fdisk_parttype_parser_flags:
 292  * @FDISK_PARTTYPE_PARSE_DATA: parse hex or UUID from string
 293  * @FDISK_PARTTYPE_PARSE_DATALAST: try hex or UUID as the last possibility (don't use!)
 294  * @FDISK_PARTTYPE_PARSE_SHORTCUT: try input as type shortcut (e.g 'L' for linux partition)
 295  * @FDISK_PARTTYPE_PARSE_ALIAS: try input as type alias (e.g. 'linux' for linux partition)
 296  * @FDISK_PARTTYPE_PARSE_DEPRECATED: accept also deprecated aliases and shortcuts
 297  * @FDISK_PARTTYPE_PARSE_DEFAULT: recommended flags for new code
 298  * @FDISK_PARTTYPE_PARSE_NOUNKNOWN: ignore unknown types
 299  * @FDISK_PARTTYPE_PARSE_SEQNUM: use input as sequntial number of type (e.g. list-types fdisk dialog)
 300  * @FDISK_PARTTYPE_PARSE_NAME: parse type human readable name
 301  */
 302 enum fdisk_parttype_parser_flags {
 303         FDISK_PARTTYPE_PARSE_DATA       = (1 << 1),
 304         FDISK_PARTTYPE_PARSE_DATALAST   = (1 << 2),
 305         FDISK_PARTTYPE_PARSE_SHORTCUT   = (1 << 3),
 306         FDISK_PARTTYPE_PARSE_ALIAS      = (1 << 4),
 307         FDISK_PARTTYPE_PARSE_DEPRECATED = (1 << 5),
 308         FDISK_PARTTYPE_PARSE_NOUNKNOWN  = (1 << 6),
 309         FDISK_PARTTYPE_PARSE_SEQNUM     = (1 << 7),
 310         FDISK_PARTTYPE_PARSE_NAME       = (1 << 8),
 311
 312         FDISK_PARTTYPE_PARSE_DEFAULT = (FDISK_PARTTYPE_PARSE_DATA | \
 313                                         FDISK_PARTTYPE_PARSE_SHORTCUT | \
 314                                         FDISK_PARTTYPE_PARSE_ALIAS | \
 315                                         FDISK_PARTTYPE_PARSE_NAME | \
 316                                         FDISK_PARTTYPE_PARSE_SEQNUM )
 317 };
 318
 319 const char *fdisk_parttype_get_string(const struct fdisk_parttype *t);
 320 unsigned int fdisk_parttype_get_code(const struct fdisk_parttype *t);
 321 const char *fdisk_parttype_get_name(const struct fdisk_parttype *t);
 322 int fdisk_parttype_is_unknown(const struct fdisk_parttype *t);
 323
 324
 325 /* field.c */
 326 extern int fdisk_field_get_id(const struct fdisk_field *field);
 327 extern const char *fdisk_field_get_name(const struct fdisk_field *field);
 328 extern double fdisk_field_get_width(const struct fdisk_field *field);
 329 extern int fdisk_field_is_number(const struct fdisk_field *field);
 330
 331
 332 /* label.c */
 333
 334 /**
 335  * fdisk_fieldtype:
 336  * @FDISK_FIELD_NONE: unspecified item
 337  * @FDISK_FIELD_DEVICE: partition device name
 338  * @FDISK_FIELD_START: start offset of the partition
 339  * @FDISK_FIELD_END: end offset of the partition
 340  * @FDISK_FIELD_SECTORS: number of sectors
 341  * @FDISK_FIELD_CYLINDERS: number of cylinders (deprecated)
 342  * @FDISK_FIELD_SIZE: partition size
 343  * @FDISK_FIELD_TYPE: partition type
 344  * @FDISK_FIELD_TYPEID: partition type ID
 345  * @FDISK_FIELD_ATTR: partition attribute (GPT)
 346  * @FDISK_FIELD_BOOT: partition boot flag
 347  * @FDISK_FIELD_BSIZE: size of the boot area (BSD)
 348  * @FDISK_FIELD_CPG: BSD
 349  * @FDISK_FIELD_EADDR: End-C/H/S (MBR)
 350  * @FDISK_FIELD_FSIZE: BSD
 351  * @FDISK_FIELD_NAME: partition label/name
 352  * @FDISK_FIELD_SADDR: Start-C/H/S (MBR)
 353  * @FDISK_FIELD_UUID: partition UUID (GPT)
 354  * @FDISK_FIELD_FSUUID: Filesystem UUID
 355  * @FDISK_FIELD_FSLABEL: Filesystem LABEL
 356  * @FDISK_FIELD_FSTYPE: Filesystem type
 357  * @FDISK_NFIELDS: Don't use, counter.
 358  *
 359  * Types of fdisk_field. The fields describe a partition.
 360  */
 361 enum fdisk_fieldtype {
 362         FDISK_FIELD_NONE = 0,
 363
 364         /* generic */
 365         FDISK_FIELD_DEVICE,
 366         FDISK_FIELD_START,
 367         FDISK_FIELD_END,
 368         FDISK_FIELD_SECTORS,
 369         FDISK_FIELD_CYLINDERS,
 370         FDISK_FIELD_SIZE,
 371         FDISK_FIELD_TYPE,
 372         FDISK_FIELD_TYPEID,
 373
 374         /* label specific */
 375         FDISK_FIELD_ATTR,
 376         FDISK_FIELD_BOOT,
 377         FDISK_FIELD_BSIZE,
 378         FDISK_FIELD_CPG,
 379         FDISK_FIELD_EADDR,
 380         FDISK_FIELD_FSIZE,
 381         FDISK_FIELD_NAME,
 382         FDISK_FIELD_SADDR,
 383         FDISK_FIELD_UUID,
 384
 385         FDISK_FIELD_FSUUID,
 386         FDISK_FIELD_FSLABEL,
 387         FDISK_FIELD_FSTYPE,
 388
 389         FDISK_NFIELDS           /* must be last */
 390 };
 391
 392 int fdisk_label_get_type(const struct fdisk_label *lb);
 393 const char *fdisk_label_get_name(const struct fdisk_label *lb);
 394 int fdisk_label_require_geometry(const struct fdisk_label *lb);
 395
 396
 397 extern int fdisk_write_disklabel(struct fdisk_context *cxt);
 398 extern int fdisk_verify_disklabel(struct fdisk_context *cxt);
 399 extern int fdisk_create_disklabel(struct fdisk_context *cxt, const char *name);
 400 extern int fdisk_list_disklabel(struct fdisk_context *cxt);
 401 extern int fdisk_locate_disklabel(struct fdisk_context *cxt, int n,
 402                                   const char **name,
 403                                   uint64_t *offset,
 404                                   size_t *size);
 405
 406 extern int fdisk_label_get_geomrange_cylinders(const struct fdisk_label *lb,
 407                         fdisk_sector_t *mi, fdisk_sector_t *ma);
 408 extern int fdisk_label_get_geomrange_heads(const struct fdisk_label *lb,
 409                         unsigned int *mi, unsigned int *ma);
 410 extern int fdisk_label_get_geomrange_sectors(const struct fdisk_label *lb,
 411                         fdisk_sector_t *mi, fdisk_sector_t *ma);
 412
 413 /**
 414  * fdisk_labelitem_gen:
 415  * @FDISK_LABELITEM_ID: Unique disk identifier
 416  * @__FDISK_NLABELITEMS: Specifies reserved range for generic items (0..7)
 417  *
 418  * Generic disklabel items.
 419  */
 420 enum fdisk_labelitem_gen {
 421         FDISK_LABELITEM_ID = 0,
 422         __FDISK_NLABELITEMS = 8
 423 };
 424
 425 /* item.c */
 426 extern struct fdisk_labelitem *fdisk_new_labelitem(void);
 427 extern void fdisk_ref_labelitem(struct fdisk_labelitem *li);
 428 extern int fdisk_reset_labelitem(struct fdisk_labelitem *li);
 429 extern void fdisk_unref_labelitem(struct fdisk_labelitem *li);
 430 extern const char *fdisk_labelitem_get_name(struct fdisk_labelitem *li);
 431 extern int fdisk_labelitem_get_id(struct fdisk_labelitem *li);
 432 extern int fdisk_labelitem_get_data_u64(struct fdisk_labelitem *li, uint64_t *data);
 433 extern int fdisk_labelitem_get_data_string(struct fdisk_labelitem *li, const char **data);
 434 extern int fdisk_labelitem_is_string(struct fdisk_labelitem *li);
 435 extern int fdisk_labelitem_is_number(struct fdisk_labelitem *li);
 436
 437 extern int fdisk_get_disklabel_item(struct fdisk_context *cxt, int id, struct fdisk_labelitem *item);
 438
 439 extern int fdisk_get_disklabel_id(struct fdisk_context *cxt, char **id);
 440 extern int fdisk_set_disklabel_id(struct fdisk_context *cxt);
 441 extern int fdisk_set_disklabel_id_from_string(struct fdisk_context *cxt, const char *str);
 442
 443 extern int fdisk_get_partition(struct fdisk_context *cxt, size_t partno, struct fdisk_partition **pa);
 444 extern int fdisk_set_partition(struct fdisk_context *cxt, size_t partno, struct fdisk_partition *pa);
 445 extern int fdisk_add_partition(struct fdisk_context *cxt, struct fdisk_partition *pa, size_t *partno);
 446 extern int fdisk_delete_partition(struct fdisk_context *cxt, size_t partno);
 447 extern int fdisk_delete_all_partitions(struct fdisk_context *cxt);
 448
 449 extern int fdisk_wipe_partition(struct fdisk_context *cxt, size_t partno, int enable);
 450
 451 extern int fdisk_set_partition_type(struct fdisk_context *cxt, size_t partnum,
 452                              struct fdisk_parttype *t);
 453
 454
 455 extern int fdisk_label_get_fields_ids(
 456                         const struct fdisk_label *lb,
 457                         struct fdisk_context *cxt,
 458                         int **ids, size_t *nids);
 459
 460 extern int fdisk_label_get_fields_ids_all(
 461                         const struct fdisk_label *lb,
 462                         struct fdisk_context *cxt,
 463                         int **ids, size_t *nids);
 464
 465 extern const struct fdisk_field *fdisk_label_get_field(const struct fdisk_label *lb, int id);
 466 extern const struct fdisk_field *fdisk_label_get_field_by_name(
 467                         const struct fdisk_label *lb,
 468                         const char *name);
 469
 470 extern void fdisk_label_set_changed(struct fdisk_label *lb, int changed);
 471 extern int fdisk_label_is_changed(const struct fdisk_label *lb);
 472
 473 extern void fdisk_label_set_disabled(struct fdisk_label *lb, int disabled);
 474 extern int fdisk_label_is_disabled(const struct fdisk_label *lb);
 475
 476 extern int fdisk_is_partition_used(struct fdisk_context *cxt, size_t n);
 477
 478 extern int fdisk_toggle_partition_flag(struct fdisk_context *cxt, size_t partnum, unsigned long flag);
 479
 480 extern struct fdisk_partition *fdisk_new_partition(void);
 481 extern void fdisk_reset_partition(struct fdisk_partition *pa);
 482 extern void fdisk_ref_partition(struct fdisk_partition *pa);
 483 extern void fdisk_unref_partition(struct fdisk_partition *pa);
 484 extern int fdisk_partition_is_freespace(struct fdisk_partition *pa);
 485
 486 int fdisk_partition_set_start(struct fdisk_partition *pa, uint64_t off);
 487 int fdisk_partition_unset_start(struct fdisk_partition *pa);
 488 fdisk_sector_t fdisk_partition_get_start(struct fdisk_partition *pa);
 489 int fdisk_partition_has_start(struct fdisk_partition *pa);
 490 int fdisk_partition_cmp_start(struct fdisk_partition *a,
 491                               struct fdisk_partition *b);
 492 int fdisk_partition_start_follow_default(struct fdisk_partition *pa, int enable);
 493 int fdisk_partition_start_is_default(struct fdisk_partition *pa);
 494
 495 int fdisk_partition_set_size(struct fdisk_partition *pa, uint64_t sz);
 496 int fdisk_partition_unset_size(struct fdisk_partition *pa);
 497 fdisk_sector_t fdisk_partition_get_size(struct fdisk_partition *pa);
 498 int fdisk_partition_has_size(struct fdisk_partition *pa);
 499 int fdisk_partition_size_explicit(struct fdisk_partition *pa, int enable);
 500
 501 int fdisk_partition_has_end(struct fdisk_partition *pa);
 502 fdisk_sector_t fdisk_partition_get_end(struct fdisk_partition *pa);
 503
 504 int fdisk_partition_set_partno(struct fdisk_partition *pa, size_t num);
 505 int fdisk_partition_unset_partno(struct fdisk_partition *pa);
 506 size_t fdisk_partition_get_partno(struct fdisk_partition *pa);
 507 int fdisk_partition_has_partno(struct fdisk_partition *pa);
 508 int fdisk_partition_cmp_partno(struct fdisk_partition *a,
 509                                        struct fdisk_partition *b);
 510
 511 int fdisk_partition_partno_follow_default(struct fdisk_partition *pa, int enable);
 512
 513 extern int fdisk_partition_set_type(struct fdisk_partition *pa, struct fdisk_parttype *type);
 514 extern struct fdisk_parttype *fdisk_partition_get_type(struct fdisk_partition *pa);
 515 extern int fdisk_partition_set_name(struct fdisk_partition *pa, const char *name);
 516 extern const char *fdisk_partition_get_name(struct fdisk_partition *pa);
 517 extern int fdisk_partition_set_uuid(struct fdisk_partition *pa, const char *uuid);
 518 extern int fdisk_partition_set_attrs(struct fdisk_partition *pa, const char *attrs);
 519 extern const char *fdisk_partition_get_uuid(struct fdisk_partition *pa);
 520 extern const char *fdisk_partition_get_attrs(struct fdisk_partition *pa);
 521 extern int fdisk_partition_is_nested(struct fdisk_partition *pa);
 522 extern int fdisk_partition_is_container(struct fdisk_partition *pa);
 523 extern int fdisk_partition_get_parent(struct fdisk_partition *pa, size_t *parent);
 524 extern int fdisk_partition_is_used(struct fdisk_partition *pa);
 525 extern int fdisk_partition_is_bootable(struct fdisk_partition *pa);
 526 extern int fdisk_partition_is_wholedisk(struct fdisk_partition *pa);
 527 extern int fdisk_partition_to_string(struct fdisk_partition *pa,
 528                                      struct fdisk_context *cxt,
 529                                      int id, char **data);
 530
 531 int fdisk_partition_next_partno(struct fdisk_partition *pa,
 532                                        struct fdisk_context *cxt,
 533                                        size_t *n);
 534
 535 extern int fdisk_partition_end_follow_default(struct fdisk_partition *pa, int enable);
 536 extern int fdisk_partition_end_is_default(struct fdisk_partition *pa);
 537
 538 extern int fdisk_reorder_partitions(struct fdisk_context *cxt);
 539
 540 extern int fdisk_partition_has_wipe(struct fdisk_context *cxt, struct fdisk_partition *pa);
 541
 542 extern int fdisk_partition_get_max_size(struct fdisk_context *cxt, size_t n,
 543                                         fdisk_sector_t *maxsz);
 544
 545
 546 /* table.c */
 547 extern struct fdisk_table *fdisk_new_table(void);
 548 extern int fdisk_reset_table(struct fdisk_table *tb);
 549 extern void fdisk_ref_table(struct fdisk_table *tb);
 550 extern void fdisk_unref_table(struct fdisk_table *tb);
 551 extern size_t fdisk_table_get_nents(struct fdisk_table *tb);
 552 extern int fdisk_table_is_empty(struct fdisk_table *tb);
 553 extern int fdisk_table_add_partition(struct fdisk_table *tb, struct fdisk_partition *pa);
 554 extern int fdisk_table_remove_partition(struct fdisk_table *tb, struct fdisk_partition *pa);
 555
 556 extern int fdisk_get_partitions(struct fdisk_context *cxt, struct fdisk_table **tb);
 557 extern int fdisk_get_freespaces(struct fdisk_context *cxt, struct fdisk_table **tb);
 558
 559
 560 extern int fdisk_table_wrong_order(struct fdisk_table *tb);
 561 extern int fdisk_table_sort_partitions(struct fdisk_table *tb,
 562                         int (*cmp)(struct fdisk_partition *,
 563                                    struct fdisk_partition *));
 564
 565 extern int fdisk_table_next_partition(
 566                         struct fdisk_table *tb,
 567                         struct fdisk_iter *itr,
 568                         struct fdisk_partition **pa);
 569
 570 extern struct fdisk_partition *fdisk_table_get_partition(
 571                         struct fdisk_table *tb,
 572                         size_t n);
 573 extern struct fdisk_partition *fdisk_table_get_partition_by_partno(
 574                         struct fdisk_table *tb,
 575                         size_t partno);
 576
 577 extern int fdisk_apply_table(struct fdisk_context *cxt, struct fdisk_table *tb);
 578
 579 /* alignment.c */
 580 #define FDISK_ALIGN_UP          1
 581 #define FDISK_ALIGN_DOWN        2
 582 #define FDISK_ALIGN_NEAREST     3
 583
 584 fdisk_sector_t fdisk_align_lba(struct fdisk_context *cxt, fdisk_sector_t lba, int direction);
 585 fdisk_sector_t fdisk_align_lba_in_range(struct fdisk_context *cxt,
 586                                   fdisk_sector_t lba, fdisk_sector_t start, fdisk_sector_t stop);
 587 int fdisk_lba_is_phy_aligned(struct fdisk_context *cxt, fdisk_sector_t lba);
 588
 589 int fdisk_override_geometry(struct fdisk_context *cxt,
 590                             unsigned int cylinders,
 591                             unsigned int heads,
 592                             unsigned int sectors);
 593 int fdisk_save_user_geometry(struct fdisk_context *cxt,
 594                             unsigned int cylinders,
 595                             unsigned int heads,
 596                             unsigned int sectors);
 597 int fdisk_save_user_sector_size(struct fdisk_context *cxt,
 598                                 unsigned int phy,
 599                                 unsigned int log);
 600
 601 int fdisk_save_user_grain(struct fdisk_context *cxt, unsigned long grain);
 602
 603 int fdisk_has_user_device_properties(struct fdisk_context *cxt);
 604 int fdisk_reset_alignment(struct fdisk_context *cxt);
 605 int fdisk_reset_device_properties(struct fdisk_context *cxt);
 606 int fdisk_reread_partition_table(struct fdisk_context *cxt);
 607 int fdisk_reread_changes(struct fdisk_context *cxt, struct fdisk_table *org);
 608
 609 /* iter.c */
 610 enum {
 611
 612         FDISK_ITER_FORWARD = 0,
 613         FDISK_ITER_BACKWARD
 614 };
 615 extern struct fdisk_iter *fdisk_new_iter(int direction);
 616 extern void fdisk_free_iter(struct fdisk_iter *itr);
 617 extern void fdisk_reset_iter(struct fdisk_iter *itr, int direction);
 618 extern int fdisk_iter_get_direction(struct fdisk_iter *itr);
 619
 620
 621 /* dos.c */
 622 #define DOS_FLAG_ACTIVE 1
 623
 624 extern int fdisk_dos_fix_chs(struct fdisk_context *cxt);
 625 extern int fdisk_dos_move_begin(struct fdisk_context *cxt, size_t i);
 626 extern int fdisk_dos_enable_compatible(struct fdisk_label *lb, int enable);
 627 extern int fdisk_dos_is_compatible(struct fdisk_label *lb);
 628
 629 /* sun.h */
 630 extern int fdisk_sun_set_alt_cyl(struct fdisk_context *cxt);
 631 extern int fdisk_sun_set_xcyl(struct fdisk_context *cxt);
 632 extern int fdisk_sun_set_ilfact(struct fdisk_context *cxt);
 633 extern int fdisk_sun_set_rspeed(struct fdisk_context *cxt);
 634 extern int fdisk_sun_set_pcylcount(struct fdisk_context *cxt);
 635
 636 /**
 637  * fdisk_labelitem_sun:
 638  * @SUN_LABELITEM_LABELID: Label ID
 639  * @SUN_LABELITEM_VTOCID: Volume ID
 640  * @SUN_LABELITEM_RPM: Rpm
 641  * @SUN_LABELITEM_ACYL: Alternate cylinders
 642  * @SUN_LABELITEM_PCYL: Physical cylinders
 643  * @SUN_LABELITEM_APC: Extra sects/cyl
 644  * @SUN_LABELITEM_INTRLV: Interleave
 645  *
 646  * SUN specific label items.
 647  */
 648 enum fdisk_labelitem_sun {
 649         SUN_LABELITEM_LABELID = __FDISK_NLABELITEMS,
 650         SUN_LABELITEM_VTOCID,
 651         SUN_LABELITEM_RPM,
 652         SUN_LABELITEM_ACYL,
 653         SUN_LABELITEM_PCYL,
 654         SUN_LABELITEM_APC,
 655         SUN_LABELITEM_INTRLV
 656 };
 657
 658 /* bsd.c */
 659 extern int fdisk_bsd_edit_disklabel(struct fdisk_context *cxt);
 660 extern int fdisk_bsd_write_bootstrap(struct fdisk_context *cxt);
 661 extern int fdisk_bsd_link_partition(struct fdisk_context *cxt);
 662
 663 /**
 664  * fdisk_labelitem_bsd:
 665  * @BSD_LABELITEM_TYPE: type
 666  * @BSD_LABELITEM_DISK: disk
 667  * @BSD_LABELITEM_PACKNAME: packname
 668  * @BSD_LABELITEM_FLAGS: flags (removable, ecc, badsect)
 669  * @BSD_LABELITEM_SECSIZE: Bytes/Sector
 670  * @BSD_LABELITEM_NTRACKS: Tracks/Cylinder
 671  * @BSD_LABELITEM_SECPERCYL: Sectors/Cylinder
 672  * @BSD_LABELITEM_CYLINDERS: Cylinders
 673  * @BSD_LABELITEM_RPM: rpm
 674  * @BSD_LABELITEM_INTERLEAVE: interleave
 675  * @BSD_LABELITEM_TRACKSKEW: trackskew
 676  * @BSD_LABELITEM_CYLINDERSKEW: cylinderskew
 677  * @BSD_LABELITEM_HEADSWITCH: headswitch
 678  * @BSD_LABELITEM_TRKSEEK: track-to-track seek
 679  *
 680  * BSD specific label items.
 681  */
 682 enum fdisk_labelitem_bsd {
 683         /* specific */
 684         BSD_LABELITEM_TYPE = __FDISK_NLABELITEMS,
 685         BSD_LABELITEM_DISK,
 686         BSD_LABELITEM_PACKNAME,
 687         BSD_LABELITEM_FLAGS,
 688         BSD_LABELITEM_SECSIZE,
 689         BSD_LABELITEM_NTRACKS,
 690         BSD_LABELITEM_SECPERCYL,
 691         BSD_LABELITEM_CYLINDERS,
 692         BSD_LABELITEM_RPM,
 693         BSD_LABELITEM_INTERLEAVE,
 694         BSD_LABELITEM_TRACKSKEW,
 695         BSD_LABELITEM_CYLINDERSKEW,
 696         BSD_LABELITEM_HEADSWITCH,
 697         BSD_LABELITEM_TRKSEEK
 698 };
 699
 700 /* sgi.h */
 701 #define SGI_FLAG_BOOT   1
 702 #define SGI_FLAG_SWAP   2
 703 extern int fdisk_sgi_set_bootfile(struct fdisk_context *cxt);
 704 extern int fdisk_sgi_create_info(struct fdisk_context *cxt);
 705
 706 /**
 707  * fdisk_labelitem_sgi:
 708  * @SGI_LABELITEM_PCYLCOUNT: Physical cylinders
 709  * @SGI_LABELITEM_SPARECYL: Extra sects/cyl
 710  * @SGI_LABELITEM_ILFACT: nterleave
 711  * @SGI_LABELITEM_BOOTFILE: Bootfile
 712  *
 713  * SGI specific label items.
 714  */
 715 enum fdisk_labelitem_sgi {
 716         SGI_LABELITEM_PCYLCOUNT = __FDISK_NLABELITEMS,
 717         SGI_LABELITEM_SPARECYL,
 718         SGI_LABELITEM_ILFACT,
 719         SGI_LABELITEM_BOOTFILE
 720 };
 721
 722 /* gpt */
 723
 724 /*
 725  * GPT partition attributes
 726  */
 727
 728 /**
 729  * GPT_FLAG_REQUIRED:
 730  *
 731  * GPT attribute; marks a partition as system partition (disk
 732  * partitioning utilities must preserve the partition as is)
 733  */
 734 #define GPT_FLAG_REQUIRED       1
 735
 736 /**
 737  * GPT_FLAG_NOBLOCK:
 738  *
 739  * GPT attribute; EFI firmware should ignore the content of the
 740  * partition and not try to read from it
 741  */
 742 #define GPT_FLAG_NOBLOCK        2
 743
 744 /**
 745  * GPT_FLAG_LEGACYBOOT:
 746  *
 747  * GPT attribute; use the partition for legacy boot method
 748  */
 749 #define GPT_FLAG_LEGACYBOOT     3
 750
 751 /**
 752  * GPT_FLAG_GUIDSPECIFIC:
 753  *
 754  * GPT attribute; for bites 48-63, defined and used by the individual partition
 755  * type.
 756  *
 757  * The flag GPT_FLAG_GUIDSPECIFIC forces libfdisk to ask (by ask API)
 758  * for a bit number. If you want to toggle specific bit and avoid any
 759  * dialog, then use the bit number (in range 48..63). For example:
 760  *
 761  * // start dialog to ask for bit number
 762  * fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_GUIDSPECIFIC);
 763  *
 764  * // toggle bit 60
 765  * fdisk_toggle_partition_flag(cxt, n, 60);
 766  */
 767 #define GPT_FLAG_GUIDSPECIFIC   4
 768
 769 extern int fdisk_gpt_is_hybrid(struct fdisk_context *cxt);
 770 extern int fdisk_gpt_set_npartitions(struct fdisk_context *cxt, uint32_t nents);
 771 extern int fdisk_gpt_get_partition_attrs(struct fdisk_context *cxt, size_t partnum, uint64_t *attrs);
 772 extern int fdisk_gpt_set_partition_attrs(struct fdisk_context *cxt, size_t partnum, uint64_t attrs);
 773
 774 extern void fdisk_gpt_disable_relocation(struct fdisk_label *lb, int disable);
 775 extern void fdisk_gpt_enable_minimize(struct fdisk_label *lb, int enable);
 776
 777 /**
 778  * fdisk_labelitem_gpt:
 779  * @GPT_LABELITEM_ID: GPT disklabel UUID (!= partition UUID)
 780  * @GPT_LABELITEM_FIRSTLBA: First Usable LBA
 781  * @GPT_LABELITEM_LASTLBA: Last Usable LBA
 782  * @GPT_LABELITEM_ALTLBA: Alternative LBA (backup header LBA)
 783  * @GPT_LABELITEM_ENTRIESLBA: Partitions entries array LBA
 784  * @GPT_LABELITEM_ENTRIESALLOC: Number of allocated entries in entries array
 785  * @GPT_LABELITEM_ENTRIESLASTLBA: Last LBA where is entries array
 786  *
 787  * GPT specific label items.
 788  */
 789 enum fdisk_labelitem_gpt {
 790         /* generic */
 791         GPT_LABELITEM_ID = FDISK_LABELITEM_ID,
 792         /* specific */
 793         GPT_LABELITEM_FIRSTLBA = __FDISK_NLABELITEMS,
 794         GPT_LABELITEM_LASTLBA,
 795         GPT_LABELITEM_ALTLBA,
 796         GPT_LABELITEM_ENTRIESLBA,
 797         GPT_LABELITEM_ENTRIESALLOC,
 798         GPT_LABELITEM_ENTRIESLASTLBA
 799 };
 800
 801 /* script.c */
 802 struct fdisk_script *fdisk_new_script(struct fdisk_context *cxt);
 803 struct fdisk_script *fdisk_new_script_from_file(struct fdisk_context *cxt,
 804                                                  const char *filename);
 805 void fdisk_ref_script(struct fdisk_script *dp);
 806 void fdisk_unref_script(struct fdisk_script *dp);
 807
 808 const char *fdisk_script_get_header(struct fdisk_script *dp, const char *name);
 809 int fdisk_script_set_header(struct fdisk_script *dp, const char *name, const char *data);
 810 struct fdisk_table *fdisk_script_get_table(struct fdisk_script *dp);
 811 int fdisk_script_set_table(struct fdisk_script *dp, struct fdisk_table *tb);
 812 int fdisk_script_get_nlines(struct fdisk_script *dp);
 813 int fdisk_script_has_force_label(struct fdisk_script *dp);
 814
 815 int fdisk_script_set_userdata(struct fdisk_script *dp, void *data);
 816 void *fdisk_script_get_userdata(struct fdisk_script *dp);
 817
 818 int fdisk_script_set_fgets(struct fdisk_script *dp,
 819                            char *(*fn_fgets)(struct fdisk_script *, char *, size_t, FILE *));
 820 int fdisk_script_read_context(struct fdisk_script *dp, struct fdisk_context *cxt);
 821 int fdisk_script_enable_json(struct fdisk_script *dp, int json);
 822 int fdisk_script_write_file(struct fdisk_script *dp, FILE *f);
 823 int fdisk_script_read_file(struct fdisk_script *dp, FILE *f);
 824 int fdisk_script_read_line(struct fdisk_script *dp, FILE *f, char *buf, size_t bufsz);
 825
 826 int fdisk_set_script(struct fdisk_context *cxt, struct fdisk_script *dp);
 827 struct fdisk_script *fdisk_get_script(struct fdisk_context *cxt);
 828
 829 int fdisk_apply_script_headers(struct fdisk_context *cxt, struct fdisk_script *dp);
 830 int fdisk_apply_script(struct fdisk_context *cxt, struct fdisk_script *dp);
 831
 832
 833 /* ask.c */
 834 #define fdisk_is_ask(a, x) (fdisk_ask_get_type(a) == FDISK_ASKTYPE_ ## x)
 835
 836 int fdisk_set_ask(struct fdisk_context *cxt,
 837                 int (*ask_cb)(struct fdisk_context *, struct fdisk_ask *, void *),
 838                 void *data);
 839
 840
 841 void fdisk_ref_ask(struct fdisk_ask *ask);
 842 void fdisk_unref_ask(struct fdisk_ask *ask);
 843 const char *fdisk_ask_get_query(struct fdisk_ask *ask);
 844 int fdisk_ask_get_type(struct fdisk_ask *ask);
 845 const char *fdisk_ask_number_get_range(struct fdisk_ask *ask);
 846 uint64_t fdisk_ask_number_get_default(struct fdisk_ask *ask);
 847 uint64_t fdisk_ask_number_get_low(struct fdisk_ask *ask);
 848 uint64_t fdisk_ask_number_get_high(struct fdisk_ask *ask);
 849 uint64_t fdisk_ask_number_get_result(struct fdisk_ask *ask);
 850 int fdisk_ask_number_set_result(struct fdisk_ask *ask, uint64_t result);
 851 uint64_t fdisk_ask_number_get_base(struct fdisk_ask *ask);
 852 uint64_t fdisk_ask_number_get_unit(struct fdisk_ask *ask);
 853 int fdisk_ask_number_set_relative(struct fdisk_ask *ask, int relative);
 854 int fdisk_ask_number_is_wrap_negative(struct fdisk_ask *ask);
 855 int fdisk_ask_number_inchars(struct fdisk_ask *ask);
 856 int fdisk_ask_partnum(struct fdisk_context *cxt, size_t *partnum, int wantnew);
 857
 858 int fdisk_ask_number(struct fdisk_context *cxt,
 859                      uintmax_t low,
 860                      uintmax_t dflt,
 861                      uintmax_t high,
 862                      const char *query,
 863                      uintmax_t *result);
 864 char *fdisk_ask_string_get_result(struct fdisk_ask *ask);
 865 int fdisk_ask_string_set_result(struct fdisk_ask *ask, char *result);
 866 int fdisk_ask_string(struct fdisk_context *cxt,
 867                      const char *query,
 868                      char **result);
 869 int fdisk_ask_yesno(struct fdisk_context *cxt,
 870                      const char *query,
 871                      int *result);
 872 int fdisk_ask_yesno_get_result(struct fdisk_ask *ask);
 873 int fdisk_ask_yesno_set_result(struct fdisk_ask *ask, int result);
 874
 875 int fdisk_ask_menu(struct fdisk_context *cxt, char *query, int *result, int dflt, ...);
 876
 877 int fdisk_ask_menu_get_default(struct fdisk_ask *ask);
 878 int fdisk_ask_menu_set_result(struct fdisk_ask *ask, int key);
 879 int fdisk_ask_menu_get_result(struct fdisk_ask *ask, int *key);
 880 int fdisk_ask_menu_get_item(struct fdisk_ask *ask, size_t idx, int *key,
 881                             const char **name, const char **desc);
 882 size_t fdisk_ask_menu_get_nitems(struct fdisk_ask *ask);
 883 int fdisk_ask_print_get_errno(struct fdisk_ask *ask);
 884 const char *fdisk_ask_print_get_mesg(struct fdisk_ask *ask);
 885
 886 int fdisk_info(struct fdisk_context *cxt, const char *fmt, ...)
 887                         __attribute__ ((__format__ (__printf__, 2, 3)));
 888 int fdisk_warn(struct fdisk_context *cxt, const char *fmt, ...)
 889                         __attribute__ ((__format__ (__printf__, 2, 3)));
 890 int fdisk_warnx(struct fdisk_context *cxt, const char *fmt, ...)
 891                         __attribute__ ((__format__ (__printf__, 2, 3)));
 892
 893 /* utils.h */
 894 extern char *fdisk_partname(const char *dev, size_t partno);
 895
 896 #ifdef __cplusplus
 897 }
 898 #endif
 899
 900 #endif /* _LIBFDISK_H */