Home | History | Annotate | Line # | Download | only in sysinst
disklabel.c revision 1.10
      1  1.10  martin /*	$NetBSD: disklabel.c,v 1.10 2019/07/26 08:18:47 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.1  martin 	parts->dp.disk = 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.1  martin disklabel_parts_read(const char *disk, daddr_t start, daddr_t len)
    168   1.1  martin {
    169   1.1  martin 	int fd;
    170   1.1  martin 	char diskpath[MAXPATHLEN];
    171   1.1  martin 	uint flags;
    172   1.1  martin 
    173   1.1  martin 	if (run_program(RUN_SILENT | RUN_ERROR_OK,
    174   1.1  martin 	    "disklabel -r %s", disk) != 0)
    175   1.1  martin 		return NULL;
    176   1.1  martin 
    177   1.1  martin 	/* read partitions */
    178   1.1  martin 
    179   1.1  martin 	struct disklabel_disk_partitions *parts = calloc(1, sizeof(*parts));
    180   1.1  martin 	if (parts == NULL)
    181   1.1  martin 		return NULL;
    182   1.1  martin 
    183   1.1  martin 	fd = opendisk(disk, O_RDONLY, diskpath, sizeof(diskpath), 0);
    184   1.1  martin 	if (fd == -1) {
    185   1.1  martin 		free(parts);
    186   1.1  martin 		return NULL;
    187   1.1  martin 	}
    188   1.1  martin 
    189   1.1  martin 	/*
    190   1.1  martin 	 * We should actually try to read the label inside the start/len
    191   1.1  martin 	 * boundary, but for simplicity just rely on the kernel and
    192   1.1  martin 	 * instead verify a FS_UNUSED partition at RAW_PART-1 (if
    193   1.1  martin 	 * RAW_PART > 'c') is within the given limits.
    194   1.1  martin 	 */
    195   1.1  martin 	if (ioctl(fd, DIOCGDINFO, &parts->l) < 0) {
    196   1.1  martin 		free(parts);
    197   1.1  martin 		close(fd);
    198   1.1  martin 		return NULL;
    199   1.1  martin 	}
    200   1.1  martin #if RAW_PART > 2
    201   1.1  martin 	if (parts->l.d_partitions[RAW_PART-1].p_fstype == FS_UNUSED) {
    202   1.1  martin 		daddr_t dlstart = parts->l.d_partitions[RAW_PART-1].p_offset;
    203   1.1  martin 		daddr_t dlend = start +
    204   1.1  martin 		    parts->l.d_partitions[RAW_PART-1].p_size;
    205   1.1  martin 
    206   1.1  martin 		if (dlstart < start && dlend > (start+len)) {
    207   1.1  martin 			assert(false);
    208   1.1  martin 			free(parts);
    209   1.1  martin 			close(fd);
    210   1.1  martin 			return NULL;
    211   1.1  martin 		}
    212   1.1  martin 	}
    213   1.1  martin #endif
    214   1.1  martin 
    215   1.1  martin 	if (len > disklabel_parts.size_limit)
    216   1.1  martin 		len = disklabel_parts.size_limit;
    217   1.1  martin 	parts->dp.pscheme = &disklabel_parts;
    218   1.1  martin 	parts->dp.disk = disk;
    219   1.1  martin 	parts->dp.disk_start = start;
    220   1.1  martin 	parts->dp.disk_size = parts->dp.free_space = len;
    221   1.1  martin 	disklabel_init_default_alignment(parts, 0);
    222   1.1  martin 
    223   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    224   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    225   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    226   1.1  martin 			continue;
    227   1.1  martin 
    228   1.1  martin 		parts->dp.num_part++;
    229   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED)
    230   1.1  martin 			continue;
    231   1.1  martin 
    232   1.1  martin 		flags = 0;
    233   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_MSDOS)
    234   1.1  martin 			flags = GLM_MAYBE_FAT32;
    235   1.1  martin 		else if (parts->l.d_partitions[part].p_fstype == FS_BSDFFS)
    236   1.1  martin 			flags = GLM_LIKELY_FFS;
    237   1.1  martin 		if (flags != 0) {
    238   1.1  martin 			uint fs_type, fs_sub_type;
    239   1.1  martin 			const char *lm = get_last_mounted(fd,
    240   1.1  martin 			    parts->l.d_partitions[part].p_offset,
    241   1.1  martin 			    &fs_type, &fs_sub_type, flags);
    242   1.1  martin 			if (lm != NULL && *lm != 0) {
    243   1.1  martin 				strlcpy(parts->last_mounted[part], lm,
    244   1.1  martin 				    sizeof(parts->last_mounted[part]));
    245   1.1  martin 				if (parts->l.d_partitions[part].p_fstype ==
    246   1.1  martin 				    fs_type)
    247   1.1  martin 					parts->fs_sub_type[part] = fs_sub_type;
    248  1.10  martin 				canonicalize_last_mounted(
    249  1.10  martin 				    parts->last_mounted[part]);
    250   1.1  martin 			}
    251   1.1  martin 		}
    252   1.1  martin 
    253   1.1  martin 		if (parts->l.d_partitions[part].p_size > parts->dp.free_space)
    254   1.1  martin 			parts->dp.free_space = 0;
    255   1.1  martin 		else
    256   1.1  martin 			parts->dp.free_space -=
    257   1.1  martin 			    parts->l.d_partitions[part].p_size;
    258   1.1  martin 	}
    259   1.1  martin 	close(fd);
    260   1.1  martin 
    261   1.1  martin 	return &parts->dp;
    262   1.1  martin }
    263   1.1  martin 
    264   1.1  martin static bool
    265   1.1  martin disklabel_write_to_disk(struct disk_partitions *arg)
    266   1.1  martin {
    267   1.1  martin 	struct disklabel_disk_partitions *parts =
    268   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    269   1.1  martin 	FILE *f;
    270   1.1  martin 	char fname[PATH_MAX], packname[sizeof(parts->l.d_packname)+1];
    271   1.2  martin 	int i, rv = 0;
    272   1.1  martin 	const char *disk = parts->dp.disk, *s;
    273   1.1  martin 	const struct partition *lp;
    274   1.1  martin 	char *d;
    275   1.1  martin 	size_t n;
    276   1.1  martin 
    277   1.5  martin 	assert(parts->l.d_secsize != 0);
    278   1.9  martin 	assert(parts->l.d_nsectors != 0);
    279   1.9  martin 	assert(parts->l.d_ntracks != 0);
    280   1.9  martin 	assert(parts->l.d_ncylinders != 0);
    281   1.9  martin 	assert(parts->l.d_secpercyl != 0);
    282   1.5  martin 
    283   1.1  martin 	sprintf(fname, "/tmp/disklabel.%u", getpid());
    284   1.1  martin 	f = fopen(fname, "w");
    285   1.1  martin 	if (f == NULL)
    286   1.1  martin 		return false;
    287   1.1  martin 
    288   1.1  martin 	/* make sure we have a 0 terminated packname */
    289   1.1  martin 	strlcpy(packname, parts->l.d_packname, sizeof packname);
    290   1.1  martin 
    291   1.1  martin 	/* fill typename with disk name prefix, if not already set */
    292   1.1  martin 	if (strlen(parts->l.d_typename) == 0) {
    293   1.1  martin 		for (n = 0, d = parts->l.d_typename, s = disk;
    294   1.1  martin 		    *s && n < sizeof(parts->l.d_typename); d++, s++, n++) {
    295   1.1  martin 			if (isdigit((unsigned char)*s))
    296   1.1  martin 				break;
    297   1.1  martin 			*d = *s;
    298   1.1  martin 		}
    299   1.1  martin 	}
    300   1.1  martin 	parts->l.d_typename[sizeof(parts->l.d_typename)-1] = 0;
    301   1.1  martin 
    302   1.1  martin 	/* we need a valid disk type name, so enforce an arbitrary if
    303   1.1  martin 	 * above did not yield a usable one */
    304   1.1  martin 	if (strlen(parts->l.d_typename) == 0)
    305   1.1  martin 		strncpy(parts->l.d_typename, "SCSI",
    306   1.1  martin 		    sizeof(parts->l.d_typename));
    307   1.1  martin 
    308   1.1  martin 	lp = parts->l.d_partitions;
    309   1.8  martin 	scripting_fprintf(NULL, "cat <<EOF >%s\n", fname);
    310   1.8  martin 	scripting_fprintf(f, "%s|NetBSD installation generated:\\\n",
    311   1.1  martin 	    parts->l.d_typename);
    312   1.8  martin 	scripting_fprintf(f, "\t:nc#%d:nt#%d:ns#%d:\\\n",
    313   1.1  martin 	    parts->l.d_ncylinders, parts->l.d_ntracks, parts->l.d_nsectors);
    314   1.8  martin 	scripting_fprintf(f, "\t:sc#%d:su#%" PRIu32 ":\\\n",
    315   1.1  martin 	    parts->l.d_secpercyl, lp[RAW_PART].p_offset+lp[RAW_PART].p_size);
    316   1.8  martin 	scripting_fprintf(f, "\t:se#%d:\\\n", parts->l.d_secsize);
    317   1.1  martin 
    318   1.1  martin 	for (i = 0; i < parts->l.d_npartitions; i++) {
    319   1.8  martin 		scripting_fprintf(f, "\t:p%c#%" PRIu32 ":o%c#%" PRIu32
    320   1.1  martin 		    ":t%c=%s:", 'a'+i, (uint32_t)lp[i].p_size,
    321   1.1  martin 		    'a'+i, (uint32_t)lp[i].p_offset, 'a'+i,
    322   1.1  martin 		    getfslabelname(lp[i].p_fstype, 0));
    323   1.1  martin 		if (lp[i].p_fstype == FS_BSDLFS ||
    324   1.1  martin 		    lp[i].p_fstype == FS_BSDFFS)
    325   1.8  martin 			scripting_fprintf (f, "b%c#%" PRIu32 ":f%c#%" PRIu32
    326   1.1  martin 			    ":", 'a'+i,
    327   1.1  martin 			    (uint32_t)(lp[i].p_fsize *
    328   1.1  martin 			    lp[i].p_frag),
    329   1.1  martin 			    'a'+i, (uint32_t)lp[i].p_fsize);
    330   1.1  martin 
    331   1.1  martin 		if (i < parts->l.d_npartitions - 1)
    332   1.8  martin 			scripting_fprintf(f, "\\\n");
    333   1.1  martin 		else
    334   1.8  martin 			scripting_fprintf(f, "\n");
    335   1.1  martin 	}
    336   1.8  martin 	scripting_fprintf(NULL, "EOF\n");
    337   1.1  martin 
    338   1.1  martin 	fclose(f);
    339   1.1  martin 
    340   1.1  martin 	/*
    341   1.1  martin 	 * Label a disk using an MD-specific string DISKLABEL_CMD for
    342   1.1  martin 	 * to invoke disklabel.
    343   1.1  martin 	 * if MD code does not define DISKLABEL_CMD, this is a no-op.
    344   1.1  martin 	 *
    345   1.1  martin 	 * i386 port uses "/sbin/disklabel -w -r", just like i386
    346   1.1  martin 	 * miniroot scripts, though this may leave a bogus incore label.
    347   1.1  martin 	 *
    348   1.1  martin 	 * Sun ports should use DISKLABEL_CMD "/sbin/disklabel -w"
    349   1.1  martin 	 * to get incore to ondisk inode translation for the Sun proms.
    350   1.1  martin 	 */
    351   1.1  martin #ifdef DISKLABEL_CMD
    352   1.1  martin 	/* disklabel the disk */
    353   1.1  martin 	rv = run_program(RUN_DISPLAY, "%s -f %s %s %s %s",
    354   1.1  martin 	    DISKLABEL_CMD, fname, disk, parts->l.d_typename, packname);
    355   1.1  martin #endif
    356   1.1  martin 
    357   1.1  martin 	unlink(fname);
    358   1.1  martin 
    359   1.1  martin 	return rv == 0;
    360   1.1  martin }
    361   1.1  martin 
    362   1.1  martin static bool
    363   1.1  martin disklabel_delete_all(struct disk_partitions *arg)
    364   1.1  martin {
    365   1.1  martin 	struct disklabel_disk_partitions *parts =
    366   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    367   1.1  martin 	daddr_t total_size = parts->l.d_partitions[RAW_PART].p_size;
    368   1.1  martin 
    369   1.6  martin 	memset(&parts->l.d_partitions, 0, sizeof(parts->l.d_partitions));
    370   1.1  martin 	parts->dp.num_part = 0;
    371   1.1  martin 
    372   1.1  martin #if RAW_PART > 2
    373   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_fstype = FS_UNUSED;
    374   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_offset = parts->dp.disk_start;
    375   1.1  martin 	parts->l.d_partitions[RAW_PART-1].p_size = parts->dp.disk_size;
    376   1.1  martin 	parts->dp.num_part++;
    377   1.1  martin #endif
    378   1.1  martin 	parts->l.d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    379   1.1  martin 	parts->l.d_partitions[RAW_PART].p_offset = 0;
    380   1.1  martin 	parts->l.d_partitions[RAW_PART].p_size = total_size;
    381   1.1  martin 	parts->dp.num_part++;
    382   1.1  martin 
    383   1.1  martin 	parts->l.d_npartitions = RAW_PART+1;
    384   1.1  martin 	return true;
    385   1.1  martin }
    386   1.1  martin 
    387   1.1  martin static bool
    388   1.1  martin disklabel_delete(struct disk_partitions *arg, part_id id,
    389   1.1  martin     const char **err_msg)
    390   1.1  martin {
    391   1.1  martin 	struct disklabel_disk_partitions *parts =
    392   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    393   1.1  martin 	part_id ndx;
    394   1.1  martin 
    395   1.1  martin 	ndx = 0;
    396   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    397   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    398   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    399   1.1  martin 			continue;
    400   1.1  martin 
    401   1.1  martin 		if (ndx == id) {
    402   1.1  martin 			if (part == RAW_PART
    403   1.1  martin #if RAW_PART > 2
    404   1.1  martin 				|| part == RAW_PART-1
    405   1.1  martin #endif
    406   1.1  martin 						) {
    407   1.1  martin 				if (err_msg)
    408   1.1  martin 					*err_msg = msg_string(
    409   1.1  martin 					    MSG_part_not_deletable);
    410   1.1  martin 				return false;
    411   1.1  martin 			}
    412   1.1  martin 			parts->l.d_partitions[part].p_size = 0;
    413   1.1  martin 			parts->l.d_partitions[part].p_offset = 0;
    414   1.1  martin 			parts->l.d_partitions[part].p_fstype = FS_UNUSED;
    415   1.1  martin 			parts->dp.num_part--;
    416   1.1  martin 			return true;
    417   1.1  martin 		}
    418   1.1  martin 		ndx++;
    419   1.1  martin 	}
    420   1.1  martin 
    421   1.1  martin 	if (err_msg)
    422   1.1  martin 		*err_msg = INTERNAL_ERROR;
    423   1.1  martin 	return false;
    424   1.1  martin }
    425   1.1  martin 
    426   1.1  martin static bool
    427   1.1  martin disklabel_delete_range(struct disk_partitions *arg, daddr_t r_start,
    428   1.1  martin     daddr_t r_size)
    429   1.1  martin {
    430   1.1  martin 	struct disklabel_disk_partitions *parts =
    431   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    432   1.1  martin 
    433   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    434   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    435   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    436   1.1  martin 			continue;
    437   1.1  martin 
    438   1.1  martin 		if (part == RAW_PART)
    439   1.1  martin 			continue;
    440   1.1  martin 
    441   1.1  martin 		daddr_t start = parts->l.d_partitions[part].p_offset;
    442   1.1  martin 		daddr_t end = start + parts->l.d_partitions[part].p_size;
    443   1.1  martin 
    444   1.1  martin #if RAW_PART > 2
    445   1.1  martin 		if (part == RAW_PART - 1 && start == r_start &&
    446   1.1  martin 		    r_start + r_size == end)
    447   1.1  martin 			continue;
    448   1.1  martin #endif
    449   1.1  martin 
    450   1.1  martin 		if ((start >= r_start && start <= r_start+r_size) ||
    451   1.1  martin 		    (end >= r_start && end <= r_start+r_size)) {
    452   1.1  martin 			if (parts->dp.num_part > 1)
    453   1.1  martin 				parts->dp.num_part--;
    454   1.1  martin 			parts->dp.free_space +=
    455   1.1  martin 			    parts->l.d_partitions[part].p_size;
    456   1.1  martin 			parts->l.d_partitions[part].p_fstype = FS_UNUSED;
    457   1.1  martin 			parts->l.d_partitions[part].p_size = 0;
    458   1.1  martin 		}
    459   1.1  martin 	}
    460   1.1  martin 
    461   1.1  martin 	return true;
    462   1.1  martin }
    463   1.1  martin 
    464   1.1  martin static void
    465   1.1  martin dl_init_types(void)
    466   1.1  martin {
    467   1.1  martin 	for (size_t i = 0; i < __arraycount(dl_types); i++) {
    468   1.1  martin 		if (fstypenames[i] == NULL)
    469   1.1  martin 			break;
    470   1.1  martin 		dl_types[i].short_desc =
    471   1.1  martin 		dl_types[i].description = getfslabelname(i, 0);
    472   1.1  martin 		enum part_type pt;
    473   1.1  martin 		switch (i) {
    474   1.1  martin 		case FS_UNUSED:	pt = PT_undef; break;
    475   1.1  martin 		case FS_BSDFFS:	pt = PT_root; break;
    476   1.1  martin 		case FS_SWAP:	pt = PT_swap; break;
    477   1.1  martin 		case FS_MSDOS:	pt = PT_FAT; break;
    478   1.1  martin 		default:	pt = PT_unknown; break;
    479   1.1  martin 		}
    480   1.1  martin 		dl_types[i].generic_ptype = pt;
    481   1.1  martin 	}
    482   1.1  martin }
    483   1.1  martin 
    484   1.1  martin static uint8_t
    485   1.1  martin dl_part_type_from_generic(const struct part_type_desc *gent)
    486   1.1  martin {
    487   1.1  martin 
    488   1.1  martin 	if (dl_types[0].description == NULL)
    489   1.1  martin 		dl_init_types();
    490   1.1  martin 	for (size_t i = 0; i < __arraycount(dl_types); i++)
    491   1.1  martin 		if (gent == &dl_types[i])
    492   1.1  martin 			return (uint8_t)i;
    493   1.1  martin 
    494   1.1  martin 	for (size_t i = 0; i < dl_custom_ptype_count; i++)
    495   1.1  martin 		if (gent == &dl_custom_ptypes[i].desc)
    496   1.1  martin 			return dl_custom_ptypes[i].type;
    497   1.1  martin 
    498   1.1  martin 	return 0;
    499   1.1  martin }
    500   1.1  martin 
    501   1.1  martin static size_t
    502   1.1  martin disklabel_type_count(void)
    503   1.1  martin {
    504   1.1  martin 	return __arraycount(dl_types) + dl_custom_ptype_count;
    505   1.1  martin }
    506   1.1  martin 
    507   1.1  martin static const struct part_type_desc *
    508   1.1  martin disklabel_get_type(size_t ndx)
    509   1.1  martin {
    510   1.1  martin 	if (dl_types[0].description == NULL)
    511   1.1  martin 		dl_init_types();
    512   1.1  martin 
    513   1.1  martin 	if (ndx < __arraycount(dl_types))
    514   1.1  martin 		return &dl_types[ndx];
    515   1.1  martin 
    516   1.1  martin 	ndx -= __arraycount(dl_types);
    517   1.1  martin 	if (ndx >= dl_custom_ptype_count)
    518   1.1  martin 		return NULL;
    519   1.1  martin 
    520   1.1  martin 	return &dl_custom_ptypes[ndx].desc;
    521   1.1  martin }
    522   1.1  martin 
    523   1.1  martin static const struct part_type_desc *
    524   1.1  martin disklabel_find_type(uint type, bool create_if_unknown)
    525   1.1  martin {
    526   1.1  martin 	if (dl_types[0].description == NULL)
    527   1.1  martin 		dl_init_types();
    528   1.1  martin 
    529   1.1  martin 	if (type < __arraycount(dl_types))
    530   1.1  martin 		return &dl_types[type];
    531   1.1  martin 
    532   1.1  martin 	for (size_t i = 0; i < dl_custom_ptype_count; i++)
    533   1.1  martin 		if (dl_custom_ptypes[i].type == type)
    534   1.1  martin 			return &dl_custom_ptypes[i].desc;
    535   1.1  martin 
    536   1.1  martin 	if (create_if_unknown) {
    537   1.1  martin 		struct dl_custom_ptype *nt;
    538   1.1  martin 
    539   1.1  martin 		nt = realloc(dl_custom_ptypes, dl_custom_ptype_count+1);
    540   1.1  martin 		if (nt == NULL)
    541   1.1  martin 			return NULL;
    542   1.1  martin 		dl_custom_ptypes = nt;
    543   1.1  martin 		nt = dl_custom_ptypes + dl_custom_ptype_count;
    544   1.1  martin 		dl_custom_ptype_count++;
    545   1.1  martin 		memset(nt, 0, sizeof(*nt));
    546   1.1  martin 		nt->type = type;
    547   1.1  martin 		snprintf(nt->short_desc, sizeof(nt->short_desc), "%u", type);
    548   1.1  martin 		nt->short_desc[sizeof(nt->short_desc)-1] = 0;
    549   1.1  martin 		snprintf(nt->description, sizeof(nt->description),
    550   1.1  martin 		    "%s (%u)", msg_string(MSG_custom_type), type);
    551   1.1  martin 		nt->description[sizeof(nt->description)-1] = 0;
    552   1.1  martin 		nt->desc.generic_ptype = PT_unknown;
    553   1.1  martin 		nt->desc.short_desc = nt->short_desc;
    554   1.1  martin 		nt->desc.description = nt->description;
    555   1.1  martin 		return &nt->desc;
    556   1.1  martin 	}
    557   1.1  martin 
    558   1.1  martin 	return NULL;
    559   1.1  martin }
    560   1.1  martin 
    561   1.1  martin static const struct part_type_desc *
    562   1.1  martin disklabel_create_custom_part_type(const char *custom, const char **err_msg)
    563   1.1  martin {
    564   1.1  martin 	char *endp;
    565   1.1  martin 	unsigned long fstype;
    566   1.1  martin 
    567   1.1  martin 	fstype = strtoul(custom, &endp, 10);
    568   1.1  martin 	if (*endp != 0) {
    569   1.1  martin 		if (err_msg)
    570   1.1  martin 			*err_msg = msg_string(MSG_dl_type_invalid);
    571   1.1  martin 		return NULL;
    572   1.1  martin 	}
    573   1.1  martin 
    574   1.1  martin 	return disklabel_find_type(fstype, true);
    575   1.1  martin }
    576   1.1  martin 
    577   1.1  martin static const struct part_type_desc *
    578   1.1  martin disklabel_get_fs_part_type(unsigned fstype, unsigned subtype)
    579   1.1  martin {
    580   1.1  martin 	return disklabel_find_type(fstype, false);
    581   1.1  martin }
    582   1.1  martin 
    583   1.1  martin static const struct part_type_desc *
    584   1.1  martin disklabel_get_generic_type(enum part_type pt)
    585   1.1  martin {
    586   1.1  martin 	size_t nt;
    587   1.1  martin 
    588   1.1  martin 	if (dl_types[0].description == NULL)
    589   1.1  martin 		dl_init_types();
    590   1.1  martin 
    591   1.1  martin 	switch (pt) {
    592   1.1  martin 	case PT_root:	nt = FS_BSDFFS; break;
    593   1.1  martin 	case PT_swap:	nt = FS_SWAP; break;
    594   1.1  martin 	case PT_FAT:
    595   1.1  martin 	case PT_EFI_SYSTEM:
    596   1.1  martin 			nt = FS_MSDOS; break;
    597   1.1  martin 	default:	nt = FS_UNUSED; break;
    598   1.1  martin 	}
    599   1.1  martin 
    600   1.1  martin 	return disklabel_get_type(nt);
    601   1.1  martin }
    602   1.1  martin 
    603   1.1  martin static bool
    604   1.1  martin disklabel_get_part_info(const struct disk_partitions *arg, part_id id,
    605   1.1  martin     struct disk_part_info *info)
    606   1.1  martin {
    607   1.1  martin 	const struct disklabel_disk_partitions *parts =
    608   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    609   1.1  martin 	part_id ndx;
    610   1.1  martin 
    611   1.1  martin 	if (dl_types[0].description == NULL)
    612   1.1  martin 		dl_init_types();
    613   1.1  martin 
    614   1.1  martin 	ndx = 0;
    615   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    616   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    617   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    618   1.1  martin 			continue;
    619   1.1  martin 
    620   1.1  martin 		if (ndx == id) {
    621   1.1  martin 			memset(info, 0, sizeof(*info));
    622   1.1  martin 			info->start = parts->l.d_partitions[part].p_offset;
    623   1.1  martin 			info->size = parts->l.d_partitions[part].p_size;
    624   1.1  martin 			info->nat_type = disklabel_find_type(
    625   1.1  martin 			    parts->l.d_partitions[part].p_fstype, true);
    626   1.1  martin 			if (parts->last_mounted[part][0] != 0)
    627   1.1  martin 				info->last_mounted = parts->last_mounted[part];
    628   1.1  martin 			info->fs_type = parts->l.d_partitions[part].p_fstype;
    629   1.1  martin 			info->fs_sub_type = parts->fs_sub_type[part];
    630   1.1  martin 			if (part == RAW_PART &&
    631   1.1  martin 			    parts->l.d_partitions[part].p_fstype == FS_UNUSED)
    632   1.1  martin 				info->flags |=
    633   1.1  martin 				    PTI_PSCHEME_INTERNAL|PTI_RAW_PART;
    634   1.1  martin #if RAW_PART > 2
    635   1.1  martin 			if (part == (RAW_PART-1) &&
    636   1.1  martin 			    parts->l.d_partitions[part].p_fstype == FS_UNUSED)
    637   1.1  martin 				info->flags |=
    638   1.1  martin 				    PTI_PSCHEME_INTERNAL|PTI_WHOLE_DISK;
    639   1.1  martin #endif
    640   1.1  martin 			return true;
    641   1.1  martin 		}
    642   1.1  martin 
    643   1.1  martin 		ndx++;
    644   1.1  martin 		if (ndx > parts->dp.num_part || ndx > id)
    645   1.1  martin 			break;
    646   1.1  martin 	}
    647   1.1  martin 
    648   1.1  martin 	return false;
    649   1.1  martin }
    650   1.1  martin 
    651   1.1  martin static bool
    652   1.1  martin disklabel_set_part_info(struct disk_partitions *arg, part_id id,
    653   1.1  martin     const struct disk_part_info *info, const char **err_msg)
    654   1.1  martin {
    655   1.1  martin 	struct disklabel_disk_partitions *parts =
    656   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    657   1.1  martin 	part_id ndx;
    658   1.1  martin 
    659   1.1  martin 	if (dl_types[0].description == NULL)
    660   1.1  martin 		dl_init_types();
    661   1.1  martin 
    662   1.1  martin 	ndx = 0;
    663   1.1  martin 	for (int part = 0; part < parts->l.d_npartitions; part++) {
    664   1.1  martin 		if (parts->l.d_partitions[part].p_fstype == FS_UNUSED
    665   1.1  martin 		    && parts->l.d_partitions[part].p_size == 0)
    666   1.1  martin 			continue;
    667   1.1  martin 
    668   1.1  martin 		if (ndx == id) {
    669   1.1  martin 			parts->l.d_partitions[part].p_offset = info->start;
    670   1.1  martin 			parts->l.d_partitions[part].p_size = info->size;
    671   1.1  martin 			parts->l.d_partitions[part].p_fstype =
    672   1.1  martin 			    dl_part_type_from_generic(info->nat_type);
    673   1.1  martin 			if (info->last_mounted != NULL &&
    674   1.1  martin 			    info->last_mounted != parts->last_mounted[part])
    675   1.1  martin 				strlcpy(parts->last_mounted[part],
    676   1.1  martin 				    info->last_mounted,
    677   1.1  martin 				    sizeof(parts->last_mounted[part]));
    678   1.1  martin 			assert(info->fs_type == 0 || info->fs_type ==
    679   1.1  martin 			    parts->l.d_partitions[part].p_fstype);
    680   1.1  martin 			if (info->fs_sub_type != 0)
    681   1.1  martin 				parts->fs_sub_type[part] = info->fs_sub_type;
    682   1.1  martin 			return true;
    683   1.1  martin 		}
    684   1.1  martin 
    685   1.1  martin 		ndx++;
    686   1.1  martin 		if (ndx > parts->dp.num_part || ndx > id)
    687   1.1  martin 			break;
    688   1.1  martin 	}
    689   1.1  martin 
    690   1.1  martin 	return false;
    691   1.1  martin }
    692   1.1  martin 
    693   1.1  martin static size_t
    694   1.1  martin disklabel_get_free_spaces_internal(const struct
    695   1.1  martin     disklabel_disk_partitions *parts,
    696   1.1  martin     struct disk_part_free_space *result, size_t max_num_result,
    697   1.1  martin     daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore)
    698   1.1  martin {
    699   1.1  martin 	size_t cnt = 0, i;
    700   1.1  martin 	daddr_t s, e, from, size, end_of_disk;
    701   1.1  martin 
    702   1.3  martin 	if (start < parts->dp.disk_start)
    703   1.1  martin 		start = parts->dp.disk_start;
    704   1.1  martin 	if (min_space_size < 1)
    705   1.1  martin 		min_space_size = 1;
    706   1.3  martin 	if (align > 1 && (start % align) != 0)
    707   1.1  martin 		start = max(roundup(start, align), align);
    708   1.1  martin 	end_of_disk = parts->dp.disk_start + parts->dp.disk_size;
    709   1.1  martin 	from = start;
    710   1.1  martin 	while (from < end_of_disk && cnt < max_num_result) {
    711   1.1  martin again:
    712   1.1  martin 		size = parts->dp.disk_start + parts->dp.disk_size - from;
    713   1.1  martin 		start = from;
    714   1.1  martin 		for (i = 0; i < parts->l.d_npartitions; i++) {
    715   1.1  martin 			if (i == RAW_PART)
    716   1.1  martin 				continue;
    717   1.1  martin 			if (parts->l.d_partitions[i].p_fstype == FS_UNUSED)
    718   1.1  martin 				continue;
    719   1.1  martin 
    720   1.1  martin 			s = parts->l.d_partitions[i].p_offset;
    721   1.1  martin 			e = parts->l.d_partitions[i].p_size + s;
    722   1.1  martin 			if (s == ignore)
    723   1.1  martin 				continue;
    724   1.1  martin 			if (e < from)
    725   1.1  martin 				continue;
    726   1.1  martin 			if (s <= from && e > from) {
    727   1.1  martin 				if (e - 1 >= end_of_disk)
    728   1.1  martin 					return cnt;
    729   1.1  martin 
    730   1.1  martin 				from = e + 1;
    731   1.1  martin 				if (align > 1) {
    732   1.1  martin 					from = max(roundup(from, align), align);
    733   1.1  martin 					if (from >= end_of_disk) {
    734   1.1  martin 						size = 0;
    735   1.1  martin 						break;
    736   1.1  martin 					}
    737   1.1  martin 				}
    738   1.1  martin 				goto again;
    739   1.1  martin 			}
    740   1.1  martin 			if (s > from && s - from < size) {
    741   1.1  martin 				size = s - from;
    742   1.1  martin 			}
    743   1.1  martin 		}
    744   1.1  martin 		if (size >= min_space_size) {
    745   1.1  martin 			result->start = start;
    746   1.1  martin 			result->size = size;
    747   1.1  martin 			result++;
    748   1.1  martin 			cnt++;
    749   1.1  martin 		}
    750   1.1  martin 		from += size + 1;
    751   1.1  martin 		if (align > 1)
    752   1.1  martin 			from = max(roundup(from, align), align);
    753   1.1  martin 	}
    754   1.1  martin 
    755   1.1  martin 	return cnt;
    756   1.1  martin }
    757   1.1  martin 
    758   1.1  martin static bool
    759   1.1  martin disklabel_can_add_partition(const struct disk_partitions *arg)
    760   1.1  martin {
    761   1.1  martin 	const struct disklabel_disk_partitions *parts =
    762   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    763   1.1  martin 	struct disk_part_free_space space;
    764   1.1  martin 	int i;
    765   1.1  martin 
    766   1.1  martin 	if (dl_maxpart == 0)
    767   1.1  martin 		dl_maxpart = getmaxpartitions();
    768   1.1  martin 	if (parts->dp.free_space < parts->ptn_alignment)
    769   1.1  martin 		return false;
    770   1.1  martin 	if (parts->dp.num_part >= dl_maxpart)
    771   1.1  martin 		return false;
    772   1.1  martin 	if (disklabel_get_free_spaces_internal(parts, &space, 1,
    773   1.1  martin 	    parts->ptn_alignment, parts->ptn_alignment, 0, -1) < 1)
    774   1.1  martin 		return false;
    775   1.1  martin 
    776   1.1  martin 	for (i = 0; i < parts->l.d_npartitions; i++) {
    777   1.1  martin 		if (i == RAW_PART)
    778   1.1  martin 			continue;
    779   1.1  martin #if RAW_PART > 2
    780   1.1  martin 		if (i == RAW_PART-1)
    781   1.1  martin 			continue;
    782   1.1  martin #endif
    783   1.1  martin 		if (parts->l.d_partitions[i].p_fstype == FS_UNUSED)
    784   1.1  martin 			return true;
    785   1.1  martin 	}
    786   1.1  martin 	return false;
    787   1.1  martin }
    788   1.1  martin 
    789   1.1  martin static bool
    790   1.1  martin disklabel_get_disk_pack_name(const struct disk_partitions *arg,
    791   1.1  martin     char *buf, size_t len)
    792   1.1  martin {
    793   1.1  martin 	const struct disklabel_disk_partitions *parts =
    794   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    795   1.1  martin 
    796   1.1  martin 	strlcpy(buf, parts->l.d_packname, min(len,
    797   1.1  martin 	    sizeof(parts->l.d_packname)+1));
    798   1.1  martin 	return true;
    799   1.1  martin }
    800   1.1  martin 
    801   1.1  martin static bool
    802   1.1  martin disklabel_set_disk_pack_name(struct disk_partitions *arg, const char *pack)
    803   1.1  martin {
    804   1.1  martin 	struct disklabel_disk_partitions *parts =
    805   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    806   1.1  martin 
    807   1.1  martin 	strncpy(parts->l.d_packname, pack, sizeof(parts->l.d_packname));
    808   1.1  martin 	return true;
    809   1.1  martin }
    810   1.1  martin 
    811   1.1  martin static bool
    812   1.1  martin disklabel_get_part_device(const struct disk_partitions *arg,
    813   1.1  martin     part_id ptn, char *devname, size_t max_devname_len, int *part,
    814   1.1  martin     enum dev_name_usage which_name, bool with_path)
    815   1.1  martin {
    816   1.1  martin 
    817   1.1  martin 	if (part != 0)
    818   1.1  martin 		*part = ptn;
    819   1.1  martin 
    820   1.1  martin 	switch (which_name) {
    821   1.1  martin 	case parent_device_only:
    822   1.1  martin 		strlcpy(devname, arg->disk, max_devname_len);
    823   1.1  martin 		return true;
    824   1.1  martin 	case logical_name:
    825   1.1  martin 	case plain_name:
    826   1.1  martin 		if (with_path)
    827   1.1  martin 			snprintf(devname, max_devname_len, _PATH_DEV "%s%c",
    828   1.1  martin 			    arg->disk, (char)ptn + 'a');
    829   1.1  martin 		else
    830   1.1  martin 			snprintf(devname, max_devname_len, "%s%c",
    831   1.1  martin 			    arg->disk, (char)ptn + 'a');
    832   1.1  martin 		return true;
    833   1.1  martin 	case raw_dev_name:
    834   1.1  martin 		if (with_path)
    835   1.1  martin 			snprintf(devname, max_devname_len, _PATH_DEV "r%s%c",
    836   1.1  martin 			    arg->disk, (char)ptn + 'a');
    837   1.1  martin 		else
    838   1.1  martin 			snprintf(devname, max_devname_len, "r%s%c",
    839   1.1  martin 			    arg->disk, (char)ptn + 'a');
    840   1.1  martin 		return true;
    841   1.1  martin 	}
    842   1.1  martin 
    843   1.1  martin 	return false;
    844   1.1  martin }
    845   1.1  martin 
    846   1.1  martin static part_id
    847   1.1  martin disklabel_add_partition(struct disk_partitions *arg,
    848   1.1  martin     const struct disk_part_info *info, const char **err_msg)
    849   1.1  martin {
    850   1.1  martin 	struct disklabel_disk_partitions *parts =
    851   1.1  martin 	    (struct disklabel_disk_partitions*)arg;
    852   1.1  martin 	int i, part = -1;
    853   1.1  martin 	part_id new_id;
    854   1.1  martin 	struct disk_part_free_space space;
    855   1.1  martin 	struct disk_part_info data = *info;
    856   1.1  martin 
    857   1.1  martin 	if (disklabel_get_free_spaces_internal(parts, &space, 1, 1, 1,
    858   1.1  martin 	    info->start, -1) < 1) {
    859   1.1  martin 		if (err_msg)
    860   1.1  martin 			*err_msg = msg_string(MSG_No_free_space);
    861   1.1  martin 		return NO_PART;
    862   1.1  martin 	}
    863   1.1  martin 	if (data.size > space.size)
    864   1.1  martin 		data.size = space.size;
    865   1.1  martin 	daddr_t dend = data.start+data.size;
    866   1.1  martin 	if (space.start > data.start)
    867   1.1  martin 		data.start = space.start;
    868   1.1  martin 	if (space.start + space.size < dend)
    869   1.1  martin 		data.size = space.start+space.size-data.start;
    870   1.1  martin 
    871   1.1  martin 	if (dl_maxpart == 0)
    872   1.1  martin 		dl_maxpart = getmaxpartitions();
    873   1.1  martin 
    874   1.1  martin 	for (new_id = 0, i = 0; i < parts->l.d_npartitions; i++) {
    875   1.1  martin 		if (parts->l.d_partitions[i].p_size > 0)
    876   1.1  martin 			new_id++;
    877   1.1  martin 		if (info->nat_type->generic_ptype != PT_root &&
    878   1.1  martin 		    info->nat_type->generic_ptype != PT_swap && i < RAW_PART)
    879   1.1  martin 			continue;
    880   1.1  martin 		if (i == 0 && info->nat_type->generic_ptype != PT_root)
    881   1.1  martin 			continue;
    882   1.1  martin 		if (i == 1 && info->nat_type->generic_ptype != PT_swap)
    883   1.1  martin 			continue;
    884   1.1  martin 		if (i == RAW_PART)
    885   1.1  martin 			continue;
    886   1.1  martin #if RAW_PART > 2
    887   1.1  martin 		if (i == RAW_PART-1)
    888   1.1  martin 			continue;
    889   1.1  martin #endif
    890   1.1  martin 		if (parts->l.d_partitions[i].p_size > 0)
    891   1.1  martin 			continue;
    892   1.1  martin 		part = i;
    893   1.1  martin 		break;
    894   1.1  martin 	}
    895   1.1  martin 
    896   1.1  martin 	if (part < 0) {
    897   1.1  martin 		if (parts->l.d_npartitions >= dl_maxpart) {
    898   1.1  martin 			if (err_msg)
    899   1.1  martin 				*err_msg =
    900   1.1  martin 				    msg_string(MSG_err_too_many_partitions);
    901   1.1  martin 			return NO_PART;
    902   1.1  martin 		}
    903   1.1  martin 
    904   1.1  martin 		part = parts->l.d_npartitions++;
    905   1.1  martin 	}
    906   1.1  martin 	parts->l.d_partitions[part].p_offset = data.start;
    907   1.1  martin 	parts->l.d_partitions[part].p_size = data.size;
    908   1.1  martin 	parts->l.d_partitions[part].p_fstype =
    909   1.1  martin 	     dl_part_type_from_generic(info->nat_type);
    910   1.1  martin 	if (info->last_mounted && info->last_mounted[0])
    911   1.1  martin 		strlcpy(parts->last_mounted[part], info->last_mounted,
    912   1.1  martin 		    sizeof(parts->last_mounted[part]));
    913   1.1  martin 	else
    914   1.1  martin 		parts->last_mounted[part][0] = 0;
    915   1.1  martin 	parts->fs_sub_type[part] = info->fs_sub_type;
    916   1.1  martin 	parts->dp.num_part++;
    917   1.1  martin 	if (data.size <= parts->dp.free_space)
    918   1.1  martin 		parts->dp.free_space -= data.size;
    919   1.1  martin 	else
    920   1.1  martin 		parts->dp.free_space = 0;
    921   1.1  martin 
    922   1.1  martin 	return new_id;
    923   1.1  martin }
    924   1.1  martin 
    925   1.7  martin static part_id
    926   1.7  martin disklabel_add_outer_partition(struct disk_partitions *arg,
    927   1.7  martin     const struct disk_part_info *info, const char **err_msg)
    928   1.7  martin {
    929   1.7  martin 	struct disklabel_disk_partitions *parts =
    930   1.7  martin 	    (struct disklabel_disk_partitions*)arg;
    931   1.7  martin 	int i, part = -1;
    932   1.7  martin 	part_id new_id;
    933   1.7  martin 
    934   1.7  martin 	if (dl_maxpart == 0)
    935   1.7  martin 		dl_maxpart = getmaxpartitions();
    936   1.7  martin 
    937   1.7  martin 	for (new_id = 0, i = 0; i < parts->l.d_npartitions; i++) {
    938   1.7  martin 		if (parts->l.d_partitions[i].p_size > 0)
    939   1.7  martin 			new_id++;
    940   1.7  martin 		if (info->nat_type->generic_ptype != PT_root &&
    941   1.7  martin 		    info->nat_type->generic_ptype != PT_swap && i < RAW_PART)
    942   1.7  martin 			continue;
    943   1.7  martin 		if (i == 0 && info->nat_type->generic_ptype != PT_root)
    944   1.7  martin 			continue;
    945   1.7  martin 		if (i == 1 && info->nat_type->generic_ptype != PT_swap)
    946   1.7  martin 			continue;
    947   1.7  martin 		if (i == RAW_PART)
    948   1.7  martin 			continue;
    949   1.7  martin #if RAW_PART > 2
    950   1.7  martin 		if (i == RAW_PART-1)
    951   1.7  martin 			continue;
    952   1.7  martin #endif
    953   1.7  martin 		if (parts->l.d_partitions[i].p_size > 0)
    954   1.7  martin 			continue;
    955   1.7  martin 		part = i;
    956   1.7  martin 		break;
    957   1.7  martin 	}
    958   1.7  martin 
    959   1.7  martin 	if (part < 0) {
    960   1.7  martin 		if (parts->l.d_npartitions >= dl_maxpart) {
    961   1.7  martin 			if (err_msg)
    962   1.7  martin 				*err_msg =
    963   1.7  martin 				    msg_string(MSG_err_too_many_partitions);
    964   1.7  martin 			return NO_PART;
    965   1.7  martin 		}
    966   1.7  martin 
    967   1.7  martin 		part = parts->l.d_npartitions++;
    968   1.7  martin 	}
    969   1.7  martin 	parts->l.d_partitions[part].p_offset = info->start;
    970   1.7  martin 	parts->l.d_partitions[part].p_size = info->size;
    971   1.7  martin 	parts->l.d_partitions[part].p_fstype =
    972   1.7  martin 	     dl_part_type_from_generic(info->nat_type);
    973   1.7  martin 	if (info->last_mounted && info->last_mounted[0])
    974   1.7  martin 		strlcpy(parts->last_mounted[part], info->last_mounted,
    975   1.7  martin 		    sizeof(parts->last_mounted[part]));
    976   1.7  martin 	else
    977   1.7  martin 		parts->last_mounted[part][0] = 0;
    978   1.7  martin 	parts->fs_sub_type[part] = info->fs_sub_type;
    979   1.7  martin 	parts->dp.num_part++;
    980   1.7  martin 
    981   1.7  martin 	return new_id;
    982   1.7  martin }
    983   1.7  martin 
    984   1.1  martin static size_t
    985   1.1  martin disklabel_get_free_spaces(const struct disk_partitions *arg,
    986   1.1  martin     struct disk_part_free_space *result, size_t max_num_result,
    987   1.1  martin     daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore)
    988   1.1  martin {
    989   1.1  martin 	const struct disklabel_disk_partitions *parts =
    990   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
    991   1.1  martin 
    992   1.1  martin 	return disklabel_get_free_spaces_internal(parts, result,
    993   1.1  martin 	    max_num_result, min_space_size, align, start, ignore);
    994   1.1  martin }
    995   1.1  martin 
    996   1.1  martin static daddr_t
    997   1.1  martin disklabel_max_free_space_at(const struct disk_partitions *arg, daddr_t start)
    998   1.1  martin {
    999   1.1  martin 	const struct disklabel_disk_partitions *parts =
   1000   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
   1001   1.1  martin 	struct disk_part_free_space space;
   1002   1.1  martin 
   1003   1.1  martin 	if (disklabel_get_free_spaces_internal(parts, &space, 1, 1, 0,
   1004   1.1  martin 	    start, start) == 1)
   1005   1.1  martin 		return space.size;
   1006   1.1  martin 
   1007   1.1  martin 	return 0;
   1008   1.1  martin }
   1009   1.1  martin 
   1010   1.1  martin static daddr_t
   1011   1.1  martin disklabel_get_alignment(const struct disk_partitions *arg)
   1012   1.1  martin {
   1013   1.1  martin 	const struct disklabel_disk_partitions *parts =
   1014   1.1  martin 	    (const struct disklabel_disk_partitions*)arg;
   1015   1.1  martin 
   1016   1.1  martin 	return parts->ptn_alignment;
   1017   1.1  martin }
   1018   1.1  martin 
   1019   1.1  martin static void
   1020   1.1  martin disklabel_free(struct disk_partitions *arg)
   1021   1.1  martin {
   1022   1.1  martin 
   1023   1.1  martin 	assert(arg != NULL);
   1024   1.1  martin 	free(arg);
   1025   1.1  martin }
   1026   1.1  martin 
   1027   1.1  martin const struct disk_partitioning_scheme
   1028   1.1  martin disklabel_parts = {
   1029   1.1  martin 	.name = MSG_parttype_disklabel,
   1030   1.1  martin 	.short_name = MSG_parttype_disklabel_short,
   1031   1.1  martin 	.new_type_prompt = MSG_dl_get_custom_fstype,
   1032   1.1  martin 	.size_limit = (daddr_t)UINT32_MAX,
   1033   1.1  martin 	.write_to_disk = disklabel_write_to_disk,
   1034   1.1  martin 	.read_from_disk = disklabel_parts_read,
   1035   1.1  martin 	.create_new_for_disk = disklabel_parts_new,
   1036   1.1  martin 	.change_disk_geom = disklabel_change_geom,
   1037   1.1  martin 	.get_disk_pack_name = disklabel_get_disk_pack_name,
   1038   1.1  martin 	.set_disk_pack_name = disklabel_set_disk_pack_name,
   1039   1.1  martin 	.delete_all_partitions = disklabel_delete_all,
   1040   1.1  martin 	.delete_partitions_in_range = disklabel_delete_range,
   1041   1.1  martin 	.delete_partition = disklabel_delete,
   1042   1.1  martin 	.get_part_types_count = disklabel_type_count,
   1043   1.1  martin 	.get_part_type = disklabel_get_type,
   1044   1.1  martin 	.get_generic_part_type = disklabel_get_generic_type,
   1045   1.1  martin 	.get_fs_part_type = disklabel_get_fs_part_type,
   1046   1.1  martin 	.create_custom_part_type = disklabel_create_custom_part_type,
   1047   1.1  martin 	.get_part_alignment = disklabel_get_alignment,
   1048   1.1  martin 	.get_part_info = disklabel_get_part_info,
   1049   1.1  martin 	.can_add_partition = disklabel_can_add_partition,
   1050   1.1  martin 	.set_part_info = disklabel_set_part_info,
   1051   1.1  martin 	.add_partition = disklabel_add_partition,
   1052   1.7  martin 	.add_outer_partition = disklabel_add_outer_partition,
   1053   1.1  martin 	.max_free_space_at = disklabel_max_free_space_at,
   1054   1.1  martin 	.get_free_spaces = disklabel_get_free_spaces,
   1055   1.1  martin 	.get_part_device = disklabel_get_part_device,
   1056   1.1  martin 	.free = disklabel_free,
   1057   1.1  martin };
   1058