1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
|
package partition_table; # $Id$
use diagnostics;
use strict;
use common;
use fs::type;
use partition_table::raw;
use detect_devices;
use log;
our @fields2save = qw(primary extended totalsectors isDirty will_tell_kernel);
sub hd2minimal_part {
my ($hd) = @_;
{
rootDevice => $hd->{device},
if_($hd->{usb_media_type}, is_removable => 1),
};
}
#- works for both hard drives and partitions ;p
sub description {
my ($hd) = @_;
my $win = $hd->{device_windobe};
sprintf "%s%s (%s)",
$hd->{device},
$win && " [$win:]",
join(', ',
grep { $_ }
formatXiB($hd->{totalsectors} || $hd->{size}, 512),
$hd->{info}, $hd->{mntpoint}, $hd->{fs_type});
}
sub isPrimary {
my ($part, $hd) = @_;
foreach (@{$hd->{primary}{raw}}) { $part eq $_ and return 1 }
0;
}
sub adjustStartAndEnd {
my ($hd, $part) = @_;
$hd->adjustStart($part);
$hd->adjustEnd($part);
}
sub verifyNotOverlap {
my ($a, $b) = @_;
$a->{start} + $a->{size} <= $b->{start} || $b->{start} + $b->{size} <= $a->{start};
}
sub verifyInside {
my ($a, $b) = @_;
$b->{start} <= $a->{start} && $a->{start} + $a->{size} <= $b->{start} + $b->{size};
}
sub verifyParts_ {
foreach my $i (@_) {
foreach (@_) {
next if !$i || !$_ || $i == $_ || isWholedisk($i) || isExtended($i); #- avoid testing twice for simplicity :-)
if (isWholedisk($_)) {
verifyInside($i, $_) or
cdie sprintf("partition sector #$i->{start} (%s) is not inside whole disk (%s)!",
formatXiB($i->{size}, 512), formatXiB($_->{size}, 512));
} elsif (isExtended($_)) {
verifyNotOverlap($i, $_) or
log::l(sprintf("warning partition sector #$i->{start} (%s) is overlapping with extended partition!",
formatXiB($i->{size}, 512))); #- only warning for this one is acceptable
} else {
verifyNotOverlap($i, $_) or
cdie sprintf("partitions sector #$i->{start} (%s) and sector #$_->{start} (%s) are overlapping!",
formatXiB($i->{size}, 512), formatXiB($_->{size}, 512));
}
}
}
}
sub verifyParts {
my ($hd) = @_;
verifyParts_(get_normal_parts($hd));
}
sub verifyPrimary {
my ($pt) = @_;
$_->{start} > 0 || arch() =~ /^sparc/ || die "partition must NOT start at sector 0" foreach @{$pt->{normal}};
verifyParts_(@{$pt->{normal}}, $pt->{extended});
}
sub compute_device_name {
my ($part, $hd) = @_;
$part->{device} = $hd->{prefix} . $part->{part_number};
$part->{devfs_device} = $hd->{devfs_prefix} . '/part' . $part->{part_number};
}
sub assign_device_numbers {
my ($hd) = @_;
my $i = 1;
my $start = 1;
#- on PPC we need to assign device numbers to the holes too - big FUN!
#- not if it's an IBM machine using a DOS partition table though
if (arch() =~ /ppc/ && detect_devices::get_mac_model() !~ /^IBM/) {
#- first sort the normal parts
$hd->{primary}{normal} = [ sort { $a->{start} <=> $b->{start} } @{$hd->{primary}{normal}} ];
#- now loop through them, assigning partition numbers - reserve one for the holes
foreach (@{$hd->{primary}{normal}}) {
if ($_->{start} > $start) {
log::l("PPC: found a hole on $hd->{prefix} before $_->{start}, skipping device...");
$i++;
}
$_->{part_number} = $i;
compute_device_name($_, $hd);
$start = $_->{start} + $_->{size};
$i++;
}
} else {
foreach (@{$hd->{primary}{raw}}) {
$_->{part_number} = $i;
compute_device_name($_, $hd);
$i++;
}
foreach (map { $_->{normal} } @{$hd->{extended} || []}) {
my $dev = $hd->{prefix} . $i;
my $renumbered = $_->{device} && $dev ne $_->{device};
if ($renumbered) {
require fs;
eval { fs::umount_part($_) }; #- at least try to umount it
will_tell_kernel($hd, del => $_, 'delay_del');
push @{$hd->{partitionsRenumbered}}, [ $_->{device}, $dev ];
}
$_->{part_number} = $i;
compute_device_name($_, $hd);
if ($renumbered) {
will_tell_kernel($hd, add => $_, 'delay_add');
}
$i++;
}
}
#- try to figure what the windobe drive letter could be!
#
#- first verify there's at least one primary dos partition, otherwise it
#- means it is a secondary disk and all will be false :(
#-
my ($c, @others) = grep { isFat_or_NTFS($_) } @{$hd->{primary}{normal}};
$i = ord 'C';
$c->{device_windobe} = chr($i++) if $c;
$_->{device_windobe} = chr($i++) foreach grep { isFat_or_NTFS($_) } map { $_->{normal} } @{$hd->{extended}};
$_->{device_windobe} = chr($i++) foreach @others;
}
sub remove_empty_extended {
my ($hd) = @_;
my $last = $hd->{primary}{extended} or return;
@{$hd->{extended}} = grep {
if ($_->{normal}) {
$last = $_;
} else {
%{$last->{extended}} = $_->{extended} ? %{$_->{extended}} : ();
}
$_->{normal};
} @{$hd->{extended}};
adjust_main_extended($hd);
}
sub adjust_main_extended {
my ($hd) = @_;
if (!is_empty_array_ref $hd->{extended}) {
my ($l, @l) = @{$hd->{extended}};
# the first is a special case, must recompute its real size
my $start = round_down($l->{normal}{start} - 1, $hd->{geom}{sectors});
my $end = $l->{normal}{start} + $l->{normal}{size};
my $only_linux = 1; my $has_win_lba = 0;
foreach (map { $_->{normal} } $l, @l) {
$start = min($start, $_->{start});
$end = max($end, $_->{start} + $_->{size});
$only_linux &&= isTrueLocalFS($_) || isSwap($_);
$has_win_lba ||= $_->{pt_type} == 0xc || $_->{pt_type} == 0xe;
}
$l->{start} = $hd->{primary}{extended}{start} = $start;
$l->{size} = $hd->{primary}{extended}{size} = $end - $start;
}
if (!@{$hd->{extended} || []} && $hd->{primary}{extended}) {
will_tell_kernel($hd, del => $hd->{primary}{extended});
%{$hd->{primary}{extended}} = (); #- modify the raw entry
delete $hd->{primary}{extended};
}
verifyParts($hd); #- verify everything is all right
}
sub adjust_local_extended {
my ($hd, $part) = @_;
my $extended = find { $_->{normal} == $part } @{$hd->{extended} || []} or return;
$extended->{size} = $part->{size} + $part->{start} - $extended->{start};
#- must write it there too because values are not shared
my $prev = find { $_->{extended}{start} == $extended->{start} } @{$hd->{extended} || []} or return;
$prev->{extended}{size} = $part->{size} + $part->{start} - $prev->{extended}{start};
}
sub get_normal_parts {
my ($hd) = @_;
@{$hd->{primary}{normal} || []}, map { $_->{normal} } @{$hd->{extended} || []};
}
sub get_normal_parts_and_holes {
my ($hd) = @_;
my ($start, $last) = ($hd->first_usable_sector, $hd->last_usable_sector);
ref($hd) or print("get_normal_parts_and_holes: bad hd" . backtrace(), "\n");
my $minimal_hole = put_in_hash({ pt_type => 0 }, hd2minimal_part($hd));
my @l = map {
my $current = $start;
$start = $_->{start} + $_->{size};
my $hole = { start => $current, size => $_->{start} - $current, %$minimal_hole };
put_in_hash($hole, hd2minimal_part($hd));
$hole, $_;
} sort { $a->{start} <=> $b->{start} } grep { !isWholedisk($_) } get_normal_parts($hd);
push @l, { start => $start, size => $last - $start, %$minimal_hole };
grep { !isEmpty($_) || $_->{size} >= $hd->cylinder_size } @l;
}
sub read_one($$) {
my ($hd, $sector) = @_;
my ($pt, $info);
#- it can be safely considered that the first sector is used to probe the partition table
#- but other sectors (typically for extended partition ones) have to match this type!
if (!$sector) {
my @parttype = (
if_(arch() =~ /^ia64/, 'gpt'),
arch() =~ /^sparc/ ? ('sun', 'bsd') : ('dos', 'bsd', 'sun', 'mac'),
);
foreach ('empty', @parttype, 'unknown') {
/unknown/ and die "unknown partition table format on disk " . $hd->{file};
eval {
# perl_checker: require partition_table::bsd
# perl_checker: require partition_table::dos
# perl_checker: require partition_table::empty
# perl_checker: require partition_table::gpt
# perl_checker: require partition_table::mac
# perl_checker: require partition_table::sun
require "partition_table/$_.pm";
bless $hd, "partition_table::$_";
($pt, $info) = $hd->read($sector);
log::l("found a $_ partition table on $hd->{file} at sector $sector");
};
$@ or last;
}
} else {
#- keep current blessed object for that, this means it is neccessary to read sector 0 before.
($pt, $info) = $hd->read($sector);
}
my @extended = $hd->hasExtended ? grep { isExtended($_) } @$pt : ();
my @normal = grep { $_->{size} && !isEmpty($_) && !isExtended($_) } @$pt;
my $nb_special_empty = int(grep { $_->{size} && isEmpty($_) } @$pt);
@extended > 1 and die "more than one extended partition";
put_in_hash($_, hd2minimal_part($hd)) foreach @normal, @extended;
{ raw => $pt, extended => $extended[0], normal => \@normal, info => $info, nb_special_empty => $nb_special_empty };
}
sub read {
my ($hd) = @_;
my $pt = read_one($hd, 0) or return 0;
$hd->{primary} = $pt;
undef $hd->{extended};
verifyPrimary($pt);
eval {
my $need_removing_empty_extended;
if ($pt->{extended}) {
read_extended($hd, $pt->{extended}, \$need_removing_empty_extended) or return 0;
}
if ($need_removing_empty_extended) {
#- special case when hda5 is empty, it must be skipped
#- (windows XP generates such partition tables)
remove_empty_extended($hd); #- includes adjust_main_extended
}
};
die "extended partition: $@" if $@;
assign_device_numbers($hd);
remove_empty_extended($hd);
$hd->set_best_geometry_for_the_partition_table;
1;
}
sub read_extended {
my ($hd, $extended, $need_removing_empty_extended) = @_;
my $pt = read_one($hd, $extended->{start}) or return 0;
$pt = { %$extended, %$pt };
push @{$hd->{extended}}, $pt;
@{$hd->{extended}} > 100 and die "oops, seems like we're looping here :( (or you have more than 100 extended partitions!)";
if (@{$pt->{normal}} == 0) {
$$need_removing_empty_extended = 1;
delete $pt->{normal};
print "need_removing_empty_extended\n";
} elsif (@{$pt->{normal}} > 1) {
die "more than one normal partition in extended partition";
} else {
$pt->{normal} = $pt->{normal}[0];
#- in case of extended partitions, the start sector is local to the partition or to the first extended_part!
$pt->{normal}{start} += $pt->{start};
#- the following verification can broke an existing partition table that is
#- correctly read by fdisk or cfdisk. maybe the extended partition can be
#- recomputed to get correct size.
if (!verifyInside($pt->{normal}, $extended)) {
$extended->{size} = $pt->{normal}{start} + $pt->{normal}{size};
verifyInside($pt->{normal}, $extended) or die "partition $pt->{normal}{device} is not inside its extended partition";
}
}
if ($pt->{extended}) {
$pt->{extended}{start} += $hd->{primary}{extended}{start};
return read_extended($hd, $pt->{extended}, $need_removing_empty_extended);
} else {
1;
}
}
sub will_tell_kernel {
my ($hd, $action, $o_part, $o_delay) = @_;
if ($action eq 'resize') {
will_tell_kernel($hd, del => $o_part);
will_tell_kernel($hd, add => $o_part);
} else {
my $part_number;
if ($o_part) {
($part_number) = $o_part->{device} =~ /(\d+)$/ or
#- do not die, it occurs when we zero_MBR_and_dirty a raw_lvm_PV
log::l("ERROR: will_tell_kernel bad device " . description($o_part)), return;
}
my @para =
$action eq 'force_reboot' ? () :
$action eq 'add' ? ($part_number, $o_part->{start}, $o_part->{size}) :
$action eq 'del' ? $part_number :
internal_error("unknown action $action");
push @{$hd->{'will_tell_kernel' . ($o_delay || '')} ||= []}, [ $action, @para ];
}
if (!$o_delay) {
foreach my $delay ('delay_del', 'delay_add') {
my $l = delete $hd->{"will_tell_kernel$delay"} or next;
push @{$hd->{will_tell_kernel} ||= []}, @$l;
}
}
$hd->{isDirty} = 1;
}
sub tell_kernel {
my ($hd, $tell_kernel) = @_;
my $F = partition_table::raw::openit($hd);
my $force_reboot = any { $_->[0] eq 'force_reboot' } @$tell_kernel;
if (!$force_reboot) {
foreach (@$tell_kernel) {
my ($action, $part_number, $o_start, $o_size) = @$_;
if ($action eq 'add') {
$force_reboot ||= !c::add_partition(fileno $F, $part_number, $o_start, $o_size);
} elsif ($action eq 'del') {
$force_reboot ||= !c::del_partition(fileno $F, $part_number);
}
log::l("tell kernel $action ($hd->{device} $part_number $o_start $o_size), rebootNeeded is now " . bool2text($hd->{rebootNeeded}));
}
}
if ($force_reboot) {
my @magic_parts = grep { $_->{isMounted} && $_->{real_mntpoint} } get_normal_parts($hd);
foreach (@magic_parts) {
syscall_('umount', $_->{real_mntpoint}) or log::l(N("error unmounting %s: %s", $_->{real_mntpoint}, $!));
}
$hd->{rebootNeeded} = !ioctl($F, c::BLKRRPART(), 0);
log::l("tell kernel force_reboot ($hd->{device}), rebootNeeded is now $hd->{rebootNeeded}.");
foreach (@magic_parts) {
syscall_('mount', $_->{real_mntpoint}, $_->{fs_type}, c::MS_MGC_VAL()) or log::l(N("mount failed: ") . $!);
}
}
}
# write the partition table
sub write {
my ($hd) = @_;
$hd->{isDirty} or return;
$hd->{readonly} and die "a read-only partition table should not be dirty!";
#- set first primary partition active if no primary partitions are marked as active.
if (my @l = @{$hd->{primary}{raw}}) {
foreach (@l) {
$_->{local_start} = $_->{start};
$_->{active} ||= 0;
}
$l[0]{active} = 0x80 if !any { $_->{active} } @l;
}
#- last chance for verification, this make sure if an error is detected,
#- it will never be writed back on partition table.
verifyParts($hd);
$hd->write(0, $hd->{primary}{raw}, $hd->{primary}{info}) or die "writing of partition table failed";
#- should be fixed but a extended exist with no real extended partition, that blanks mbr!
if (arch() !~ /^sparc/) {
foreach (@{$hd->{extended}}) {
# in case of extended partitions, the start sector must be local to the partition
$_->{normal}{local_start} = $_->{normal}{start} - $_->{start};
$_->{extended} and $_->{extended}{local_start} = $_->{extended}{start} - $hd->{primary}{extended}{start};
$hd->write($_->{start}, $_->{raw}) or die "writing of partition table failed";
}
}
$hd->{isDirty} = 0;
$hd->{hasBeenDirty} = 1; #- used in undo (to know if undo should believe isDirty or not)
if (my $tell_kernel = delete $hd->{will_tell_kernel}) {
tell_kernel($hd, $tell_kernel);
}
}
sub active {
my ($hd, $part) = @_;
$_->{active} = 0 foreach @{$hd->{primary}{normal}};
$part->{active} = 0x80;
$hd->{isDirty} = 1;
}
# remove a normal partition from hard drive hd
sub remove {
my ($hd, $part) = @_;
my $i;
#- first search it in the primary partitions
$i = 0; foreach (@{$hd->{primary}{normal}}) {
if ($_ eq $part) {
will_tell_kernel($hd, del => $_);
splice(@{$hd->{primary}{normal}}, $i, 1);
%$_ = (); #- blank it
$hd->raw_removed($hd->{primary}{raw});
return 1;
}
$i++;
}
my ($first, $second, $third) = map { $_->{normal} } @{$hd->{extended} || []};
if ($third && $first eq $part) {
die "Can not handle removing hda5 when hda6 is not the second partition" if $second->{start} > $third->{start};
}
#- otherwise search it in extended partitions
foreach (@{$hd->{extended} || []}) {
$_->{normal} eq $part or next;
delete $_->{normal}; #- remove it
remove_empty_extended($hd);
assign_device_numbers($hd);
will_tell_kernel($hd, del => $part);
return 1;
}
0;
}
# create of partition at starting at `start', of size `size' and of type `pt_type' (nice comment, uh?)
sub add_primary {
my ($hd, $part) = @_;
{
local $hd->{primary}{normal}; #- save it to fake an addition of $part, that way add_primary do not modify $hd if it fails
push @{$hd->{primary}{normal}}, $part;
adjust_main_extended($hd); #- verify
$hd->raw_add($hd->{primary}{raw}, $part);
}
push @{$hd->{primary}{normal}}, $part; #- really do it
}
sub add_extended {
arch() =~ /^sparc|ppc/ and die N("Extended partition not supported on this platform");
my ($hd, $part, $extended_type) = @_;
$extended_type =~ s/Extended_?//;
my $e = $hd->{primary}{extended};
if ($e && !verifyInside($part, $e)) {
#-die "sorry, can not add outside the main extended partition" unless $::unsafe;
my $end = $e->{start} + $e->{size};
my $start = min($e->{start}, $part->{start});
$end = max($end, $part->{start} + $part->{size}) - $start;
{ #- faking a resizing of the main extended partition to test for problems
local $e->{start} = $start;
local $e->{size} = $end - $start;
eval { verifyPrimary($hd->{primary}) };
$@ and die
N("You have a hole in your partition table but I can not use it.
The only solution is to move your primary partitions to have the hole next to the extended partitions.");
}
}
if ($e && $part->{start} < $e->{start}) {
my $l = first(@{$hd->{extended}});
#- the first is a special case, must recompute its real size
$l->{start} = round_down($l->{normal}{start} - 1, $hd->cylinder_size);
$l->{size} = $l->{normal}{start} + $l->{normal}{size} - $l->{start};
my $ext = { %$l };
unshift @{$hd->{extended}}, { pt_type => 5, raw => [ $part, $ext, {}, {} ], normal => $part, extended => $ext };
#- size will be autocalculated :)
} else {
my ($ext, $ext_size) = is_empty_array_ref($hd->{extended}) ?
($hd->{primary}, -1) : #- -1 size will be computed by adjust_main_extended
(top(@{$hd->{extended}}), $part->{size});
my %ext = (pt_type => $extended_type || 5, start => $part->{start}, size => $ext_size);
$hd->raw_add($ext->{raw}, \%ext);
$ext->{extended} = \%ext;
push @{$hd->{extended}}, { %ext, raw => [ $part, {}, {}, {} ], normal => $part };
}
$part->{start}++; $part->{size}--; #- let it start after the extended partition sector
adjustStartAndEnd($hd, $part);
adjust_main_extended($hd);
}
sub add {
my ($hd, $part, $b_primaryOrExtended, $b_forceNoAdjust) = @_;
get_normal_parts($hd) >= ($hd->{device} =~ /^rd/ ? 7 : $hd->{device} =~ /^(sd|ida|cciss|ataraid)/ ? 15 : 63) and cdie "maximum number of partitions handled by linux reached";
set_isFormatted($part, 0);
put_in_hash($part, hd2minimal_part($hd));
$part->{start} ||= 1 if arch() !~ /^sparc/; #- starting at sector 0 is not allowed
adjustStartAndEnd($hd, $part) unless $b_forceNoAdjust;
my $nb_primaries = $hd->{device} =~ /^rd/ ? 3 : 1;
if (arch() =~ /^sparc|ppc/ ||
$b_primaryOrExtended eq 'Primary' ||
$b_primaryOrExtended !~ /Extended/ && @{$hd->{primary}{normal} || []} < $nb_primaries) {
eval { add_primary($hd, $part) };
goto success if !$@;
}
if ($hd->hasExtended) {
eval { add_extended($hd, $part, $b_primaryOrExtended) };
goto success if !$@;
}
{
add_primary($hd, $part);
}
success:
assign_device_numbers($hd);
will_tell_kernel($hd, add => $part);
}
# search for the next partition
sub next {
my ($hd, $part) = @_;
first(
sort { $a->{start} <=> $b->{start} }
grep { $_->{start} >= $part->{start} + $part->{size} }
get_normal_parts($hd)
);
}
sub next_start {
my ($hd, $part) = @_;
my $next = &next($hd, $part);
$next ? $next->{start} : $hd->{totalsectors};
}
sub load {
my ($hd, $file, $b_force) = @_;
my $F;
if (ref $file) {
$F = $file;
} else {
open($F, $file) or die N("Error reading file %s", $file);
}
my $h;
{
local $/ = "\0";
eval <$F>;
}
$@ and die N("Restoring from file %s failed: %s", $file, $@);
ref($h) eq 'ARRAY' or die N("Bad backup file");
my %h; @h{@fields2save} = @$h;
$h{totalsectors} == $hd->{totalsectors} or $b_force or cdie "bad totalsectors";
#- unsure we do not modify totalsectors
local $hd->{totalsectors};
@$hd{@fields2save} = @$h;
delete @$_{qw(isMounted isFormatted notFormatted toFormat toFormatUnsure)} foreach get_normal_parts($hd);
will_tell_kernel($hd, 'force_reboot'); #- just like undo, do not force write_partitions so that user can see the new partition table but can still discard it
}
sub save {
my ($hd, $file) = @_;
my @h = @$hd{@fields2save};
require Data::Dumper;
eval { output($file, Data::Dumper->Dump([\@h], ['$h']), "\0") }
or die N("Error writing to file %s", $file);
}
1;
|