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