resize: Get the partition table type of the source disk earlier.
[libguestfs.git] / resize / resize.ml
1 (* virt-resize
2  * Copyright (C) 2010-2011 Red Hat Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  *)
18
19 open Printf
20
21 module G = Guestfs
22
23 open Utils
24
25 (* Minimum surplus before we create an extra partition. *)
26 let min_extra_partition = 10L *^ 1024L *^ 1024L
27
28 (* Command line argument parsing. *)
29 let prog = Filename.basename Sys.executable_name
30
31 type align_first_t = [ `Never | `Always | `Auto ]
32
33 let infile, outfile, align_first, alignment, copy_boot_loader, debug, deletes,
34   dryrun, expand, expand_content, extra_partition, format, ignores,
35   lv_expands, machine_readable, ntfsresize_force, output_format,
36   quiet, resizes, resizes_force, shrink =
37   let display_version () =
38     let g = new G.guestfs () in
39     let version = g#version () in
40     printf "virt-resize %Ld.%Ld.%Ld%s\n"
41       version.G.major version.G.minor version.G.release version.G.extra;
42     exit 0
43   in
44
45   let add xs s = xs := s :: !xs in
46
47   let align_first = ref "auto" in
48   let alignment = ref 128 in
49   let copy_boot_loader = ref true in
50   let debug = ref false in
51   let deletes = ref [] in
52   let dryrun = ref false in
53   let expand = ref "" in
54   let set_expand s =
55     if s = "" then error "%s: empty --expand option" prog
56     else if !expand <> "" then error "--expand option given twice"
57     else expand := s
58   in
59   let expand_content = ref true in
60   let extra_partition = ref true in
61   let format = ref "" in
62   let ignores = ref [] in
63   let lv_expands = ref [] in
64   let machine_readable = ref false in
65   let ntfsresize_force = ref false in
66   let output_format = ref "" in
67   let quiet = ref false in
68   let resizes = ref [] in
69   let resizes_force = ref [] in
70   let shrink = ref "" in
71   let set_shrink s =
72     if s = "" then error "empty --shrink option"
73     else if !shrink <> "" then error "--shrink option given twice"
74     else shrink := s
75   in
76
77   let argspec = Arg.align [
78     "--align-first", Arg.Set_string align_first, "never|always|auto Align first partition (default: auto)";
79     "--alignment", Arg.Set_int alignment,   "sectors Set partition alignment (default: 128 sectors)";
80     "--no-copy-boot-loader", Arg.Clear copy_boot_loader, " Don't copy boot loader";
81     "-d",        Arg.Set debug,             " Enable debugging messages";
82     "--debug",   Arg.Set debug,             " -\"-";
83     "--delete",  Arg.String (add deletes),  "part Delete partition";
84     "--expand",  Arg.String set_expand,     "part Expand partition";
85     "--no-expand-content", Arg.Clear expand_content, " Don't expand content";
86     "--no-extra-partition", Arg.Clear extra_partition, " Don't create extra partition";
87     "--format",  Arg.Set_string format,     "format Format of input disk";
88     "--ignore",  Arg.String (add ignores),  "part Ignore partition";
89     "--lv-expand", Arg.String (add lv_expands), "lv Expand logical volume";
90     "--LV-expand", Arg.String (add lv_expands), "lv -\"-";
91     "--lvexpand", Arg.String (add lv_expands), "lv -\"-";
92     "--LVexpand", Arg.String (add lv_expands), "lv -\"-";
93     "--machine-readable", Arg.Set machine_readable, " Make output machine readable";
94     "-n",        Arg.Set dryrun,            " Don't perform changes";
95     "--dryrun",  Arg.Set dryrun,            " -\"-";
96     "--dry-run", Arg.Set dryrun,            " -\"-";
97     "--ntfsresize-force", Arg.Set ntfsresize_force, " Force ntfsresize";
98     "--output-format", Arg.Set_string format, "format Format of output disk";
99     "-q",        Arg.Set quiet,             " Don't print the summary";
100     "--quiet",   Arg.Set quiet,             " -\"-";
101     "--resize",  Arg.String (add resizes),  "part=size Resize partition";
102     "--resize-force", Arg.String (add resizes_force), "part=size Forcefully resize partition";
103     "--shrink",  Arg.String set_shrink,     "part Shrink partition";
104     "-V",        Arg.Unit display_version,  " Display version and exit";
105     "--version", Arg.Unit display_version,  " -\"-";
106   ] in
107   let disks = ref [] in
108   let anon_fun s = disks := s :: !disks in
109   let usage_msg =
110     sprintf "\
111 %s: resize a virtual machine disk
112
113 A short summary of the options is given below.  For detailed help please
114 read the man page virt-resize(1).
115 "
116       prog in
117   Arg.parse argspec anon_fun usage_msg;
118
119   let debug = !debug in
120   if debug then (
121     eprintf "command line:";
122     List.iter (eprintf " %s") (Array.to_list Sys.argv);
123     prerr_newline ()
124   );
125
126   (* Dereference the rest of the args. *)
127   let alignment = !alignment in
128   let copy_boot_loader = !copy_boot_loader in
129   let deletes = List.rev !deletes in
130   let dryrun = !dryrun in
131   let expand = match !expand with "" -> None | str -> Some str in
132   let expand_content = !expand_content in
133   let extra_partition = !extra_partition in
134   let format = match !format with "" -> None | str -> Some str in
135   let ignores = List.rev !ignores in
136   let lv_expands = List.rev !lv_expands in
137   let machine_readable = !machine_readable in
138   let ntfsresize_force = !ntfsresize_force in
139   let output_format = match !output_format with "" -> None | str -> Some str in
140   let quiet = !quiet in
141   let resizes = List.rev !resizes in
142   let resizes_force = List.rev !resizes_force in
143   let shrink = match !shrink with "" -> None | str -> Some str in
144
145   if alignment < 1 then
146     error "alignment cannot be < 1";
147   let alignment = Int64.of_int alignment in
148
149   let align_first =
150     match !align_first with
151     | "never" -> `Never
152     | "always" -> `Always
153     | "auto" -> `Auto
154     | _ ->
155       error "unknown --align-first option: use never|always|auto" in
156
157   (* No arguments and machine-readable mode?  Print out some facts
158    * about what this binary supports.  We only need to print out new
159    * things added since this option, or things which depend on features
160    * of the appliance.
161    *)
162   if !disks = [] && machine_readable then (
163     printf "virt-resize\n";
164     printf "ntfsresize-force\n";
165     printf "32bitok\n";
166     printf "128-sector-alignment\n";
167     printf "alignment\n";
168     printf "align-first\n";
169     let g = new G.guestfs () in
170     g#add_drive_opts "/dev/null";
171     g#launch ();
172     if feature_available g [| "ntfsprogs"; "ntfs3g" |] then
173       printf "ntfs\n";
174     if feature_available g [| "btrfs" |] then
175       printf "btrfs\n";
176     exit 0
177   );
178
179   (* Verify we got exactly 2 disks. *)
180   let infile, outfile =
181     match List.rev !disks with
182     | [infile; outfile] -> infile, outfile
183     | _ ->
184         error "usage is: %s [--options] indisk outdisk" prog in
185
186   infile, outfile, align_first, alignment, copy_boot_loader, debug, deletes,
187   dryrun, expand, expand_content, extra_partition, format, ignores,
188   lv_expands, machine_readable, ntfsresize_force, output_format,
189   quiet, resizes, resizes_force, shrink
190
191 (* Default to true, since NTFS and btrfs support are usually available. *)
192 let ntfs_available = ref true
193 let btrfs_available = ref true
194
195 (* Add in and out disks to the handle and launch. *)
196 let connect_both_disks () =
197   let g = new G.guestfs () in
198   if debug then g#set_trace true;
199   g#add_drive_opts ?format ~readonly:true infile;
200   g#add_drive_opts ?format:output_format ~readonly:false outfile;
201   if not quiet then Progress.set_up_progress_bar ~machine_readable g;
202   g#launch ();
203
204   (* Set the filter to /dev/sda, in case there are any rogue
205    * PVs lying around on the target disk.
206    *)
207   g#lvm_set_filter [|"/dev/sda"|];
208
209   (* Update features available in the daemon. *)
210   ntfs_available := feature_available g [|"ntfsprogs"; "ntfs3g"|];
211   btrfs_available := feature_available g [|"btrfs"|];
212
213   g
214
215 let g =
216   if not quiet then
217     printf "Examining %s ...\n%!" infile;
218
219   let g = connect_both_disks () in
220
221   g
222
223 (* Get the size in bytes of each disk.
224  *
225  * Originally we computed this by looking at the same of the host file,
226  * but of course this failed for qcow2 images (RHBZ#633096).  The right
227  * way to do it is with g#blockdev_getsize64.
228  *)
229 let sectsize, insize, outsize =
230   let sectsize = g#blockdev_getss "/dev/sdb" in
231   let insize = g#blockdev_getsize64 "/dev/sda" in
232   let outsize = g#blockdev_getsize64 "/dev/sdb" in
233   if debug then (
234     eprintf "%s size %Ld bytes\n" infile insize;
235     eprintf "%s size %Ld bytes\n" outfile outsize
236   );
237   sectsize, insize, outsize
238
239 let max_bootloader =
240   (* In reality the number of sectors containing boot loader data will be
241    * less than this (although Windows 7 defaults to putting the first
242    * partition on sector 2048, and has quite a large boot loader).
243    *
244    * However make this large enough to be sure that we have copied over
245    * the boot loader.  We could also do this by looking for the sector
246    * offset of the first partition.
247    *
248    * It doesn't matter if we copy too much.
249    *)
250   4096 * 512
251
252 (* Check the disks are at least as big as the bootloader. *)
253 let () =
254   if insize < Int64.of_int max_bootloader then
255     error "%s: file is too small to be a disk image (%Ld bytes)"
256       infile insize;
257   if outsize < Int64.of_int max_bootloader then
258     error "%s: file is too small to be a disk image (%Ld bytes)"
259       outfile outsize
260
261 (* Get the source partition type. *)
262 type parttype = MBR | GPT        (* Only these are supported by virt-resize. *)
263
264 let parttype, parttype_string =
265   let pt = g#part_get_parttype "/dev/sda" in
266   if debug then eprintf "partition table type: %s\n%!" pt;
267
268   match pt with
269   | "msdos" -> MBR, "msdos"
270   | "gpt" -> GPT, "gpt"
271   | _ ->
272     error "%s: unknown partition table type\nvirt-resize only supports MBR (DOS) and GPT partition tables." infile
273
274 (* Build a data structure describing the source disk's partition layout. *)
275 type partition = {
276   p_name : string;               (* Device name, like /dev/sda1. *)
277   p_part : G.partition;          (* SOURCE partition data from libguestfs. *)
278   p_bootable : bool;             (* Is it bootable? *)
279   p_mbr_id : int option;         (* MBR ID, if it has one. *)
280   p_type : partition_content;    (* Content type and content size. *)
281
282   (* What we're going to do: *)
283   mutable p_operation : partition_operation;
284   p_target_partnum : int;        (* TARGET partition number. *)
285   p_target_start : int64;        (* TARGET partition start (sector num). *)
286   p_target_end : int64;          (* TARGET partition end (sector num). *)
287 }
288 and partition_content =
289   | ContentUnknown               (* undetermined *)
290   | ContentPV of int64           (* physical volume (size of PV) *)
291   | ContentFS of string * int64  (* mountable filesystem (FS type, FS size) *)
292 and partition_operation =
293   | OpCopy                       (* copy it as-is, no resizing *)
294   | OpIgnore                     (* ignore it (create on target, but don't
295                                     copy any content) *)
296   | OpDelete                     (* delete it *)
297   | OpResize of int64            (* resize it to the new size *)
298
299 let rec debug_partition p =
300   eprintf "%s:\n" p.p_name;
301   eprintf "\tpartition data: %ld %Ld-%Ld (%Ld bytes)\n"
302     p.p_part.G.part_num p.p_part.G.part_start p.p_part.G.part_end
303     p.p_part.G.part_size;
304   eprintf "\tbootable: %b\n" p.p_bootable;
305   eprintf "\tpartition ID: %s\n"
306     (match p.p_mbr_id with None -> "(none)" | Some i -> sprintf "0x%x" i);
307   eprintf "\tcontent: %s\n" (string_of_partition_content p.p_type)
308 and string_of_partition_content = function
309   | ContentUnknown -> "unknown data"
310   | ContentPV sz -> sprintf "LVM PV (%Ld bytes)" sz
311   | ContentFS (fs, sz) -> sprintf "filesystem %s (%Ld bytes)" fs sz
312 and string_of_partition_content_no_size = function
313   | ContentUnknown -> "unknown data"
314   | ContentPV _ -> sprintf "LVM PV"
315   | ContentFS (fs, _) -> sprintf "filesystem %s" fs
316
317 let get_partition_content =
318   let pvs_full = Array.to_list (g#pvs_full ()) in
319   fun dev ->
320     try
321       let fs = g#vfs_type dev in
322       if fs = "unknown" then
323         ContentUnknown
324       else if fs = "LVM2_member" then (
325         let rec loop = function
326           | [] ->
327               error "%s: physical volume not returned by pvs_full"
328                 dev
329           | pv :: _ when canonicalize pv.G.pv_name = dev ->
330               ContentPV pv.G.pv_size
331           | _ :: pvs -> loop pvs
332         in
333         loop pvs_full
334       )
335       else (
336         g#mount_ro dev "/";
337         let stat = g#statvfs "/" in
338         let size = stat.G.bsize *^ stat.G.blocks in
339         ContentFS (fs, size)
340       )
341     with
342       G.Error _ -> ContentUnknown
343
344 let partitions : partition list =
345   let parts = Array.to_list (g#part_list "/dev/sda") in
346
347   if List.length parts = 0 then
348     error "the source disk has no partitions";
349
350   let partitions =
351     List.map (
352       fun ({ G.part_num = part_num } as part) ->
353         let part_num = Int32.to_int part_num in
354         let name = sprintf "/dev/sda%d" part_num in
355         let bootable = g#part_get_bootable "/dev/sda" part_num in
356         let mbr_id =
357           try Some (g#part_get_mbr_id "/dev/sda" part_num)
358           with G.Error _ -> None in
359         let typ = get_partition_content name in
360
361         { p_name = name; p_part = part;
362           p_bootable = bootable; p_mbr_id = mbr_id; p_type = typ;
363           p_operation = OpCopy; p_target_partnum = 0;
364           p_target_start = 0L; p_target_end = 0L }
365     ) parts in
366
367   if debug then (
368     eprintf "%d partitions found\n" (List.length partitions);
369     List.iter debug_partition partitions
370   );
371
372   (* Check content isn't larger than partitions.  If it is then
373    * something has gone wrong and we shouldn't continue.  Old
374    * virt-resize didn't do these checks.
375    *)
376   List.iter (
377     function
378     | { p_name = name; p_part = { G.part_size = size };
379         p_type = ContentPV pv_size }
380         when size < pv_size ->
381         error "%s: partition size %Ld < physical volume size %Ld"
382           name size pv_size
383     | { p_name = name; p_part = { G.part_size = size };
384         p_type = ContentFS (_, fs_size) }
385         when size < fs_size ->
386         error "%s: partition size %Ld < filesystem size %Ld"
387           name size fs_size
388     | _ -> ()
389   ) partitions;
390
391   (* Check partitions don't overlap. *)
392   let rec loop end_of_prev = function
393     | [] -> ()
394     | { p_name = name; p_part = { G.part_start = part_start } } :: _
395         when end_of_prev > part_start ->
396         error "%s: this partition overlaps the previous one" name
397     | { p_part = { G.part_end = part_end } } :: parts -> loop part_end parts
398   in
399   loop 0L partitions;
400
401   partitions
402
403 (* Build a data structure describing LVs on the source disk.
404  * This is only used if the user gave the --lv-expand option.
405  *)
406 type logvol = {
407   lv_name : string;
408   lv_type : logvol_content;
409   mutable lv_operation : logvol_operation
410 }
411 and logvol_content = partition_content (* except ContentPV cannot occur *)
412 and logvol_operation =
413   | LVOpNone                     (* nothing *)
414   | LVOpExpand                   (* expand it *)
415
416 let debug_logvol lv =
417   eprintf "%s:\n" lv.lv_name;
418   eprintf "\tcontent: %s\n" (string_of_partition_content lv.lv_type)
419
420 let lvs =
421   let lvs = Array.to_list (g#lvs ()) in
422
423   let lvs = List.map (
424     fun name ->
425       let typ = get_partition_content name in
426       assert (match typ with ContentPV _ -> false | _ -> true);
427
428       { lv_name = name; lv_type = typ; lv_operation = LVOpNone }
429   ) lvs in
430
431   if debug then (
432     eprintf "%d logical volumes found\n" (List.length lvs);
433     List.iter debug_logvol lvs
434   );
435
436   lvs
437
438 (* These functions tell us if we know how to expand the content of
439  * a particular partition or LV, and what method to use.
440  *)
441 type expand_content_method =
442   | PVResize | Resize2fs | NTFSResize | BtrfsFilesystemResize
443
444 let string_of_expand_content_method = function
445   | PVResize -> "pvresize"
446   | Resize2fs -> "resize2fs"
447   | NTFSResize -> "ntfsresize"
448   | BtrfsFilesystemResize -> "btrfs-filesystem-resize"
449
450 let can_expand_content =
451   if expand_content then
452     function
453     | ContentUnknown -> false
454     | ContentPV _ -> true
455     | ContentFS (("ext2"|"ext3"|"ext4"), _) -> true
456     | ContentFS (("ntfs"), _) when !ntfs_available -> true
457     | ContentFS (("btrfs"), _) when !btrfs_available -> true
458     | ContentFS (_, _) -> false
459   else
460     fun _ -> false
461
462 let expand_content_method =
463   if expand_content then
464     function
465     | ContentUnknown -> assert false
466     | ContentPV _ -> PVResize
467     | ContentFS (("ext2"|"ext3"|"ext4"), _) -> Resize2fs
468     | ContentFS (("ntfs"), _) when !ntfs_available -> NTFSResize
469     | ContentFS (("btrfs"), _) when !btrfs_available -> BtrfsFilesystemResize
470     | ContentFS (_, _) -> assert false
471   else
472     fun _ -> assert false
473
474 (* Helper function to locate a partition given what the user might
475  * type on the command line.  It also gives errors for partitions
476  * that the user has asked to be ignored or deleted.
477  *)
478 let find_partition =
479   let hash = Hashtbl.create 13 in
480   List.iter (fun ({ p_name = name } as p) -> Hashtbl.add hash name p)
481     partitions;
482   fun ~option name ->
483     let name =
484       if String.length name < 5 || String.sub name 0 5 <> "/dev/" then
485         "/dev/" ^ name
486       else
487         name in
488     let name = canonicalize name in
489
490     let partition =
491       try Hashtbl.find hash name
492       with Not_found ->
493         error "%s: partition not found in the source disk image (this error came from '%s' option on the command line).  Try running this command: virt-filesystems --partitions --long -a %s"
494           name option infile in
495
496     if partition.p_operation = OpIgnore then
497       error "%s: partition already ignored, you cannot use it in '%s' option"
498         name option;
499
500     if partition.p_operation = OpDelete then
501       error "%s: partition already deleted, you cannot use it in '%s' option"
502         name option;
503
504     partition
505
506 (* Handle --ignore option. *)
507 let () =
508   List.iter (
509     fun dev ->
510       let p = find_partition ~option:"--ignore" dev in
511       p.p_operation <- OpIgnore
512   ) ignores
513
514 (* Handle --delete option. *)
515 let () =
516   List.iter (
517     fun dev ->
518       let p = find_partition ~option:"--delete" dev in
519       p.p_operation <- OpDelete
520   ) deletes
521
522 (* Helper function to mark a partition for resizing.  It prevents the
523  * user from trying to mark the same partition twice.  If the force
524  * flag is given, then we will allow the user to shrink the partition
525  * even if we think that would destroy the content.
526  *)
527 let mark_partition_for_resize ~option ?(force = false) p newsize =
528   let name = p.p_name in
529   let oldsize = p.p_part.G.part_size in
530
531   (match p.p_operation with
532    | OpResize _ ->
533        error "%s: this partition has already been marked for resizing"
534          name
535    | OpIgnore | OpDelete ->
536        (* This error should have been caught already by find_partition ... *)
537        error "%s: this partition has already been ignored or deleted"
538          name
539    | OpCopy -> ()
540   );
541
542   (* Only do something if the size will change. *)
543   if oldsize <> newsize then (
544     let bigger = newsize > oldsize in
545
546     if not bigger && not force then (
547       (* Check if this contains filesystem content, and how big that is
548        * and whether we will destroy any content by shrinking this.
549        *)
550       match p.p_type with
551       | ContentUnknown ->
552           error "%s: This partition has unknown content which might be damaged by shrinking it.  If you want to shrink this partition, you need to use the '--resize-force' option, but that could destroy any data on this partition.  (This error came from '%s' option on the command line.)"
553             name option
554       | ContentPV size when size > newsize ->
555           error "%s: This partition has contains an LVM physical volume which will be damaged by shrinking it below %Ld bytes (user asked to shrink it to %Ld bytes).  If you want to shrink this partition, you need to use the '--resize-force' option, but that could destroy any data on this partition.  (This error came from '%s' option on the command line.)"
556             name size newsize option
557       | ContentPV _ -> ()
558       | ContentFS (fstype, size) when size > newsize ->
559           error "%s: This partition has contains a %s filesystem which will be damaged by shrinking it below %Ld bytes (user asked to shrink it to %Ld bytes).  If you want to shrink this partition, you need to use the '--resize-force' option, but that could destroy any data on this partition.  (This error came from '%s' option on the command line.)"
560             name fstype size newsize option
561       | ContentFS _ -> ()
562     );
563
564     p.p_operation <- OpResize newsize
565   )
566
567 (* Handle --resize and --resize-force options. *)
568 let () =
569   let do_resize ~option ?(force = false) arg =
570     (* Argument is "dev=size". *)
571     let dev, sizefield =
572       try
573         let i = String.index arg '=' in
574         let n = String.length arg - (i+1) in
575         if n == 0 then raise Not_found;
576         String.sub arg 0 i, String.sub arg (i+1) n
577       with Not_found ->
578         error "%s: missing size field in '%s' option" arg option in
579
580     let p = find_partition ~option dev in
581
582     (* Parse the size field. *)
583     let oldsize = p.p_part.G.part_size in
584     let newsize = parse_size oldsize sizefield in
585
586     if newsize <= 0L then
587       error "%s: new partition size is zero or negative" dev;
588
589     mark_partition_for_resize ~option ~force p newsize
590   in
591
592   List.iter (do_resize ~option:"--resize") resizes;
593   List.iter (do_resize ~option:"--resize-force" ~force:true) resizes_force
594
595 (* Helper function calculates the surplus space, given the total
596  * required so far for the current partition layout, compared to
597  * the size of the target disk.  If the return value >= 0 then it's
598  * a surplus, if it is < 0 then it's a deficit.
599  *)
600 let calculate_surplus () =
601   (* We need some overhead for partitioning.  Worst case would be for
602    * EFI partitioning + massive per-partition alignment.
603    *)
604   let nr_partitions = List.length partitions in
605   let overhead = (Int64.of_int sectsize) *^ (
606     2L *^ 64L +^                                 (* GPT start and end *)
607     (alignment *^ (Int64.of_int (nr_partitions + 1))) (* Maximum alignment *)
608   ) +^
609   (Int64.of_int (max_bootloader - 64 * 512)) in  (* Bootloader *)
610
611   let required = List.fold_left (
612     fun total p ->
613       let newsize =
614         match p.p_operation with
615         | OpCopy | OpIgnore -> p.p_part.G.part_size
616         | OpDelete -> 0L
617         | OpResize newsize -> newsize in
618       total +^ newsize
619   ) 0L partitions in
620
621   outsize -^ (required +^ overhead)
622
623 (* Handle --expand and --shrink options. *)
624 let () =
625   if expand <> None && shrink <> None then
626     error "you cannot use options --expand and --shrink together";
627
628   if expand <> None || shrink <> None then (
629     let surplus = calculate_surplus () in
630
631     if debug then
632       eprintf "surplus before --expand or --shrink: %Ld\n" surplus;
633
634     (match expand with
635      | None -> ()
636      | Some dev ->
637          if surplus < 0L then
638            error "You cannot use --expand when there is no surplus space to expand into.  You need to make the target disk larger by at least %s."
639              (human_size (Int64.neg surplus));
640
641          let option = "--expand" in
642          let p = find_partition ~option dev in
643          let oldsize = p.p_part.G.part_size in
644          mark_partition_for_resize ~option p (oldsize +^ surplus)
645     );
646     (match shrink with
647      | None -> ()
648      | Some dev ->
649          if surplus > 0L then
650            error "You cannot use --shrink when there is no deficit (see 'deficit' in the virt-resize(1) man page).";
651
652          let option = "--shrink" in
653          let p = find_partition ~option dev in
654          let oldsize = p.p_part.G.part_size in
655          mark_partition_for_resize ~option p (oldsize +^ surplus)
656     )
657   )
658
659 (* Calculate the final surplus.
660  * At this point, this number must be >= 0.
661  *)
662 let surplus =
663   let surplus = calculate_surplus () in
664
665   if surplus < 0L then (
666     let deficit = Int64.neg surplus in
667     error "There is a deficit of %Ld bytes (%s).  You need to make the target disk larger by at least this amount or adjust your resizing requests."
668       deficit (human_size deficit)
669   );
670
671   surplus
672
673 (* Mark the --lv-expand LVs. *)
674 let () =
675   let hash = Hashtbl.create 13 in
676   List.iter (fun ({ lv_name = name } as lv) -> Hashtbl.add hash name lv) lvs;
677
678   List.iter (
679     fun name ->
680       let lv =
681         try Hashtbl.find hash name
682         with Not_found ->
683           error "%s: logical volume not found in the source disk image (this error came from '--lv-expand' option on the command line).  Try running this command: virt-filesystems --logical-volumes --long -a %s"
684             name infile in
685       lv.lv_operation <- LVOpExpand
686   ) lv_expands
687
688 (* Print a summary of what we will do. *)
689 let () =
690   flush stderr;
691
692   if not quiet then (
693     printf "**********\n\n";
694     printf "Summary of changes:\n\n";
695
696     List.iter (
697       fun ({ p_name = name; p_part = { G.part_size = oldsize }} as p) ->
698         let text =
699           match p.p_operation with
700           | OpCopy ->
701               sprintf "%s: This partition will be left alone." name
702           | OpIgnore ->
703               sprintf "%s: This partition will be created, but the contents will be ignored (ie. not copied to the target)." name
704           | OpDelete ->
705               sprintf "%s: This partition will be deleted." name
706           | OpResize newsize ->
707               sprintf "%s: This partition will be resized from %s to %s."
708                 name (human_size oldsize) (human_size newsize) ^
709               if can_expand_content p.p_type then (
710                 sprintf "  The %s on %s will be expanded using the '%s' method."
711                   (string_of_partition_content_no_size p.p_type)
712                   name
713                   (string_of_expand_content_method
714                      (expand_content_method p.p_type))
715               ) else "" in
716
717         wrap ~hanging:4 (text ^ "\n\n")
718     ) partitions;
719
720     List.iter (
721       fun ({ lv_name = name } as lv) ->
722         match lv.lv_operation with
723         | LVOpNone -> ()
724         | LVOpExpand ->
725             let text =
726               sprintf "%s: This logical volume will be expanded to maximum size."
727                 name ^
728               if can_expand_content lv.lv_type then (
729                 sprintf "  The %s on %s will be expanded using the '%s' method."
730                   (string_of_partition_content_no_size lv.lv_type)
731                   name
732                   (string_of_expand_content_method
733                      (expand_content_method lv.lv_type))
734               ) else "" in
735
736             wrap ~hanging:4 (text ^ "\n\n")
737     ) lvs;
738
739     if surplus > 0L then (
740       let text =
741         sprintf "There is a surplus of %s." (human_size surplus) ^
742         if extra_partition then (
743           if surplus >= min_extra_partition then
744             sprintf "  An extra partition will be created for the surplus."
745           else
746             sprintf "  The surplus space is not large enough for an extra partition to be created and so it will just be ignored."
747         ) else
748           sprintf "  The surplus space will be ignored.  Run a partitioning program in the guest to partition this extra space if you want." in
749
750       wrap (text ^ "\n\n")
751     );
752
753     printf "**********\n";
754     flush stdout
755   );
756
757   if dryrun then exit 0
758
759 (* Create a partition table.
760  *
761  * We *must* do this before copying the bootloader across, and copying
762  * the bootloader must be careful not to disturb this partition table
763  * (RHBZ#633766).  There are two reasons for this:
764  *
765  * (1) The 'parted' library is stupid and broken.  In many ways.  In
766  * this particular instance the stupid and broken bit is that it
767  * overwrites the whole boot sector when initializating a partition
768  * table.  (Upstream don't consider this obvious problem to be a bug).
769  *
770  * (2) GPT has a backup partition table located at the end of the disk.
771  * It's non-movable, because the primary GPT contains fixed references
772  * to both the size of the disk and the backup partition table at the
773  * end.  This would be a problem for any resize that didn't either
774  * carefully move the backup GPT (and rewrite those references) or
775  * recreate the whole partition table from scratch.
776  *)
777 let g =
778   (* Try hard to initialize the partition table.  This might involve
779    * relaunching another handle.
780    *)
781   if not quiet then
782     printf "Setting up initial partition table on %s ...\n%!" outfile;
783
784   let last_error = ref "" in
785   let rec initialize_partition_table g attempts =
786     let ok =
787       try g#part_init "/dev/sdb" parttype_string; true
788       with G.Error error -> last_error := error; false in
789     if ok then g, true
790     else if attempts > 0 then (
791       g#zero "/dev/sdb";
792       g#sync ();
793       g#close ();
794
795       let g = connect_both_disks () in
796       initialize_partition_table g (attempts-1)
797     )
798     else g, false
799   in
800
801   let g, ok = initialize_partition_table g 5 in
802   if not ok then
803     error "Failed to initialize the partition table on the target disk.  You need to wipe or recreate the target disk and then run virt-resize again.\n\nThe underlying error was: %s" !last_error;
804
805   g
806
807 (* Copy the bootloader across.
808  * Don't disturb the partition table that we just wrote.
809  * https://secure.wikimedia.org/wikipedia/en/wiki/Master_Boot_Record
810  * https://secure.wikimedia.org/wikipedia/en/wiki/GUID_Partition_Table
811  *)
812 let () =
813   if copy_boot_loader then (
814     let bootsect = g#pread_device "/dev/sda" 446 0L in
815     if String.length bootsect < 446 then
816       error "pread-device: short read";
817     ignore (g#pwrite_device "/dev/sdb" bootsect 0L);
818
819     let start =
820       if parttype <> GPT then 512L
821       else
822         (* XXX With 4K sectors does GPT just fit more entries in a
823          * sector, or does it always use 34 sectors?
824          *)
825         17408L in
826
827     let loader = g#pread_device "/dev/sda" max_bootloader start in
828     if String.length loader < max_bootloader then
829       error "pread-device: short read";
830     ignore (g#pwrite_device "/dev/sdb" loader start)
831   )
832
833 (* Are we going to align the first partition and fix the bootloader? *)
834 let align_first_partition_and_fix_bootloader =
835   (* Bootloaders that we know how to fix. *)
836   let can_fix_boot_loader =
837     match partitions with
838     | { p_type = ContentFS ("ntfs", _); p_bootable = true;
839         p_operation = OpCopy | OpIgnore | OpResize _ } :: _ -> true
840     | _ -> false
841   in
842
843   match align_first, can_fix_boot_loader with
844   | `Never, _
845   | `Auto, false -> false
846   | `Always, _
847   | `Auto, true -> true
848
849 (* Repartition the target disk. *)
850
851 (* Calculate the location of the partitions on the target disk.  This
852  * also removes from the list any partitions that will be deleted, so
853  * the final list just contains partitions that need to be created
854  * on the target.
855  *)
856 let partitions =
857   let sectsize = Int64.of_int sectsize in
858
859   (* Return 'i' rounded up to the next multiple of 'a'. *)
860   let roundup64 i a = let a = a -^ 1L in (i +^ a) &^ (~^ a) in
861
862   let rec loop partnum start = function
863     | p :: ps ->
864       (match p.p_operation with
865        | OpDelete -> loop partnum start ps      (* skip p *)
866
867        | OpIgnore | OpCopy ->           (* same size *)
868          (* Size in sectors. *)
869          let size = (p.p_part.G.part_size +^ sectsize -^ 1L) /^ sectsize in
870          (* Start of next partition + alignment. *)
871          let end_ = start +^ size in
872          let next = roundup64 end_ alignment in
873
874          { p with p_target_start = start; p_target_end = end_ -^ 1L;
875            p_target_partnum = partnum } :: loop (partnum+1) next ps
876
877        | OpResize newsize ->            (* resized partition *)
878          (* New size in sectors. *)
879          let size = (newsize +^ sectsize -^ 1L) /^ sectsize in
880          (* Start of next partition + alignment. *)
881          let next = start +^ size in
882          let next = roundup64 next alignment in
883
884          { p with p_target_start = start; p_target_end = next -^ 1L;
885            p_target_partnum = partnum } :: loop (partnum+1) next ps
886       )
887
888     | [] ->
889       (* Create the surplus partition if there is room for it. *)
890       if extra_partition && surplus >= min_extra_partition then (
891         [ {
892           (* Since this partition has no source, this data is
893            * meaningless and not used since the operation is
894            * OpIgnore.
895            *)
896           p_name = "";
897           p_part = { G.part_num = 0l; part_start = 0L; part_end = 0L;
898                      part_size = 0L };
899           p_bootable = false; p_mbr_id = None; p_type = ContentUnknown;
900
901           (* Target information is meaningful. *)
902           p_operation = OpIgnore;
903           p_target_partnum = partnum;
904           p_target_start = start; p_target_end = ~^ 64L
905         } ]
906       )
907       else
908         []
909   in
910
911   (* Choose the alignment of the first partition based on the
912    * '--align-first' option.  Old virt-resize used to always align this
913    * to 64 sectors, but this causes boot failures unless we are able to
914    * adjust the bootloader accordingly.
915    *)
916   let start =
917     if align_first_partition_and_fix_bootloader then
918       alignment
919     else
920       (* Preserve the existing start, but convert to sectors. *)
921       (List.hd partitions).p_part.G.part_start /^ sectsize in
922
923   loop 1 start partitions
924
925 (* Now partition the target disk. *)
926 let () =
927   List.iter (
928     fun p ->
929       g#part_add "/dev/sdb" "primary" p.p_target_start p.p_target_end;
930
931       (* Set bootable and MBR IDs *)
932       if p.p_bootable then
933         g#part_set_bootable "/dev/sdb" p.p_target_partnum true;
934
935       (match p.p_mbr_id with
936       | None -> ()
937       | Some mbr_id ->
938         g#part_set_mbr_id "/dev/sdb" p.p_target_partnum mbr_id
939       );
940   ) partitions
941
942 (* Copy over the data. *)
943 let () =
944   List.iter (
945     fun p ->
946       match p.p_operation with
947       | OpCopy | OpResize _ ->
948         (* XXX Old code had 'when target_partnum > 0', but it appears
949          * to have served no purpose since the field could never be 0
950          * at this point.
951          *)
952
953         let oldsize = p.p_part.G.part_size in
954         let newsize =
955           match p.p_operation with OpResize s -> s | _ -> oldsize in
956
957         let copysize = if newsize < oldsize then newsize else oldsize in
958
959         let source = p.p_name in
960         let target = sprintf "/dev/sdb%d" p.p_target_partnum in
961
962         if not quiet then
963           printf "Copying %s ...\n%!" source;
964
965         g#copy_size source target copysize;
966
967       | _ -> ()
968   ) partitions
969
970 (* Fix the bootloader if we aligned the first partition. *)
971 let () =
972   if align_first_partition_and_fix_bootloader then (
973     (* See can_fix_boot_loader above. *)
974     match partitions with
975     | { p_type = ContentFS ("ntfs", _); p_bootable = true;
976         p_target_partnum = partnum; p_target_start = start } :: _ ->
977       (* If the first partition is NTFS and bootable, set the "Number of
978        * Hidden Sectors" field in the NTFS Boot Record so that the
979        * filesystem is still bootable.
980        *)
981
982       (* Should always be /dev/sdb1? *)
983       let target = sprintf "/dev/sdb%d" partnum in
984
985       (* Sanity check: it contains the NTFS magic. *)
986       let magic = g#pread_device target 8 3L in
987       if magic <> "NTFS    " then
988         eprintf "warning: first partition is NTFS but does not contain NTFS boot loader magic\n%!"
989       else (
990         if not quiet then
991           printf "Fixing first NTFS partition boot record ...\n%!";
992
993         if debug then (
994           let old_hidden = int_of_le32 (g#pread_device target 4 0x1c_L) in
995           eprintf "old hidden sectors value: 0x%Lx\n%!" old_hidden
996         );
997
998         let new_hidden = le32_of_int start in
999         ignore (g#pwrite_device target new_hidden 0x1c_L)
1000       )
1001
1002     | _ -> ()
1003   )
1004
1005 (* After copying the data over we must shut down and restart the
1006  * appliance in order to expand the content.  The reason for this may
1007  * not be obvious, but it's because otherwise we'll have duplicate VGs
1008  * (the old VG(s) and the new VG(s)) which breaks LVM.
1009  *
1010  * The restart is only required if we're going to expand something.
1011  *)
1012 let to_be_expanded =
1013   List.exists (
1014     function
1015     | ({ p_operation = OpResize _ } as p) -> can_expand_content p.p_type
1016     | _ -> false
1017   ) partitions
1018   || List.exists (
1019     function
1020     | ({ lv_operation = LVOpExpand } as lv) -> can_expand_content lv.lv_type
1021     | _ -> false
1022   ) lvs
1023
1024 let g =
1025   if to_be_expanded then (
1026     g#umount_all ();
1027     g#sync ();
1028     g#close ();
1029
1030     let g = new G.guestfs () in
1031     if debug then g#set_trace true;
1032     g#add_drive_opts ?format:output_format ~readonly:false outfile;
1033     if not quiet then Progress.set_up_progress_bar ~machine_readable g;
1034     g#launch ();
1035
1036     g (* Return new handle. *)
1037   )
1038   else g (* Return existing handle. *)
1039
1040 let () =
1041   if to_be_expanded then (
1042     (* Helper function to expand partition or LV content. *)
1043     let do_expand_content target = function
1044       | PVResize -> g#pvresize target
1045       | Resize2fs ->
1046           g#e2fsck_f target;
1047           g#resize2fs target
1048       | NTFSResize -> g#ntfsresize_opts ~force:ntfsresize_force target
1049       | BtrfsFilesystemResize ->
1050           (* Complicated ...  Btrfs forces us to mount the filesystem
1051            * in order to resize it.
1052            *)
1053           assert (Array.length (g#mounts ()) = 0);
1054           g#mount_options "" target "/";
1055           g#btrfs_filesystem_resize "/";
1056           g#umount "/"
1057     in
1058
1059     (* Expand partition content as required. *)
1060     List.iter (
1061       function
1062       | ({ p_operation = OpResize _ } as p) when can_expand_content p.p_type ->
1063           let source = p.p_name in
1064           let target = sprintf "/dev/sda%d" p.p_target_partnum in
1065           let meth = expand_content_method p.p_type in
1066
1067           if not quiet then
1068             printf "Expanding %s%s using the '%s' method ...\n%!"
1069               source
1070               (if source <> target then sprintf " (now %s)" target else "")
1071               (string_of_expand_content_method meth);
1072
1073           do_expand_content target meth
1074       | _ -> ()
1075     ) partitions;
1076
1077     (* Expand logical volume content as required. *)
1078     List.iter (
1079       function
1080       | ({ lv_operation = LVOpExpand } as lv) when can_expand_content lv.lv_type ->
1081           let name = lv.lv_name in
1082           let meth = expand_content_method lv.lv_type in
1083
1084           if not quiet then
1085             printf "Expanding %s using the '%s' method ...\n%!"
1086               name
1087               (string_of_expand_content_method meth);
1088
1089           (* First expand the LV itself to maximum size. *)
1090           g#lvresize_free name 100;
1091
1092           (* Then expand the content in the LV. *)
1093           do_expand_content name meth
1094       | _ -> ()
1095     ) lvs
1096   )
1097
1098 (* Finished.  Unmount disks and exit. *)
1099 let () =
1100   g#umount_all ();
1101   g#sync ();
1102   g#close ();
1103
1104   if not quiet then (
1105     print_newline ();
1106     wrap "Resize operation completed with no errors.  Before deleting the old disk, carefully check that the resized disk boots and works correctly.\n";
1107   );
1108
1109   exit 0