Home | History | Annotate | Line # | Download | only in sysinst
disklabel.c revision 1.18
      1  1.18  martin /*	$NetBSD: disklabel.c,v 1.18 2019/12/09 19:16:53 martin Exp $	*/
      2   1.1  martin 
      3   1.1  martin /*
      4   1.1  martin  * Copyright 2018 The NetBSD Foundation, Inc.
      5   1.1  martin  * All rights reserved.
      6   1.1  martin  *
      7   1.1  martin  * Redistribution and use in source and binary forms, with or without
      8   1.1  martin  * modification, are permitted provided that the following conditions
      9   1.1  martin  * are met:
     10   1.1  martin  * 1. Redistributions of source code must retain the above copyright
     11   1.1  martin  *    notice, this list of conditions and the following disclaimer.
     12   1.1  martin  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.1  martin  *    notice, this list of conditions and the following disclaimer in the
     14   1.1  martin  *    documentation and/or other materials provided with the distribution.
     15   1.1  martin  *
     16   1.1  martin  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
     17   1.1  martin  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18   1.1  martin  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19   1.1  martin  * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
     20   1.1  martin  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21   1.1  martin  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22   1.1  martin  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23   1.1  martin  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24   1.1  martin  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25   1.1  martin  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     26   1.1  martin  * THE POSSIBILITY OF SUCH DAMAGE.
     27   1.1  martin  *
     28   1.1  martin  */
     29   1.1  martin 
     30   1.1  martin #include "defs.h"
     31   1.1  martin #include "md.h"
     32   1.1  martin #include <assert.h>
     33   1.1  martin #include <util.h>
     34   1.1  martin #include <paths.h>
     35   1.1  martin #include <sys/ioctl.h>
     36   1.1  martin #include <sys/param.h>
     37   1.1  martin 
     38   1.1  martin const struct disk_partitioning_scheme disklabel_parts;
     39   1.1  martin 
     40   1.1  martin /*************** disklabel ******************************************/
     41   1.1  martin /* a disklabel based disk_partitions interface */
     42   1.1  martin struct disklabel_disk_partitions {
     43   1.1  martin 	struct disk_partitions dp;
     44   1.1  martin 	struct disklabel l;
     45   1.1  martin 	daddr_t ptn_alignment;
     46   1.1  martin 	char last_mounted[MAXPARTITIONS][MOUNTLEN];
     47   1.1  martin 	uint fs_sub_type[MAXPARTITIONS];
     48   1.1  martin };
     49   1.1  martin 
     50   1.1  martin /*
     51   1.1  martin  * Maximum number of disklabel partitions the current kernel supports
     52   1.1  martin  */
     53   1.1  martin size_t dl_maxpart;
     54   1.1  martin 
     55   1.1  martin /* index into this arrray is the type code */
     56   1.1  martin static struct part_type_desc dl_types[__arraycount(fstypenames)-1];
     57   1.1  martin 
     58   1.1  martin struct dl_custom_ptype {
     59   1.1  martin 	unsigned int type;
     60   1.1  martin 	char short_desc[6], description[30];
     61   1.1  martin 	struct part_type_desc desc;
     62   1.1  martin };
     63   1.1  martin struct dl_custom_ptype * dl_custom_ptypes;
     64   1.1  martin size_t dl_custom_ptype_count;
     65   1.1  martin 
     66   1.1  martin static uint8_t dl_part_type_from_generic(const struct part_type_desc*);
     67   1.1  martin 
     68   1.1  martin static void
     69   1.1  martin disklabel_init_default_alignment(struct disklabel_disk_partitions *parts,
     70   1.1  martin     uint track)
     71   1.1  martin {
     72   1.1  martin 	if (track == 0)
     73   1.1  martin 		track = MEG / 512;
     74   1.1  martin 
     75   1.1  martin 	if (dl_maxpart == 0)
     76   1.1  martin 		dl_maxpart = getmaxpartitions();
     77   1.1  martin 
     78   1.4  martin #ifdef MD_DISKLABEL_SET_ALIGN_PRE
     79   1.4  martin 	if (MD_DISKLABEL_SET_ALIGN_PRE(parts->ptn_alignment, track))
     80   1.4  martin 		return;
     81   1.4  martin #endif
     82   1.1  martin 	/* Use 1MB alignemnt for large (>128GB) disks */
     83   1.1  martin 	if (parts->dp.disk_size > HUGE_DISK_SIZE) {
     84   1.1  martin 		parts->ptn_alignment = 2048;
     85   1.1  martin 	} else if (parts->dp.disk_size > TINY_DISK_SIZE) {
     86   1.1  martin 		parts->ptn_alignment = 64;
     87   1.1  martin 	} else {
     88   1.1  martin 		parts->ptn_alignment = 1;
     89   1.1  martin 	}
     90   1.4  martin #ifdef MD_DISKLABEL_SET_ALIGN_POST
     91   1.4  martin 	MD_DISKLABEL_SET_ALIGN_POST(parts->ptn_alignment, track);
     92   1.1  martin #endif
     93   1.1  martin }
     94   1.1  martin 
     95   1.1  martin static bool
     96   1.1  martin disklabel_change_geom(struct disk_partitions *arg, int ncyl, int nhead,
     97   1.1  martin     int nsec)
     98   1.1  martin {
     99   1.1  martin 	struct disklabel_disk_partitions *parts =
    100   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    101   1.1  martin 
    102   1.9  martin 	assert(parts->l.d_secsize != 0);
    103   1.9  martin 	assert(parts->l.d_nsectors != 0);
    104   1.9  martin 	assert(parts->l.d_ntracks != 0);
    105   1.9  martin 	assert(parts->l.d_ncylinders != 0);
    106   1.9  martin 	assert(parts->l.d_secpercyl != 0);
    107   1.9  martin 
    108   1.1  martin 	disklabel_init_default_alignment(parts, nhead * nsec);
    109   1.1  martin 	if (ncyl*nhead*nsec <= TINY_DISK_SIZE)
    110   1.1  martin 		set_default_sizemult(1);
    111   1.1  martin 	else
    112   1.1  martin 		set_default_sizemult(MEG/512);
    113   1.9  martin 
    114   1.1  martin 	return true;
    115   1.1  martin }
    116   1.1  martin 
    117   1.1  martin static struct disk_partitions *
    118   1.1  martin disklabel_parts_new(const char *dev, daddr_t start, daddr_t len,
    119   1.1  martin     daddr_t total_size, bool is_boot_drive)
    120   1.1  martin {
    121   1.1  martin 	struct disklabel_disk_partitions *parts;
    122   1.1  martin 	struct disk_geom geo;
    123   1.1  martin 
    124   1.1  martin 	if (!get_disk_geom(dev, &geo))
    125   1.1  martin 		return NULL;
    126   1.1  martin 
    127   1.1  martin 	parts = calloc(1, sizeof(*parts));
    128   1.1  martin 	if (parts == NULL)
    129   1.1  martin 		return NULL;
    130   1.1  martin 
    131   1.1  martin 	if (len > disklabel_parts.size_limit)
    132   1.1  martin 		len = disklabel_parts.size_limit;
    133   1.1  martin 	if (total_size > disklabel_parts.size_limit)
    134   1.1  martin 		total_size = disklabel_parts.size_limit;
    135   1.1  martin 
    136   1.1  martin 	parts->l.d_ncylinders = geo.dg_ncylinders;
    137   1.1  martin 	parts->l.d_ntracks = geo.dg_ntracks;
    138   1.1  martin 	parts->l.d_nsectors = geo.dg_nsectors;
    139   1.1  martin 	parts->l.d_secsize = geo.dg_secsize;
    140   1.1  martin 	parts->l.d_secpercyl = geo.dg_nsectors * geo.dg_ntracks;
    141   1.1  martin 
    142   1.1  martin 	parts->dp.pscheme = &disklabel_parts;
    143  1.15  martin 	parts->dp.disk = strdup(dev);
    144   1.1  martin 	parts->dp.disk_start = start;
    145   1.1  martin 	parts->dp.disk_size = parts->dp.free_space = len;
    146   1.1  martin 	disklabel_init_default_alignment(parts, parts->l.d_secpercyl);
    147   1.1  martin 
    148   1.1  martin 	strncpy(parts->l.d_packname, "fictious", sizeof parts->l.d_packname);
    149   1.1  martin 
    150   1.1  martin #if RAW_PART > 2
    151   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_fstype = FS_UNUSED;
    152   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_offset = start;
    153   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_size = len;
    154   1.1  martin 	parts->dp.num_part++;
    155   1.1  martin #endif
    156   1.1  martin 	parts->l.d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    157   1.1  martin 	parts->l.d_partitions[RAW_PART].p_offset = 0;
    158   1.1  martin 	parts->l.d_partitions[RAW_PART].p_size = total_size;
    159   1.1  martin 	parts->dp.num_part++;
    160   1.1  martin 
    161   1.1  martin 	parts->l.d_npartitions = RAW_PART+1;
    162   1.1  martin 
    163   1.1  martin 	return &parts->dp;
    164   1.1  martin }
    165   1.1  martin 
    166   1.1  martin static struct disk_partitions *
    167  1.12  martin disklabel_parts_read(const char *disk, daddr_t start, daddr_t len,
    168  1.12  martin     const struct disk_partitioning_scheme *scheme)
    169   1.1  martin {
    170   1.1  martin 	int fd;
    171   1.1  martin 	char diskpath[MAXPATHLEN];
    172   1.1  martin 	uint flags;
    173   1.1  martin 
    174  1.18  martin #ifndef DISKLABEL_NO_ONDISK_VERIFY
    175  1.18  martin 	if (!only_have_disklabel()) {
    176  1.18  martin 		/*
    177  1.18  martin 		 * If there are alternative partitioning schemes,
    178  1.18  martin 		 * verify we really have a disklabel.
    179  1.18  martin 		 */
    180  1.18  martin 		if (run_program(RUN_SILENT | RUN_ERROR_OK,
    181  1.18  martin 		    "disklabel -r %s", disk) != 0)
    182  1.18  martin 			return NULL;
    183  1.18  martin 	}
    184  1.18  martin #endif
    185   1.1  martin 
    186   1.1  martin 	/* read partitions */
    187   1.1  martin 
    188   1.1  martin 	struct disklabel_disk_partitions *parts = calloc(1, sizeof(*parts));
    189   1.1  martin 	if (parts == NULL)
    190   1.1  martin 		return NULL;
    191   1.1  martin 
    192   1.1  martin 	fd = opendisk(disk, O_RDONLY, diskpath, sizeof(diskpath), 0);
    193   1.1  martin 	if (fd == -1) {
    194   1.1  martin 		free(parts);
    195   1.1  martin 		return NULL;
    196   1.1  martin 	}
    197   1.1  martin 
    198   1.1  martin 	/*
    199   1.1  martin 	 * We should actually try to read the label inside the start/len
    200   1.1  martin 	 * boundary, but for simplicity just rely on the kernel and
    201   1.1  martin 	 * instead verify a FS_UNUSED partition at RAW_PART-1 (if
    202   1.1  martin 	 * RAW_PART > 'c') is within the given limits.
    203   1.1  martin 	 */
    204   1.1  martin 	if (ioctl(fd, DIOCGDINFO, &parts->l) < 0) {
    205   1.1  martin 		free(parts);
    206   1.1  martin 		close(fd);
    207   1.1  martin 		return NULL;
    208   1.1  martin 	}
    209   1.1  martin #if RAW_PART > 2
    210   1.1  martin 	if (parts->l.d_partitions[RAW_PART-1].p_fstype == FS_UNUSED) {
    211   1.1  martin 		daddr_t dlstart = parts->l.d_partitions[RAW_PART-1].p_offset;
    212   1.1  martin 		daddr_t dlend = start +
    213   1.1  martin 		    parts->l.d_partitions[RAW_PART-1].p_size;
    214   1.1  martin 
    215   1.1  martin 		if (dlstart < start && dlend > (start+len)) {
    216   1.1  martin 			assert(false);
    217   1.1  martin 			free(parts);
    218   1.1  martin 			close(fd);
    219   1.1  martin 			return NULL;
    220   1.1  martin 		}
    221   1.1  martin 	}
    222   1.1  martin #endif
    223   1.1  martin 
    224   1.1  martin 	if (len > disklabel_parts.size_limit)
    225   1.1  martin 		len = disklabel_parts.size_limit;
    226  1.12  martin 	parts->dp.pscheme = scheme;
    227  1.15  martin 	parts->dp.disk = strdup(disk);
    228   1.1  martin 	parts->dp.disk_start = start;
    229   1.1  martin 	parts->dp.disk_size = parts->dp.free_space = len;
    230   1.1  martin 	disklabel_init_default_alignment(parts, 0);
    231   1.1  martin 
    232   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    233   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    234   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    235   1.1  martin 			continue;
    236   1.1  martin 
    237   1.1  martin 		parts->dp.num_part++;
    238   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED)
    239   1.1  martin 			continue;
    240   1.1  martin 
    241   1.1  martin 		flags = 0;
    242   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_MSDOS)
    243   1.1  martin 			flags = GLM_MAYBE_FAT32;
    244   1.1  martin 		else if (parts->l.d_partitions[part].p_fstype == FS_BSDFFS)
    245   1.1  martin 			flags = GLM_LIKELY_FFS;
    246   1.1  martin 		if (flags != 0) {
    247   1.1  martin 			uint fs_type, fs_sub_type;
    248   1.1  martin 			const char *lm = get_last_mounted(fd,
    249   1.1  martin 			    parts->l.d_partitions[part].p_offset,
    250   1.1  martin 			    &fs_type, &fs_sub_type, flags);
    251   1.1  martin 			if (lm != NULL && *lm != 0) {
    252   1.1  martin 				strlcpy(parts->last_mounted[part], lm,
    253   1.1  martin 				    sizeof(parts->last_mounted[part]));
    254   1.1  martin 				if (parts->l.d_partitions[part].p_fstype ==
    255   1.1  martin 				    fs_type)
    256   1.1  martin 					parts->fs_sub_type[part] = fs_sub_type;
    257  1.10  martin 				canonicalize_last_mounted(
    258  1.10  martin 				    parts->last_mounted[part]);
    259   1.1  martin 			}
    260   1.1  martin 		}
    261   1.1  martin 
    262   1.1  martin 		if (parts->l.d_partitions[part].p_size > parts->dp.free_space)
    263   1.1  martin 			parts->dp.free_space = 0;
    264   1.1  martin 		else
    265   1.1  martin 			parts->dp.free_space -=
    266   1.1  martin 			    parts->l.d_partitions[part].p_size;
    267   1.1  martin 	}
    268   1.1  martin 	close(fd);
    269   1.1  martin 
    270   1.1  martin 	return &parts->dp;
    271   1.1  martin }
    272   1.1  martin 
    273  1.17  martin /*
    274  1.17  martin  * Escape a string for usage as a tag name in a capfile(5),
    275  1.17  martin  * we really know there is enough space in the destination buffer...
    276  1.17  martin  */
    277  1.17  martin static void
    278  1.17  martin escape_capfile(char *dest, const char *src, size_t len)
    279  1.17  martin {
    280  1.17  martin 	while (*src && len > 0) {
    281  1.17  martin 		if (*src == ':')
    282  1.17  martin 			*dest++ = ' ';
    283  1.17  martin 		else
    284  1.17  martin 			*dest++ = *src;
    285  1.17  martin 		src++;
    286  1.17  martin 		len--;
    287  1.17  martin 	}
    288  1.17  martin 	*dest = 0;
    289  1.17  martin }
    290  1.17  martin 
    291   1.1  martin static bool
    292   1.1  martin disklabel_write_to_disk(struct disk_partitions *arg)
    293   1.1  martin {
    294   1.1  martin 	struct disklabel_disk_partitions *parts =
    295   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    296   1.1  martin 	FILE *f;
    297  1.17  martin 	char fname[PATH_MAX], packname[sizeof(parts->l.d_packname)+1],
    298  1.17  martin 	    disktype[sizeof(parts->l.d_typename)+1];
    299   1.2  martin 	int i, rv = 0;
    300   1.1  martin 	const char *disk = parts->dp.disk, *s;
    301   1.1  martin 	const struct partition *lp;
    302   1.1  martin 	char *d;
    303   1.1  martin 	size_t n;
    304   1.1  martin 
    305   1.5  martin 	assert(parts->l.d_secsize != 0);
    306   1.9  martin 	assert(parts->l.d_nsectors != 0);
    307   1.9  martin 	assert(parts->l.d_ntracks != 0);
    308   1.9  martin 	assert(parts->l.d_ncylinders != 0);
    309   1.9  martin 	assert(parts->l.d_secpercyl != 0);
    310   1.5  martin 
    311   1.1  martin 	/* make sure we have a 0 terminated packname */
    312   1.1  martin 	strlcpy(packname, parts->l.d_packname, sizeof packname);
    313  1.16  martin 	if (packname[0] == 0)
    314  1.16  martin 		strcpy(packname, "fictious");
    315   1.1  martin 
    316   1.1  martin 	/* fill typename with disk name prefix, if not already set */
    317   1.1  martin 	if (strlen(parts->l.d_typename) == 0) {
    318   1.1  martin 		for (n = 0, d = parts->l.d_typename, s = disk;
    319   1.1  martin 		    *s && n < sizeof(parts->l.d_typename); d++, s++, n++) {
    320   1.1  martin 			if (isdigit((unsigned char)*s))
    321   1.1  martin 				break;
    322   1.1  martin 			*d = *s;
    323   1.1  martin 		}
    324   1.1  martin 	}
    325   1.1  martin 
    326   1.1  martin 	/* we need a valid disk type name, so enforce an arbitrary if
    327   1.1  martin 	 * above did not yield a usable one */
    328   1.1  martin 	if (strlen(parts->l.d_typename) == 0)
    329   1.1  martin 		strncpy(parts->l.d_typename, "SCSI",
    330   1.1  martin 		    sizeof(parts->l.d_typename));
    331  1.17  martin 	escape_capfile(disktype, parts->l.d_typename,
    332  1.17  martin 	    sizeof(parts->l.d_typename));
    333   1.1  martin 
    334  1.16  martin 	sprintf(fname, "/tmp/disklabel.%u", getpid());
    335  1.16  martin 	f = fopen(fname, "w");
    336  1.16  martin 	if (f == NULL)
    337  1.16  martin 		return false;
    338  1.16  martin 
    339   1.1  martin 	lp = parts->l.d_partitions;
    340   1.8  martin 	scripting_fprintf(NULL, "cat <<EOF >%s\n", fname);
    341   1.8  martin 	scripting_fprintf(f, "%s|NetBSD installation generated:\\\n",
    342  1.17  martin 	    disktype);
    343   1.8  martin 	scripting_fprintf(f, "\t:nc#%d:nt#%d:ns#%d:\\\n",
    344   1.1  martin 	    parts->l.d_ncylinders, parts->l.d_ntracks, parts->l.d_nsectors);
    345   1.8  martin 	scripting_fprintf(f, "\t:sc#%d:su#%" PRIu32 ":\\\n",
    346   1.1  martin 	    parts->l.d_secpercyl, lp[RAW_PART].p_offset+lp[RAW_PART].p_size);
    347   1.8  martin 	scripting_fprintf(f, "\t:se#%d:\\\n", parts->l.d_secsize);
    348   1.1  martin 
    349   1.1  martin 	for (i = 0; i < parts->l.d_npartitions; i++) {
    350   1.8  martin 		scripting_fprintf(f, "\t:p%c#%" PRIu32 ":o%c#%" PRIu32
    351   1.1  martin 		    ":t%c=%s:", 'a'+i, (uint32_t)lp[i].p_size,
    352   1.1  martin 		    'a'+i, (uint32_t)lp[i].p_offset, 'a'+i,
    353   1.1  martin 		    getfslabelname(lp[i].p_fstype, 0));
    354   1.1  martin 		if (lp[i].p_fstype == FS_BSDLFS ||
    355   1.1  martin 		    lp[i].p_fstype == FS_BSDFFS)
    356   1.8  martin 			scripting_fprintf (f, "b%c#%" PRIu32 ":f%c#%" PRIu32
    357   1.1  martin 			    ":", 'a'+i,
    358   1.1  martin 			    (uint32_t)(lp[i].p_fsize *
    359   1.1  martin 			    lp[i].p_frag),
    360   1.1  martin 			    'a'+i, (uint32_t)lp[i].p_fsize);
    361   1.1  martin 
    362   1.1  martin 		if (i < parts->l.d_npartitions - 1)
    363   1.8  martin 			scripting_fprintf(f, "\\\n");
    364   1.1  martin 		else
    365   1.8  martin 			scripting_fprintf(f, "\n");
    366   1.1  martin 	}
    367   1.8  martin 	scripting_fprintf(NULL, "EOF\n");
    368   1.1  martin 
    369   1.1  martin 	fclose(f);
    370   1.1  martin 
    371   1.1  martin 	/*
    372   1.1  martin 	 * Label a disk using an MD-specific string DISKLABEL_CMD for
    373   1.1  martin 	 * to invoke disklabel.
    374   1.1  martin 	 * if MD code does not define DISKLABEL_CMD, this is a no-op.
    375   1.1  martin 	 *
    376   1.1  martin 	 * i386 port uses "/sbin/disklabel -w -r", just like i386
    377   1.1  martin 	 * miniroot scripts, though this may leave a bogus incore label.
    378   1.1  martin 	 *
    379   1.1  martin 	 * Sun ports should use DISKLABEL_CMD "/sbin/disklabel -w"
    380   1.1  martin 	 * to get incore to ondisk inode translation for the Sun proms.
    381   1.1  martin 	 */
    382   1.1  martin #ifdef DISKLABEL_CMD
    383   1.1  martin 	/* disklabel the disk */
    384  1.17  martin 	rv = run_program(RUN_DISPLAY, "%s -f %s %s '%s' '%s'",
    385  1.17  martin 	    DISKLABEL_CMD, fname, disk, disktype, packname);
    386   1.1  martin #endif
    387   1.1  martin 
    388   1.1  martin 	unlink(fname);
    389   1.1  martin 
    390   1.1  martin 	return rv == 0;
    391   1.1  martin }
    392   1.1  martin 
    393   1.1  martin static bool
    394   1.1  martin disklabel_delete_all(struct disk_partitions *arg)
    395   1.1  martin {
    396   1.1  martin 	struct disklabel_disk_partitions *parts =
    397   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    398   1.1  martin 	daddr_t total_size = parts->l.d_partitions[RAW_PART].p_size;
    399   1.1  martin 
    400   1.6  martin 	memset(&parts->l.d_partitions, 0, sizeof(parts->l.d_partitions));
    401   1.1  martin 	parts->dp.num_part = 0;
    402   1.1  martin 
    403   1.1  martin #if RAW_PART > 2
    404   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_fstype = FS_UNUSED;
    405   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_offset = parts->dp.disk_start;
    406   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_size = parts->dp.disk_size;
    407   1.1  martin 	parts->dp.num_part++;
    408   1.1  martin #endif
    409   1.1  martin 	parts->l.d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    410   1.1  martin 	parts->l.d_partitions[RAW_PART].p_offset = 0;
    411   1.1  martin 	parts->l.d_partitions[RAW_PART].p_size = total_size;
    412   1.1  martin 	parts->dp.num_part++;
    413   1.1  martin 
    414   1.1  martin 	parts->l.d_npartitions = RAW_PART+1;
    415   1.1  martin 	return true;
    416   1.1  martin }
    417   1.1  martin 
    418   1.1  martin static bool
    419   1.1  martin disklabel_delete(struct disk_partitions *arg, part_id id,
    420   1.1  martin     const char **err_msg)
    421   1.1  martin {
    422   1.1  martin 	struct disklabel_disk_partitions *parts =
    423   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    424   1.1  martin 	part_id ndx;
    425   1.1  martin 
    426   1.1  martin 	ndx = 0;
    427   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    428   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    429   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    430   1.1  martin 			continue;
    431   1.1  martin 
    432   1.1  martin 		if (ndx == id) {
    433   1.1  martin 			if (part == RAW_PART
    434   1.1  martin #if RAW_PART > 2
    435   1.1  martin 				|| part == RAW_PART-1
    436   1.1  martin #endif
    437   1.1  martin 						) {
    438   1.1  martin 				if (err_msg)
    439   1.1  martin 					*err_msg = msg_string(
    440   1.1  martin 					    MSG_part_not_deletable);
    441   1.1  martin 				return false;
    442   1.1  martin 			}
    443   1.1  martin 			parts->l.d_partitions[part].p_size = 0;
    444   1.1  martin 			parts->l.d_partitions[part].p_offset = 0;
    445   1.1  martin 			parts->l.d_partitions[part].p_fstype = FS_UNUSED;
    446   1.1  martin 			parts->dp.num_part--;
    447   1.1  martin 			return true;
    448   1.1  martin 		}
    449   1.1  martin 		ndx++;
    450   1.1  martin 	}
    451   1.1  martin 
    452   1.1  martin 	if (err_msg)
    453   1.1  martin 		*err_msg = INTERNAL_ERROR;
    454   1.1  martin 	return false;
    455   1.1  martin }
    456   1.1  martin 
    457   1.1  martin static bool
    458   1.1  martin disklabel_delete_range(struct disk_partitions *arg, daddr_t r_start,
    459   1.1  martin     daddr_t r_size)
    460   1.1  martin {
    461   1.1  martin 	struct disklabel_disk_partitions *parts =
    462   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    463   1.1  martin 
    464   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    465   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    466   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    467   1.1  martin 			continue;
    468   1.1  martin 
    469   1.1  martin 		if (part == RAW_PART)
    470   1.1  martin 			continue;
    471   1.1  martin 
    472   1.1  martin 		daddr_t start = parts->l.d_partitions[part].p_offset;
    473   1.1  martin 		daddr_t end = start + parts->l.d_partitions[part].p_size;
    474   1.1  martin 
    475   1.1  martin #if RAW_PART > 2
    476   1.1  martin 		if (part == RAW_PART - 1 && start == r_start &&
    477   1.1  martin 		    r_start + r_size == end)
    478   1.1  martin 			continue;
    479   1.1  martin #endif
    480   1.1  martin 
    481   1.1  martin 		if ((start >= r_start && start <= r_start+r_size) ||
    482   1.1  martin 		    (end >= r_start && end <= r_start+r_size)) {
    483   1.1  martin 			if (parts->dp.num_part > 1)
    484   1.1  martin 				parts->dp.num_part--;
    485   1.1  martin 			parts->dp.free_space +=
    486   1.1  martin 			    parts->l.d_partitions[part].p_size;
    487   1.1  martin 			parts->l.d_partitions[part].p_fstype = FS_UNUSED;
    488   1.1  martin 			parts->l.d_partitions[part].p_size = 0;
    489   1.1  martin 		}
    490   1.1  martin 	}
    491   1.1  martin 
    492   1.1  martin 	return true;
    493   1.1  martin }
    494   1.1  martin 
    495   1.1  martin static void
    496   1.1  martin dl_init_types(void)
    497   1.1  martin {
    498   1.1  martin 	for (size_t i = 0; i < __arraycount(dl_types); i++) {
    499   1.1  martin 		if (fstypenames[i] == NULL)
    500   1.1  martin 			break;
    501   1.1  martin 		dl_types[i].short_desc =
    502   1.1  martin 		dl_types[i].description = getfslabelname(i, 0);
    503   1.1  martin 		enum part_type pt;
    504   1.1  martin 		switch (i) {
    505   1.1  martin 		case FS_UNUSED:	pt = PT_undef; break;
    506   1.1  martin 		case FS_BSDFFS:	pt = PT_root; break;
    507   1.1  martin 		case FS_SWAP:	pt = PT_swap; break;
    508   1.1  martin 		case FS_MSDOS:	pt = PT_FAT; break;
    509   1.1  martin 		default:	pt = PT_unknown; break;
    510   1.1  martin 		}
    511   1.1  martin 		dl_types[i].generic_ptype = pt;
    512   1.1  martin 	}
    513   1.1  martin }
    514   1.1  martin 
    515   1.1  martin static uint8_t
    516   1.1  martin dl_part_type_from_generic(const struct part_type_desc *gent)
    517   1.1  martin {
    518   1.1  martin 
    519   1.1  martin 	if (dl_types[0].description == NULL)
    520   1.1  martin 		dl_init_types();
    521   1.1  martin 	for (size_t i = 0; i < __arraycount(dl_types); i++)
    522   1.1  martin 		if (gent == &dl_types[i])
    523   1.1  martin 			return (uint8_t)i;
    524   1.1  martin 
    525   1.1  martin 	for (size_t i = 0; i < dl_custom_ptype_count; i++)
    526   1.1  martin 		if (gent == &dl_custom_ptypes[i].desc)
    527   1.1  martin 			return dl_custom_ptypes[i].type;
    528   1.1  martin 
    529   1.1  martin 	return 0;
    530   1.1  martin }
    531   1.1  martin 
    532   1.1  martin static size_t
    533   1.1  martin disklabel_type_count(void)
    534   1.1  martin {
    535   1.1  martin 	return __arraycount(dl_types) + dl_custom_ptype_count;
    536   1.1  martin }
    537   1.1  martin 
    538   1.1  martin static const struct part_type_desc *
    539   1.1  martin disklabel_get_type(size_t ndx)
    540   1.1  martin {
    541   1.1  martin 	if (dl_types[0].description == NULL)
    542   1.1  martin 		dl_init_types();
    543   1.1  martin 
    544   1.1  martin 	if (ndx < __arraycount(dl_types))
    545   1.1  martin 		return &dl_types[ndx];
    546   1.1  martin 
    547   1.1  martin 	ndx -= __arraycount(dl_types);
    548   1.1  martin 	if (ndx >= dl_custom_ptype_count)
    549   1.1  martin 		return NULL;
    550   1.1  martin 
    551   1.1  martin 	return &dl_custom_ptypes[ndx].desc;
    552   1.1  martin }
    553   1.1  martin 
    554   1.1  martin static const struct part_type_desc *
    555   1.1  martin disklabel_find_type(uint type, bool create_if_unknown)
    556   1.1  martin {
    557   1.1  martin 	if (dl_types[0].description == NULL)
    558   1.1  martin 		dl_init_types();
    559   1.1  martin 
    560   1.1  martin 	if (type < __arraycount(dl_types))
    561   1.1  martin 		return &dl_types[type];
    562   1.1  martin 
    563   1.1  martin 	for (size_t i = 0; i < dl_custom_ptype_count; i++)
    564   1.1  martin 		if (dl_custom_ptypes[i].type == type)
    565   1.1  martin 			return &dl_custom_ptypes[i].desc;
    566   1.1  martin 
    567   1.1  martin 	if (create_if_unknown) {
    568   1.1  martin 		struct dl_custom_ptype *nt;
    569   1.1  martin 
    570   1.1  martin 		nt = realloc(dl_custom_ptypes, dl_custom_ptype_count+1);
    571   1.1  martin 		if (nt == NULL)
    572   1.1  martin 			return NULL;
    573   1.1  martin 		dl_custom_ptypes = nt;
    574   1.1  martin 		nt = dl_custom_ptypes + dl_custom_ptype_count;
    575   1.1  martin 		dl_custom_ptype_count++;
    576   1.1  martin 		memset(nt, 0, sizeof(*nt));
    577   1.1  martin 		nt->type = type;
    578   1.1  martin 		snprintf(nt->short_desc, sizeof(nt->short_desc), "%u", type);
    579   1.1  martin 		nt->short_desc[sizeof(nt->short_desc)-1] = 0;
    580   1.1  martin 		snprintf(nt->description, sizeof(nt->description),
    581   1.1  martin 		    "%s (%u)", msg_string(MSG_custom_type), type);
    582   1.1  martin 		nt->description[sizeof(nt->description)-1] = 0;
    583   1.1  martin 		nt->desc.generic_ptype = PT_unknown;
    584   1.1  martin 		nt->desc.short_desc = nt->short_desc;
    585   1.1  martin 		nt->desc.description = nt->description;
    586   1.1  martin 		return &nt->desc;
    587   1.1  martin 	}
    588   1.1  martin 
    589   1.1  martin 	return NULL;
    590   1.1  martin }
    591   1.1  martin 
    592   1.1  martin static const struct part_type_desc *
    593   1.1  martin disklabel_create_custom_part_type(const char *custom, const char **err_msg)
    594   1.1  martin {
    595   1.1  martin 	char *endp;
    596   1.1  martin 	unsigned long fstype;
    597   1.1  martin 
    598   1.1  martin 	fstype = strtoul(custom, &endp, 10);
    599   1.1  martin 	if (*endp != 0) {
    600   1.1  martin 		if (err_msg)
    601   1.1  martin 			*err_msg = msg_string(MSG_dl_type_invalid);
    602   1.1  martin 		return NULL;
    603   1.1  martin 	}
    604   1.1  martin 
    605   1.1  martin 	return disklabel_find_type(fstype, true);
    606   1.1  martin }
    607   1.1  martin 
    608   1.1  martin static const struct part_type_desc *
    609   1.1  martin disklabel_get_fs_part_type(unsigned fstype, unsigned subtype)
    610   1.1  martin {
    611   1.1  martin 	return disklabel_find_type(fstype, false);
    612   1.1  martin }
    613   1.1  martin 
    614   1.1  martin static const struct part_type_desc *
    615  1.15  martin disklabel_create_unknown_part_type(void)
    616  1.15  martin {
    617  1.15  martin 	return disklabel_find_type(FS_OTHER, false);
    618  1.15  martin }
    619  1.15  martin 
    620  1.15  martin static const struct part_type_desc *
    621   1.1  martin disklabel_get_generic_type(enum part_type pt)
    622   1.1  martin {
    623   1.1  martin 	size_t nt;
    624   1.1  martin 
    625   1.1  martin 	if (dl_types[0].description == NULL)
    626   1.1  martin 		dl_init_types();
    627   1.1  martin 
    628   1.1  martin 	switch (pt) {
    629   1.1  martin 	case PT_root:	nt = FS_BSDFFS; break;
    630   1.1  martin 	case PT_swap:	nt = FS_SWAP; break;
    631   1.1  martin 	case PT_FAT:
    632   1.1  martin 	case PT_EFI_SYSTEM:
    633   1.1  martin 			nt = FS_MSDOS; break;
    634   1.1  martin 	default:	nt = FS_UNUSED; break;
    635   1.1  martin 	}
    636   1.1  martin 
    637   1.1  martin 	return disklabel_get_type(nt);
    638   1.1  martin }
    639   1.1  martin 
    640   1.1  martin static bool
    641   1.1  martin disklabel_get_part_info(const struct disk_partitions *arg, part_id id,
    642   1.1  martin     struct disk_part_info *info)
    643   1.1  martin {
    644   1.1  martin 	const struct disklabel_disk_partitions *parts =
    645   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    646   1.1  martin 	part_id ndx;
    647   1.1  martin 
    648   1.1  martin 	if (dl_types[0].description == NULL)
    649   1.1  martin 		dl_init_types();
    650   1.1  martin 
    651   1.1  martin 	ndx = 0;
    652   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    653   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    654   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    655   1.1  martin 			continue;
    656   1.1  martin 
    657   1.1  martin 		if (ndx == id) {
    658   1.1  martin 			memset(info, 0, sizeof(*info));
    659   1.1  martin 			info->start = parts->l.d_partitions[part].p_offset;
    660   1.1  martin 			info->size = parts->l.d_partitions[part].p_size;
    661   1.1  martin 			info->nat_type = disklabel_find_type(
    662   1.1  martin 			    parts->l.d_partitions[part].p_fstype, true);
    663   1.1  martin 			if (parts->last_mounted[part][0] != 0)
    664   1.1  martin 				info->last_mounted = parts->last_mounted[part];
    665   1.1  martin 			info->fs_type = parts->l.d_partitions[part].p_fstype;
    666   1.1  martin 			info->fs_sub_type = parts->fs_sub_type[part];
    667   1.1  martin 			if (part == RAW_PART &&
    668   1.1  martin 			    parts->l.d_partitions[part].p_fstype == FS_UNUSED)
    669   1.1  martin 				info->flags |=
    670   1.1  martin 				    PTI_PSCHEME_INTERNAL|PTI_RAW_PART;
    671   1.1  martin #if RAW_PART > 2
    672   1.1  martin 			if (part == (RAW_PART-1) &&
    673   1.1  martin 			    parts->l.d_partitions[part].p_fstype == FS_UNUSED)
    674   1.1  martin 				info->flags |=
    675   1.1  martin 				    PTI_PSCHEME_INTERNAL|PTI_WHOLE_DISK;
    676   1.1  martin #endif
    677   1.1  martin 			return true;
    678   1.1  martin 		}
    679   1.1  martin 
    680   1.1  martin 		ndx++;
    681   1.1  martin 		if (ndx > parts->dp.num_part || ndx > id)
    682   1.1  martin 			break;
    683   1.1  martin 	}
    684   1.1  martin 
    685   1.1  martin 	return false;
    686   1.1  martin }
    687   1.1  martin 
    688   1.1  martin static bool
    689   1.1  martin disklabel_set_part_info(struct disk_partitions *arg, part_id id,
    690   1.1  martin     const struct disk_part_info *info, const char **err_msg)
    691   1.1  martin {
    692   1.1  martin 	struct disklabel_disk_partitions *parts =
    693   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    694   1.1  martin 	part_id ndx;
    695   1.1  martin 
    696   1.1  martin 	if (dl_types[0].description == NULL)
    697   1.1  martin 		dl_init_types();
    698   1.1  martin 
    699   1.1  martin 	ndx = 0;
    700   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    701   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    702   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    703   1.1  martin 			continue;
    704   1.1  martin 
    705   1.1  martin 		if (ndx == id) {
    706   1.1  martin 			parts->l.d_partitions[part].p_offset = info->start;
    707   1.1  martin 			parts->l.d_partitions[part].p_size = info->size;
    708   1.1  martin 			parts->l.d_partitions[part].p_fstype =
    709   1.1  martin 			    dl_part_type_from_generic(info->nat_type);
    710   1.1  martin 			if (info->last_mounted != NULL &&
    711   1.1  martin 			    info->last_mounted != parts->last_mounted[part])
    712   1.1  martin 				strlcpy(parts->last_mounted[part],
    713   1.1  martin 				    info->last_mounted,
    714   1.1  martin 				    sizeof(parts->last_mounted[part]));
    715   1.1  martin 			assert(info->fs_type == 0 || info->fs_type ==
    716   1.1  martin 			    parts->l.d_partitions[part].p_fstype);
    717   1.1  martin 			if (info->fs_sub_type != 0)
    718   1.1  martin 				parts->fs_sub_type[part] = info->fs_sub_type;
    719   1.1  martin 			return true;
    720   1.1  martin 		}
    721   1.1  martin 
    722   1.1  martin 		ndx++;
    723   1.1  martin 		if (ndx > parts->dp.num_part || ndx > id)
    724   1.1  martin 			break;
    725   1.1  martin 	}
    726   1.1  martin 
    727   1.1  martin 	return false;
    728   1.1  martin }
    729   1.1  martin 
    730   1.1  martin static size_t
    731   1.1  martin disklabel_get_free_spaces_internal(const struct
    732   1.1  martin     disklabel_disk_partitions *parts,
    733   1.1  martin     struct disk_part_free_space *result, size_t max_num_result,
    734   1.1  martin     daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore)
    735   1.1  martin {
    736   1.1  martin 	size_t cnt = 0, i;
    737   1.1  martin 	daddr_t s, e, from, size, end_of_disk;
    738   1.1  martin 
    739   1.3  martin 	if (start < parts->dp.disk_start)
    740   1.1  martin 		start = parts->dp.disk_start;
    741   1.1  martin 	if (min_space_size < 1)
    742   1.1  martin 		min_space_size = 1;
    743   1.3  martin 	if (align > 1 && (start % align) != 0)
    744   1.1  martin 		start = max(roundup(start, align), align);
    745   1.1  martin 	end_of_disk = parts->dp.disk_start + parts->dp.disk_size;
    746   1.1  martin 	from = start;
    747   1.1  martin 	while (from < end_of_disk && cnt < max_num_result) {
    748   1.1  martin again:
    749   1.1  martin 		size = parts->dp.disk_start + parts->dp.disk_size - from;
    750   1.1  martin 		start = from;
    751   1.1  martin 		for (i = 0; i < parts->l.d_npartitions; i++) {
    752   1.1  martin 			if (i == RAW_PART)
    753   1.1  martin 				continue;
    754   1.1  martin 			if (parts->l.d_partitions[i].p_fstype == FS_UNUSED)
    755   1.1  martin 				continue;
    756  1.14  martin 			if (parts->l.d_partitions[i].p_size == 0)
    757  1.14  martin 				continue;
    758   1.1  martin 
    759   1.1  martin 			s = parts->l.d_partitions[i].p_offset;
    760   1.1  martin 			e = parts->l.d_partitions[i].p_size + s;
    761   1.1  martin 			if (s == ignore)
    762   1.1  martin 				continue;
    763   1.1  martin 			if (e < from)
    764   1.1  martin 				continue;
    765   1.1  martin 			if (s <= from && e > from) {
    766   1.1  martin 				if (e - 1 >= end_of_disk)
    767   1.1  martin 					return cnt;
    768   1.1  martin 
    769   1.1  martin 				from = e + 1;
    770   1.1  martin 				if (align > 1) {
    771   1.1  martin 					from = max(roundup(from, align), align);
    772   1.1  martin 					if (from >= end_of_disk) {
    773   1.1  martin 						size = 0;
    774   1.1  martin 						break;
    775   1.1  martin 					}
    776   1.1  martin 				}
    777   1.1  martin 				goto again;
    778   1.1  martin 			}
    779   1.1  martin 			if (s > from && s - from < size) {
    780   1.1  martin 				size = s - from;
    781   1.1  martin 			}
    782   1.1  martin 		}
    783   1.1  martin 		if (size >= min_space_size) {
    784   1.1  martin 			result->start = start;
    785   1.1  martin 			result->size = size;
    786   1.1  martin 			result++;
    787   1.1  martin 			cnt++;
    788   1.1  martin 		}
    789   1.1  martin 		from += size + 1;
    790   1.1  martin 		if (align > 1)
    791   1.1  martin 			from = max(roundup(from, align), align);
    792   1.1  martin 	}
    793   1.1  martin 
    794   1.1  martin 	return cnt;
    795   1.1  martin }
    796   1.1  martin 
    797   1.1  martin static bool
    798   1.1  martin disklabel_can_add_partition(const struct disk_partitions *arg)
    799   1.1  martin {
    800   1.1  martin 	const struct disklabel_disk_partitions *parts =
    801   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    802   1.1  martin 	struct disk_part_free_space space;
    803   1.1  martin 	int i;
    804   1.1  martin 
    805   1.1  martin 	if (dl_maxpart == 0)
    806   1.1  martin 		dl_maxpart = getmaxpartitions();
    807   1.1  martin 	if (parts->dp.free_space < parts->ptn_alignment)
    808   1.1  martin 		return false;
    809   1.1  martin 	if (parts->dp.num_part >= dl_maxpart)
    810   1.1  martin 		return false;
    811   1.1  martin 	if (disklabel_get_free_spaces_internal(parts, &space, 1,
    812   1.1  martin 	    parts->ptn_alignment, parts->ptn_alignment, 0, -1) < 1)
    813   1.1  martin 		return false;
    814   1.1  martin 
    815   1.1  martin 	for (i = 0; i < parts->l.d_npartitions; i++) {
    816   1.1  martin 		if (i == RAW_PART)
    817   1.1  martin 			continue;
    818   1.1  martin #if RAW_PART > 2
    819   1.1  martin 		if (i == RAW_PART-1)
    820   1.1  martin 			continue;
    821   1.1  martin #endif
    822   1.1  martin 		if (parts->l.d_partitions[i].p_fstype == FS_UNUSED)
    823   1.1  martin 			return true;
    824   1.1  martin 	}
    825   1.1  martin 	return false;
    826   1.1  martin }
    827   1.1  martin 
    828   1.1  martin static bool
    829   1.1  martin disklabel_get_disk_pack_name(const struct disk_partitions *arg,
    830   1.1  martin     char *buf, size_t len)
    831   1.1  martin {
    832   1.1  martin 	const struct disklabel_disk_partitions *parts =
    833   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    834   1.1  martin 
    835   1.1  martin 	strlcpy(buf, parts->l.d_packname, min(len,
    836   1.1  martin 	    sizeof(parts->l.d_packname)+1));
    837   1.1  martin 	return true;
    838   1.1  martin }
    839   1.1  martin 
    840   1.1  martin static bool
    841   1.1  martin disklabel_set_disk_pack_name(struct disk_partitions *arg, const char *pack)
    842   1.1  martin {
    843   1.1  martin 	struct disklabel_disk_partitions *parts =
    844   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    845   1.1  martin 
    846   1.1  martin 	strncpy(parts->l.d_packname, pack, sizeof(parts->l.d_packname));
    847   1.1  martin 	return true;
    848   1.1  martin }
    849   1.1  martin 
    850   1.1  martin static bool
    851   1.1  martin disklabel_get_part_device(const struct disk_partitions *arg,
    852   1.1  martin     part_id ptn, char *devname, size_t max_devname_len, int *part,
    853   1.1  martin     enum dev_name_usage which_name, bool with_path)
    854   1.1  martin {
    855  1.13  martin 	const struct disklabel_disk_partitions *parts =
    856  1.13  martin 	    (const struct disklabel_disk_partitions*)arg;
    857  1.13  martin 	part_id id;
    858  1.13  martin 	int part_index;
    859  1.13  martin 	char pname;
    860  1.13  martin 
    861  1.13  martin 	if (ptn >= parts->l.d_npartitions)
    862  1.13  martin 		return false;
    863  1.13  martin 
    864  1.14  martin 	for (id = part_index = 0; part_index < parts->l.d_npartitions;
    865  1.14  martin 	    part_index++) {
    866  1.14  martin 		if (parts->l.d_partitions[part_index].p_fstype == FS_UNUSED &&
    867  1.14  martin 		    parts->l.d_partitions[part_index].p_size == 0)
    868  1.14  martin 			continue;
    869  1.14  martin 		if (id == ptn)
    870  1.14  martin 			break;
    871  1.14  martin 		id++;
    872  1.14  martin 		if (id > ptn)
    873  1.14  martin 			return false;
    874  1.14  martin 	}
    875   1.1  martin 
    876   1.1  martin 	if (part != 0)
    877  1.13  martin 		*part = part_index;
    878  1.13  martin 
    879  1.13  martin 	pname = 'a'+ part_index;
    880   1.1  martin 
    881   1.1  martin 	switch (which_name) {
    882   1.1  martin 	case parent_device_only:
    883   1.1  martin 		strlcpy(devname, arg->disk, max_devname_len);
    884   1.1  martin 		return true;
    885   1.1  martin 	case logical_name:
    886   1.1  martin 	case plain_name:
    887   1.1  martin 		if (with_path)
    888   1.1  martin 			snprintf(devname, max_devname_len, _PATH_DEV "%s%c",
    889  1.13  martin 			    arg->disk, pname);
    890   1.1  martin 		else
    891   1.1  martin 			snprintf(devname, max_devname_len, "%s%c",
    892  1.13  martin 			    arg->disk, pname);
    893   1.1  martin 		return true;
    894   1.1  martin 	case raw_dev_name:
    895   1.1  martin 		if (with_path)
    896   1.1  martin 			snprintf(devname, max_devname_len, _PATH_DEV "r%s%c",
    897  1.13  martin 			    arg->disk, pname);
    898   1.1  martin 		else
    899   1.1  martin 			snprintf(devname, max_devname_len, "r%s%c",
    900  1.13  martin 			    arg->disk, pname);
    901   1.1  martin 		return true;
    902   1.1  martin 	}
    903   1.1  martin 
    904   1.1  martin 	return false;
    905   1.1  martin }
    906   1.1  martin 
    907   1.1  martin static part_id
    908   1.1  martin disklabel_add_partition(struct disk_partitions *arg,
    909   1.1  martin     const struct disk_part_info *info, const char **err_msg)
    910   1.1  martin {
    911   1.1  martin 	struct disklabel_disk_partitions *parts =
    912   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    913   1.1  martin 	int i, part = -1;
    914   1.1  martin 	part_id new_id;
    915   1.1  martin 	struct disk_part_free_space space;
    916   1.1  martin 	struct disk_part_info data = *info;
    917   1.1  martin 
    918   1.1  martin 	if (disklabel_get_free_spaces_internal(parts, &space, 1, 1, 1,
    919   1.1  martin 	    info->start, -1) < 1) {
    920   1.1  martin 		if (err_msg)
    921   1.1  martin 			*err_msg = msg_string(MSG_No_free_space);
    922   1.1  martin 		return NO_PART;
    923   1.1  martin 	}
    924   1.1  martin 	if (data.size > space.size)
    925   1.1  martin 		data.size = space.size;
    926   1.1  martin 	daddr_t dend = data.start+data.size;
    927   1.1  martin 	if (space.start > data.start)
    928   1.1  martin 		data.start = space.start;
    929   1.1  martin 	if (space.start + space.size < dend)
    930   1.1  martin 		data.size = space.start+space.size-data.start;
    931   1.1  martin 
    932   1.1  martin 	if (dl_maxpart == 0)
    933   1.1  martin 		dl_maxpart = getmaxpartitions();
    934   1.1  martin 
    935   1.1  martin 	for (new_id = 0, i = 0; i < parts->l.d_npartitions; i++) {
    936   1.1  martin 		if (parts->l.d_partitions[i].p_size > 0)
    937   1.1  martin 			new_id++;
    938   1.1  martin 		if (info->nat_type->generic_ptype != PT_root &&
    939   1.1  martin 		    info->nat_type->generic_ptype != PT_swap && i < RAW_PART)
    940   1.1  martin 			continue;
    941   1.1  martin 		if (i == 0 && info->nat_type->generic_ptype != PT_root)
    942   1.1  martin 			continue;
    943   1.1  martin 		if (i == 1 && info->nat_type->generic_ptype != PT_swap)
    944   1.1  martin 			continue;
    945   1.1  martin 		if (i == RAW_PART)
    946   1.1  martin 			continue;
    947   1.1  martin #if RAW_PART > 2
    948   1.1  martin 		if (i == RAW_PART-1)
    949   1.1  martin 			continue;
    950   1.1  martin #endif
    951   1.1  martin 		if (parts->l.d_partitions[i].p_size > 0)
    952   1.1  martin 			continue;
    953   1.1  martin 		part = i;
    954   1.1  martin 		break;
    955   1.1  martin 	}
    956   1.1  martin 
    957   1.1  martin 	if (part < 0) {
    958   1.1  martin 		if (parts->l.d_npartitions >= dl_maxpart) {
    959   1.1  martin 			if (err_msg)
    960   1.1  martin 				*err_msg =
    961   1.1  martin 				    msg_string(MSG_err_too_many_partitions);
    962   1.1  martin 			return NO_PART;
    963   1.1  martin 		}
    964   1.1  martin 
    965   1.1  martin 		part = parts->l.d_npartitions++;
    966   1.1  martin 	}
    967   1.1  martin 	parts->l.d_partitions[part].p_offset = data.start;
    968   1.1  martin 	parts->l.d_partitions[part].p_size = data.size;
    969   1.1  martin 	parts->l.d_partitions[part].p_fstype =
    970   1.1  martin 	     dl_part_type_from_generic(info->nat_type);
    971   1.1  martin 	if (info->last_mounted && info->last_mounted[0])
    972   1.1  martin 		strlcpy(parts->last_mounted[part], info->last_mounted,
    973   1.1  martin 		    sizeof(parts->last_mounted[part]));
    974   1.1  martin 	else
    975   1.1  martin 		parts->last_mounted[part][0] = 0;
    976   1.1  martin 	parts->fs_sub_type[part] = info->fs_sub_type;
    977   1.1  martin 	parts->dp.num_part++;
    978   1.1  martin 	if (data.size <= parts->dp.free_space)
    979   1.1  martin 		parts->dp.free_space -= data.size;
    980   1.1  martin 	else
    981   1.1  martin 		parts->dp.free_space = 0;
    982   1.1  martin 
    983   1.1  martin 	return new_id;
    984   1.1  martin }
    985   1.1  martin 
    986   1.7  martin static part_id
    987   1.7  martin disklabel_add_outer_partition(struct disk_partitions *arg,
    988   1.7  martin     const struct disk_part_info *info, const char **err_msg)
    989   1.7  martin {
    990   1.7  martin 	struct disklabel_disk_partitions *parts =
    991   1.7  martin 	    (struct disklabel_disk_partitions*)arg;
    992   1.7  martin 	int i, part = -1;
    993   1.7  martin 	part_id new_id;
    994   1.7  martin 
    995   1.7  martin 	if (dl_maxpart == 0)
    996   1.7  martin 		dl_maxpart = getmaxpartitions();
    997   1.7  martin 
    998   1.7  martin 	for (new_id = 0, i = 0; i < parts->l.d_npartitions; i++) {
    999   1.7  martin 		if (parts->l.d_partitions[i].p_size > 0)
   1000   1.7  martin 			new_id++;
   1001   1.7  martin 		if (info->nat_type->generic_ptype != PT_root &&
   1002   1.7  martin 		    info->nat_type->generic_ptype != PT_swap && i < RAW_PART)
   1003   1.7  martin 			continue;
   1004   1.7  martin 		if (i == 0 && info->nat_type->generic_ptype != PT_root)
   1005   1.7  martin 			continue;
   1006   1.7  martin 		if (i == 1 && info->nat_type->generic_ptype != PT_swap)
   1007   1.7  martin 			continue;
   1008   1.7  martin 		if (i == RAW_PART)
   1009   1.7  martin 			continue;
   1010   1.7  martin #if RAW_PART > 2
   1011   1.7  martin 		if (i == RAW_PART-1)
   1012   1.7  martin 			continue;
   1013   1.7  martin #endif
   1014   1.7  martin 		if (parts->l.d_partitions[i].p_size > 0)
   1015   1.7  martin 			continue;
   1016   1.7  martin 		part = i;
   1017   1.7  martin 		break;
   1018   1.7  martin 	}
   1019   1.7  martin 
   1020   1.7  martin 	if (part < 0) {
   1021   1.7  martin 		if (parts->l.d_npartitions >= dl_maxpart) {
   1022   1.7  martin 			if (err_msg)
   1023   1.7  martin 				*err_msg =
   1024   1.7  martin 				    msg_string(MSG_err_too_many_partitions);
   1025   1.7  martin 			return NO_PART;
   1026   1.7  martin 		}
   1027   1.7  martin 
   1028   1.7  martin 		part = parts->l.d_npartitions++;
   1029   1.7  martin 	}
   1030   1.7  martin 	parts->l.d_partitions[part].p_offset = info->start;
   1031   1.7  martin 	parts->l.d_partitions[part].p_size = info->size;
   1032   1.7  martin 	parts->l.d_partitions[part].p_fstype =
   1033   1.7  martin 	     dl_part_type_from_generic(info->nat_type);
   1034   1.7  martin 	if (info->last_mounted && info->last_mounted[0])
   1035   1.7  martin 		strlcpy(parts->last_mounted[part], info->last_mounted,
   1036   1.7  martin 		    sizeof(parts->last_mounted[part]));
   1037   1.7  martin 	else
   1038   1.7  martin 		parts->last_mounted[part][0] = 0;
   1039   1.7  martin 	parts->fs_sub_type[part] = info->fs_sub_type;
   1040   1.7  martin 	parts->dp.num_part++;
   1041   1.7  martin 
   1042   1.7  martin 	return new_id;
   1043   1.7  martin }
   1044   1.7  martin 
   1045   1.1  martin static size_t
   1046   1.1  martin disklabel_get_free_spaces(const struct disk_partitions *arg,
   1047   1.1  martin     struct disk_part_free_space *result, size_t max_num_result,
   1048   1.1  martin     daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore)
   1049   1.1  martin {
   1050   1.1  martin 	const struct disklabel_disk_partitions *parts =
   1051   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
   1052   1.1  martin 
   1053   1.1  martin 	return disklabel_get_free_spaces_internal(parts, result,
   1054   1.1  martin 	    max_num_result, min_space_size, align, start, ignore);
   1055   1.1  martin }
   1056   1.1  martin 
   1057   1.1  martin static daddr_t
   1058   1.1  martin disklabel_max_free_space_at(const struct disk_partitions *arg, daddr_t start)
   1059   1.1  martin {
   1060   1.1  martin 	const struct disklabel_disk_partitions *parts =
   1061   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
   1062   1.1  martin 	struct disk_part_free_space space;
   1063   1.1  martin 
   1064   1.1  martin 	if (disklabel_get_free_spaces_internal(parts, &space, 1, 1, 0,
   1065   1.1  martin 	    start, start) == 1)
   1066   1.1  martin 		return space.size;
   1067   1.1  martin 
   1068   1.1  martin 	return 0;
   1069   1.1  martin }
   1070   1.1  martin 
   1071   1.1  martin static daddr_t
   1072   1.1  martin disklabel_get_alignment(const struct disk_partitions *arg)
   1073   1.1  martin {
   1074   1.1  martin 	const struct disklabel_disk_partitions *parts =
   1075   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
   1076   1.1  martin 
   1077   1.1  martin 	return parts->ptn_alignment;
   1078   1.1  martin }
   1079   1.1  martin 
   1080  1.11  martin static part_id
   1081  1.11  martin disklabel_find_by_name(struct disk_partitions *arg, const char *name)
   1082  1.11  martin {
   1083  1.11  martin 	const struct disklabel_disk_partitions *parts =
   1084  1.11  martin 	    (const struct disklabel_disk_partitions*)arg;
   1085  1.11  martin 	char *sl, part;
   1086  1.11  martin 	ptrdiff_t n;
   1087  1.13  martin 	part_id pno, id, i;
   1088  1.11  martin 
   1089  1.11  martin 	sl = strrchr(name, '/');
   1090  1.11  martin 	if (sl == NULL)
   1091  1.11  martin 		return NO_PART;
   1092  1.11  martin 	n = sl - name;
   1093  1.11  martin 	if (strncmp(name, parts->l.d_packname, n) != 0)
   1094  1.11  martin 		return NO_PART;
   1095  1.11  martin 	part = name[n+1];
   1096  1.11  martin 	if (part < 'a')
   1097  1.11  martin 		return NO_PART;
   1098  1.11  martin 	pno = part - 'a';
   1099  1.11  martin 	if (pno >= parts->l.d_npartitions)
   1100  1.11  martin 		return NO_PART;
   1101  1.11  martin 	if (parts->l.d_partitions[pno].p_fstype == FS_UNUSED)
   1102  1.11  martin 		return NO_PART;
   1103  1.13  martin 	for (id = 0, i = 0; i < pno; i++)
   1104  1.13  martin 		if (parts->l.d_partitions[i].p_fstype != FS_UNUSED ||
   1105  1.13  martin 		    parts->l.d_partitions[i].p_size != 0)
   1106  1.13  martin 			id++;
   1107  1.13  martin 	return id;
   1108  1.11  martin }
   1109  1.11  martin 
   1110   1.1  martin static void
   1111   1.1  martin disklabel_free(struct disk_partitions *arg)
   1112   1.1  martin {
   1113   1.1  martin 
   1114   1.1  martin 	assert(arg != NULL);
   1115  1.15  martin 	free(__UNCONST(arg->disk));
   1116   1.1  martin 	free(arg);
   1117   1.1  martin }
   1118   1.1  martin 
   1119   1.1  martin const struct disk_partitioning_scheme
   1120   1.1  martin disklabel_parts = {
   1121   1.1  martin 	.name = MSG_parttype_disklabel,
   1122   1.1  martin 	.short_name = MSG_parttype_disklabel_short,
   1123   1.1  martin 	.new_type_prompt = MSG_dl_get_custom_fstype,
   1124   1.1  martin 	.size_limit = (daddr_t)UINT32_MAX,
   1125   1.1  martin 	.write_to_disk = disklabel_write_to_disk,
   1126   1.1  martin 	.read_from_disk = disklabel_parts_read,
   1127   1.1  martin 	.create_new_for_disk = disklabel_parts_new,
   1128   1.1  martin 	.change_disk_geom = disklabel_change_geom,
   1129  1.11  martin 	.find_by_name = disklabel_find_by_name,
   1130   1.1  martin 	.get_disk_pack_name = disklabel_get_disk_pack_name,
   1131   1.1  martin 	.set_disk_pack_name = disklabel_set_disk_pack_name,
   1132   1.1  martin 	.delete_all_partitions = disklabel_delete_all,
   1133   1.1  martin 	.delete_partitions_in_range = disklabel_delete_range,
   1134   1.1  martin 	.delete_partition = disklabel_delete,
   1135   1.1  martin 	.get_part_types_count = disklabel_type_count,
   1136   1.1  martin 	.get_part_type = disklabel_get_type,
   1137   1.1  martin 	.get_generic_part_type = disklabel_get_generic_type,
   1138   1.1  martin 	.get_fs_part_type = disklabel_get_fs_part_type,
   1139   1.1  martin 	.create_custom_part_type = disklabel_create_custom_part_type,
   1140  1.15  martin 	.create_unknown_part_type = disklabel_create_unknown_part_type,
   1141   1.1  martin 	.get_part_alignment = disklabel_get_alignment,
   1142  1.15  martin 	.adapt_foreign_part_info = generic_adapt_foreign_part_info,
   1143   1.1  martin 	.get_part_info = disklabel_get_part_info,
   1144   1.1  martin 	.can_add_partition = disklabel_can_add_partition,
   1145   1.1  martin 	.set_part_info = disklabel_set_part_info,
   1146   1.1  martin 	.add_partition = disklabel_add_partition,
   1147   1.7  martin 	.add_outer_partition = disklabel_add_outer_partition,
   1148   1.1  martin 	.max_free_space_at = disklabel_max_free_space_at,
   1149   1.1  martin 	.get_free_spaces = disklabel_get_free_spaces,
   1150   1.1  martin 	.get_part_device = disklabel_get_part_device,
   1151   1.1  martin 	.free = disklabel_free,
   1152   1.1  martin };
   1153