Merge lp:~trapnine/maas/fix-1513085-1.9 into lp:maas/1.9

[Jeffrey C Jones]

Align partitions and logical volumes to 4MiB.

[Mike Pontillo (mpontillo)]

Approving this since it is a backport from an approved branch on trunk.

review: Approve

=== modified file 'src/maasserver/api/tests/test_raid.py'
--- src/maasserver/api/tests/test_raid.py	2015-10-28 17:32:43 +0000
+++ src/maasserver/api/tests/test_raid.py	2015-11-17 23:23:01 +0000
@@ -403,10 +403,8 @@
         (parsed_block_devices, parsed_partitions,
             parsed_block_device_spares, parsed_partition_spares) = (
             get_devices_from_raid(parsed_device))
-        # Size is equivalent to 7 devices of 9 TB each.
-        self.assertEqual(
-            7 * ((9 * 1000 ** 4) - PARTITION_TABLE_EXTRA_SPACE),
-            parsed_device['size'])
+        # Size is equivalent to 7 of the smallest device (the partitions).
+        self.assertEqual(7 * large_partitions[0].size, parsed_device['size'])
         self.assertItemsEqual(block_devices, parsed_block_devices)
         self.assertItemsEqual(partitions, parsed_partitions)
         self.assertItemsEqual(spare_devices, parsed_block_device_spares)
@@ -450,10 +448,8 @@
         (parsed_block_devices, parsed_partitions,
          parsed_block_device_spares, parsed_partition_spares) = (
             get_devices_from_raid(parsed_device))
-        # Size is equivalent to 6 devices of 9 TB each.
-        self.assertEqual(
-            6 * ((9 * 1000 ** 4) - PARTITION_TABLE_EXTRA_SPACE),
-            parsed_device['size'])
+        # Size is equivalent to 6 of the smallest device (the partitions).
+        self.assertEqual(6 * large_partitions[0].size, parsed_device['size'])
         self.assertItemsEqual(block_devices, parsed_block_devices)
         self.assertItemsEqual(partitions, parsed_partitions)
         self.assertItemsEqual(spare_devices, parsed_block_device_spares)
@@ -497,10 +493,8 @@
         (parsed_block_devices, parsed_partitions,
             parsed_block_device_spares, parsed_partition_spares) = (
             get_devices_from_raid(parsed_device))
-        # Size is equivalent to 4 devices of 9 TB each.
-        self.assertEqual(
-            4 * ((9 * 1000 ** 4) - PARTITION_TABLE_EXTRA_SPACE),
-            parsed_device['size'])
+        # Size is equivalent to 4 of the smallest device (the partitions).
+        self.assertEqual(4 * large_partitions[0].size, parsed_device['size'])
         self.assertItemsEqual(block_devices, parsed_block_devices)
         self.assertItemsEqual(partitions, parsed_partitions)
         self.assertItemsEqual(spare_devices, parsed_block_device_spares)

=== modified file 'src/maasserver/api/tests/test_volume_groups.py'
--- src/maasserver/api/tests/test_volume_groups.py	2015-09-24 16:22:12 +0000
+++ src/maasserver/api/tests/test_volume_groups.py	2015-11-17 23:23:01 +0000
@@ -26,11 +26,18 @@
     NODE_STATUS,
 )
 from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
+from maasserver.models.partition import (
+    MIN_PARTITION_SIZE,
+    PARTITION_ALIGNMENT_SIZE,
+)
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.testing.api import APITestCase
 from maasserver.testing.factory import factory
 from maasserver.testing.orm import reload_object
-from maasserver.utils.converters import human_readable_bytes
+from maasserver.utils.converters import (
+    human_readable_bytes,
+    round_size_to_nearest_block,
+)
 from testtools.matchers import (
     ContainsDict,
     Equals,
@@ -132,11 +139,11 @@
         ]
         block_device = factory.make_PhysicalBlockDevice(
             node=node,
-            size=(MIN_BLOCK_DEVICE_SIZE * 3) + PARTITION_TABLE_EXTRA_SPACE)
+            size=MIN_PARTITION_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE)
         partition_table = factory.make_PartitionTable(
             block_device=block_device)
         partitions = [
-            partition_table.add_partition(size=MIN_BLOCK_DEVICE_SIZE)
+            partition_table.add_partition(size=MIN_PARTITION_SIZE)
             for _ in range(2)
         ]
         partition_ids = [
@@ -411,10 +418,12 @@
             })
         self.assertEqual(httplib.OK, response.status_code, response.content)
         logical_volume = json.loads(response.content)
+        expected_size = round_size_to_nearest_block(
+            size, PARTITION_ALIGNMENT_SIZE, False)
         self.assertThat(logical_volume, ContainsDict({
             "name": Equals("%s-%s" % (volume_group.name, name)),
             "uuid": Equals(vguuid),
-            "size": Equals(size),
+            "size": Equals(expected_size),
             }))
 
     def test_delete_logical_volume_204_when_invalid_id(self):

=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py	2015-11-02 16:32:29 +0000
+++ src/maasserver/forms.py	2015-11-17 23:23:01 +0000
@@ -154,6 +154,7 @@
     nodegroup_fqdn,
 )
 from maasserver.models.nodegroup import NODEGROUP_CLUSTER_NAME_TEMPLATE
+from maasserver.models.partition import MIN_PARTITION_SIZE
 from maasserver.models.subnet import (
     create_cidr,
     Subnet,
@@ -3253,7 +3254,7 @@
         This needs to be done on the fly so that we can pass the maximum size.
         """
         self.fields['size'] = BytesField(
-            min_value=MIN_BLOCK_DEVICE_SIZE,
+            min_value=MIN_PARTITION_SIZE,
             max_value=self.block_device.size,
             required=True)
 

=== modified file 'src/maasserver/models/blockdevice.py'
--- src/maasserver/models/blockdevice.py	2015-10-28 01:59:30 +0000
+++ src/maasserver/models/blockdevice.py	2015-11-17 23:23:01 +0000
@@ -51,7 +51,7 @@
 )
 
 
-MIN_BLOCK_DEVICE_SIZE = 2 * 1024 * 1024  # 2MiB
+MIN_BLOCK_DEVICE_SIZE = 4 * 1024 * 1024  # 4MiB
 MIN_BLOCK_DEVICE_BLOCK_SIZE = 512  # A ProDOS block
 
 

=== modified file 'src/maasserver/models/partition.py'
--- src/maasserver/models/partition.py	2015-10-20 15:02:19 +0000
+++ src/maasserver/models/partition.py	2015-11-17 23:23:01 +0000
@@ -32,7 +32,6 @@
 from django.dispatch import receiver
 from maasserver import DefaultMeta
 from maasserver.enum import PARTITION_TABLE_TYPE
-from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
 from maasserver.models.cleansave import CleanSave
 from maasserver.models.timestampedmodel import TimestampedModel
 from maasserver.utils.converters import (
@@ -45,8 +44,10 @@
 )
 
 
-MIN_PARTITION_SIZE = MIN_BLOCK_DEVICE_SIZE
 MAX_PARTITION_SIZE_FOR_MBR = (((2 ** 32) - 1) * 512) - (1024 ** 2)  # 2 TiB
+# All partitions are aligned down to 4MiB blocks for performance (lp:1513085)
+PARTITION_ALIGNMENT_SIZE = 4 * 1024 * 1024
+MIN_PARTITION_SIZE = PARTITION_ALIGNMENT_SIZE
 
 
 class PartitionManager(Manager):
@@ -216,17 +217,16 @@
             bd=self.partition_table.block_device.__unicode__())
 
     def _round_size(self):
-        """Round the size of this partition to the nearest block."""
+        """Round the size of this partition down for alignment."""
         if self.size is not None and self.partition_table is not None:
             self.size = round_size_to_nearest_block(
-                self.size, self.partition_table.get_block_size())
+                self.size, PARTITION_ALIGNMENT_SIZE, False)
 
     @classmethod
     def _get_mbr_max_for_block_device(self, block_device):
         """Get the maximum partition size for MBR for this block device."""
-        block_size = block_device.block_size
-        number_of_blocks = MAX_PARTITION_SIZE_FOR_MBR / block_size
-        return block_size * (number_of_blocks - 1)
+        return round_size_to_nearest_block(
+            MAX_PARTITION_SIZE_FOR_MBR, PARTITION_ALIGNMENT_SIZE, False)
 
     def _get_mbr_max_for_partition(self):
         """Get the maximum partition size for MBR for this partition."""

=== modified file 'src/maasserver/models/partitiontable.py'
--- src/maasserver/models/partitiontable.py	2015-11-04 04:27:46 +0000
+++ src/maasserver/models/partitiontable.py	2015-11-17 23:23:01 +0000
@@ -29,13 +29,17 @@
 )
 from maasserver.models.blockdevice import BlockDevice
 from maasserver.models.cleansave import CleanSave
-from maasserver.models.partition import Partition
+from maasserver.models.partition import (
+    Partition,
+    PARTITION_ALIGNMENT_SIZE,
+)
 from maasserver.models.timestampedmodel import TimestampedModel
 from maasserver.utils.converters import round_size_to_nearest_block
 
-# The first partition on the disk must start at 2MiB, as all previous bytes
-# will be used by the partition table and grub.
-INITIAL_PARTITION_OFFSET = 2 * 1024 * 1024
+# The first 2MiB of the device are used by the partition table and grub. We'll
+# reserve the first 4MiB to make sure all partitions stay aligned to 4MB across
+# the device.
+INITIAL_PARTITION_OFFSET = 4 * 1024 * 1024
 
 # An additional 1MiB of space is left open at the end of the disk to allow for
 # the extra MBR table.
@@ -67,11 +71,11 @@
         return self.block_device.node
 
     def get_size(self):
-        """Size of partition table."""
-        return (
-            self.block_device.size -
-            round_size_to_nearest_block(
-                PARTITION_TABLE_EXTRA_SPACE, self.get_block_size()))
+        """Total usable size of partition table."""
+        return round_size_to_nearest_block(
+            self.block_device.size - PARTITION_TABLE_EXTRA_SPACE,
+            PARTITION_ALIGNMENT_SIZE,
+            False)
 
     def get_block_size(self):
         """Block size of partition table."""
@@ -89,15 +93,15 @@
         if used_size is None:
             used_size = 0
         # The extra space taken by the partition table header is used space.
-        used_size += round_size_to_nearest_block(
-            PARTITION_TABLE_EXTRA_SPACE, self.get_block_size())
-        return round_size_to_nearest_block(
-            used_size, self.get_block_size())
+        return used_size + PARTITION_TABLE_EXTRA_SPACE
 
     def get_available_size(self, ignore_partitions=[]):
         """Return the remaining size available for partitions."""
         used_size = self.get_used_size(ignore_partitions=ignore_partitions)
-        return self.block_device.size - used_size
+        # Only report 'alignable' space as available for new partitions
+        return round_size_to_nearest_block(
+            self.block_device.size - used_size,
+            PARTITION_ALIGNMENT_SIZE, False)
 
     def add_partition(self, size=None, bootable=False, uuid=None):
         """Adds a partition to this partition table, returns the added
@@ -105,15 +109,15 @@
 
         If size is omitted, the partition will extend to the end of the device.
 
-        If size is not a multiple of the device's block size, the size will be
-        rounded up to the next multiple.
+        All partition sizes will be aligned down to PARTITION_ALIGNMENT_SIZE.
         """
         if size is None:
             size = self.get_available_size()
             if self.table_type == PARTITION_TABLE_TYPE.MBR:
                 size = min(size, Partition._get_mbr_max_for_block_device(
                     self.block_device))
-        size = round_size_to_nearest_block(size, self.get_block_size())
+        size = round_size_to_nearest_block(
+            size, PARTITION_ALIGNMENT_SIZE, False)
         return Partition.objects.create(
             partition_table=self, size=size, uuid=uuid, bootable=bootable)
 

=== modified file 'src/maasserver/models/tests/test_blockdevice.py'
--- src/maasserver/models/tests/test_blockdevice.py	2015-10-28 01:59:30 +0000
+++ src/maasserver/models/tests/test_blockdevice.py	2015-11-17 23:23:01 +0000
@@ -34,6 +34,7 @@
     VirtualBlockDevice,
     VolumeGroup,
 )
+from maasserver.models.partition import PARTITION_ALIGNMENT_SIZE
 from maasserver.testing.factory import factory
 from maasserver.testing.orm import reload_object
 from maasserver.testing.testcase import MAASServerTestCase
@@ -428,8 +429,9 @@
         boot_disk = factory.make_PhysicalBlockDevice(node=node)
         partition = boot_disk.create_partition_if_boot_disk()
         self.assertIsNotNone(partition)
-        self.assertEquals(
-            boot_disk.get_available_size(), 0,
+        available_size = boot_disk.get_available_size()
+        self.assertTrue(
+            available_size >= 0 and available_size < PARTITION_ALIGNMENT_SIZE,
             "Should create a partition for the entire disk.")
 
 

=== modified file 'src/maasserver/models/tests/test_filesystemgroup.py'
--- src/maasserver/models/tests/test_filesystemgroup.py	2015-11-10 16:55:24 +0000
+++ src/maasserver/models/tests/test_filesystemgroup.py	2015-11-17 23:23:01 +0000
@@ -43,6 +43,7 @@
     VolumeGroup,
     VolumeGroupManager,
 )
+from maasserver.models.partition import PARTITION_ALIGNMENT_SIZE
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.models.physicalblockdevice import PhysicalBlockDevice
 from maasserver.models.virtualblockdevice import VirtualBlockDevice
@@ -52,7 +53,10 @@
     reload_objects,
 )
 from maasserver.testing.testcase import MAASServerTestCase
-from maasserver.utils.converters import machine_readable_bytes
+from maasserver.utils.converters import (
+    machine_readable_bytes,
+    round_size_to_nearest_block,
+)
 from maastesting.matchers import (
     MockCalledOnceWith,
     MockNotCalled,
@@ -327,13 +331,16 @@
             [filesystem_group.id], result_filesystem_group_ids)
 
     def test__bcache_on_partitions(self):
-        block_device = factory.make_PhysicalBlockDevice()
+        device_size = random.randint(
+            MIN_BLOCK_DEVICE_SIZE * 4, MIN_BLOCK_DEVICE_SIZE * 1024)
+        block_device = factory.make_PhysicalBlockDevice(
+            size=device_size + PARTITION_TABLE_EXTRA_SPACE)
         partition_table = factory.make_PartitionTable(
             block_device=block_device)
         partition_one = factory.make_Partition(
-            partition_table=partition_table)
+            partition_table=partition_table, size=device_size / 2)
         partition_two = factory.make_Partition(
-            partition_table=partition_table)
+            partition_table=partition_table, size=device_size / 2)
         cache_set = factory.make_CacheSet(partition=partition_one)
         filesystem_backing = factory.make_Filesystem(
             fstype=FILESYSTEM_TYPE.BCACHE_BACKING, partition=partition_two)
@@ -1324,9 +1331,11 @@
         factory.make_VirtualBlockDevice(
             filesystem_group=fsgroup, size=5 * 1000 ** 3)
 
-        self.assertEqual(40 * 1000 ** 3, fsgroup.get_lvm_allocated_size())
+        expected_size = round_size_to_nearest_block(
+            40 * 1000 ** 3, PARTITION_ALIGNMENT_SIZE, False)
+        self.assertEqual(expected_size, fsgroup.get_lvm_allocated_size())
         self.assertEqual(
-            usable_size - (40 * 1000 ** 3), fsgroup.get_lvm_free_space())
+            usable_size - expected_size, fsgroup.get_lvm_free_space())
 
     def test_get_virtual_block_device_block_size_returns_backing_for_bc(self):
         # This test is not included in the scenario below
@@ -1567,10 +1576,12 @@
         logical_volume = volume_group.create_logical_volume(
             name=name, uuid=vguuid, size=size)
         logical_volume = reload_object(logical_volume)
+        expected_size = round_size_to_nearest_block(
+            size, PARTITION_ALIGNMENT_SIZE, False)
         self.assertThat(logical_volume, MatchesStructure.byEquality(
             name=name,
             uuid=vguuid,
-            size=size,
+            size=expected_size,
             block_size=volume_group.get_virtual_block_device_block_size(),
             ))
 
@@ -1597,8 +1608,6 @@
             bd.get_partitiontable().add_partition()
             for bd in block_devices[5:]
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         spare_block_device = block_devices[0]
         spare_partition = partitions[0]
         uuid = unicode(uuid4())
@@ -1611,7 +1620,7 @@
             spare_devices=[spare_block_device],
             spare_partitions=[spare_partition])
         self.assertEqual('md0', raid.name)
-        self.assertEqual(6 * partition_size, raid.get_size())
+        self.assertEqual(6 * partitions[1].size, raid.get_size())
         self.assertEqual(FILESYSTEM_GROUP_TYPE.RAID_6, raid.group_type)
         self.assertEqual(uuid, raid.uuid)
         self.assertEqual(10, raid.filesystems.count())
@@ -1689,7 +1698,6 @@
             for bd in block_devices[5:]
         ]
         # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         spare_block_device = block_devices[0]
         spare_partition = partitions[0]
         uuid = unicode(uuid4())
@@ -1702,7 +1710,7 @@
             spare_devices=[spare_block_device],
             spare_partitions=[spare_partition])
         self.assertEqual('md0', raid.name)
-        self.assertEqual(partition_size, raid.get_size())
+        self.assertEqual(partitions[1].size, raid.get_size())
         self.assertEqual(FILESYSTEM_GROUP_TYPE.RAID_1, raid.group_type)
         self.assertEqual(uuid, raid.uuid)
         self.assertEqual(10, raid.filesystems.count())
@@ -1742,8 +1750,6 @@
             bd.get_partitiontable().add_partition()
             for bd in block_devices[5:]
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         spare_block_device = block_devices[0]
         spare_partition = partitions[0]
         uuid = unicode(uuid4())
@@ -1756,7 +1762,7 @@
             spare_devices=[spare_block_device],
             spare_partitions=[spare_partition])
         self.assertEqual('md0', raid.name)
-        self.assertEqual(7 * partition_size, raid.get_size())
+        self.assertEqual(7 * partitions[1].size, raid.get_size())
         self.assertEqual(FILESYSTEM_GROUP_TYPE.RAID_5, raid.group_type)
         self.assertEqual(uuid, raid.uuid)
         self.assertEqual(10, raid.filesystems.count())
@@ -1906,11 +1912,9 @@
         partition = factory.make_PartitionTable(
             block_device=factory.make_PhysicalBlockDevice(
                 node=node, size=device_size)).add_partition()
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         raid.add_partition(partition, FILESYSTEM_TYPE.RAID)
         self.assertEqual(11, raid.filesystems.count())
-        self.assertEqual(10 * partition_size, raid.get_size())
+        self.assertEqual(10 * partition.size, raid.get_size())
 
     def test_add_spare_partition_to_array(self):
         node = factory.make_Node()
@@ -1928,11 +1932,9 @@
         partition = factory.make_PartitionTable(
             block_device=factory.make_PhysicalBlockDevice(
                 node=node, size=device_size)).add_partition()
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         raid.add_partition(partition, FILESYSTEM_TYPE.RAID_SPARE)
         self.assertEqual(11, raid.filesystems.count())
-        self.assertEqual(9 * partition_size, raid.get_size())
+        self.assertEqual(9 * partition.size, raid.get_size())
 
     def test_add_device_from_another_node_to_array_fails(self):
         node = factory.make_Node()
@@ -2054,8 +2056,6 @@
                     node=node, size=device_size)).add_partition()
             for _ in range(4)
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         uuid = unicode(uuid4())
         raid = RAID.objects.create_raid(
             name='md0',
@@ -2070,7 +2070,7 @@
                 "devices and any number of spares.']}")):
             raid.remove_partition(partitions[0])
         self.assertEqual(4, raid.filesystems.count())
-        self.assertEqual(2 * partition_size, raid.get_size())
+        self.assertEqual(2 * partitions[0].size, raid.get_size())
         # Ensure the filesystems are the exact same before and after.
         self.assertItemsEqual(
             fsids_before, [fs.id for fs in raid.filesystems.all()])
@@ -2102,8 +2102,6 @@
                     node=node, size=device_size)).add_partition()
             for _ in range(10)
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         uuid = unicode(uuid4())
         raid = RAID.objects.create_raid(
             name='md0',
@@ -2113,7 +2111,7 @@
             spare_partitions=partitions[-2:])
         raid.remove_partition(partitions[0])
         self.assertEqual(9, raid.filesystems.count())
-        self.assertEqual(6 * partition_size, raid.get_size())
+        self.assertEqual(6 * partitions[0].size, raid.get_size())
 
     def test_remove_invalid_partition_from_array_fails(self):
         node = factory.make_Node(bios_boot_method="uefi")
@@ -2125,8 +2123,6 @@
                     node=node, size=device_size)).add_partition()
             for _ in range(10)
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         uuid = unicode(uuid4())
         raid = RAID.objects.create_raid(
             name='md0',
@@ -2142,7 +2138,7 @@
                     block_device=factory.make_PhysicalBlockDevice(
                         node=node, size=device_size)).add_partition())
         self.assertEqual(10, raid.filesystems.count())
-        self.assertEqual(9 * partition_size, raid.get_size())
+        self.assertEqual(9 * partitions[0].size, raid.get_size())
 
     def test_remove_device_from_array_fails(self):
         node = factory.make_Node()
@@ -2251,8 +2247,6 @@
         backing_partition = factory.make_PartitionTable(
             block_device=factory.make_PhysicalBlockDevice(
                 node=node, size=backing_size)).add_partition()
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = backing_size - PARTITION_TABLE_EXTRA_SPACE
         uuid = unicode(uuid4())
         bcache = Bcache.objects.create_bcache(
             name='bcache0',
@@ -2262,7 +2256,7 @@
             cache_mode=CACHE_MODE_TYPE.WRITEBACK)
 
         # Verify the filesystems were properly created on the target devices
-        self.assertEqual(partition_size, bcache.get_size())
+        self.assertEqual(backing_partition.size, bcache.get_size())
         self.assertEqual(
             FILESYSTEM_TYPE.BCACHE_CACHE,
             cache_partition.get_effective_filesystem().fstype)

=== modified file 'src/maasserver/models/tests/test_partition.py'
--- src/maasserver/models/tests/test_partition.py	2015-11-04 19:39:51 +0000
+++ src/maasserver/models/tests/test_partition.py	2015-11-17 23:23:01 +0000
@@ -29,6 +29,7 @@
 from maasserver.models.partition import (
     MIN_PARTITION_SIZE,
     Partition,
+    PARTITION_ALIGNMENT_SIZE,
 )
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.testing.factory import factory
@@ -45,18 +46,18 @@
         node = factory.make_Node()
         block_device = factory.make_PhysicalBlockDevice(
             node=node,
-            size=(MIN_BLOCK_DEVICE_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE)
+            size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE)
         partition_table = factory.make_PartitionTable(
             block_device=block_device)
         free_partitions = [
-            partition_table.add_partition(size=MIN_BLOCK_DEVICE_SIZE)
+            partition_table.add_partition(size=MIN_PARTITION_SIZE)
             for _ in range(2)
         ]
         # Make used partitions.
         for _ in range(2):
             factory.make_Filesystem(
                 partition=partition_table.add_partition(
-                    size=MIN_BLOCK_DEVICE_SIZE))
+                    size=MIN_PARTITION_SIZE))
         self.assertItemsEqual(
             free_partitions,
             Partition.objects.get_free_partitions_for_node(node))
@@ -213,12 +214,12 @@
         partition.save()
         self.assertEquals('%s' % uuid, partition.uuid)
 
-    def test_size_is_rounded_to_next_block(self):
+    def test_size_is_rounded_to_current_block(self):
         partition = factory.make_Partition()
-        partition.size = partition.get_block_size() * 4096
+        partition.size = PARTITION_ALIGNMENT_SIZE * 4
         partition.size += 1
         partition.save()
-        self.assertEquals(4097, partition.size / partition.get_block_size())
+        self.assertEquals(PARTITION_ALIGNMENT_SIZE * 4, partition.size)
 
     def test_validate_enough_space_for_new_partition(self):
         partition_table = factory.make_PartitionTable()
@@ -235,7 +236,7 @@
     def test_validate_enough_space_for_resize_partition(self):
         partition_table = factory.make_PartitionTable()
         partition = partition_table.add_partition()
-        partition.size += partition_table.get_block_size() * 2
+        partition.size += PARTITION_ALIGNMENT_SIZE * 2
         error = self.assertRaises(ValidationError, partition.save)
         self.assertEquals({
             "size": [
@@ -298,7 +299,7 @@
         node = factory.make_Node(bios_boot_method="uefi")
         block_device = factory.make_PhysicalBlockDevice(
             node=node,
-            size=(MIN_BLOCK_DEVICE_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE)
+            size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE)
         partition_table = factory.make_PartitionTable(
             block_device=block_device, table_type=PARTITION_TABLE_TYPE.GPT)
         partitions = [

=== modified file 'src/maasserver/models/tests/test_partitiontable.py'
--- src/maasserver/models/tests/test_partitiontable.py	2015-11-04 04:27:46 +0000
+++ src/maasserver/models/tests/test_partitiontable.py	2015-11-17 23:23:01 +0000
@@ -23,7 +23,11 @@
     BlockDevice,
     MIN_BLOCK_DEVICE_SIZE,
 )
-from maasserver.models.partition import MAX_PARTITION_SIZE_FOR_MBR
+from maasserver.models.partition import (
+    MAX_PARTITION_SIZE_FOR_MBR,
+    MIN_PARTITION_SIZE,
+    PARTITION_ALIGNMENT_SIZE,
+)
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
@@ -41,7 +45,11 @@
     def test_get_size_returns_block_device_size_minus_initial_offset(self):
         partition_table = factory.make_PartitionTable()
         self.assertEquals(
-            partition_table.block_device.size - PARTITION_TABLE_EXTRA_SPACE,
+            round_size_to_nearest_block(
+                partition_table.block_device.size -
+                PARTITION_TABLE_EXTRA_SPACE,
+                PARTITION_ALIGNMENT_SIZE,
+                False),
             partition_table.get_size())
 
     def test_get_block_size_returns_block_device_block_size(self):
@@ -52,17 +60,17 @@
 
     def test_add_misaligned_partition(self):
         """Tests whether a partition size are adjusted according to
-        device block size."""
+        partition alignment size (4MiB)."""
         block_size = 4096
         device = factory.make_BlockDevice(
-            size=MIN_BLOCK_DEVICE_SIZE * 2 + PARTITION_TABLE_EXTRA_SPACE,
+            size=MIN_PARTITION_SIZE * 2 + PARTITION_TABLE_EXTRA_SPACE,
             block_size=block_size)
         partition_table = factory.make_PartitionTable(block_device=device)
         partition = partition_table.add_partition(
-            size=MIN_BLOCK_DEVICE_SIZE + 54)
+            size=MIN_PARTITION_SIZE + 54)
         self.assertEqual(
             round_size_to_nearest_block(
-                MIN_BLOCK_DEVICE_SIZE + 54, block_size),
+                MIN_PARTITION_SIZE + 54, PARTITION_ALIGNMENT_SIZE, False),
             partition.size)
 
     def test_add_partition_no_size(self):
@@ -85,9 +93,10 @@
         partition_table = factory.make_PartitionTable(
             table_type=PARTITION_TABLE_TYPE.MBR, block_device=device)
         partition = partition_table.add_partition()
-        number_of_blocks = MAX_PARTITION_SIZE_FOR_MBR / block_size
         self.assertEqual(
-            partition.size, block_size * (number_of_blocks - 1))
+            round_size_to_nearest_block(
+                MAX_PARTITION_SIZE_FOR_MBR, PARTITION_ALIGNMENT_SIZE, False),
+            partition.size)
 
     def test_add_second_partition_no_size(self):
         """Tests whether a second partition with no specified size starts from
@@ -95,12 +104,12 @@
         device."""
         block_size = 4096
         device = factory.make_BlockDevice(
-            size=MIN_BLOCK_DEVICE_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE,
+            size=MIN_PARTITION_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE,
             block_size=block_size)
         partition_table = factory.make_PartitionTable(block_device=device)
-        partition_table.add_partition(size=MIN_BLOCK_DEVICE_SIZE)
+        partition_table.add_partition(size=MIN_PARTITION_SIZE)
         partition = partition_table.add_partition()
-        self.assertEqual(MIN_BLOCK_DEVICE_SIZE * 2, partition.size)
+        self.assertEqual(MIN_PARTITION_SIZE * 2, partition.size)
 
     def test_add_partition_to_full_device(self):
         """Tests whether we fail to add a partition to an already full device.
@@ -117,26 +126,26 @@
     def test_get_available_size(self):
         block_size = 4096
         device = factory.make_BlockDevice(
-            size=MIN_BLOCK_DEVICE_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE,
+            size=MIN_PARTITION_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE,
             block_size=block_size)
         partition_table = factory.make_PartitionTable(block_device=device)
-        partition_table.add_partition(size=MIN_BLOCK_DEVICE_SIZE)
+        partition_table.add_partition(size=MIN_PARTITION_SIZE)
         self.assertEquals(
-            MIN_BLOCK_DEVICE_SIZE * 2, partition_table.get_available_size())
+            MIN_PARTITION_SIZE * 2, partition_table.get_available_size())
 
     def test_get_available_size_skips_partitions(self):
         block_size = 4096
         device = factory.make_BlockDevice(
-            size=MIN_BLOCK_DEVICE_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE,
+            size=MIN_PARTITION_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE,
             block_size=block_size)
         partition_table = factory.make_PartitionTable(block_device=device)
         ignore_partitions = [
-            partition_table.add_partition(size=MIN_BLOCK_DEVICE_SIZE)
+            partition_table.add_partition(size=MIN_PARTITION_SIZE)
             for _ in range(2)
             ]
-        partition_table.add_partition(size=MIN_BLOCK_DEVICE_SIZE)
+        partition_table.add_partition(size=MIN_PARTITION_SIZE)
         self.assertEquals(
-            MIN_BLOCK_DEVICE_SIZE * 2,
+            MIN_PARTITION_SIZE * 2,
             partition_table.get_available_size(
                 ignore_partitions=ignore_partitions))
 

=== modified file 'src/maasserver/models/virtualblockdevice.py'
--- src/maasserver/models/virtualblockdevice.py	2015-08-14 13:48:59 +0000
+++ src/maasserver/models/virtualblockdevice.py	2015-11-17 23:23:01 +0000
@@ -30,7 +30,11 @@
 )
 from maasserver.models.filesystemgroup import FilesystemGroup
 from maasserver.models.node import Node
-from maasserver.utils.converters import human_readable_bytes
+from maasserver.models.partition import PARTITION_ALIGNMENT_SIZE
+from maasserver.utils.converters import (
+    human_readable_bytes,
+    round_size_to_nearest_block,
+)
 from maasserver.utils.orm import get_one
 
 
@@ -109,16 +113,22 @@
 
         # Check if the size of this is not larger than the free size of
         # its filesystem group if its lvm.
-        if (self.filesystem_group.is_lvm() and
-                self.size > self.filesystem_group.get_lvm_free_space(
-                    skip_volumes=[self])):
-            raise ValidationError(
-                "There is not enough free space (%s) "
-                "on volume group %s." % (
-                    human_readable_bytes(self.size),
-                    self.filesystem_group.name,
-                    ))
-        elif not self.filesystem_group.is_lvm():
+        if self.filesystem_group.is_lvm():
+
+            # align virtual partition to partition alignment size
+            # otherwise on creation it may be rounded up, overfilling group
+            self.size = round_size_to_nearest_block(
+                self.size, PARTITION_ALIGNMENT_SIZE, False)
+
+            if self.size > self.filesystem_group.get_lvm_free_space(
+                    skip_volumes=[self]):
+                raise ValidationError(
+                    "There is not enough free space (%s) "
+                    "on volume group %s." % (
+                        human_readable_bytes(self.size),
+                        self.filesystem_group.name,
+                        ))
+        else:
             # If not a volume group the size of the virtual block device
             # must equal the size of the filesystem group.
             assert self.size == self.filesystem_group.get_size()

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2015-11-02 22:17:02 +0000
+++ src/maasserver/testing/factory.py	2015-11-17 23:23:01 +0000
@@ -1287,9 +1287,7 @@
                 raise ValueError(
                     "Cannot make another partition on partition_table not "
                     "enough free space.")
-            size = round_size_to_nearest_block(
-                random.randint(MIN_PARTITION_SIZE, available_size),
-                partition_table.get_block_size())
+            size = random.randint(MIN_PARTITION_SIZE, available_size)
         if bootable is None:
             bootable = random.choice([True, False])
         return Partition.objects.create(

=== modified file 'src/maasserver/tests/test_forms_blockdevice.py'
--- src/maasserver/tests/test_forms_blockdevice.py	2015-09-24 19:54:30 +0000
+++ src/maasserver/tests/test_forms_blockdevice.py	2015-11-17 23:23:01 +0000
@@ -31,9 +31,11 @@
 )
 from maasserver.models import Filesystem
 from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
+from maasserver.models.partition import PARTITION_ALIGNMENT_SIZE
 from maasserver.testing.factory import factory
 from maasserver.testing.orm import reload_object
 from maasserver.testing.testcase import MAASServerTestCase
+from maasserver.utils.converters import round_size_to_nearest_block
 from maasserver.utils.orm import get_one
 from testtools.matchers import MatchesStructure
 
@@ -379,8 +381,10 @@
             })
         self.assertTrue(form.is_valid(), form.errors)
         block_device = form.save()
+        expected_size = round_size_to_nearest_block(
+            size, PARTITION_ALIGNMENT_SIZE, False)
         self.assertThat(block_device, MatchesStructure.byEquality(
             name=name,
             uuid=vguuid,
-            size=size,
+            size=expected_size,
             ))

=== modified file 'src/maasserver/tests/test_forms_partition.py'
--- src/maasserver/tests/test_forms_partition.py	2015-09-24 19:54:30 +0000
+++ src/maasserver/tests/test_forms_partition.py	2015-11-17 23:23:01 +0000
@@ -26,9 +26,11 @@
 )
 from maasserver.models import Filesystem
 from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
+from maasserver.models.partition import PARTITION_ALIGNMENT_SIZE
 from maasserver.testing.factory import factory
 from maasserver.testing.orm import reload_object
 from maasserver.testing.testcase import MAASServerTestCase
+from maasserver.utils.converters import round_size_to_nearest_block
 from maasserver.utils.orm import get_one
 
 
@@ -84,15 +86,13 @@
             form.is_valid(),
             "Should be valid because size is large enough and a string.")
 
-    def test_size_rounded_up_and_placed_on_block_boundry(self):
+    def test_size_rounded_down_and_placed_on_alignment_boundry(self):
         block_size = 4096
         block_device = factory.make_PhysicalBlockDevice(block_size=block_size)
         k_size = (MIN_BLOCK_DEVICE_SIZE / 1000) + 1
         size = "%sk" % k_size
-        block_count = (k_size * 1000) / block_size
-        if (k_size * 1000) % block_size > 0:
-            block_count += 1
-        rounded_size = block_count * block_size
+        rounded_size = round_size_to_nearest_block(
+            k_size * 1000, PARTITION_ALIGNMENT_SIZE, False)
         data = {
             'size': size,
             }

=== modified file 'src/maasserver/tests/test_forms_raid.py'
--- src/maasserver/tests/test_forms_raid.py	2015-10-29 16:39:49 +0000
+++ src/maasserver/tests/test_forms_raid.py	2015-11-17 23:23:01 +0000
@@ -26,7 +26,6 @@
     UpdateRaidForm,
 )
 from maasserver.models.filesystemgroup import RAID
-from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
 
@@ -126,12 +125,11 @@
             for bd in bds
             if bd.get_partitiontable() is None
         ]
-        partitions = [
-            bd.get_partitiontable().add_partition().id
+        partition_objs = [
+            bd.get_partitiontable().add_partition()
             for bd in bds[5:]
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
+        partitions = [partition.id for partition in partition_objs]
         form = CreateRaidForm(node=node, data={
             'name': 'md1',
             'level': FILESYSTEM_GROUP_TYPE.RAID_6,
@@ -141,7 +139,7 @@
         self.assertTrue(form.is_valid(), form.errors)
         raid = form.save()
         self.assertEqual('md1', raid.name)
-        self.assertEqual(8 * partition_size, raid.get_size())
+        self.assertEqual(8 * partition_objs[0].size, raid.get_size())
         self.assertEqual(FILESYSTEM_GROUP_TYPE.RAID_6, raid.group_type)
         self.assertItemsEqual(
             block_devices,
@@ -183,8 +181,6 @@
             part.name
             for part in partitions
         ]
-        # Partition size will be smaller than the disk, because of overhead.
-        partition_size = device_size - PARTITION_TABLE_EXTRA_SPACE
         form = CreateRaidForm(node=node, data={
             'name': 'md1',
             'level': FILESYSTEM_GROUP_TYPE.RAID_6,
@@ -194,7 +190,7 @@
         self.assertTrue(form.is_valid(), form.errors)
         raid = form.save()
         self.assertEqual('md1', raid.name)
-        self.assertEqual(8 * partition_size, raid.get_size())
+        self.assertEqual(8 * partitions[0].size, raid.get_size())
         self.assertEqual(FILESYSTEM_GROUP_TYPE.RAID_6, raid.group_type)
         self.assertItemsEqual(
             block_devices_ids,

=== modified file 'src/maasserver/tests/test_forms_volume_group.py'
--- src/maasserver/tests/test_forms_volume_group.py	2015-10-28 01:59:30 +0000
+++ src/maasserver/tests/test_forms_volume_group.py	2015-11-17 23:23:01 +0000
@@ -24,9 +24,11 @@
     UpdateVolumeGroupForm,
 )
 from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
+from maasserver.models.partition import PARTITION_ALIGNMENT_SIZE
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
+from maasserver.utils.converters import round_size_to_nearest_block
 from testtools.matchers import MatchesStructure
 
 
@@ -512,9 +514,10 @@
             factory.make_name("lv"),
             size=volume_group.get_size() - MIN_BLOCK_DEVICE_SIZE - 1)
         name = factory.make_name("lv")
+        free_space = volume_group.get_lvm_free_space()
         data = {
             'name': name,
-            'size': MIN_BLOCK_DEVICE_SIZE + 2,
+            'size': free_space + 2,
             }
         form = CreateLogicalVolumeForm(volume_group, data=data)
         self.assertFalse(
@@ -560,9 +563,11 @@
         form = CreateLogicalVolumeForm(volume_group, data=data)
         self.assertTrue(form.is_valid(), form._errors)
         logical_volume = form.save()
+        expected_size = round_size_to_nearest_block(
+            size, PARTITION_ALIGNMENT_SIZE, False)
         self.assertThat(
             logical_volume, MatchesStructure.byEquality(
                 name=name,
                 uuid=vguuid,
-                size=size,
+                size=expected_size,
                 ))

=== modified file 'src/maasserver/tests/test_preseed_storage.py'
--- src/maasserver/tests/test_preseed_storage.py	2015-11-04 04:27:46 +0000
+++ src/maasserver/tests/test_preseed_storage.py	2015-11-17 23:23:01 +0000
@@ -83,7 +83,7 @@
             size: 536870912B
             device: sda
             wipe: superblock
-            offset: 2097152B
+            offset: 4194304B
             flag: boot
           - id: sda-part2
             name: sda-part2
@@ -99,7 +99,7 @@
             type: partition
             number: 3
             uuid: f74ff260-2a5b-4a36-b1b8-37f746b946bf
-            size: 6976176128B
+            size: 6970933248B
             wipe: superblock
             device: sda
           - id: sda-part1_format
@@ -195,7 +195,7 @@
             size: 536870912B
             device: sda
             wipe: superblock
-            offset: 2097152B
+            offset: 4194304B
             flag: boot
           - id: sda-part2
             name: sda-part2
@@ -233,7 +233,7 @@
             type: partition
             number: 6
             uuid: 8c365c80-900b-40a1-a8c7-1e445878d19a
-            size: 2144337920B
+            size: 2139095040B
             device: sda
             wipe: superblock
             flag: logical
@@ -370,10 +370,10 @@
             type: partition
             number: 1
             uuid: 6efc2c3d-bc9d-4ee5-a7ed-c6e1574d5398
-            size: 8586788864B
+            size: 8581545984B
             device: sda
             wipe: superblock
-            offset: 2097152B
+            offset: 4194304B
           - id: sda-part1_format
             type: format
             fstype: ext4
@@ -435,10 +435,10 @@
             type: partition
             number: 1
             uuid: 6efc2c3d-bc9d-4ee5-a7ed-c6e1574d5398
-            size: 8586788864B
+            size: 8581545984B
             device: sda
             wipe: superblock
-            offset: 2097152B
+            offset: 4194304B
           - id: sda-part1_format
             type: format
             fstype: ext4
@@ -548,7 +548,7 @@
             size: 536870912B
             device: sda
             wipe: superblock
-            offset: 2097152B
+            offset: 4194304B
             flag: boot
           - id: sda-part2
             name: sda-part2
@@ -564,16 +564,16 @@
             type: partition
             number: 3
             uuid: f74ff260-2a5b-4a36-b1b8-37f746b946bf
-            size: 6976176128B
+            size: 6970933248B
             device: sda
             wipe: superblock
           - id: sdb-part1
             name: sdb-part1
             type: partition
             number: 1
-            offset: 2097152B
+            offset: 4194304B
             uuid: f3281144-a0b6-46f1-90af-8541f97f7b1f
-            size: 2144337920B
+            size: 2139095040B
             wipe: superblock
             device: sdb
           - id: bcache0
@@ -610,9 +610,9 @@
             name: md0-part1
             type: partition
             number: 1
-            offset: 2097152B
+            offset: 4194304B
             uuid: 18a6e885-3e6d-4505-8a0d-cf34df11a8b0
-            size: 2199020109824B
+            size: 2199014866944B
             wipe: superblock
             device: md0
           - id: sda-part1_format

=== modified file 'src/maasserver/tests/test_storage_layouts.py'
--- src/maasserver/tests/test_storage_layouts.py	2015-10-27 20:53:16 +0000
+++ src/maasserver/tests/test_storage_layouts.py	2015-11-17 23:23:01 +0000
@@ -25,7 +25,10 @@
 )
 from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
 from maasserver.models.filesystemgroup import VolumeGroup
-from maasserver.models.partition import MAX_PARTITION_SIZE_FOR_MBR
+from maasserver.models.partition import (
+    MAX_PARTITION_SIZE_FOR_MBR,
+    PARTITION_ALIGNMENT_SIZE,
+)
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.storage_layouts import (
     BcacheStorageLayout,
@@ -46,6 +49,7 @@
 )
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
+from maasserver.utils.converters import round_size_to_nearest_block
 from maastesting.matchers import MockCalledOnceWith
 from testtools.matchers import MatchesStructure
 
@@ -53,13 +57,6 @@
 LARGE_BLOCK_DEVICE = 10 * 1024 * 1024 * 1024  # 10 GiB
 
 
-def round_size_by_blocks(size, block_size):
-    number_of_blocks = size / block_size
-    if size % block_size > 0:
-        number_of_blocks += 1
-    return number_of_blocks * block_size
-
-
 def make_Node_with_uefi_boot_method(*args, **kwargs):
     kwargs['bios_boot_method'] = "uefi"
     kwargs['with_boot_disk'] = False
@@ -435,7 +432,8 @@
     def assertEFIPartition(self, partition, boot_disk):
         self.assertIsNotNone(partition)
         self.assertEquals(
-            round_size_by_blocks(EFI_PARTITION_SIZE, boot_disk.block_size),
+            round_size_to_nearest_block(
+                EFI_PARTITION_SIZE, boot_disk.block_size),
             partition.size)
         self.assertThat(
             partition.get_effective_filesystem(), MatchesStructure.byEquality(
@@ -474,9 +472,10 @@
         root_partition = partitions[0]
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            round_size_by_blocks(
+            round_size_to_nearest_block(
                 boot_disk.size - PARTITION_TABLE_EXTRA_SPACE,
-                boot_disk.block_size),
+                PARTITION_ALIGNMENT_SIZE,
+                False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -500,10 +499,12 @@
         # Validate root partition.
         partitions = partition_table.partitions.order_by('id').all()
         root_partition = partitions[0]
-        number_of_blocks = MAX_PARTITION_SIZE_FOR_MBR / boot_disk.block_size
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            (boot_disk.block_size * (number_of_blocks - 1)),
+            round_size_to_nearest_block(
+                MAX_PARTITION_SIZE_FOR_MBR,
+                PARTITION_ALIGNMENT_SIZE,
+                False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -533,10 +534,11 @@
         root_partition = partitions[1]
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            round_size_by_blocks(
+            round_size_to_nearest_block(
                 boot_disk.size - EFI_PARTITION_SIZE -
                 PARTITION_TABLE_EXTRA_SPACE,
-                boot_disk.block_size),
+                PARTITION_ALIGNMENT_SIZE,
+                False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -570,8 +572,8 @@
         boot_partition = partitions[1]
         self.assertIsNotNone(boot_partition)
         self.assertEquals(
-            round_size_by_blocks(
-                boot_size, boot_disk.block_size),
+            round_size_to_nearest_block(
+                boot_size, PARTITION_ALIGNMENT_SIZE, False),
             boot_partition.size)
         self.assertThat(
             boot_partition.get_effective_filesystem(),
@@ -585,10 +587,11 @@
         root_partition = partitions[2]
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            round_size_by_blocks(
+            round_size_to_nearest_block(
                 boot_disk.size - boot_partition.size -
                 EFI_PARTITION_SIZE - PARTITION_TABLE_EXTRA_SPACE,
-                boot_disk.block_size),
+                PARTITION_ALIGNMENT_SIZE,
+                False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -622,7 +625,8 @@
         root_partition = partitions[1]
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            round_size_by_blocks(root_size, boot_disk.block_size),
+            round_size_to_nearest_block(
+                root_size, PARTITION_ALIGNMENT_SIZE, False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -659,8 +663,8 @@
         boot_partition = partitions[1]
         self.assertIsNotNone(boot_partition)
         self.assertEquals(
-            round_size_by_blocks(
-                boot_size, boot_disk.block_size),
+            round_size_to_nearest_block(
+                boot_size, PARTITION_ALIGNMENT_SIZE, False),
             boot_partition.size)
         self.assertThat(
             boot_partition.get_effective_filesystem(),
@@ -674,7 +678,8 @@
         root_partition = partitions[2]
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            round_size_by_blocks(root_size, boot_disk.block_size),
+            round_size_to_nearest_block(
+                root_size, PARTITION_ALIGNMENT_SIZE, False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -716,7 +721,8 @@
             'id').all()[0]
         self.assertIsNotNone(root_partition)
         self.assertEquals(
-            round_size_by_blocks(root_size, root_device.block_size),
+            round_size_to_nearest_block(
+                root_size, PARTITION_ALIGNMENT_SIZE, False),
             root_partition.size)
         self.assertThat(
             root_partition.get_effective_filesystem(),
@@ -980,7 +986,9 @@
             1, volume_group.virtual_devices.count(),
             "Should have only 1 logical volume.")
         logical_volume = volume_group.virtual_devices.first()
-        self.assertEquals(lv_size, logical_volume.size)
+        expected_size = round_size_to_nearest_block(
+            lv_size, PARTITION_ALIGNMENT_SIZE, False)
+        self.assertEquals(expected_size, logical_volume.size)
         self.assertEquals(layout.DEFAULT_LV_NAME, logical_volume.name)
         self.assertThat(
             logical_volume.get_effective_filesystem(),
@@ -1003,14 +1011,13 @@
         root_partition = partitions[0]
         volume_group = VolumeGroup.objects.get(
             filesystems__partition=root_partition)
-        number_of_blocks = MAX_PARTITION_SIZE_FOR_MBR / boot_disk.block_size
         self.assertIsNotNone(volume_group)
         self.assertEquals(
             4, partition_table.partitions.count(),
             "Should have 4 partitions.")
-        self.assertEquals(
-            boot_disk.block_size * (number_of_blocks - 1),
-            root_partition.size)
+        expected_size = round_size_to_nearest_block(
+            MAX_PARTITION_SIZE_FOR_MBR, PARTITION_ALIGNMENT_SIZE, False)
+        self.assertEquals(expected_size, root_partition.size)
 
 
 class TestBcacheStorageLayoutBase(MAASServerTestCase):
@@ -1185,7 +1192,7 @@
         ssd = factory.make_PhysicalBlockDevice(
             node=node, size=5 * 1024 * 1024 * 1024, block_size=4096,
             tags=['ssd'])
-        cache_size = round_size_by_blocks(
+        cache_size = round_size_to_nearest_block(
             random.randint(
                 3 * 1024 * 1024 * 1024, 5 * 1024 * 1024 * 1024),
             4096)
@@ -1200,7 +1207,10 @@
         self.assertIsNotNone(partition_table)
         partition = partition_table.partitions.order_by('id').all()[0]
         self.assertEquals(partition, cache_device)
-        self.assertEquals(cache_size, partition.size)
+        self.assertEquals(
+            round_size_to_nearest_block(
+                cache_size, PARTITION_ALIGNMENT_SIZE, False),
+            partition.size)
 
     def test_raises_error_when_invalid_cache_device(self):
         node = make_Node_with_uefi_boot_method()
@@ -1234,7 +1244,8 @@
                 "Cannot use cache_size and cache_no_part at the same time."],
             "cache_no_part": [
                 "Cannot use cache_size and cache_no_part at the same time."],
-            }, layout.errors)
+            },
+            layout.errors)
 
     def test_raises_error_when_precentage_to_low_for_cache_size(self):
         node = make_Node_with_uefi_boot_method()

=== modified file 'src/maasserver/utils/converters.py'
--- src/maasserver/utils/converters.py	2015-10-11 00:26:09 +0000
+++ src/maasserver/utils/converters.py	2015-11-17 23:23:01 +0000
@@ -100,12 +100,14 @@
         return int(humanized)
 
 
-def round_size_to_nearest_block(size, block_size):
+def round_size_to_nearest_block(size, block_size, round_up=True):
     """Round the size to the nearest block returning the new size.
 
-    :param round_up: Round the size to fill an entire block.
+    :param size: The requested size to round.
+    :param block_size: The block size to round to.
+    :param round_up: If True, will round up to fill current block, else down.
     """
     number_of_blocks = size / block_size
-    if size % block_size > 0:
+    if round_up and size % block_size > 0:
         number_of_blocks += 1
     return block_size * number_of_blocks

=== modified file 'src/maasserver/utils/tests/test_converters.py'
--- src/maasserver/utils/tests/test_converters.py	2015-08-14 13:48:59 +0000
+++ src/maasserver/utils/tests/test_converters.py	2015-11-17 23:23:01 +0000
@@ -114,18 +114,34 @@
 
 class TestRoundSizeToNearestBlock(MAASTestCase):
 
-    def test__adds_extra_block(self):
+    def test__round_up_adds_extra_block(self):
         block_size = 4096
         size = block_size + 1
         self.assertEquals(
             2 * block_size,
-            round_size_to_nearest_block(size, block_size),
-            "Should add another block to the size.")
+            round_size_to_nearest_block(size, block_size, True),
+            "Should add an extra block to the size.")
 
-    def test__doesnt_add_extra_block(self):
+    def test__round_up_doesnt_add_extra_block(self):
         block_size = 4096
         size = block_size
         self.assertEquals(
             size,
-            round_size_to_nearest_block(size, block_size),
-            "Shouldn't add another block to the size.")
+            round_size_to_nearest_block(size, block_size, True),
+            "Shouldn't add an extra block to the size.")
+
+    def test__round_down_removes_block(self):
+        block_size = 4096
+        size = block_size + 1
+        self.assertEquals(
+            1 * block_size,
+            round_size_to_nearest_block(size, block_size, False),
+            "Should remove block from the size.")
+
+    def test__round_down_doesnt_remove_block(self):
+        block_size = 4096
+        size = block_size * 2
+        self.assertEquals(
+            size,
+            round_size_to_nearest_block(size, block_size, False),
+            "Shouldn't remove a block from the size.")

=== modified file 'src/maasserver/websockets/handlers/tests/test_node.py'
--- src/maasserver/websockets/handlers/tests/test_node.py	2015-11-10 23:41:49 +0000
+++ src/maasserver/websockets/handlers/tests/test_node.py	2015-11-17 23:23:01 +0000
@@ -48,7 +48,10 @@
 from maasserver.models.interface import Interface
 from maasserver.models.node import Node
 from maasserver.models.nodeprobeddetails import get_single_probed_details
-from maasserver.models.partition import Partition
+from maasserver.models.partition import (
+    Partition,
+    PARTITION_ALIGNMENT_SIZE,
+)
 from maasserver.node_action import compile_node_actions
 from maasserver.rpc.testing.fixtures import MockLiveRegionToClusterRPCFixture
 from maasserver.testing.architecture import make_usable_architecture
@@ -66,6 +69,7 @@
 from maasserver.third_party_drivers import get_third_party_driver
 from maasserver.utils.converters import (
     human_readable_bytes,
+    round_size_to_nearest_block,
     XMLToYAML,
 )
 from maasserver.utils.orm import (
@@ -1477,7 +1481,9 @@
         self.assertEquals(
             1, Partition.objects.count())
         self.assertEquals(
-            human_readable_bytes(size),
+            human_readable_bytes(
+                round_size_to_nearest_block(
+                    size, PARTITION_ALIGNMENT_SIZE, False)),
             human_readable_bytes(Partition.objects.first().size))
 
     def test_create_partition_with_filesystem(self):
@@ -1502,7 +1508,9 @@
         self.assertEquals(
             1, Partition.objects.count())
         self.assertEquals(
-            human_readable_bytes(size),
+            human_readable_bytes(
+                round_size_to_nearest_block(
+                    size, PARTITION_ALIGNMENT_SIZE, False)),
             human_readable_bytes(Partition.objects.first().size))
         self.assertEquals(
             fstype,