source: mainline/uspace/app/fdisk/fdisk.c@ 9c4cf0d

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

Slightly more graceful handling of missing devices in fdisk.
  • Property mode set to 100644
File size: 20.2 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 fdisk
30 * @brief Disk management tool
31 * @{
32 */
33/**
34 * @file
35 */
36
37#include <errno.h>
38#include <nchoice.h>
39#include <stdbool.h>
40#include <stdio.h>
41#include <stdlib.h>
42#include <fdisk.h>
43
44static bool quit = false;
45static fdisk_t *fdisk;
46
47/** Device menu actions */
48typedef enum {
49 /** Create label */
50 devac_create_label,
51 /** Delete label */
52 devac_delete_label,
53 /** Erase disk */
54 devac_erase_disk,
55 /** Create (primary) partition */
56 devac_create_pri_part,
57 /** Create extended partition */
58 devac_create_ext_part,
59 /** Create logical partition */
60 devac_create_log_part,
61 /** Delete partition */
62 devac_delete_part,
63 /** Exit */
64 devac_exit
65} devac_t;
66
67static int fdsk_pcnt_fs_format(vol_part_cnt_t pcnt, vol_fstype_t fstype,
68 char **rstr)
69{
70 int rc;
71 char *s;
72
73 switch (pcnt) {
74 case vpc_empty:
75 s = str_dup("Empty");
76 if (s == NULL)
77 return ENOMEM;
78 break;
79 case vpc_fs:
80 rc = fdisk_fstype_format(fstype, &s);
81 if (rc != EOK)
82 return ENOMEM;
83 break;
84 case vpc_unknown:
85 s = str_dup("Unknown");
86 if (s == NULL)
87 return ENOMEM;
88 break;
89 }
90
91 *rstr = s;
92 return EOK;
93}
94
95/** Confirm user selection. */
96static int fdsk_confirm(const char *msg, bool *rconfirm)
97{
98 tinput_t *tinput = NULL;
99 char *answer;
100 int rc;
101
102 tinput = tinput_new();
103 if (tinput == NULL) {
104 rc = ENOMEM;
105 goto error;
106 }
107
108 rc = tinput_set_prompt(tinput, "y/n> ");
109 if (rc != EOK)
110 goto error;
111
112 while (true) {
113 printf("%s\n", msg);
114
115 rc = tinput_read(tinput, &answer);
116 if (rc == ENOENT) {
117 *rconfirm = false;
118 free(answer);
119 break;
120 }
121
122 if (rc != EOK)
123 goto error;
124
125 if (str_cmp(answer, "y") == 0) {
126 *rconfirm = true;
127 free(answer);
128 break;
129 } else if (str_cmp(answer, "n") == 0) {
130 *rconfirm = false;
131 free(answer);
132 break;
133 }
134 }
135
136 tinput_destroy(tinput);
137 return EOK;
138error:
139 if (tinput != NULL)
140 tinput_destroy(tinput);
141 return rc;
142}
143
144/** Device selection */
145static int fdsk_dev_sel_choice(service_id_t *rsvcid)
146{
147 fdisk_dev_list_t *devlist = NULL;
148 fdisk_dev_info_t *info;
149 nchoice_t *choice = NULL;
150 char *svcname = NULL;
151 fdisk_cap_t cap;
152 fdisk_dev_info_t *sdev;
153 char *scap = NULL;
154 char *dtext = NULL;
155 service_id_t svcid;
156 void *sel;
157 int ndevs;
158 int rc;
159
160 rc = nchoice_create(&choice);
161 if (rc != EOK) {
162 assert(rc == ENOMEM);
163 printf("Out of memory.\n");
164 goto error;
165 }
166
167 rc = nchoice_set_prompt(choice, "Select device");
168 if (rc != EOK) {
169 assert(rc == ENOMEM);
170 printf("Out of memory.\n");
171 goto error;
172 }
173
174 rc = fdisk_dev_list_get(fdisk, &devlist);
175 if (rc != EOK) {
176 printf("Error getting device list.\n");
177 goto error;
178 }
179
180 info = fdisk_dev_first(devlist);
181 ndevs = 0;
182 while (info != NULL) {
183 rc = fdisk_dev_info_get_svcname(info, &svcname);
184 if (rc != EOK) {
185 fdisk_dev_info_get_svcid(info, &svcid);
186 printf("Error getting device service name "
187 "(service ID %zu).\n", svcid);
188 info = fdisk_dev_next(info);
189 continue;
190 }
191
192 rc = fdisk_dev_info_capacity(info, &cap);
193 if (rc != EOK) {
194 printf("Error getting device capacity "
195 "(device %s).\n", svcname);
196 info = fdisk_dev_next(info);
197 continue;
198 }
199
200 fdisk_cap_simplify(&cap);
201
202 rc = fdisk_cap_format(&cap, &scap);
203 if (rc != EOK) {
204 assert(rc == ENOMEM);
205 printf("Out of memory.\n");
206 goto error;
207 }
208
209 rc = asprintf(&dtext, "%s (%s)", svcname, scap);
210 if (rc < 0) {
211 rc = ENOMEM;
212 printf("Out of memory.\n");
213 goto error;
214 }
215
216 free(svcname);
217 svcname = NULL;
218 free(scap);
219 scap = NULL;
220
221 rc = nchoice_add(choice, dtext, info, 0);
222 if (rc != EOK) {
223 assert(rc == ENOMEM);
224 printf("Out of memory.\n");
225 goto error;
226 }
227
228 ++ndevs;
229
230 free(dtext);
231 dtext = NULL;
232
233 info = fdisk_dev_next(info);
234 }
235
236 if (ndevs == 0) {
237 printf("No disk devices found.\n");
238 rc = ENOENT;
239 goto error;
240 }
241
242 rc = nchoice_add(choice, "Exit", NULL, 0);
243 if (rc != EOK) {
244 assert(rc == ENOMEM);
245 printf("Out of memory.\n");
246 goto error;
247 }
248
249 rc = nchoice_get(choice, &sel);
250 if (rc != EOK) {
251 printf("Error getting user selection.\n");
252 return rc;
253 }
254
255 sdev = (fdisk_dev_info_t *)sel;
256 if (sdev != NULL) {
257 fdisk_dev_info_get_svcid(sdev, &svcid);
258 } else {
259 svcid = 0;
260 }
261
262 fdisk_dev_list_free(devlist);
263
264 nchoice_destroy(choice);
265 *rsvcid = svcid;
266 return EOK;
267error:
268 if (devlist != NULL)
269 fdisk_dev_list_free(devlist);
270 if (choice != NULL)
271 nchoice_destroy(choice);
272 free(dtext);
273 free(svcname);
274 free(scap);
275 return rc;
276}
277
278static int fdsk_create_label(fdisk_dev_t *dev)
279{
280 nchoice_t *choice = NULL;
281 void *sel;
282 char *sltype = NULL;
283 int i;
284 int rc;
285
286 rc = nchoice_create(&choice);
287 if (rc != EOK) {
288 assert(rc == ENOMEM);
289 printf("Out of memory.\n");
290 goto error;
291 }
292
293 rc = nchoice_set_prompt(choice, "Select label type");
294 if (rc != EOK) {
295 assert(rc == ENOMEM);
296 printf("Out of memory.\n");
297 goto error;
298 }
299
300 for (i = LT_FIRST; i < LT_LIMIT; i++) {
301 rc = fdisk_ltype_format(i, &sltype);
302 if (rc != EOK)
303 goto error;
304
305 rc = nchoice_add(choice, sltype, (void *)(uintptr_t)i,
306 i == LT_DEFAULT);
307 if (rc != EOK) {
308 assert(rc == ENOMEM);
309 printf("Out of memory.\n");
310 goto error;
311 }
312
313 free(sltype);
314 sltype = NULL;
315 }
316
317 rc = nchoice_get(choice, &sel);
318 if (rc != EOK) {
319 printf("Error getting user selection.\n");
320 goto error;
321 }
322
323 rc = fdisk_label_create(dev, (label_type_t)sel);
324 if (rc != EOK) {
325 printf("Error creating label.\n");
326 goto error;
327 }
328
329 nchoice_destroy(choice);
330 return EOK;
331error:
332 free(sltype);
333 if (choice != NULL)
334 nchoice_destroy(choice);
335 return rc;
336}
337
338static int fdsk_delete_label(fdisk_dev_t *dev)
339{
340 bool confirm;
341 int rc;
342
343 rc = fdsk_confirm("Warning. Any data on disk will be lost. "
344 "Really delete label?", &confirm);
345 if (rc != EOK) {
346 printf("Error getting user confirmation.\n");
347 return rc;
348 }
349
350 if (!confirm)
351 return EOK;
352
353 rc = fdisk_label_destroy(dev);
354 if (rc != EOK) {
355 printf("Error deleting label.\n");
356 return rc;
357 }
358
359 return EOK;
360}
361
362static int fdsk_erase_disk(fdisk_dev_t *dev)
363{
364 bool confirm;
365 int rc;
366
367 rc = fdsk_confirm("Warning. Any data on disk will be lost. "
368 "Really erase disk?", &confirm);
369 if (rc != EOK) {
370 printf("Error getting user confirmation.\n");
371 return rc;
372 }
373
374 if (!confirm)
375 return EOK;
376
377 rc = fdisk_dev_erase(dev);
378 if (rc != EOK) {
379 printf("Error erasing disk.\n");
380 return rc;
381 }
382
383 return EOK;
384}
385
386static int fdsk_select_fstype(vol_fstype_t *fstype)
387{
388 nchoice_t *choice = NULL;
389 void *sel;
390 char *sfstype;
391 int i;
392 int rc;
393
394 rc = nchoice_create(&choice);
395 if (rc != EOK) {
396 assert(rc == ENOMEM);
397 printf("Out of memory.\n");
398 goto error;
399 }
400
401 rc = nchoice_set_prompt(choice, "Select file system type");
402 if (rc != EOK) {
403 assert(rc == ENOMEM);
404 printf("Out of memory.\n");
405 goto error;
406 }
407
408 for (i = 0; i < VOL_FSTYPE_LIMIT; i++) {
409 rc = fdisk_fstype_format(i, &sfstype);
410 if (rc != EOK)
411 goto error;
412
413 rc = nchoice_add(choice, sfstype, (void *)(uintptr_t)i,
414 i == VOL_FSTYPE_DEFAULT);
415 if (rc != EOK) {
416 assert(rc == ENOMEM);
417 printf("Out of memory.\n");
418 goto error;
419 }
420
421 free(sfstype);
422 sfstype = NULL;
423 }
424
425 rc = nchoice_get(choice, &sel);
426 if (rc != EOK) {
427 printf("Error getting user selection.\n");
428 goto error;
429 }
430
431 nchoice_destroy(choice);
432 *fstype = (vol_fstype_t)sel;
433 return EOK;
434error:
435 free(sfstype);
436 if (choice != NULL)
437 nchoice_destroy(choice);
438 return rc;
439}
440
441static int fdsk_create_part(fdisk_dev_t *dev, label_pkind_t pkind)
442{
443 int rc;
444 fdisk_part_spec_t pspec;
445 fdisk_cap_t cap;
446 fdisk_cap_t mcap;
447 vol_fstype_t fstype = 0;
448 tinput_t *tinput = NULL;
449 fdisk_spc_t spc;
450 char *scap;
451 char *smcap = NULL;
452
453 if (pkind == lpk_logical)
454 spc = spc_log;
455 else
456 spc = spc_pri;
457
458 rc = fdisk_part_get_max_avail(dev, spc, &mcap);
459 if (rc != EOK) {
460 rc = EIO;
461 goto error;
462 }
463
464 fdisk_cap_simplify(&mcap);
465
466 rc = fdisk_cap_format(&mcap, &smcap);
467 if (rc != EOK) {
468 rc = ENOMEM;
469 goto error;
470 }
471
472 tinput = tinput_new();
473 if (tinput == NULL) {
474 rc = ENOMEM;
475 goto error;
476 }
477
478 rc = tinput_set_prompt(tinput, "?> ");
479 if (rc != EOK)
480 goto error;
481
482 while (true) {
483 printf("Enter capacity of new partition.\n");
484 rc = tinput_read_i(tinput, smcap, &scap);
485 if (rc != EOK)
486 goto error;
487
488 rc = fdisk_cap_parse(scap, &cap);
489 if (rc == EOK)
490 break;
491 }
492
493 tinput_destroy(tinput);
494 tinput = NULL;
495 free(smcap);
496 smcap = NULL;
497
498 if (pkind != lpk_extended) {
499 rc = fdsk_select_fstype(&fstype);
500 if (rc != EOK)
501 goto error;
502 }
503
504 fdisk_pspec_init(&pspec);
505 pspec.capacity = cap;
506 pspec.pkind = pkind;
507 pspec.fstype = fstype;
508
509 rc = fdisk_part_create(dev, &pspec, NULL);
510 if (rc != EOK) {
511 printf("Error creating partition.\n");
512 goto error;
513 }
514
515 return EOK;
516error:
517 free(smcap);
518 if (tinput != NULL)
519 tinput_destroy(tinput);
520 return rc;
521}
522
523static int fdsk_delete_part(fdisk_dev_t *dev)
524{
525 nchoice_t *choice = NULL;
526 fdisk_part_t *part;
527 fdisk_part_info_t pinfo;
528 char *scap = NULL;
529 char *spkind = NULL;
530 char *sfstype = NULL;
531 char *sdesc = NULL;
532 bool confirm;
533 void *sel;
534 int rc;
535
536 rc = nchoice_create(&choice);
537 if (rc != EOK) {
538 assert(rc == ENOMEM);
539 printf("Out of memory.\n");
540 goto error;
541 }
542
543 rc = nchoice_set_prompt(choice, "Select partition to delete");
544 if (rc != EOK) {
545 assert(rc == ENOMEM);
546 printf("Out of memory.\n");
547 goto error;
548 }
549
550 part = fdisk_part_first(dev);
551 while (part != NULL) {
552 rc = fdisk_part_get_info(part, &pinfo);
553 if (rc != EOK) {
554 printf("Error getting partition information.\n");
555 goto error;
556 }
557
558 fdisk_cap_simplify(&pinfo.capacity);
559
560 rc = fdisk_cap_format(&pinfo.capacity, &scap);
561 if (rc != EOK) {
562 printf("Out of memory.\n");
563 goto error;
564 }
565
566 rc = fdisk_pkind_format(pinfo.pkind, &spkind);
567 if (rc != EOK) {
568 printf("\nOut of memory.\n");
569 goto error;
570 }
571
572 if (pinfo.pkind != lpk_extended) {
573 rc = fdsk_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
574 if (rc != EOK) {
575 printf("Out of memory.\n");
576 goto error;
577 }
578
579 rc = asprintf(&sdesc, "%s, %s, %s", scap, spkind, sfstype);
580 if (rc < 0) {
581 rc = ENOMEM;
582 goto error;
583 }
584
585 } else {
586 rc = asprintf(&sdesc, "%s, %s", scap, spkind);
587 if (rc < 0) {
588 rc = ENOMEM;
589 goto error;
590 }
591 }
592
593 rc = nchoice_add(choice, sdesc, (void *)part, 0);
594 if (rc != EOK) {
595 assert(rc == ENOMEM);
596 printf("Out of memory.\n");
597 goto error;
598 }
599
600 free(scap);
601 scap = NULL;
602 free(spkind);
603 spkind = NULL;
604 free(sfstype);
605 sfstype = NULL;
606 free(sdesc);
607 sdesc = NULL;
608
609 part = fdisk_part_next(part);
610 }
611
612 rc = nchoice_add(choice, "Cancel", NULL, 0);
613 if (rc != EOK) {
614 assert(rc == ENOMEM);
615 printf("Out of memory.\n");
616 goto error;
617 }
618
619 rc = nchoice_get(choice, &sel);
620 if (rc == ENOENT)
621 return EOK;
622 if (rc != EOK) {
623 printf("Error getting user selection.\n");
624 goto error;
625 }
626
627
628 nchoice_destroy(choice);
629 choice = NULL;
630
631 if (sel == NULL)
632 return EOK;
633
634 rc = fdsk_confirm("Warning. Any data in partition will be lost. "
635 "Really delete partition?", &confirm);
636 if (rc != EOK) {
637 printf("Error getting user confirmation.\n");
638 goto error;
639 }
640
641 if (!confirm)
642 return EOK;
643
644 rc = fdisk_part_destroy((fdisk_part_t *)sel);
645 if (rc != EOK) {
646 printf("Error deleting partition.\n");
647 return rc;
648 }
649
650 return EOK;
651error:
652 free(scap);
653 free(spkind);
654 free(sfstype);
655 free(sdesc);
656
657 if (choice != NULL)
658 nchoice_destroy(choice);
659 return rc;
660}
661
662/** Device menu */
663static int fdsk_dev_menu(fdisk_dev_t *dev)
664{
665 nchoice_t *choice = NULL;
666 fdisk_label_info_t linfo;
667 fdisk_part_t *part;
668 fdisk_part_info_t pinfo;
669 fdisk_cap_t cap;
670 fdisk_cap_t mcap;
671 fdisk_dev_flags_t dflags;
672 char *sltype = NULL;
673 char *sdcap = NULL;
674 char *scap = NULL;
675 char *smcap = NULL;
676 char *sfstype = NULL;
677 char *svcname = NULL;
678 char *spkind;
679 int rc;
680 int npart;
681 void *sel;
682
683 rc = nchoice_create(&choice);
684 if (rc != EOK) {
685 assert(rc == ENOMEM);
686 printf("Out of memory.\n");
687 goto error;
688 }
689
690 rc = nchoice_set_prompt(choice, "Select action");
691 if (rc != EOK) {
692 assert(rc == ENOMEM);
693 printf("Out of memory.\n");
694 goto error;
695 }
696
697 rc = fdisk_dev_capacity(dev, &cap);
698 if (rc != EOK) {
699 printf("Error getting device capacity.\n");
700 goto error;
701 }
702
703 fdisk_cap_simplify(&cap);
704
705 rc = fdisk_cap_format(&cap, &sdcap);
706 if (rc != EOK) {
707 printf("Out of memory.\n");
708 goto error;
709 }
710
711 rc = fdisk_dev_get_svcname(dev, &svcname);
712 if (rc != EOK) {
713 printf("Error getting device service name.\n");
714 goto error;
715 }
716
717 fdisk_dev_get_flags(dev, &dflags);
718
719 printf("Device: %s, %s\n", sdcap, svcname);
720 free(sdcap);
721 sdcap = NULL;
722
723 rc = fdisk_label_get_info(dev, &linfo);
724 if (rc != EOK) {
725 printf("Error getting label information.\n");
726 goto error;
727 }
728
729 switch (linfo.ltype) {
730 case lt_none:
731 printf("Disk contains no label.\n");
732 break;
733 default:
734 rc = fdisk_ltype_format(linfo.ltype, &sltype);
735 if (rc != EOK) {
736 assert(rc == ENOMEM);
737 printf("Out of memory.\n");
738 goto error;
739 }
740
741 printf("Label type: %s\n", sltype);
742 free(sltype);
743 sltype = NULL;
744 break;
745 }
746
747 part = fdisk_part_first(dev);
748 npart = 0;
749 while (part != NULL) {
750 ++npart;
751 rc = fdisk_part_get_info(part, &pinfo);
752 if (rc != EOK) {
753 printf("Error getting partition information.\n");
754 goto error;
755 }
756
757 fdisk_cap_simplify(&pinfo.capacity);
758
759 rc = fdisk_cap_format(&pinfo.capacity, &scap);
760 if (rc != EOK) {
761 printf("Out of memory.\n");
762 goto error;
763 }
764
765 rc = fdsk_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
766 if (rc != EOK) {
767 printf("Out of memory.\n");
768 goto error;
769 }
770
771 if (linfo.ltype == lt_none)
772 printf("Entire disk: %s", scap);
773 else
774 printf("Partition %d: %s", npart, scap);
775
776 if ((linfo.flags & lf_ext_supp) != 0) {
777 rc = fdisk_pkind_format(pinfo.pkind, &spkind);
778 if (rc != EOK) {
779 printf("\nOut of memory.\n");
780 goto error;
781 }
782
783 printf(", %s", spkind);
784 free(spkind);
785 }
786
787 if (pinfo.pkind != lpk_extended) {
788 printf(", %s", sfstype);
789 }
790
791 printf("\n");
792
793 free(scap);
794 scap = NULL;
795 free(sfstype);
796 sfstype = NULL;
797
798 part = fdisk_part_next(part);
799 }
800
801 /* Display available space */
802 if ((linfo.flags & lf_can_create_pri) != 0) {
803 rc = fdisk_part_get_max_avail(dev, spc_pri, &mcap);
804 if (rc != EOK) {
805 rc = EIO;
806 goto error;
807 }
808
809 fdisk_cap_simplify(&mcap);
810
811 rc = fdisk_cap_format(&mcap, &smcap);
812 if (rc != EOK) {
813 rc = ENOMEM;
814 goto error;
815 }
816
817 if ((linfo.flags & lf_ext_supp) != 0)
818 printf("Maximum free primary block: %s\n", smcap);
819 else
820 printf("Maximum free block: %s\n", smcap);
821
822 free(smcap);
823 smcap = NULL;
824
825 rc = fdisk_part_get_tot_avail(dev, spc_pri, &mcap);
826 if (rc != EOK) {
827 rc = EIO;
828 goto error;
829 }
830
831 fdisk_cap_simplify(&mcap);
832
833 rc = fdisk_cap_format(&mcap, &smcap);
834 if (rc != EOK) {
835 rc = ENOMEM;
836 goto error;
837 }
838
839 if ((linfo.flags & lf_ext_supp) != 0)
840 printf("Total free primary space: %s\n", smcap);
841 else
842 printf("Total free space: %s\n", smcap);
843
844 free(smcap);
845 smcap = NULL;
846 }
847
848 /* Display available space */
849 if ((linfo.flags & lf_can_create_log) != 0) {
850 rc = fdisk_part_get_max_avail(dev, spc_log, &mcap);
851 if (rc != EOK) {
852 rc = EIO;
853 goto error;
854 }
855
856 fdisk_cap_simplify(&mcap);
857
858 rc = fdisk_cap_format(&mcap, &smcap);
859 if (rc != EOK) {
860 rc = ENOMEM;
861 goto error;
862 }
863
864 printf("Maximum free logical block: %s\n", smcap);
865 free(smcap);
866 smcap = NULL;
867
868 rc = fdisk_part_get_tot_avail(dev, spc_log, &mcap);
869 if (rc != EOK) {
870 rc = EIO;
871 goto error;
872 }
873
874 fdisk_cap_simplify(&mcap);
875
876 rc = fdisk_cap_format(&mcap, &smcap);
877 if (rc != EOK) {
878 rc = ENOMEM;
879 goto error;
880 }
881
882 printf("Total free logical space: %s\n", smcap);
883 free(smcap);
884 smcap = NULL;
885 }
886
887 rc = nchoice_set_prompt(choice, "Select action");
888 if (rc != EOK) {
889 assert(rc == ENOMEM);
890 printf("Out of memory.\n");
891 goto error;
892 }
893
894 if ((linfo.flags & lf_ext_supp) != 0) {
895 if ((linfo.flags & lf_can_create_pri) != 0) {
896 rc = nchoice_add(choice, "Create primary "
897 "partition",
898 (void *)devac_create_pri_part, 0);
899 if (rc != EOK) {
900 assert(rc == ENOMEM);
901 printf("Out of memory.\n");
902 goto error;
903 }
904 }
905
906 if ((linfo.flags & lf_can_create_ext) != 0) {
907 rc = nchoice_add(choice, "Create extended "
908 "partition",
909 (void *)devac_create_ext_part, 0);
910 if (rc != EOK) {
911 assert(rc == ENOMEM);
912 printf("Out of memory.\n");
913 goto error;
914 }
915 }
916
917 if ((linfo.flags & lf_can_create_log) != 0) {
918 rc = nchoice_add(choice, "Create logical "
919 "partition",
920 (void *)devac_create_log_part, 0);
921 if (rc != EOK) {
922 assert(rc == ENOMEM);
923 printf("Out of memory.\n");
924 goto error;
925 }
926 }
927 } else { /* (linfo.flags & lf_ext_supp) == 0 */
928 if ((linfo.flags & lf_can_create_pri) != 0) {
929 rc = nchoice_add(choice, "Create partition",
930 (void *)devac_create_pri_part, 0);
931 if (rc != EOK) {
932 assert(rc == ENOMEM);
933 printf("Out of memory.\n");
934 goto error;
935 }
936 }
937 }
938
939 if ((linfo.flags & lf_can_delete_part) != 0) {
940 rc = nchoice_add(choice, "Delete partition",
941 (void *)devac_delete_part, 0);
942 if (rc != EOK) {
943 assert(rc == ENOMEM);
944 printf("Out of memory.\n");
945 goto error;
946 }
947 }
948
949 if ((dflags & fdf_can_create_label) != 0) {
950 rc = nchoice_add(choice, "Create label",
951 (void *)devac_create_label, 0);
952 if (rc != EOK) {
953 assert(rc == ENOMEM);
954 printf("Out of memory.\n");
955 goto error;
956 }
957 }
958
959 if ((dflags & fdf_can_delete_label) != 0) {
960 rc = nchoice_add(choice, "Delete label",
961 (void *)devac_delete_label, 0);
962 if (rc != EOK) {
963 assert(rc == ENOMEM);
964 printf("Out of memory.\n");
965 goto error;
966 }
967 }
968
969 if ((dflags & fdf_can_erase_dev) != 0) {
970 rc = nchoice_add(choice, "Erase disk",
971 (void *)devac_erase_disk, 0);
972 if (rc != EOK) {
973 assert(rc == ENOMEM);
974 printf("Out of memory.\n");
975 goto error;
976 }
977 }
978
979 rc = nchoice_add(choice, "Exit", (void *)devac_exit, 0);
980 if (rc != EOK) {
981 assert(rc == ENOMEM);
982 printf("Out of memory.\n");
983 goto error;
984 }
985
986 rc = nchoice_get(choice, &sel);
987 if (rc != EOK) {
988 printf("Error getting user selection.\n");
989 return rc;
990 }
991
992 switch ((devac_t)sel) {
993 case devac_create_label:
994 (void) fdsk_create_label(dev);
995 break;
996 case devac_delete_label:
997 (void) fdsk_delete_label(dev);
998 break;
999 case devac_erase_disk:
1000 (void) fdsk_erase_disk(dev);
1001 break;
1002 case devac_create_pri_part:
1003 (void) fdsk_create_part(dev, lpk_primary);
1004 break;
1005 case devac_create_ext_part:
1006 (void) fdsk_create_part(dev, lpk_extended);
1007 break;
1008 case devac_create_log_part:
1009 (void) fdsk_create_part(dev, lpk_logical);
1010 break;
1011 case devac_delete_part:
1012 (void) fdsk_delete_part(dev);
1013 break;
1014 case devac_exit:
1015 quit = true;
1016 break;
1017 }
1018
1019 nchoice_destroy(choice);
1020 return EOK;
1021error:
1022 free(sdcap);
1023 free(scap);
1024 free(smcap);
1025 free(sfstype);
1026 free(svcname);
1027 if (choice != NULL)
1028 nchoice_destroy(choice);
1029 return rc;
1030}
1031
1032int main(int argc, char *argv[])
1033{
1034 service_id_t svcid;
1035 fdisk_dev_t *dev;
1036 int rc;
1037
1038 rc = fdisk_create(&fdisk);
1039 if (rc != EOK) {
1040 printf("Error initializing Fdisk.\n");
1041 return 1;
1042 }
1043
1044 rc = fdsk_dev_sel_choice(&svcid);
1045 if (rc != EOK)
1046 return 1;
1047
1048 if (svcid == 0)
1049 return 0;
1050
1051 rc = fdisk_dev_open(fdisk, svcid, &dev);
1052 if (rc != EOK) {
1053 printf("Error opening device.\n");
1054 return 1;
1055 }
1056
1057 while (!quit) {
1058 rc = fdsk_dev_menu(dev);
1059 if (rc != EOK) {
1060 fdisk_dev_close(dev);
1061 return 1;
1062 }
1063 }
1064
1065 fdisk_dev_close(dev);
1066 fdisk_destroy(fdisk);
1067
1068 return 0;
1069}
1070
1071
1072/** @}
1073 */
Note: See TracBrowser for help on using the repository browser.