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