partitions.h revision 1.13
1 /* $NetBSD: partitions.h,v 1.13 2020/01/09 13:22:30 martin Exp $ */ 2 3 /* 4 * Copyright 2018 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS'' 17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE 20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 26 * THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 30 /* 31 * Abstract interface to access arbitrary disk partitioning schemes and 32 * keep Sysinst proper independent of the implementation / on-disk 33 * details. 34 */ 35 36 #include <sys/types.h> 37 #include <stdbool.h> 38 #include "msg_defs.h" 39 40 /* 41 * Import all the file system types, as enum fs_type. 42 */ 43 #define FSTYPE_ENUMNAME fs_type 44 #define FSTYPENAMES 45 #include <sys/disklabel.h> 46 #undef FSTYPE_ENUMNAME 47 48 #ifndef FS_TMPFS 49 #define FS_TMPFS 256 /* random value (outside uint8_t range) */ 50 #endif 51 #ifndef FS_MFS 52 #define FS_MFS 257 /* another random (out of range) value */ 53 #endif 54 55 #define MAX_LABEL_LEN 128 /* max. length of a partition label */ 56 #define MAX_SHORTCUT_LEN 8 /* max. length of a shortcut ("a:") */ 57 58 /* 59 * A partition index / handle, identifies a singlepartition within 60 * a struct disk_partitions. This is just an iterator/index - whenever 61 * changes to the set of partitions are done, partitions may get a new 62 * part_id. 63 * We assume that partitioning schemes keep partitions sorted (with 64 * key = start address, some schemes will have overlapping partitions, 65 * like MBR extended partitions). 66 */ 67 typedef size_t part_id; 68 69 /* 70 * An invalid value for a partition index / handle 71 */ 72 #define NO_PART ((part_id)~0U) 73 74 /* 75 * Intended usage for a partition 76 */ 77 enum part_type { 78 PT_undef, /* invalid value */ 79 PT_unknown, /* anything we can not map to one of these */ 80 PT_root, /* the NetBSD / partition (bootable) */ 81 PT_swap, /* the NetBSD swap partition */ 82 PT_FAT, /* boot partition (e.g. for u-boot) */ 83 PT_EFI_SYSTEM, /* (U)EFI boot partition */ 84 }; 85 86 /* 87 * A generic structure describing partition types for menu/user interface 88 * purposes. The internal details may be richer and the *pointer* value 89 * is the unique token - that is: the partitioning scheme will hand out 90 * pointers to internal data and recognize the exact partition type details 91 * by pointer comparision. 92 */ 93 struct part_type_desc { 94 enum part_type generic_ptype; /* what this maps to in generic terms */ 95 const char *short_desc; /* short type description */ 96 const char *description; /* full description */ 97 }; 98 99 /* Bits for disk_part_info.flags: */ 100 #define PTI_SEC_CONTAINER 1 /* this covers our secondary 101 partitions */ 102 #define PTI_WHOLE_DISK 2 /* all of the NetBSD disk */ 103 #define PTI_BOOT 4 /* required for booting */ 104 #define PTI_PSCHEME_INTERNAL 8 /* no user partition, e.g. 105 MBRs extend partition */ 106 #define PTI_RAW_PART 16 /* total disk */ 107 108 /* A single partition */ 109 struct disk_part_info { 110 daddr_t start, size; /* start and size on disk */ 111 uint32_t flags; /* active PTI_ flags */ 112 const struct part_type_desc *nat_type; /* native partition type */ 113 /* 114 * The following will only be available 115 * a) for a small subset of file system types 116 * b) if the partition (in this state) has already been 117 * used before 118 * It is OK to leave all these zeroed / NULL when setting 119 * partition data - or leave them at the last values a get operation 120 * returned. Backends can not rely on them to be valid. 121 */ 122 const char *last_mounted; /* last mount point or NULL */ 123 unsigned int fs_type, fs_sub_type; /* FS_* type of filesystem 124 * and for some FS a sub 125 * type (e.g. FFSv1 vs. FFSv2) 126 */ 127 }; 128 129 /* An unused area that may be used for new partitions */ 130 struct disk_part_free_space { 131 daddr_t start, size; 132 }; 133 134 /* 135 * Some partition schemes define additional data that needs to be edited. 136 * These attributes are described in this structure and referenced by 137 * their index into the fixed list of available attributes. 138 */ 139 enum custom_attr_type { pet_bool, pet_cardinal, pet_str }; 140 struct disk_part_custom_attribute { 141 msg label; /* Name, like "active partition" */ 142 enum custom_attr_type type; /* bool, long, char* */ 143 size_t strlen; /* maximum length if pet_str */ 144 }; 145 146 /* 147 * When displaying a partition editor, we have standard colums, but 148 * partitioning schemes add custom columns to the table as well. 149 * There is a fixed number of columns and they are described by this 150 * structure: 151 */ 152 struct disk_part_edit_column_desc { 153 msg title; 154 unsigned int width; 155 }; 156 157 struct disk_partitions; /* in-memory represenation of a set of partitions */ 158 159 /* 160 * When querying partition "device" names, we may ask for: 161 */ 162 enum dev_name_usage { 163 parent_device_only, /* wd0 instead of wd0i, no path */ 164 logical_name, /* NAME=my-root instead of dk7 */ 165 plain_name, /* e.g. /dev/wd0i or /dev/dk7 */ 166 raw_dev_name, /* e.g. /dev/rwd0i or /dev/rdk7 */ 167 }; 168 169 /* 170 * A scheme how to store partitions on-disk, and methods to read/write 171 * them to/from our abstract internal presentation. 172 */ 173 struct disk_partitioning_scheme { 174 /* name of the on-disk scheme, retrieved via msg_string */ 175 msg name, short_name; 176 177 /* prompt shown when creating custom partition types */ 178 msg new_type_prompt; 179 180 /* description of scheme specific partition flags */ 181 msg part_flag_desc; 182 183 /* size restrictions for this partitioning scheme */ 184 daddr_t size_limit; /* 0 if not limited */ 185 186 /* 187 * If this scheme allows sub-partitions (i.e. MBR -> disklabel), 188 * this is a pointer to the (potential/optional) secondary 189 * scheme. Depending on partitioning details it may not be 190 * used in the end. 191 * This link is only here for better help messages. 192 * See *secondary_partitions further below for actually accesing 193 * secondary partitions. 194 */ 195 const struct disk_partitioning_scheme *secondary_scheme; 196 197 /* 198 * Partition editor colum descriptions for whatever the scheme 199 * needs to display (see format_partition_table_str below). 200 */ 201 size_t edit_columns_count; 202 const struct disk_part_edit_column_desc *edit_columns; 203 204 /* 205 * Custom attributes editable by the partitioning scheme (but of 206 * no particular meaning for sysinst) 207 */ 208 size_t custom_attribute_count; 209 const struct disk_part_custom_attribute *custom_attributes; 210 211 /* 212 * Partition types supported by this scheme, 213 * first function gets the number, second queries single elements 214 */ 215 size_t (*get_part_types_count)(void); 216 const struct part_type_desc * (*get_part_type)(size_t ndx); 217 /* 218 * Get the prefered native representation for a generic partition type 219 */ 220 const struct part_type_desc * (*get_generic_part_type)(enum part_type); 221 /* 222 * Get the prefered native partition type for a specific file system 223 * type (FS_*) and subtype (fs specific value) 224 */ 225 const struct part_type_desc * (*get_fs_part_type)( 226 enum part_type, unsigned, unsigned); 227 /* 228 * Optional: inverse to above: given a part_type_desc, set default 229 * fstype and subtype. 230 */ 231 bool (*get_default_fstype)(const struct part_type_desc *, 232 unsigned *fstype, unsigned *fs_sub_type); 233 /* 234 * Create a custom partition type. If the type already exists 235 * (or there is a collision), the old existing type will be 236 * returned and no new type created. This is not considered 237 * an error (to keep the user interface simple). 238 * On failure NULL is returned and (if passed != NULL) 239 * *err_msg is set to a message describing the error. 240 */ 241 const struct part_type_desc * (*create_custom_part_type) 242 (const char *custom, const char **err_msg); 243 /* 244 * Return a usable internal partition type representation 245 * for types that are not otherwise mappable. 246 * This could be FS_OTHER for disklabel, or a randomly 247 * created type guid for GPT. This type may or may not be 248 * in the regular type list. If not, it needs to behave like a 249 * custom type. 250 */ 251 const struct part_type_desc * (*create_unknown_part_type)(void); 252 253 /* 254 * Global attributes 255 */ 256 /* 257 * Get partition alignment suggestion. The schemen may enforce 258 * additional/different alignment for some partitions. 259 */ 260 daddr_t (*get_part_alignment)(const struct disk_partitions*); 261 262 /* 263 * Methods to manipulate the in-memory abstract representation 264 */ 265 266 /* Retrieve data about a single partition, identified by the part_id. 267 * Fill the disk_part_info structure 268 */ 269 bool (*get_part_info)(const struct disk_partitions*, part_id, 270 struct disk_part_info*); 271 272 /* Optional: fill a atribute string describing the given partition */ 273 bool (*get_part_attr_str)(const struct disk_partitions*, part_id, 274 char *str, size_t avail_space); 275 /* Format a partition editor element for the "col" column in 276 * edit_columns. Used e.g. with MBR to set "active" flags. 277 */ 278 bool (*format_partition_table_str)(const struct disk_partitions*, 279 part_id, size_t col, char *outstr, size_t outspace); 280 281 /* is the type of this partition changable? */ 282 bool (*part_type_can_change)(const struct disk_partitions*, 283 part_id); 284 285 /* can we add further partitions? */ 286 bool (*can_add_partition)(const struct disk_partitions*); 287 288 /* is the custom attribut changable? */ 289 bool (*custom_attribute_writable)(const struct disk_partitions*, 290 part_id, size_t attr_no); 291 /* 292 * Output formatting for custom attributes. 293 * If "info" is != NULL, use (where it makes sense) 294 * values from that structure, as if a call to set_part_info 295 * would have been done before this call. 296 */ 297 bool (*format_custom_attribute)(const struct disk_partitions*, 298 part_id, size_t attr_no, const struct disk_part_info *info, 299 char *out, size_t out_space); 300 /* value setter functions for custom attributes */ 301 /* pet_bool: */ 302 bool (*custom_attribute_toggle)(struct disk_partitions*, 303 part_id, size_t attr_no); 304 /* pet_cardinal: */ 305 bool (*custom_attribute_set_card)(struct disk_partitions*, 306 part_id, size_t attr_no, long new_val); 307 /* pet_str or pet_cardinal: */ 308 bool (*custom_attribute_set_str)(struct disk_partitions*, 309 part_id, size_t attr_no, const char *new_val); 310 311 /* 312 * Optional: additional user information when showing the size 313 * editor (especially for existing unknown partitions) 314 */ 315 const char * (*other_partition_identifier)(const struct 316 disk_partitions*, part_id); 317 318 319 /* Retrieve device and partition names, e.g. for checking 320 * against kern.root_device or invoking newfs. 321 * For disklabel partitions, "part" will be set to the partition 322 * index (a = 0, b = 1, ...), for others it will get set to -1. 323 * If dev_name_usage is parent_device_only, the device name will 324 * not include a partition letter - obviously this only makes a 325 * difference with disklabel partitions. 326 * If dev_name_usage is logical_name instead of a device name 327 * a given name may be returned in NAME= syntax. 328 * If with_path is true (and the returned value is a device 329 * node), include the /dev/ prefix in the result string 330 * (this is ignored when returning NAME= syntax for /etc/fstab). 331 * If life is true, the device must be made available under 332 * that name (only makes a difference for NAME=syntax if 333 * no wedge has been created yet,) - implied for all variants 334 * where dev_name_usage != logical_name. 335 */ 336 bool (*get_part_device)(const struct disk_partitions*, 337 part_id, char *devname, size_t max_devname_len, int *part, 338 enum dev_name_usage, bool with_path, bool life); 339 340 /* 341 * How big could we resize the given position (start of existing 342 * partition or free space) 343 */ 344 daddr_t (*max_free_space_at)(const struct disk_partitions*, daddr_t); 345 346 /* 347 * Provide a list of free spaces usable for further partitioning, 348 * assuming the given partition alignment. 349 * If start is > 0 no space with lower sector numbers will 350 * be found. 351 * If ignore is > 0, any partition starting at that sector will 352 * be considered "free", this is used e.g. when moving an existing 353 * partition around. 354 */ 355 size_t (*get_free_spaces)(const struct disk_partitions*, 356 struct disk_part_free_space *result, size_t max_num_result, 357 daddr_t min_space_size, daddr_t align, daddr_t start, 358 daddr_t ignore /* -1 */); 359 360 /* 361 * Translate a partition description from a foreign partitioning 362 * scheme as close as possible to what we can handle in add_partition. 363 * This mostly adjusts flags and partition type pointers (using 364 * more lose matching than add_partition would do). 365 */ 366 bool (*adapt_foreign_part_info)( 367 const struct disk_partitions *myself, struct disk_part_info *dest, 368 const struct disk_partitioning_scheme *src_scheme, 369 const struct disk_part_info *src); 370 371 /* 372 * Update data for an existing partition 373 */ 374 bool (*set_part_info)(struct disk_partitions*, part_id, 375 const struct disk_part_info*, const char **err_msg); 376 377 /* Add a new partition and return its part_id. */ 378 part_id (*add_partition)(struct disk_partitions*, 379 const struct disk_part_info*, const char **err_msg); 380 381 /* 382 * Optional: add a partition from an outer scheme, accept all 383 * details w/o verification as best as possible. 384 */ 385 part_id (*add_outer_partition)(struct disk_partitions*, 386 const struct disk_part_info*, const char **err_msg); 387 388 /* Delete all partitions */ 389 bool (*delete_all_partitions)(struct disk_partitions*); 390 391 /* Optional: delete any partitions inside the given range */ 392 bool (*delete_partitions_in_range)(struct disk_partitions*, 393 daddr_t start, daddr_t size); 394 395 /* Delete the specified partition */ 396 bool (*delete_partition)(struct disk_partitions*, part_id, 397 const char **err_msg); 398 399 /* 400 * Methods for the whole set of partitions 401 */ 402 /* 403 * If this scheme only creates a singly NetBSD partition, which 404 * then is sub-partitioned (usually by disklabel), this returns a 405 * pointer to the secondary partition set. 406 * Otherwise NULL is returned, e.g. when there is no 407 * NetBSD partition defined (so this might change over time). 408 * Schemes that NEVER use a secondary scheme set this 409 * function pointer to NULL. 410 * 411 * If force_empty = true, ignore all on-disk contents and just 412 * create a new disk_partitons structure for the secondary scheme 413 * (this is used after deleting all partitions and setting up 414 * things for "use whole disk"). 415 * 416 * The returned pointer is always owned by the primary partitions, 417 * caller MUST never free it, but otherwise can manipulate it 418 * arbitrarily. 419 */ 420 struct disk_partitions * 421 (*secondary_partitions)(struct disk_partitions *, daddr_t start, 422 bool force_empty); 423 424 /* 425 * Write the whole set (in new_state) back to disk. 426 */ 427 bool (*write_to_disk)(struct disk_partitions *new_state); 428 429 /* 430 * Try to read partitions from a disk, return NULL if this is not 431 * the partitioning scheme in use on that device. 432 * Usually start and len are 0 (and ignored). 433 * If this is about a part of a disk (like only the NetBSD 434 * MBR partition, start and len are the valid part of the 435 * disk. 436 */ 437 struct disk_partitions * (*read_from_disk)(const char *, 438 daddr_t start, daddr_t len, const struct 439 disk_partitioning_scheme *); 440 441 /* 442 * Set up all internal data for a new disk 443 */ 444 struct disk_partitions * (*create_new_for_disk)(const char *, 445 daddr_t start, daddr_t len, daddr_t disk_total_size, 446 bool is_boot_drive, struct disk_partitions *parent); 447 448 /* 449 * Optional: this scheme may be used to boot from the given disk 450 */ 451 bool (*have_boot_support)(const char *disk); 452 453 /* 454 * Optional: try to guess disk geometry from the partition information 455 */ 456 int (*guess_disk_geom)(struct disk_partitions *, 457 int *cyl, int *head, int *sec); 458 459 /* 460 * Optional: change used geometry info and update internal state 461 */ 462 bool (*change_disk_geom)(struct disk_partitions *, 463 int cyl, int head, int sec); 464 465 /* 466 * Optional: 467 * Get or set a name for the whole disk (most partitioning 468 * schemes do not provide this). Used for disklabel "pack names", 469 * which then may be used for aut-discovery of wedges, so it 470 * makes sense for the user to edit them. 471 */ 472 bool (*get_disk_pack_name)(const struct disk_partitions *, 473 char *, size_t); 474 bool (*set_disk_pack_name)(struct disk_partitions *, const char *); 475 476 /* 477 * Optional: 478 * Find a partition by name (as used in /etc/fstab NAME= entries) 479 */ 480 part_id (*find_by_name)(struct disk_partitions *, const char *name); 481 482 /* 483 * Optional: 484 * Try to guess install target partition from internal data, 485 * returns true if a safe match was found and sets start/size 486 * to the target partition. 487 */ 488 bool (*guess_install_target)(const struct disk_partitions *, 489 daddr_t *start, daddr_t *size); 490 491 /* 492 * Optional: verify that the whole set of partitions would be bootable, 493 * fix up any issues (with user interaction) where needed. 494 * If "quiet" is true, fix up everything silently if possible 495 * and never return 1. 496 * Returns: 497 * 0: abort install 498 * 1: re-edit partitions 499 * 2: use anyway (continue) 500 */ 501 int (*post_edit_verify)(struct disk_partitions *, bool quiet); 502 503 /* 504 * Optional: called during updates, before mounting the target disk(s), 505 * before md_pre_update() is called. Can be used to fixup 506 * partition info for historic errors (e.g. i386 changing MBR 507 * partition type from 165 to 169), similar to post_edit_verify. 508 * Returns: 509 * true if the partition info has changed (write back required) 510 * false if nothing further needs to be done. 511 */ 512 bool (*pre_update_verify)(struct disk_partitions *); 513 514 /* Free all the data */ 515 void (*free)(struct disk_partitions*); 516 517 /* Scheme global cleanup */ 518 void (*cleanup)(void); 519 }; 520 521 /* 522 * The in-memory representation of all partitions on a concrete disk, 523 * tied to the partitioning scheme in use. 524 * 525 * Concrete schemes will derive from the abstract disk_partitions 526 * structure (by aggregation), but consumers of the API will only 527 * ever see this public part. 528 */ 529 struct disk_partitions { 530 /* which partitioning scheme is in use */ 531 const struct disk_partitioning_scheme *pscheme; 532 533 /* the disk device this came from (or should go to) */ 534 const char *disk; 535 536 /* global/public disk data */ 537 538 /* 539 * Valid partitions may have IDs in the range 0 .. num_part (excl.) 540 */ 541 part_id num_part; 542 543 /* 544 * If this is a sub-partitioning, the start of the "disk" is 545 * some arbitrary partition in the parent. Sometimes we need 546 * to be able to calculate absoluted offsets. 547 */ 548 daddr_t disk_start; 549 /* 550 * Total size of the disk (usable for partitioning) 551 */ 552 daddr_t disk_size; 553 554 /* 555 * Space not yet allocated 556 */ 557 daddr_t free_space; 558 559 /* 560 * If this is the secondary partitioning scheme, pointer to 561 * the outer one. Otherwise NULL. 562 */ 563 struct disk_partitions *parent; 564 }; 565 566 /* 567 * A list of partitioning schemes, so we can iterate over everything 568 * supported (e.g. when partitioning a new disk). NULL terminated. 569 */ 570 extern const struct disk_partitioning_scheme **available_part_schemes; 571 extern size_t num_available_part_schemes; 572 573 /* 574 * Generic reader - query a disk device and read all partitions from it 575 */ 576 struct disk_partitions * 577 partitions_read_disk(const char *, daddr_t disk_size, bool no_mbr); 578 579 /* 580 * Generic part info adaption, may be overriden by individual partitionin 581 * schemes 582 */ 583 bool generic_adapt_foreign_part_info( 584 const struct disk_partitions *myself, struct disk_part_info *dest, 585 const struct disk_partitioning_scheme *src_scheme, 586 const struct disk_part_info *src); 587 588 /* 589 * One time initialization and clenaup 590 */ 591 void partitions_init(void); 592 void partitions_cleanup(void); 593 594
Indexes created Thu Sep 25 16:09:42 GMT 2025