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