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