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