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