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