source: mainline/uspace/lib/fdisk/src/fdisk.c@ 6c4eedf

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 6c4eedf was 6c4eedf, checked in by Jiri Svoboda <jiri@…>, 8 years ago

Move capacity specification to libc.
  • Property mode set to 100644
File size: 25.0 KB
Line 
1/*
2 * Copyright (c) 2015 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libfdisk
30 * @{
31 */
32/**
33 * @file Disk management library.
34 */
35
36#include <adt/list.h>
37#include <cap.h>
38#include <errno.h>
39#include <fdisk.h>
40#include <loc.h>
41#include <macros.h>
42#include <mem.h>
43#include <stdlib.h>
44#include <str.h>
45#include <vbd.h>
46#include <vol.h>
47
48static int fdisk_dev_add_parts(fdisk_dev_t *);
49static void fdisk_dev_remove_parts(fdisk_dev_t *);
50static int fdisk_part_spec_prepare(fdisk_dev_t *, fdisk_part_spec_t *,
51 vbd_part_spec_t *);
52static void fdisk_pri_part_insert_lists(fdisk_dev_t *, fdisk_part_t *);
53static void fdisk_log_part_insert_lists(fdisk_dev_t *, fdisk_part_t *);
54static int fdisk_update_dev_info(fdisk_dev_t *);
55static uint64_t fdisk_ba_align_up(fdisk_dev_t *, uint64_t);
56static uint64_t fdisk_ba_align_down(fdisk_dev_t *, uint64_t);
57static int fdisk_part_get_max_free_range(fdisk_dev_t *, fdisk_spc_t, aoff64_t *,
58 aoff64_t *);
59static void fdisk_free_range_first(fdisk_dev_t *, fdisk_spc_t, fdisk_free_range_t *);
60static bool fdisk_free_range_next(fdisk_free_range_t *);
61static bool fdisk_free_range_get(fdisk_free_range_t *, aoff64_t *, aoff64_t *);
62
63static void fdisk_dev_info_delete(fdisk_dev_info_t *info)
64{
65 if (info == NULL)
66 return;
67
68 free(info->svcname);
69 free(info);
70}
71
72int fdisk_create(fdisk_t **rfdisk)
73{
74 fdisk_t *fdisk = NULL;
75 int rc;
76
77 fdisk = calloc(1, sizeof(fdisk_t));
78 if (fdisk == NULL) {
79 rc = ENOMEM;
80 goto error;
81 }
82
83 rc = vol_create(&fdisk->vol);
84 if (rc != EOK) {
85 rc = EIO;
86 goto error;
87 }
88
89 rc = vbd_create(&fdisk->vbd);
90 if (rc != EOK) {
91 rc = EIO;
92 goto error;
93 }
94
95 *rfdisk = fdisk;
96 return EOK;
97error:
98 fdisk_destroy(fdisk);
99
100 return rc;
101}
102
103void fdisk_destroy(fdisk_t *fdisk)
104{
105 if (fdisk == NULL)
106 return;
107
108 vol_destroy(fdisk->vol);
109 vbd_destroy(fdisk->vbd);
110 free(fdisk);
111}
112
113int fdisk_dev_list_get(fdisk_t *fdisk, fdisk_dev_list_t **rdevlist)
114{
115 fdisk_dev_list_t *devlist = NULL;
116 fdisk_dev_info_t *info;
117 service_id_t *svcs = NULL;
118 size_t count, i;
119 int rc;
120
121 devlist = calloc(1, sizeof(fdisk_dev_list_t));
122 if (devlist == NULL)
123 return ENOMEM;
124
125 devlist->fdisk = fdisk;
126 list_initialize(&devlist->devinfos);
127
128 rc = vbd_get_disks(fdisk->vbd, &svcs, &count);
129 if (rc != EOK) {
130 rc = EIO;
131 goto error;
132 }
133
134 for (i = 0; i < count; i++) {
135 info = calloc(1, sizeof(fdisk_dev_info_t));
136 if (info == NULL) {
137 rc = ENOMEM;
138 goto error;
139 }
140
141 info->svcid = svcs[i];
142 info->devlist = devlist;
143 list_append(&info->ldevlist, &devlist->devinfos);
144 }
145
146 *rdevlist = devlist;
147 free(svcs);
148 return EOK;
149error:
150 free(svcs);
151 fdisk_dev_list_free(devlist);
152 return rc;
153}
154
155void fdisk_dev_list_free(fdisk_dev_list_t *devlist)
156{
157 fdisk_dev_info_t *info;
158
159 if (devlist == NULL)
160 return;
161
162 while (!list_empty(&devlist->devinfos)) {
163 info = list_get_instance(list_first(
164 &devlist->devinfos), fdisk_dev_info_t,
165 ldevlist);
166
167 list_remove(&info->ldevlist);
168 fdisk_dev_info_delete(info);
169 }
170
171 free(devlist);
172}
173
174fdisk_dev_info_t *fdisk_dev_first(fdisk_dev_list_t *devlist)
175{
176 if (list_empty(&devlist->devinfos))
177 return NULL;
178
179 return list_get_instance(list_first(&devlist->devinfos),
180 fdisk_dev_info_t, ldevlist);
181}
182
183fdisk_dev_info_t *fdisk_dev_next(fdisk_dev_info_t *devinfo)
184{
185 link_t *lnext;
186
187 lnext = list_next(&devinfo->ldevlist,
188 &devinfo->devlist->devinfos);
189 if (lnext == NULL)
190 return NULL;
191
192 return list_get_instance(lnext, fdisk_dev_info_t,
193 ldevlist);
194}
195
196void fdisk_dev_info_get_svcid(fdisk_dev_info_t *info, service_id_t *rsid)
197{
198 *rsid = info->svcid;
199}
200
201int fdisk_dev_info_get_svcname(fdisk_dev_info_t *info, char **rname)
202{
203 char *name;
204 int rc;
205
206 if (info->svcname == NULL) {
207 rc = loc_service_get_name(info->svcid,
208 &info->svcname);
209 if (rc != EOK)
210 return rc;
211 }
212
213 name = str_dup(info->svcname);
214 if (name == NULL)
215 return ENOMEM;
216
217 *rname = name;
218 return EOK;
219}
220
221int fdisk_dev_info_capacity(fdisk_dev_info_t *info, cap_spec_t *cap)
222{
223 vbd_disk_info_t vinfo;
224 int rc;
225
226 rc = vbd_disk_info(info->devlist->fdisk->vbd, info->svcid, &vinfo);
227 if (rc != EOK)
228 return EIO;
229
230 cap_from_blocks(vinfo.nblocks, vinfo.block_size, cap);
231 return EOK;
232}
233
234/** Add partition to our inventory. */
235static int fdisk_part_add(fdisk_dev_t *dev, vbd_part_id_t partid,
236 fdisk_part_t **rpart)
237{
238 fdisk_part_t *part;
239 vbd_part_info_t pinfo;
240 vol_part_info_t vpinfo;
241 int rc;
242
243 part = calloc(1, sizeof(fdisk_part_t));
244 if (part == NULL)
245 return ENOMEM;
246
247 rc = vbd_part_get_info(dev->fdisk->vbd, partid, &pinfo);
248 if (rc != EOK) {
249 rc = EIO;
250 goto error;
251 }
252
253 if (pinfo.svc_id != 0) {
254 /*
255 * Normally vol service discovers the partition asynchronously.
256 * Here we need to make sure the partition is already known to it.
257 */
258 rc = vol_part_add(dev->fdisk->vol, pinfo.svc_id);
259 if (rc != EOK && rc != EEXIST) {
260 rc = EIO;
261 goto error;
262 }
263
264 rc = vol_part_info(dev->fdisk->vol, pinfo.svc_id, &vpinfo);
265 if (rc != EOK) {
266 rc = EIO;
267 goto error;
268 }
269
270 part->pcnt = vpinfo.pcnt;
271 part->fstype = vpinfo.fstype;
272 part->label = str_dup(vpinfo.label);
273 }
274
275 part->dev = dev;
276 part->index = pinfo.index;
277 part->block0 = pinfo.block0;
278 part->nblocks = pinfo.nblocks;
279 part->pkind = pinfo.pkind;
280 part->svc_id = pinfo.svc_id;
281
282 switch (part->pkind) {
283 case lpk_primary:
284 case lpk_extended:
285 fdisk_pri_part_insert_lists(dev, part);
286 break;
287 case lpk_logical:
288 fdisk_log_part_insert_lists(dev, part);
289 break;
290 }
291
292 list_append(&part->lparts, &dev->parts);
293
294 if (part->pkind == lpk_extended)
295 dev->ext_part = part;
296
297 cap_from_blocks(part->nblocks, dev->dinfo.block_size,
298 &part->capacity);
299 part->part_id = partid;
300
301 if (rpart != NULL)
302 *rpart = part;
303 return EOK;
304error:
305 if (part != NULL)
306 free(part->label);
307 free(part);
308 return rc;
309}
310
311/** Remove partition from our inventory. */
312static void fdisk_part_remove(fdisk_part_t *part)
313{
314 list_remove(&part->lparts);
315 if (link_used(&part->lpri_ba))
316 list_remove(&part->lpri_ba);
317 if (link_used(&part->lpri_idx))
318 list_remove(&part->lpri_idx);
319 if (link_used(&part->llog_ba))
320 list_remove(&part->llog_ba);
321
322 free(part->label);
323 free(part);
324}
325
326static void fdisk_pri_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
327{
328 link_t *link;
329 fdisk_part_t *p;
330
331 /* Insert to list by block address */
332 link = list_first(&dev->pri_ba);
333 while (link != NULL) {
334 p = list_get_instance(link, fdisk_part_t, lpri_ba);
335 if (p->block0 > part->block0) {
336 list_insert_before(&part->lpri_ba, &p->lpri_ba);
337 break;
338 }
339
340 link = list_next(link, &dev->pri_ba);
341 }
342
343 if (link == NULL)
344 list_append(&part->lpri_ba, &dev->pri_ba);
345
346 /* Insert to list by index */
347 link = list_first(&dev->pri_idx);
348 while (link != NULL) {
349 p = list_get_instance(link, fdisk_part_t, lpri_idx);
350 if (p->index > part->index) {
351 list_insert_before(&part->lpri_idx, &p->lpri_idx);
352 break;
353 }
354
355 link = list_next(link, &dev->pri_idx);
356 }
357
358 if (link == NULL)
359 list_append(&part->lpri_idx, &dev->pri_idx);
360}
361
362static void fdisk_log_part_insert_lists(fdisk_dev_t *dev, fdisk_part_t *part)
363{
364 link_t *link;
365 fdisk_part_t *p;
366
367 /* Insert to list by block address */
368 link = list_first(&dev->log_ba);
369 while (link != NULL) {
370 p = list_get_instance(link, fdisk_part_t, llog_ba);
371 if (p->block0 > part->block0) {
372 list_insert_before(&part->llog_ba, &p->llog_ba);
373 break;
374 }
375
376 link = list_next(link, &dev->log_ba);
377 }
378
379 if (link == NULL)
380 list_append(&part->llog_ba, &dev->log_ba);
381}
382
383static int fdisk_dev_add_parts(fdisk_dev_t *dev)
384{
385 service_id_t *psids = NULL;
386 size_t nparts, i;
387 int rc;
388
389 rc = fdisk_update_dev_info(dev);
390 if (rc != EOK) {
391 rc = EIO;
392 goto error;
393 }
394
395 rc = vbd_label_get_parts(dev->fdisk->vbd, dev->sid, &psids, &nparts);
396 if (rc != EOK) {
397 rc = EIO;
398 goto error;
399 }
400
401 for (i = 0; i < nparts; i++) {
402 rc = fdisk_part_add(dev, psids[i], NULL);
403 if (rc != EOK) {
404 goto error;
405 }
406 }
407
408 free(psids);
409 return EOK;
410error:
411 fdisk_dev_remove_parts(dev);
412 return rc;
413}
414
415static void fdisk_dev_remove_parts(fdisk_dev_t *dev)
416{
417 fdisk_part_t *part;
418
419 part = fdisk_part_first(dev);
420 while (part != NULL) {
421 fdisk_part_remove(part);
422 part = fdisk_part_first(dev);
423 }
424}
425
426int fdisk_dev_open(fdisk_t *fdisk, service_id_t sid, fdisk_dev_t **rdev)
427{
428 fdisk_dev_t *dev = NULL;
429 service_id_t *psids = NULL;
430 size_t nparts, i;
431 int rc;
432
433 dev = calloc(1, sizeof(fdisk_dev_t));
434 if (dev == NULL)
435 return ENOMEM;
436
437 dev->fdisk = fdisk;
438 dev->sid = sid;
439 list_initialize(&dev->parts);
440 list_initialize(&dev->pri_idx);
441 list_initialize(&dev->pri_ba);
442 list_initialize(&dev->log_ba);
443
444 rc = fdisk_update_dev_info(dev);
445 if (rc != EOK) {
446 rc = EIO;
447 goto error;
448 }
449
450 rc = vbd_label_get_parts(fdisk->vbd, sid, &psids, &nparts);
451 if (rc != EOK) {
452 rc = EIO;
453 goto error;
454 }
455
456 for (i = 0; i < nparts; i++) {
457 rc = fdisk_part_add(dev, psids[i], NULL);
458 if (rc != EOK) {
459 goto error;
460 }
461 }
462
463 free(psids);
464 *rdev = dev;
465 return EOK;
466error:
467 fdisk_dev_close(dev);
468 return rc;
469}
470
471void fdisk_dev_close(fdisk_dev_t *dev)
472{
473 if (dev == NULL)
474 return;
475
476 fdisk_dev_remove_parts(dev);
477 free(dev);
478}
479
480/** Erase contents of unlabeled disk. */
481int fdisk_dev_erase(fdisk_dev_t *dev)
482{
483 fdisk_part_t *part;
484 int rc;
485
486 if (dev->dinfo.ltype != lt_none)
487 return EINVAL;
488
489 part = fdisk_part_first(dev);
490 assert(part != NULL);
491 if (part->pcnt == vpc_empty)
492 return EINVAL;
493
494 rc = vol_part_empty(dev->fdisk->vol, part->svc_id);
495 if (rc != EOK) {
496 return rc;
497 }
498
499 part->pcnt = vpc_empty;
500 return EOK;
501}
502
503void fdisk_dev_get_flags(fdisk_dev_t *dev, fdisk_dev_flags_t *rflags)
504{
505 fdisk_dev_flags_t flags;
506 fdisk_part_t *part;
507
508 flags = 0;
509
510 /* fdf_can_create_label */
511 if (dev->dinfo.ltype == lt_none) {
512 part = fdisk_part_first(dev);
513 assert(part != NULL);
514 if (part->pcnt == vpc_empty)
515 flags |= fdf_can_create_label;
516 else
517 flags |= fdf_can_erase_dev;
518 } else {
519 flags |= fdf_can_delete_label;
520 }
521
522 *rflags = flags;
523}
524
525int fdisk_dev_get_svcname(fdisk_dev_t *dev, char **rname)
526{
527 char *name;
528 int rc;
529
530 rc = loc_service_get_name(dev->sid, &name);
531 if (rc != EOK)
532 return rc;
533
534 *rname = name;
535 return EOK;
536}
537
538int fdisk_dev_capacity(fdisk_dev_t *dev, cap_spec_t *cap)
539{
540 cap_from_blocks(dev->dinfo.nblocks, dev->dinfo.block_size, cap);
541 return EOK;
542}
543
544int fdisk_label_get_info(fdisk_dev_t *dev, fdisk_label_info_t *info)
545{
546 vbd_disk_info_t vinfo;
547 uint64_t b0, nb;
548 uint64_t hdrb;
549 int rc;
550
551 rc = vbd_disk_info(dev->fdisk->vbd, dev->sid, &vinfo);
552 if (rc != EOK) {
553 rc = EIO;
554 goto error;
555 }
556
557 info->ltype = vinfo.ltype;
558 info->flags = vinfo.flags;
559
560 if ((info->flags & lf_can_create_pri) != 0 ||
561 (info->flags & lf_can_create_ext) != 0) {
562 /* Verify there is enough space to create partition */
563
564 rc = fdisk_part_get_max_free_range(dev, spc_pri, &b0, &nb);
565 if (rc != EOK)
566 info->flags &= ~(lf_can_create_pri | lf_can_create_ext);
567 }
568
569 if ((info->flags & lf_can_create_log) != 0) {
570 /* Verify there is enough space to create logical partition */
571 hdrb = max(1, dev->align);
572 rc = fdisk_part_get_max_free_range(dev, spc_log, &b0, &nb);
573 if (rc != EOK || nb <= hdrb)
574 info->flags &= ~lf_can_create_log;
575 }
576
577 return EOK;
578error:
579 return rc;
580}
581
582int fdisk_label_create(fdisk_dev_t *dev, label_type_t ltype)
583{
584 fdisk_part_t *part;
585 int rc;
586
587 /* Disk must not contain a label. */
588 if (dev->dinfo.ltype != lt_none)
589 return EEXIST;
590
591 /* Dummy partition spanning entire disk must be considered empty */
592 part = fdisk_part_first(dev);
593 assert(part != NULL);
594 if (part->pcnt != vpc_empty)
595 return EEXIST;
596
597 /* Remove dummy partition */
598 fdisk_dev_remove_parts(dev);
599
600 rc = vbd_label_create(dev->fdisk->vbd, dev->sid, ltype);
601 if (rc != EOK) {
602 /* Re-add dummy partition */
603 (void) fdisk_dev_add_parts(dev);
604 return rc;
605 }
606
607 rc = fdisk_update_dev_info(dev);
608 if (rc != EOK)
609 return rc;
610
611 return EOK;
612}
613
614int fdisk_label_destroy(fdisk_dev_t *dev)
615{
616 fdisk_part_t *part;
617 fdisk_dev_flags_t dflags;
618 int rc;
619
620 part = fdisk_part_first(dev);
621 while (part != NULL) {
622 rc = fdisk_part_destroy(part);
623 if (rc != EOK)
624 return EIO;
625 part = fdisk_part_first(dev);
626 }
627
628 rc = vbd_label_delete(dev->fdisk->vbd, dev->sid);
629 if (rc != EOK)
630 return EIO;
631
632 rc = fdisk_dev_add_parts(dev);
633 if (rc != EOK)
634 return rc;
635
636 /* Make sure device is considered empty */
637 fdisk_dev_get_flags(dev, &dflags);
638 if ((dflags & fdf_can_erase_dev) != 0) {
639 rc = fdisk_dev_erase(dev);
640 if (rc != EOK)
641 return rc;
642 }
643
644 return EOK;
645}
646
647fdisk_part_t *fdisk_part_first(fdisk_dev_t *dev)
648{
649 link_t *link;
650
651 link = list_first(&dev->parts);
652 if (link == NULL)
653 return NULL;
654
655 return list_get_instance(link, fdisk_part_t, lparts);
656}
657
658fdisk_part_t *fdisk_part_next(fdisk_part_t *part)
659{
660 link_t *link;
661
662 link = list_next(&part->lparts, &part->dev->parts);
663 if (link == NULL)
664 return NULL;
665
666 return list_get_instance(link, fdisk_part_t, lparts);
667}
668
669int fdisk_part_get_info(fdisk_part_t *part, fdisk_part_info_t *info)
670{
671 info->capacity = part->capacity;
672 info->pcnt = part->pcnt;
673 info->fstype = part->fstype;
674 info->pkind = part->pkind;
675 info->label = part->label;
676 return EOK;
677}
678
679/** Get size of largest free block. */
680int fdisk_part_get_max_avail(fdisk_dev_t *dev, fdisk_spc_t spc, cap_spec_t *cap)
681{
682 int rc;
683 uint64_t b0;
684 uint64_t nb;
685 aoff64_t hdrb;
686
687 rc = fdisk_part_get_max_free_range(dev, spc, &b0, &nb);
688 if (rc != EOK)
689 return rc;
690
691 /* For logical partitions we need to subtract header size */
692 if (spc == spc_log) {
693 hdrb = max(1, dev->align);
694 if (nb <= hdrb)
695 return ENOSPC;
696 nb -= hdrb;
697 }
698
699 cap_from_blocks(nb, dev->dinfo.block_size, cap);
700 return EOK;
701}
702
703/** Get total free space capacity. */
704int fdisk_part_get_tot_avail(fdisk_dev_t *dev, fdisk_spc_t spc,
705 cap_spec_t *cap)
706{
707 fdisk_free_range_t fr;
708 uint64_t hdrb;
709 uint64_t b0;
710 uint64_t nb;
711 uint64_t totb;
712
713 if (spc == spc_log)
714 hdrb = max(1, dev->align);
715 else
716 hdrb = 0;
717
718 totb = 0;
719 fdisk_free_range_first(dev, spc, &fr);
720 do {
721 if (fdisk_free_range_get(&fr, &b0, &nb)) {
722 if (nb > hdrb)
723 totb += nb - hdrb;
724 }
725 } while (fdisk_free_range_next(&fr));
726
727 cap_from_blocks(totb, dev->dinfo.block_size, cap);
728 return EOK;
729}
730
731int fdisk_part_create(fdisk_dev_t *dev, fdisk_part_spec_t *pspec,
732 fdisk_part_t **rpart)
733{
734 fdisk_part_t *part = NULL;
735 vbd_part_spec_t vpspec;
736 vbd_part_id_t partid = 0;
737 vol_part_info_t vpinfo;
738 const char *label;
739 int rc;
740
741 label = pspec->label != NULL ? pspec->label : "";
742
743 rc = fdisk_part_spec_prepare(dev, pspec, &vpspec);
744 if (rc != EOK) {
745 rc = EIO;
746 goto error;
747 }
748
749 rc = vbd_part_create(dev->fdisk->vbd, dev->sid, &vpspec, &partid);
750 if (rc != EOK) {
751 rc = EIO;
752 goto error;
753 }
754
755 rc = fdisk_part_add(dev, partid, &part);
756 if (rc != EOK) {
757 rc = EIO;
758 goto error;
759 }
760
761 if (part->svc_id != 0) {
762 rc = vol_part_mkfs(dev->fdisk->vol, part->svc_id, pspec->fstype,
763 label);
764 if (rc != EOK && rc != ENOTSUP) {
765 rc = EIO;
766 goto error;
767 }
768
769 /* Get the real label value */
770 rc = vol_part_info(dev->fdisk->vol, part->svc_id, &vpinfo);
771 if (rc != EOK) {
772 rc = EIO;
773 goto error;
774 }
775
776 part->pcnt = vpinfo.pcnt;
777 part->fstype = vpinfo.fstype;
778 part->label = str_dup(vpinfo.label);
779
780 if (part->label == NULL) {
781 rc = EIO;
782 goto error;
783 }
784 }
785
786 if (rpart != NULL)
787 *rpart = part;
788 return EOK;
789error:
790 /* Try rolling back */
791 if (part != NULL)
792 fdisk_part_remove(part);
793 if (partid != 0)
794 (void) vbd_part_delete(dev->fdisk->vbd, partid);
795 return rc;
796}
797
798int fdisk_part_destroy(fdisk_part_t *part)
799{
800 int rc;
801
802 rc = vbd_part_delete(part->dev->fdisk->vbd, part->part_id);
803 if (rc != EOK)
804 return EIO;
805
806 fdisk_part_remove(part);
807 return EOK;
808}
809
810void fdisk_pspec_init(fdisk_part_spec_t *pspec)
811{
812 memset(pspec, 0, sizeof(fdisk_part_spec_t));
813}
814
815int fdisk_ltype_format(label_type_t ltype, char **rstr)
816{
817 const char *sltype;
818 char *s;
819
820 sltype = NULL;
821 switch (ltype) {
822 case lt_none:
823 sltype = "None";
824 break;
825 case lt_mbr:
826 sltype = "MBR";
827 break;
828 case lt_gpt:
829 sltype = "GPT";
830 break;
831 }
832
833 s = str_dup(sltype);
834 if (s == NULL)
835 return ENOMEM;
836
837 *rstr = s;
838 return EOK;
839}
840
841int fdisk_fstype_format(vol_fstype_t fstype, char **rstr)
842{
843 const char *sfstype;
844 char *s;
845
846 sfstype = NULL;
847 switch (fstype) {
848 case fs_exfat:
849 sfstype = "ExFAT";
850 break;
851 case fs_fat:
852 sfstype = "FAT";
853 break;
854 case fs_minix:
855 sfstype = "MINIX";
856 break;
857 case fs_ext4:
858 sfstype = "Ext4";
859 break;
860 case fs_cdfs:
861 sfstype = "ISO 9660";
862 break;
863 }
864
865 s = str_dup(sfstype);
866 if (s == NULL)
867 return ENOMEM;
868
869 *rstr = s;
870 return EOK;
871}
872
873int fdisk_pkind_format(label_pkind_t pkind, char **rstr)
874{
875 const char *spkind;
876 char *s;
877
878 spkind = NULL;
879 switch (pkind) {
880 case lpk_primary:
881 spkind = "Primary";
882 break;
883 case lpk_extended:
884 spkind = "Extended";
885 break;
886 case lpk_logical:
887 spkind = "Logical";
888 break;
889 }
890
891 s = str_dup(spkind);
892 if (s == NULL)
893 return ENOMEM;
894
895 *rstr = s;
896 return EOK;
897}
898
899/** Get free partition index. */
900static int fdisk_part_get_free_idx(fdisk_dev_t *dev, int *rindex)
901{
902 link_t *link;
903 fdisk_part_t *part;
904 int nidx;
905
906 link = list_first(&dev->pri_idx);
907 nidx = 1;
908 while (link != NULL) {
909 part = list_get_instance(link, fdisk_part_t, lpri_idx);
910 if (part->index > nidx)
911 break;
912 nidx = part->index + 1;
913 link = list_next(link, &dev->pri_idx);
914 }
915
916 if (nidx > 4 /* XXXX actual number of slots*/) {
917 return ELIMIT;
918 }
919
920 *rindex = nidx;
921 return EOK;
922}
923
924/** Get free range of blocks.
925 *
926 * Get free range of blocks of at least the specified size (first fit).
927 */
928static int fdisk_part_get_free_range(fdisk_dev_t *dev, aoff64_t nblocks,
929 fdisk_spc_t spc, aoff64_t *rblock0, aoff64_t *rnblocks)
930{
931 fdisk_free_range_t fr;
932 uint64_t b0;
933 uint64_t nb;
934
935 fdisk_free_range_first(dev, spc, &fr);
936 do {
937 if (fdisk_free_range_get(&fr, &b0, &nb)) {
938 if (nb >= nblocks) {
939 *rblock0 = b0;
940 *rnblocks = nb;
941 return EOK;
942 }
943 }
944 } while (fdisk_free_range_next(&fr));
945
946 /* No conforming free range found */
947 return ENOSPC;
948}
949
950/** Get largest free range of blocks.
951 *
952 * Get free range of blocks of the maximum size.
953 */
954static int fdisk_part_get_max_free_range(fdisk_dev_t *dev, fdisk_spc_t spc,
955 aoff64_t *rblock0, aoff64_t *rnblocks)
956{
957 fdisk_free_range_t fr;
958 uint64_t b0;
959 uint64_t nb;
960 uint64_t best_b0;
961 uint64_t best_nb;
962
963 best_b0 = best_nb = 0;
964 fdisk_free_range_first(dev, spc, &fr);
965 do {
966 if (fdisk_free_range_get(&fr, &b0, &nb)) {
967 if (nb > best_nb) {
968 best_b0 = b0;
969 best_nb = nb;
970 }
971 }
972 } while (fdisk_free_range_next(&fr));
973
974 if (best_nb == 0)
975 return ENOSPC;
976
977 *rblock0 = best_b0;
978 *rnblocks = best_nb;
979 return EOK;
980}
981
982/** Prepare new partition specification for VBD. */
983static int fdisk_part_spec_prepare(fdisk_dev_t *dev, fdisk_part_spec_t *pspec,
984 vbd_part_spec_t *vpspec)
985{
986 aoff64_t nom_blocks;
987 aoff64_t min_blocks;
988 aoff64_t max_blocks;
989 aoff64_t act_blocks;
990 aoff64_t fblock0;
991 aoff64_t fnblocks;
992 aoff64_t hdrb;
993 label_pcnt_t pcnt;
994 fdisk_spc_t spc;
995 int index;
996 int rc;
997
998 rc = cap_spec_to_blocks(&pspec->capacity, cv_nom, dev->dinfo.block_size,
999 &nom_blocks);
1000 if (rc != EOK)
1001 return rc;
1002
1003 rc = cap_spec_to_blocks(&pspec->capacity, cv_min, dev->dinfo.block_size,
1004 &min_blocks);
1005 if (rc != EOK)
1006 return rc;
1007
1008 rc = cap_spec_to_blocks(&pspec->capacity, cv_max, dev->dinfo.block_size,
1009 &max_blocks);
1010 if (rc != EOK)
1011 return rc;
1012
1013 nom_blocks = fdisk_ba_align_up(dev, nom_blocks);
1014 min_blocks = fdisk_ba_align_up(dev, min_blocks);
1015 max_blocks = fdisk_ba_align_up(dev, max_blocks);
1016
1017 pcnt = -1;
1018
1019 switch (pspec->fstype) {
1020 case fs_exfat:
1021 pcnt = lpc_exfat;
1022 break;
1023 case fs_fat:
1024 pcnt = lpc_fat32; /* XXX Detect FAT12/16 vs FAT32 */
1025 break;
1026 case fs_minix:
1027 pcnt = lpc_minix;
1028 break;
1029 case fs_ext4:
1030 pcnt = lpc_ext4;
1031 break;
1032 case fs_cdfs:
1033 return EINVAL; /* You cannot create an ISO partition */
1034 }
1035
1036 if (pcnt < 0)
1037 return EINVAL;
1038
1039 if (pspec->pkind == lpk_logical) {
1040 hdrb = max(1, dev->align);
1041 spc = spc_log;
1042 } else {
1043 hdrb = 0;
1044 spc = spc_pri;
1045 }
1046
1047 rc = fdisk_part_get_free_range(dev, hdrb + nom_blocks, spc,
1048 &fblock0, &fnblocks);
1049
1050 if (rc == EOK) {
1051 /*
1052 * If the size of the free range would still give the same capacity
1053 * when rounded, allocate entire range. Otherwise allocate exactly
1054 * what we were asked for.
1055 */
1056 if (fnblocks <= max_blocks) {
1057 act_blocks = fnblocks;
1058 } else {
1059 act_blocks = hdrb + nom_blocks;
1060 }
1061 } else {
1062 assert(rc == ENOSPC);
1063
1064 /*
1065 * There is no free range that can contain exactly the requested
1066 * capacity. Try to allocate at least such number of blocks
1067 * that would still fullfill the request within the limits
1068 * of the precision with witch the capacity was specified
1069 * (i.e. when rounded up).
1070 */
1071 rc = fdisk_part_get_free_range(dev, hdrb + min_blocks, spc,
1072 &fblock0, &fnblocks);
1073 if (rc != EOK)
1074 return rc;
1075
1076 assert(fnblocks < hdrb + nom_blocks);
1077 act_blocks = fnblocks;
1078 }
1079
1080 if (pspec->pkind != lpk_logical) {
1081 rc = fdisk_part_get_free_idx(dev, &index);
1082 if (rc != EOK)
1083 return EIO;
1084 } else {
1085 index = 0;
1086 }
1087
1088 memset(vpspec, 0, sizeof(vbd_part_spec_t));
1089 vpspec->index = index;
1090 vpspec->hdr_blocks = hdrb;
1091 vpspec->block0 = fblock0 + hdrb;
1092 vpspec->nblocks = act_blocks - hdrb;
1093 vpspec->pkind = pspec->pkind;
1094
1095 if (pspec->pkind != lpk_extended) {
1096 rc = vbd_suggest_ptype(dev->fdisk->vbd, dev->sid, pcnt,
1097 &vpspec->ptype);
1098 if (rc != EOK)
1099 return EIO;
1100 }
1101
1102 return EOK;
1103}
1104
1105static int fdisk_update_dev_info(fdisk_dev_t *dev)
1106{
1107 int rc;
1108 size_t align_bytes;
1109 uint64_t avail_cap;
1110
1111 rc = vbd_disk_info(dev->fdisk->vbd, dev->sid, &dev->dinfo);
1112 if (rc != EOK)
1113 return EIO;
1114
1115 /* Capacity available for partition in bytes */
1116 avail_cap = dev->dinfo.anblocks * dev->dinfo.block_size;
1117
1118 /* Determine optimum alignment */
1119 align_bytes = 1024 * 1024; /* 1 MiB */
1120 while (align_bytes > 1 && avail_cap / align_bytes < 256) {
1121 align_bytes = align_bytes / 16;
1122 }
1123
1124 dev->align = align_bytes / dev->dinfo.block_size;
1125 if (dev->align < 1)
1126 dev->align = 1;
1127 return EOK;
1128}
1129
1130static uint64_t fdisk_ba_align_up(fdisk_dev_t *dev, uint64_t ba)
1131{
1132 return ((ba + dev->align - 1) / dev->align) * dev->align;
1133}
1134
1135static uint64_t fdisk_ba_align_down(fdisk_dev_t *dev, uint64_t ba)
1136{
1137 return ba - (ba % dev->align);
1138}
1139
1140static void fdisk_free_range_first(fdisk_dev_t *dev, fdisk_spc_t spc,
1141 fdisk_free_range_t *fr)
1142{
1143 link_t *link;
1144
1145 fr->dev = dev;
1146 fr->spc = spc;
1147
1148 if (fr->spc == spc_pri) {
1149 /* Primary partitions */
1150 fr->b0 = fdisk_ba_align_up(fr->dev, fr->dev->dinfo.ablock0);
1151
1152 link = list_first(&dev->pri_ba);
1153 if (link != NULL)
1154 fr->npart = list_get_instance(link, fdisk_part_t, lpri_ba);
1155 else
1156 fr->npart = NULL;
1157 } else { /* fr->spc == spc_log */
1158 /* Logical partitions */
1159 fr->b0 = fdisk_ba_align_up(fr->dev, fr->dev->ext_part->block0);
1160
1161 link = list_first(&dev->log_ba);
1162 if (link != NULL)
1163 fr->npart = list_get_instance(link, fdisk_part_t, llog_ba);
1164 else
1165 fr->npart = NULL;
1166 }
1167}
1168
1169static bool fdisk_free_range_next(fdisk_free_range_t *fr)
1170{
1171 link_t *link;
1172
1173 if (fr->npart == NULL)
1174 return false;
1175
1176 fr->b0 = fdisk_ba_align_up(fr->dev, fr->npart->block0 +
1177 fr->npart->nblocks);
1178
1179 if (fr->spc == spc_pri) {
1180 /* Primary partitions */
1181 link = list_next(&fr->npart->lpri_ba, &fr->dev->pri_ba);
1182 if (link != NULL)
1183 fr->npart = list_get_instance(link, fdisk_part_t, lpri_ba);
1184 else
1185 fr->npart = NULL;
1186 } else { /* fr->spc == spc_log */
1187 /* Logical partitions */
1188 link = list_next(&fr->npart->llog_ba, &fr->dev->log_ba);
1189 if (link != NULL)
1190 fr->npart = list_get_instance(link, fdisk_part_t, llog_ba);
1191 else
1192 fr->npart = NULL;
1193 }
1194
1195 return true;
1196}
1197
1198static bool fdisk_free_range_get(fdisk_free_range_t *fr,
1199 aoff64_t *b0, aoff64_t *nb)
1200{
1201 aoff64_t b1;
1202
1203 if (fr->npart != NULL) {
1204 b1 = fdisk_ba_align_down(fr->dev, fr->npart->block0);
1205 } else {
1206 if (fr->spc == spc_pri) {
1207 b1 = fdisk_ba_align_down(fr->dev,
1208 fr->dev->dinfo.ablock0 + fr->dev->dinfo.anblocks);
1209 } else { /* fr->spc == spc_log */
1210 b1 = fdisk_ba_align_down(fr->dev,
1211 fr->dev->ext_part->block0 + fr->dev->ext_part->nblocks);
1212 }
1213 }
1214
1215 if (b1 < fr->b0)
1216 return false;
1217
1218 *b0 = fr->b0;
1219 *nb = b1 - fr->b0;
1220
1221 return true;
1222}
1223
1224/** Get volume label support. */
1225int fdisk_get_vollabel_support(fdisk_dev_t *dev, vol_fstype_t fstype,
1226 vol_label_supp_t *vlsupp)
1227{
1228 return vol_part_get_lsupp(dev->fdisk->vol, fstype, vlsupp);
1229}
1230
1231/** @}
1232 */
Note: See TracBrowser for help on using the repository browser.