Merge ~cgrabowski/maas:backport_fix_overlapping_subnets_3.4 into maas:3.4

[Christian Grabowski]

fix: overlapping subnets no longer cause BIND to fail configuring
(cherry picked from commit 344fd0daa7e07955e32311bf97bd5a46225eb726)

[Christian Grabowski (cgrabowski)]

self-approving backport

review: Approve

[MAAS Lander (maas-lander)]

LANDING
-b backport_fix_overlapping_subnets_3.4 lp:~cgrabowski/maas/+git/maas into -b 3.4 lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci.internal:8080/job/maas-tester/4431/console

[MAAS Lander (maas-lander)]

UNIT TESTS
-b backport_fix_overlapping_subnets_3.4 lp:~cgrabowski/maas/+git/maas into -b 3.4 lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 6c281abeed217dd9155040df160c9f58f72a0cac

review: Approve

diff --git a/src/maasserver/dns/tests/test_zonegenerator.py b/src/maasserver/dns/tests/test_zonegenerator.py
index d213c1a..1555ae6 100644
--- a/src/maasserver/dns/tests/test_zonegenerator.py
+++ b/src/maasserver/dns/tests/test_zonegenerator.py
@@ -1,6 +1,7 @@
 # Copyright 2014-2022 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
+import os
 import random
 import socket
 from unittest.mock import ANY, call, Mock
@@ -37,7 +38,10 @@ from maasserver.enum import IPADDRESS_TYPE, NODE_STATUS, RDNS_MODE
 from maasserver.exceptions import UnresolvableHost
 from maasserver.models import Config, Domain, Subnet
 from maasserver.models.dnsdata import HostnameRRsetMapping
-from maasserver.models.staticipaddress import HostnameIPMapping
+from maasserver.models.staticipaddress import (
+    HostnameIPMapping,
+    StaticIPAddress,
+)
 from maasserver.testing.config import RegionConfigurationFixture
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import (
@@ -49,6 +53,7 @@ from maastesting.factory import factory as maastesting_factory
 from maastesting.fakemethod import FakeMethod
 from maastesting.matchers import MockAnyCall, MockCalledOnceWith, MockNotCalled
 from provisioningserver.dns.config import DynamicDNSUpdate
+from provisioningserver.dns.testing import patch_zone_file_config_path
 from provisioningserver.dns.zoneconfig import (
     DNSForwardZoneConfig,
     DNSReverseZoneConfig,
@@ -414,7 +419,7 @@ class TestZoneGenerator(MAASServerTestCase):
             ],  # purposely out of order to assert subnets are being sorted
             serial=random.randint(0, 65535),
         ).as_list()
-        self.assertEqual(len(zones), 7)
+        self.assertEqual(len(zones), 13)  # 5 /24s and 8 from the /21
         expected_domains = [
             "overlap",
             "36.232.10.in-addr.arpa",
@@ -728,14 +733,15 @@ class TestZoneGenerator(MAASServerTestCase):
     def test_supernet_inherits_rfc2317_net(self):
         domain = Domain.objects.get_default_domain()
         subnet1 = factory.make_Subnet(host_bits=2)
-        net = IPNetwork(subnet1.cidr)
-        if net.version == 6:
+        net1 = IPNetwork(subnet1.cidr)
+        if net1.version == 6:
             prefixlen = random.randint(121, 124)
         else:
             prefixlen = random.randint(22, 24)
-        parent = IPNetwork("%s/%d" % (net.network, prefixlen))
-        parent = IPNetwork("%s/%d" % (parent.network, prefixlen))
+        parent = IPNetwork(f"{net1.network}/{prefixlen:d}")
+        parent = IPNetwork(f"{parent.network}/{prefixlen:d}")
         subnet2 = factory.make_Subnet(cidr=parent)
+        net2 = IPNetwork(subnet2.cidr)
         node = factory.make_Node_with_Interface_on_Subnet(
             subnet=subnet1,
             vlan=subnet1.vlan,
@@ -746,56 +752,51 @@ class TestZoneGenerator(MAASServerTestCase):
         factory.make_StaticIPAddress(interface=boot_iface, subnet=subnet1)
         default_ttl = random.randint(10, 300)
         Config.objects.set_config("default_dns_ttl", default_ttl)
+        serial = random.randint(0, 65535)
         zones = ZoneGenerator(
             domain,
             [subnet1, subnet2],
             default_ttl=default_ttl,
-            serial=random.randint(0, 65535),
+            serial=serial,
         ).as_list()
-        self.assertThat(
-            zones,
-            MatchesSetwise(
-                forward_zone(domain.name),
-                reverse_zone(domain.name, subnet1.cidr),
-                reverse_zone(domain.name, subnet2.cidr),
+        expected = [
+            DNSForwardZoneConfig(
+                domain.name,
+                serial=serial,
+                default_ttl=default_ttl,
             ),
-        )
-        self.assertEqual(set(), zones[1]._rfc2317_ranges)
-        self.assertEqual({net}, zones[2]._rfc2317_ranges)
-
-    def test_two_managed_interfaces_yields_one_forward_two_reverse_zones(self):
-        default_domain = Domain.objects.get_default_domain().name
-        domain = factory.make_Domain()
-        subnet1 = factory.make_Subnet()
-        subnet2 = factory.make_Subnet()
-        expected_zones = [
-            forward_zone(domain.name),
-            reverse_zone(default_domain, subnet1.cidr),
-            reverse_zone(default_domain, subnet2.cidr),
         ]
-        subnets = Subnet.objects.all()
-
-        expected_zones = (
-            [forward_zone(domain.name)]
-            + [
-                reverse_zone(default_domain, subnet.get_ipnetwork())
-                for subnet in subnets
-            ]
-            + [
-                reverse_zone(
-                    default_domain,
-                    self.rfc2317_network(subnet.get_ipnetwork()),
+        for net in [net1, net2]:
+            if (
+                net.version == 6 and net.prefixlen < 124
+            ) or net.prefixlen < 24:
+                for network in ZoneGenerator._split_large_subnet(net2):
+                    expected.append(
+                        DNSReverseZoneConfig(domain.name, network=network)
+                    )
+            elif net.version == 6 and net.prefixlen > 124:
+                expected.append(
+                    DNSReverseZoneConfig(
+                        domain.name, network=IPNetwork(f"{net.network}/124")
+                    )
                 )
-                for subnet in subnets
-                if self.rfc2317_network(subnet.get_ipnetwork()) is not None
-            ]
-        )
-        self.assertThat(
-            ZoneGenerator(
-                domain, [subnet1, subnet2], serial=random.randint(0, 65535)
-            ).as_list(),
-            MatchesSetwise(*expected_zones),
+                expected.append(DNSReverseZoneConfig(domain.name, network=net))
+            elif net.version == 4 and net.prefixlen > 24:
+                expected.append(
+                    DNSReverseZoneConfig(
+                        domain.name, network=IPNetwork(f"{net.network}/24")
+                    )
+                )
+                expected.append(DNSReverseZoneConfig(domain.name, network=net))
+            else:
+                expected.append(DNSReverseZoneConfig(domain.name, network=net))
+        self.assertCountEqual(
+            set([(zone.domain, zone._network) for zone in zones]),
+            set((e.domain, e._network) for e in expected),
+            f"{subnet1} {subnet2}",
         )
+        self.assertEqual(set(), zones[1]._rfc2317_ranges)
+        self.assertEqual({net1}, zones[2]._rfc2317_ranges)
 
     def test_with_many_yields_many_zones(self):
         # This demonstrates ZoneGenerator in all-singing all-dancing mode.
@@ -806,18 +807,29 @@ class TestZoneGenerator(MAASServerTestCase):
         subnets = Subnet.objects.all()
         expected_zones = set()
         for domain in domains:
-            expected_zones.add(forward_zone(domain.name))
+            expected_zones.add(DNSForwardZoneConfig(domain.name))
         for subnet in subnets:
-            expected_zones.add(reverse_zone(default_domain.name, subnet.cidr))
-            rfc2317_net = self.rfc2317_network(subnet.get_ipnetwork())
-            if rfc2317_net is not None:
+            networks = ZoneGenerator._split_large_subnet(
+                IPNetwork(subnet.cidr)
+            )
+            for network in networks:
                 expected_zones.add(
-                    reverse_zone(default_domain.name, rfc2317_net.cidr)
+                    DNSReverseZoneConfig(default_domain.name, network=network)
                 )
+                if rfc2317_net := self.rfc2317_network(network):
+                    expected_zones.add(
+                        DNSReverseZoneConfig(
+                            default_domain.name,
+                            network=IPNetwork(rfc2317_net.cidr),
+                        )
+                    )
         actual_zones = ZoneGenerator(
             domains, subnets, serial=random.randint(0, 65535)
         ).as_list()
-        self.assertThat(actual_zones, MatchesSetwise(*expected_zones))
+        self.assertCountEqual(
+            [(zone.domain, zone._network) for zone in actual_zones],
+            [(zone.domain, zone._network) for zone in expected_zones],
+        )
 
     def test_zone_generator_handles_rdns_mode_equal_enabled(self):
         Domain.objects.get_or_create(name="one")
@@ -898,6 +910,359 @@ class TestZoneGenerator(MAASServerTestCase):
             ),
         )
 
+    def test_configs_are_merged_when_overlapping(self):
+        self.patch(warn_loopback)
+        default_domain = Domain.objects.get_default_domain()
+        subnet1 = factory.make_Subnet(cidr="10.0.1.0/24")
+        subnet2 = factory.make_Subnet(cidr="10.0.0.0/21")
+        subnet1_ips = [
+            factory.make_StaticIPAddress(
+                ip=factory.pick_ip_in_Subnet(subnet1), subnet=subnet1
+            )
+            for _ in range(3)
+        ]
+        subnet2_ips = [
+            factory.make_StaticIPAddress(
+                ip=factory.pick_ip_in_Subnet(subnet2), subnet=subnet2
+            )
+            for _ in range(3)
+        ]
+        subnet1_records = [
+            factory.make_DNSResource(domain=default_domain, ip_addresses=[ip])
+            for ip in subnet1_ips
+        ]
+        subnet2_records = [
+            factory.make_DNSResource(domain=default_domain, ip_addresses=[ip])
+            for ip in subnet2_ips
+        ]
+        serial = random.randint(0, 65535)
+        dynamic_updates = [
+            DynamicDNSUpdate(
+                operation="INSERT",
+                name=record.name,
+                zone=default_domain.name,
+                rectype="A",
+                ttl=record.address_ttl,
+                answer=ip.ip,
+            )
+            for record in subnet1_records + subnet2_records
+            for ip in record.ip_addresses.all()
+        ]
+        zones = ZoneGenerator(
+            [default_domain],
+            [subnet1, subnet2],
+            serial=serial,
+            dynamic_updates=dynamic_updates,
+        ).as_list()
+
+        def _generate_mapping_for_network(network, records):
+            mapping = {}
+            for record in records:
+                if ip_set := set(
+                    ip.ip
+                    for ip in record.ip_addresses.all()
+                    if IPAddress(ip.ip) in network
+                ):
+                    mapping[
+                        f"{record.name}.{default_domain.name}"
+                    ] = HostnameIPMapping(
+                        None,
+                        record.address_ttl,
+                        ip_set,
+                        None,
+                        1,
+                        None,
+                    )
+            return mapping
+
+        expected = [
+            DNSForwardZoneConfig(
+                default_domain.name,
+                mapping={
+                    record.name: HostnameIPMapping(
+                        None,
+                        record.address_ttl,
+                        set(record.ip_addresses.all()),
+                        None,
+                        1,
+                        None,
+                    )
+                    for record in subnet1_records + subnet2_records
+                },
+                dynamic_updates=dynamic_updates,
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork(subnet1.cidr),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork(subnet1.cidr), subnet1_records + subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork(subnet1.cidr)
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork(subnet1.cidr)
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.0.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.0.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.0.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.0.0/24")
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.2.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.2.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.2.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.2.0/24")
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.3.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.3.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.3.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.3.0/24")
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.4.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.4.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.4.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.4.0/24")
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.5.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.5.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.5.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.5.0/24")
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.6.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.6.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.6.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.6.0/24")
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork("10.0.7.0/24"),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork("10.0.7.0/24"), subnet2_records
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork("10.0.7.0/24")
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork("10.0.7.0/24")
+                ],
+            ),
+        ]
+
+        for i, zone in enumerate(zones):
+            self.assertEqual(zone.domain, expected[i].domain)
+            self.assertEqual(zone._network, expected[i]._network)
+            self.assertCountEqual(
+                zone._mapping,
+                expected[i]._mapping,
+            )
+            self.assertCountEqual(
+                zone._dynamic_updates, expected[i]._dynamic_updates
+            )
+            if isinstance(zone, DNSReverseZoneConfig):
+                self.assertCountEqual(
+                    zone._dynamic_ranges, expected[i]._dynamic_ranges
+                )
+                self.assertCountEqual(
+                    zone._rfc2317_ranges, expected[i]._rfc2317_ranges
+                )
+
+    def test_configs_are_merged_when_glue_overlaps(self):
+        self.patch(warn_loopback)
+        default_domain = Domain.objects.get_default_domain()
+        subnet1 = factory.make_Subnet(cidr="10.0.1.0/24")
+        subnet2 = factory.make_Subnet(cidr="10.0.1.0/26")
+        subnet1_ips = [
+            factory.make_StaticIPAddress(
+                ip=f"10.0.1.{253 + i}",
+                subnet=subnet1,  # avoid allocation collision
+            )
+            for i in range(3)
+        ]
+        subnet2_ips = [
+            factory.make_StaticIPAddress(
+                ip=factory.pick_ip_in_Subnet(subnet2), subnet=subnet2
+            )
+            for _ in range(3)
+        ]
+        subnet1_records = [
+            factory.make_DNSResource(domain=default_domain, ip_addresses=[ip])
+            for ip in subnet1_ips
+        ]
+        subnet2_records = [
+            factory.make_DNSResource(domain=default_domain, ip_addresses=[ip])
+            for ip in subnet2_ips
+        ]
+        serial = random.randint(0, 65535)
+        dynamic_updates = [
+            DynamicDNSUpdate(
+                operation="INSERT",
+                name=record.name,
+                zone=default_domain.name,
+                rectype="A",
+                ttl=record.address_ttl,
+                answer=ip.ip,
+            )
+            for record in subnet1_records + subnet2_records
+            for ip in record.ip_addresses.all()
+        ]
+        zones = ZoneGenerator(
+            [default_domain],
+            [subnet1, subnet2],
+            serial=serial,
+            dynamic_updates=dynamic_updates,
+        ).as_list()
+
+        def _generate_mapping_for_network(network, other_network, records):
+            mapping = {}
+            for record in records:
+                ip_set = set(
+                    ip.ip
+                    for ip in record.ip_addresses.all()
+                    if IPAddress(ip.ip) in network
+                    and (
+                        IPAddress(ip.ip) not in other_network
+                        or other_network.prefixlen < network.prefixlen
+                    )
+                )
+                if len(ip_set) > 0:
+                    mapping[
+                        f"{record.name}.{default_domain.name}"
+                    ] = HostnameIPMapping(
+                        None,
+                        record.address_ttl,
+                        ip_set,
+                        None,
+                        1,
+                        None,
+                    )
+            return mapping
+
+        expected = [
+            DNSForwardZoneConfig(
+                default_domain.name,
+                mapping={
+                    record.name: HostnameIPMapping(
+                        None,
+                        record.address_ttl,
+                        set(ip.ip for ip in record.ip_addresses.all()),
+                        None,
+                        1,
+                        None,
+                    )
+                    for record in subnet1_records + subnet2_records
+                },
+                dynamic_updates=dynamic_updates,
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork(subnet2.cidr),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork(subnet2.cidr),
+                    IPNetwork(subnet1.cidr),
+                    subnet1_records + subnet2_records,
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork(subnet2.cidr)
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork(subnet2.cidr)
+                ],
+            ),
+            DNSReverseZoneConfig(
+                default_domain.name,
+                network=IPNetwork(subnet1.cidr),
+                mapping=_generate_mapping_for_network(
+                    IPNetwork(subnet1.cidr),
+                    IPNetwork(subnet2.cidr),
+                    subnet1_records + subnet2_records,
+                ),
+                dynamic_updates=[
+                    DynamicDNSUpdate.as_reverse_record_update(
+                        update, IPNetwork(subnet1.cidr)
+                    )
+                    for update in dynamic_updates
+                    if update.answer_as_ip in IPNetwork(subnet1.cidr)
+                ],
+                rfc2317_ranges=set([IPNetwork(subnet2.cidr)]),
+            ),
+        ]
+
+        for i, zone in enumerate(zones):
+            self.assertEqual(zone.domain, expected[i].domain)
+            self.assertEqual(zone._network, expected[i]._network)
+            self.assertCountEqual(
+                zone._mapping,
+                expected[i]._mapping,
+            )
+            self.assertCountEqual(
+                zone._dynamic_updates, expected[i]._dynamic_updates
+            )
+            if isinstance(zone, DNSReverseZoneConfig):
+                self.assertCountEqual(
+                    zone._dynamic_ranges, expected[i]._dynamic_ranges
+                )
+                self.assertCountEqual(
+                    zone._rfc2317_ranges, expected[i]._rfc2317_ranges
+                )
+
 
 class TestZoneGeneratorTTL(MAASTransactionServerTestCase):
     """Tests for TTL in :class:ZoneGenerator`."""
@@ -1006,7 +1371,22 @@ class TestZoneGeneratorTTL(MAASTransactionServerTestCase):
             serial=random.randint(0, 65535),
         ).as_list()
         self.assertEqual(expected_forward, zones[0]._mapping)
-        self.assertEqual(expected_reverse, zones[1]._mapping)
+        for zone in zones[1:]:
+            if ip_set := set(
+                ip
+                for ip in expected_reverse[node.fqdn].ips
+                if IPAddress(ip) in zone._network
+            ):
+                expected_rev = {
+                    node.fqdn: HostnameIPMapping(
+                        node.system_id,
+                        node.address_ttl,
+                        ip_set,
+                        node.node_type,
+                        dnsrr.id,
+                    )
+                }
+                self.assertEqual(expected_rev, zone._mapping)
 
     @transactional
     def test_dnsresource_address_overrides_domain(self):
@@ -1058,7 +1438,22 @@ class TestZoneGeneratorTTL(MAASTransactionServerTestCase):
             serial=random.randint(0, 65535),
         ).as_list()
         self.assertEqual(expected_forward, zones[0]._mapping)
-        self.assertEqual(expected_reverse, zones[1]._mapping)
+
+        for zone in zones[1:]:
+            expected = {}
+            for expected_label, expected_mapping in expected_reverse.items():
+                if ip_set := set(
+                    ip for ip in expected_mapping.ips if ip in zone._network
+                ):
+                    expected[expected_label] = HostnameIPMapping(
+                        system_id=expected_mapping.system_id,
+                        ttl=expected_mapping.ttl,
+                        ips=ip_set,
+                        node_type=expected_mapping.node_type,
+                        dnsresource_id=expected_mapping.dnsresource_id,
+                        user_id=expected_mapping.user_id,
+                    )
+            self.assertEqual(expected, zone._mapping)
 
     @transactional
     def test_dnsdata_inherits_global(self):
@@ -1167,3 +1562,123 @@ class TestZoneGeneratorTTL(MAASTransactionServerTestCase):
         [zone_config] = ZoneGenerator(domains=[domain], subnets=[], serial=123)
         self.assertEqual(domain.name, zone_config.domain)
         self.assertEqual(42, zone_config.default_ttl)
+
+
+class TestZoneGeneratorEndToEnd(MAASServerTestCase):
+    def _find_most_specific_subnet(
+        self, ip: StaticIPAddress, subnets: list[Subnet]
+    ):
+        networks = []
+        for subnet in subnets:
+            net = IPNetwork(subnet.cidr)
+            if net.prefixlen < 24:
+                networks += ZoneGenerator._split_large_subnet(net)
+            else:
+                networks.append(net)
+        sorted_nets = sorted(networks, key=lambda net: -1 * net.prefixlen)
+        for net in sorted_nets:
+            if IPAddress(ip.ip) in net:
+                return net
+
+    def test_ZoneGenerator_generates_config_for_zone_files(self):
+        config_path = patch_zone_file_config_path(self)
+        default_domain = Domain.objects.get_default_domain()
+        domain = factory.make_Domain()
+        subnet1 = factory.make_Subnet(cidr="10.0.1.0/24")
+        subnet2 = factory.make_Subnet(cidr="10.0.0.0/22")
+        subnet3 = factory.make_Subnet(cidr="10.0.1.0/27")
+        subnet1_ips = [
+            factory.make_StaticIPAddress(
+                ip=factory.pick_ip_in_Subnet(subnet1), subnet=subnet1
+            )
+            for _ in range(3)
+        ]
+        subnet2_ips = [
+            factory.make_StaticIPAddress(
+                ip=factory.pick_ip_in_Subnet(
+                    subnet2, but_not=list(subnet1.get_ipranges_in_use())
+                ),
+                subnet=subnet2,
+            )
+            for _ in range(3)
+        ]
+        subnet3_ips = [
+            factory.make_StaticIPAddress(
+                ip=factory.pick_ip_in_Subnet(
+                    subnet3,
+                    but_not=list(subnet1.get_ipranges_in_use())
+                    + list(subnet2.get_ipranges_in_use()),
+                ),
+                subnet=subnet3,
+            )
+            for _ in range(3)
+        ]
+        subnet1_records = [
+            factory.make_DNSResource(
+                domain=random.choice((default_domain, domain)),
+                ip_addresses=[ip],
+            )
+            for ip in subnet1_ips
+        ]
+        subnet2_records = [
+            factory.make_DNSResource(
+                domain=random.choice((default_domain, domain)),
+                ip_addresses=[ip],
+            )
+            for ip in subnet2_ips
+        ]
+        subnet3_records = [
+            factory.make_DNSResource(
+                domain=random.choice((default_domain, domain)),
+                ip_addresses=[ip],
+            )
+            for ip in subnet3_ips
+        ]
+        all_records = subnet1_records + subnet2_records + subnet3_records
+        zones = ZoneGenerator(
+            [default_domain, domain],
+            [subnet1, subnet2, subnet3],
+            serial=random.randint(0, 65535),
+        ).as_list()
+        for zone in zones:
+            zone.write_config()
+
+        # check forward zones
+        with open(
+            os.path.join(config_path, f"zone.{default_domain.name}"), "r"
+        ) as zf:
+            default_domain_contents = zf.read()
+
+        with open(os.path.join(config_path, f"zone.{domain.name}"), "r") as zf:
+            domain_contents = zf.read()
+
+        for record in all_records:
+            if record.domain == default_domain:
+                contents = default_domain_contents
+            else:
+                contents = domain_contents
+
+            self.assertIn(
+                f"{record.name} 30 IN A {record.ip_addresses.first().ip}",
+                contents,
+            )
+
+        # check reverse zones
+        for record in all_records:
+            ip = record.ip_addresses.first()
+            subnet = self._find_most_specific_subnet(
+                ip, [subnet1, subnet2, subnet3]
+            )
+            rev_subnet = ".".join(str(subnet.network).split(".")[2::-1])
+            if subnet.prefixlen > 24:
+                rev_subnet = f"{str(subnet.network).split('.')[-1]}-{subnet.prefixlen}.{rev_subnet}"
+            with open(
+                os.path.join(config_path, f"zone.{rev_subnet}.in-addr.arpa"),
+                "r",
+            ) as zf:
+                contents = zf.read()
+                self.assertIn(
+                    f"{ip.ip.split('.')[-1]} 30 IN PTR {record.fqdn}",
+                    contents,
+                    f"{subnet} {ip.ip}",
+                )
diff --git a/src/maasserver/dns/zonegenerator.py b/src/maasserver/dns/zonegenerator.py
index b6fd406..8272e5c 100644
--- a/src/maasserver/dns/zonegenerator.py
+++ b/src/maasserver/dns/zonegenerator.py
@@ -18,7 +18,11 @@ from maasserver.models.config import Config
 from maasserver.models.dnsdata import DNSData, HostnameRRsetMapping
 from maasserver.models.dnsresource import separate_fqdn
 from maasserver.models.domain import Domain
-from maasserver.models.staticipaddress import StaticIPAddress
+from maasserver.models.iprange import IPRange
+from maasserver.models.staticipaddress import (
+    HostnameIPMapping,
+    StaticIPAddress,
+)
 from maasserver.models.subnet import Subnet
 from maasserver.server_address import get_maas_facing_server_addresses
 from provisioningserver.dns.config import DynamicDNSUpdate
@@ -226,6 +230,7 @@ class ZoneGenerator:
         if self._dynamic_updates is None:
             self._dynamic_updates = []
         self.force_config_write = force_config_write  # some data changed that nsupdate cannot update if true
+        self._existing_subnet_cfgs = {}
 
     @staticmethod
     def _get_mappings():
@@ -357,18 +362,93 @@ class ZoneGenerator:
             )
 
     @staticmethod
-    def _gen_reverse_zones(
-        subnets,
-        serial,
-        ns_host_name,
-        mappings,
-        default_ttl,
-        dynamic_updates,
-        force_config_write,
+    def _split_large_subnet(network: IPNetwork) -> list[IPNetwork]:
+        # Generate the name of the reverse zone file:
+        # Use netaddr's reverse_dns() to get the reverse IP name
+        # of the first IP address in the network and then drop the first
+        # octets of that name (i.e. drop the octets that will be specified in
+        # the zone file).
+        # returns a list of (IPNetwork, zone_name, zonefile_path) tuples
+        new_networks = []
+        first = IPAddress(network.first)
+        last = IPAddress(network.last)
+        if first.version == 6:
+            # IPv6.
+            # 2001:89ab::/19 yields 8.1.0.0.2.ip6.arpa, and the full list
+            # is 8.1.0.0.2.ip6.arpa, 9.1.0.0.2.ip6.arpa
+            # The ipv6 reverse dns form is 32 elements of 1 hex digit each.
+            # How many elements of the reverse DNS name to we throw away?
+            # Prefixlen of 0-3 gives us 1, 4-7 gives us 2, etc.
+            # While this seems wrong, we always _add_ a base label back in,
+            # so it's correct.
+            rest_limit = (132 - network.prefixlen) // 4
+            # What is the prefix for each inner subnet (It will be the next
+            # smaller multiple of 4.)  If it's the smallest one, then RFC2317
+            # tells us that we're adding an extra blob to the front of the
+            # reverse zone name, and we want the entire prefixlen.
+            subnet_prefix = (network.prefixlen + 3) // 4 * 4
+            if subnet_prefix == 128:
+                subnet_prefix = network.prefixlen
+            # How big is the step between subnets?  Again, special case for
+            # extra small subnets.
+            step = 1 << ((128 - network.prefixlen) // 4 * 4)
+            if step < 16:
+                step = 16
+            # Grab the base (hex) and trailing labels for our reverse zone.
+            split_zone = first.reverse_dns.split(".")
+            base = int(split_zone[rest_limit - 1], 16)
+        else:
+            # IPv4.
+            # The logic here is the same as for IPv6, but with 8 instead of 4.
+            rest_limit = (40 - network.prefixlen) // 8
+            subnet_prefix = (network.prefixlen + 7) // 8 * 8
+            if subnet_prefix == 32:
+                subnet_prefix = network.prefixlen
+            step = 1 << ((32 - network.prefixlen) // 8 * 8)
+            if step < 256:
+                step = 256
+            # Grab the base (decimal) and trailing labels for our reverse
+            # zone.
+            split_zone = first.reverse_dns.split(".")
+            base = int(split_zone[rest_limit - 1])
+
+        while first <= last:
+            if first > last:
+                # if the excluding subnet pushes the base IP beyond the bounds of the generating subnet, we've reached the end and return early
+                return new_networks
+
+            new_networks.append(IPNetwork(f"{first}/{subnet_prefix:d}"))
+            base += 1
+            try:
+                first += step
+            except IndexError:
+                # IndexError occurs when we go from 255.255.255.255 to
+                # 0.0.0.0.  If we hit that, we're all fine and done.
+                break
+        return new_networks
+
+    @staticmethod
+    def _filter_mapping_for_network(
+        network: IPNetwork, mappings: dict[str, HostnameIPMapping]
     ):
-        """Generator of reverse zones, sorted by network."""
+        net_mappings = {}
+        for k, v in mappings.items():
+            if ips_in_net := set(
+                ip for ip in v.ips if IPAddress(ip) in network
+            ):
+                net_mappings[k] = HostnameIPMapping(
+                    v.system_id,
+                    v.ttl,
+                    ips_in_net,
+                    v.node_type,
+                    v.dnsresource_id,
+                    v.user_id,
+                )
 
-        subnets = set(subnets)
+        return net_mappings
+
+    @staticmethod
+    def _generate_glue_nets(subnets: list[Subnet]):
         # Generate the list of parent networks for rfc2317 glue.  Note that we
         # need to handle the case where we are controlling both the small net
         # and a bigger network containing the /24, not just a /24 network.
@@ -393,6 +473,82 @@ class ZoneGenerator:
                     )
                     rfc2317_glue.setdefault(basenet, set()).add(network)
 
+        return rfc2317_glue
+
+    @staticmethod
+    def _find_glue_nets(
+        network: IPNetwork, rfc2317_glue: defaultdict[str, set[IPNetwork]]
+    ):
+        # Use the default_domain as the name for the NS host in the reverse
+        # zones.  If this network is actually a parent rfc2317 glue
+        # network, then we need to generate the glue records.
+        # We need to detect the need for glue in our networks that are
+        # big.
+        if (
+            network.version == 6 and network.prefixlen < 124
+        ) or network.prefixlen < 24:
+            glue = set()
+            # This is the reason for needing the subnets sorted in
+            # increasing order of size.
+            for net in rfc2317_glue.copy().keys():
+                if net in network:
+                    glue.update(rfc2317_glue[net])
+                    del rfc2317_glue[net]
+        elif network in rfc2317_glue:
+            glue = rfc2317_glue[network]
+            del rfc2317_glue[network]
+        else:
+            glue = set()
+        return glue
+
+    @staticmethod
+    def _merge_into_existing_network(
+        network: IPNetwork,
+        existing: dict[IPNetwork, DNSReverseZoneConfig],
+        mapping: dict[str, HostnameIPMapping],
+        dynamic_ranges: list[IPRange] | None = [],
+        dynamic_updates: list[DynamicDNSUpdate] | None = [],
+        glue: set[IPNetwork] | None = set(),
+        is_glue_net: bool = False,
+    ):
+        # since all dynamic updates are passed and we then filter for those belonging
+        # in the network, the existing config already has all updates and we do not need
+        # to merge them, just add them if they haven't already
+        if not existing[network]._dynamic_updates:
+            existing[network]._dynamic_updates = dynamic_updates
+        existing[network]._rfc2317_ranges = existing[
+            network
+        ]._rfc2317_ranges.union(glue)
+        for k, v in mapping.items():
+            if k in existing[network]._mapping:
+                existing[network]._mapping[k].ips.union(v.ips)
+            else:
+                existing[network]._mapping[k] = v
+        existing[network]._dynamic_ranges += dynamic_ranges
+        for glue_net in glue.union(existing[network]._rfc2317_ranges):
+            for k, v in existing[network]._mapping.copy().items():
+                if ip_set := set(ip for ip in v.ips if ip not in glue_net):
+                    existing[network]._mapping[k].ips = ip_set
+                else:
+                    del existing[network]._mapping[k]
+
+    @staticmethod
+    def _gen_reverse_zones(
+        subnets,
+        serial,
+        ns_host_name,
+        mappings,
+        default_ttl,
+        dynamic_updates,
+        force_config_write,
+        existing_subnet_cfgs={},
+    ):
+        """Generator of reverse zones, sorted by network."""
+
+        subnets = set(subnets)
+
+        rfc2317_glue = ZoneGenerator._generate_glue_nets(subnets)
+
         # Since get_hostname_ip_mapping(Subnet) ignores Subnet.id, so we can
         # just do it once and be happy.  LP#1600259
         if len(subnets):
@@ -412,7 +568,7 @@ class ZoneGenerator:
             key=lambda subnet: IPNetwork(subnet.cidr).prefixlen,
             reverse=True,
         ):
-            network = IPNetwork(subnet.cidr)
+            base_network = IPNetwork(subnet.cidr)
             if subnet.rdns_mode == RDNS_MODE.DISABLED:
                 # If we are not doing reverse dns for this subnet, then just
                 # skip to the next subnet.
@@ -421,103 +577,109 @@ class ZoneGenerator:
                 )
                 continue
 
+            networks = ZoneGenerator._split_large_subnet(base_network)
+
             # 1. Figure out the dynamic ranges.
             dynamic_ranges = [
                 ip_range.netaddr_iprange
                 for ip_range in subnet.get_dynamic_ranges()
             ]
 
-            # 2. Start with the map of all of the nodes, including all
-            # DNSResource-associated addresses.  We will prune this to just
-            # entries for the subnet when we actually generate the zonefile.
-            # If we get here, then we have subnets, so we noticed that above
-            # and created mappings['reverse'].  LP#1600259
-            mapping = mappings["reverse"]
-
-            # Use the default_domain as the name for the NS host in the reverse
-            # zones.  If this network is actually a parent rfc2317 glue
-            # network, then we need to generate the glue records.
-            # We need to detect the need for glue in our networks that are
-            # big.
-            if (
-                network.version == 6 and network.prefixlen < 124
-            ) or network.prefixlen < 24:
-                glue = set()
-                # This is the reason for needing the subnets sorted in
-                # increasing order of size.
-                for net in rfc2317_glue.copy().keys():
-                    if net in network:
-                        glue.update(rfc2317_glue[net])
-                        del rfc2317_glue[net]
-            elif network in rfc2317_glue:
-                glue = rfc2317_glue[network]
-                del rfc2317_glue[network]
-            else:
-                glue = set()
+            for network in networks:
+                # 2. Start with the map of all of the nodes, including all
+                # DNSResource-associated addresses.  We will prune this to just
+                # entries for the subnet when we actually generate the zonefile.
+                # If we get here, then we have subnets, so we noticed that above
+                # and created mappings['reverse'].  LP#1600259
+                mapping = ZoneGenerator._filter_mapping_for_network(
+                    network, mappings["reverse"]
+                )
 
-            domain_updates = [
-                DynamicDNSUpdate.as_reverse_record_update(update, network)
-                for update in dynamic_updates
-                if update.answer
-                and update.answer_is_ip
-                and (update.answer_as_ip in network)
-            ]
+                glue = ZoneGenerator._find_glue_nets(network, rfc2317_glue)
+                domain_updates = [
+                    DynamicDNSUpdate.as_reverse_record_update(update, network)
+                    for update in dynamic_updates
+                    if update.answer
+                    and update.answer_is_ip
+                    and (update.answer_as_ip in network)
+                ]
+
+                if network in existing_subnet_cfgs:
+                    ZoneGenerator._merge_into_existing_network(
+                        network,
+                        existing_subnet_cfgs,
+                        mapping,
+                        dynamic_ranges=dynamic_ranges,
+                        dynamic_updates=domain_updates,
+                        glue=glue,
+                    )
+                else:
+                    existing_subnet_cfgs[network] = DNSReverseZoneConfig(
+                        ns_host_name,
+                        serial=serial,
+                        default_ttl=default_ttl,
+                        ns_host_name=ns_host_name,
+                        mapping=mapping,
+                        network=network,
+                        dynamic_ranges=dynamic_ranges,
+                        rfc2317_ranges=glue,
+                        dynamic_updates=domain_updates,
+                        force_config_write=force_config_write,
+                    )
 
-            yield DNSReverseZoneConfig(
-                ns_host_name,
-                serial=serial,
-                default_ttl=default_ttl,
-                ns_host_name=ns_host_name,
-                mapping=mapping,
-                network=network,
-                dynamic_ranges=dynamic_ranges,
-                rfc2317_ranges=glue,
-                exclude={
-                    IPNetwork(s.cidr) for s in subnets if s is not subnet
-                },
-                dynamic_updates=domain_updates,
-                force_config_write=force_config_write,
-            )
-        # Now provide any remaining rfc2317 glue networks.
-        for network, ranges in rfc2317_glue.items():
-            exclude_set = {
-                IPNetwork(s.cidr)
-                for s in subnets
-                if network in IPNetwork(s.cidr)
-            }
-            domain_updates = []
-            for update in dynamic_updates:
-                glue_update = True
-                for exclude_net in exclude_set:
+                    yield existing_subnet_cfgs[network]
+
+            # Now provide any remaining rfc2317 glue networks.
+            for network, ranges in rfc2317_glue.items():
+                exclude_set = {
+                    IPNetwork(s.cidr)
+                    for s in subnets
+                    if network in IPNetwork(s.cidr)
+                }
+                domain_updates = []
+                for update in dynamic_updates:
+                    glue_update = True
+                    for exclude_net in exclude_set:
+                        if (
+                            update.answer
+                            and update.answer_is_ip
+                            and update.answer_as_ip in exclude_net
+                        ):
+                            glue_update = False
+                            break
                     if (
-                        update.answer
+                        glue_update
+                        and update.answer
                         and update.answer_is_ip
-                        and update.answer_as_ip in exclude_net
+                        and update.answer_as_ip in network
                     ):
-                        glue_update = False
-                        break
-                if (
-                    glue_update
-                    and update.answer
-                    and update.answer_is_ip
-                    and update.answer_as_ip in network
-                ):
-                    domain_updates.append(
-                        DynamicDNSUpdate.as_reverse_record_update(
-                            update, network
+                        domain_updates.append(
+                            DynamicDNSUpdate.as_reverse_record_update(
+                                update, network
+                            )
                         )
+
+                if network in existing_subnet_cfgs:
+                    ZoneGenerator._merge_into_existing_network(
+                        network,
+                        existing_subnet_cfgs,
+                        mapping,
+                        dynamic_updates=domain_updates,
+                        glue=ranges,
+                        is_glue_net=True,
                     )
-            yield DNSReverseZoneConfig(
-                ns_host_name,
-                serial=serial,
-                default_ttl=default_ttl,
-                network=network,
-                ns_host_name=ns_host_name,
-                rfc2317_ranges=ranges,
-                exclude=exclude_set,
-                dynamic_updates=domain_updates,
-                force_config_write=force_config_write,
-            )
+                else:
+                    existing_subnet_cfgs[network] = DNSReverseZoneConfig(
+                        ns_host_name,
+                        serial=serial,
+                        default_ttl=default_ttl,
+                        network=network,
+                        ns_host_name=ns_host_name,
+                        rfc2317_ranges=ranges,
+                        dynamic_updates=domain_updates,
+                        force_config_write=force_config_write,
+                    )
+                    yield existing_subnet_cfgs[network]
 
     def __iter__(self):
         """Iterate over zone configs.
@@ -553,6 +715,7 @@ class ZoneGenerator:
                 default_ttl,
                 self._dynamic_updates,
                 self.force_config_write,
+                existing_subnet_cfgs=self._existing_subnet_cfgs,
             ),
         )
 
diff --git a/src/provisioningserver/dns/tests/test_zoneconfig.py b/src/provisioningserver/dns/tests/test_zoneconfig.py
index 8660875..af2e299 100644
--- a/src/provisioningserver/dns/tests/test_zoneconfig.py
+++ b/src/provisioningserver/dns/tests/test_zoneconfig.py
@@ -545,17 +545,16 @@ class TestDNSReverseZoneConfig(MAASTestCase):
 
     def test_computes_zone_file_config_file_paths(self):
         domain = factory.make_name("zone")
-        reverse_file_name = [
-            "zone.%d.168.192.in-addr.arpa" % i for i in range(4)
-        ]
+        # in order to merge changes, maasserver.dns.zone_generator.ZoneGenerator will split large subnets
+        # meaning there's a 1:1 zonefile and DNSReverseZoneConfig
+        reverse_file_name = "zone.0.168.192.in-addr.arpa"
         dns_zone_config = DNSReverseZoneConfig(
-            domain, network=IPNetwork("192.168.0.0/22")
+            domain, network=IPNetwork("192.168.0.0/24")
+        )
+        self.assertEqual(
+            os.path.join(get_zone_file_config_dir(), reverse_file_name),
+            dns_zone_config.zone_info[0].target_path,
         )
-        for i in range(4):
-            self.assertEqual(
-                os.path.join(get_zone_file_config_dir(), reverse_file_name[i]),
-                dns_zone_config.zone_info[i].target_path,
-            )
 
     def test_computes_zone_file_config_file_paths_for_small_network(self):
         domain = factory.make_name("zone")
@@ -579,20 +578,8 @@ class TestDNSReverseZoneConfig(MAASTestCase):
         # A special case is the small subnet (less than 256 hosts for IPv4,
         # less than 16 hosts for IPv6), in which case, we follow RFC2317 with
         # the modern adjustment of using '-' instead of '/'.
-        zn = "%d.0.0.0.0.0.0.0.0.0.0.0.4.0.1.f.1.0.8.a.b.0.1.0.0.2.ip6.arpa"
         expected = [
             # IPv4 networks.
-            # /22 ==> 4 /24 reverse zones
-            (
-                IPNetwork("192.168.0.1/22"),
-                [
-                    DomainInfo(
-                        IPNetwork("192.168.%d.0/24" % i),
-                        "%d.168.192.in-addr.arpa" % i,
-                    )
-                    for i in range(4)
-                ],
-            ),
             # /24 ==> 1 reverse zone
             (
                 IPNetwork("192.168.0.1/24"),
@@ -649,27 +636,6 @@ class TestDNSReverseZoneConfig(MAASTestCase):
                     )
                 ],
             ),
-            # /2 with hex digits ==> 4 /4 reverse zones
-            (
-                IPNetwork("8000::/2"),
-                [
-                    DomainInfo(IPNetwork("8000::/4"), "8.ip6.arpa"),
-                    DomainInfo(IPNetwork("9000::/4"), "9.ip6.arpa"),
-                    DomainInfo(IPNetwork("a000::/4"), "a.ip6.arpa"),
-                    DomainInfo(IPNetwork("b000::/4"), "b.ip6.arpa"),
-                ],
-            ),
-            # /103 ==> 2 /104 reverse zones
-            (
-                IPNetwork("2001:ba8:1f1:400::/103"),
-                [
-                    DomainInfo(
-                        IPNetwork("2001:ba8:1f1:400:0:0:%d00:0000/104" % i),
-                        zn % i,
-                    )
-                    for i in range(2)
-                ],
-            ),
             # /125 ==> 1 reverse zone, based on RFC2317
             (
                 IPNetwork("2001:ba8:1f1:400::/125"),
@@ -843,7 +809,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
         target_dir = patch_zone_file_config_path(self)
         domain = factory.make_string()
         ns_host_name = factory.make_name("ns")
-        network = IPNetwork("192.168.0.1/22")
+        network = IPNetwork("192.168.0.1/24")
         dynamic_network = IPNetwork("192.168.0.1/28")
         dns_zone_config = DNSReverseZoneConfig(
             domain,
@@ -855,28 +821,24 @@ class TestDNSReverseZoneConfig(MAASTestCase):
             ],
         )
         dns_zone_config.write_config()
-        for sub in range(4):
-            reverse_file_name = "zone.%d.168.192.in-addr.arpa" % sub
-            expected_GEN_direct = dns_zone_config.get_GENERATE_directives(
-                dynamic_network,
-                domain,
-                DomainInfo(
-                    IPNetwork("192.168.%d.0/24" % sub),
-                    "%d.168.192.in-addr.arpa" % sub,
-                ),
-            )
-            expected = ContainsAll(
-                ["30 IN NS %s." % ns_host_name]
-                + [
-                    "$GENERATE %s %s IN PTR %s"
-                    % (iterator_values, reverse_dns, hostname)
-                    for iterator_values, reverse_dns, hostname in expected_GEN_direct
-                ]
-            )
-            self.assertThat(
-                os.path.join(target_dir, reverse_file_name),
-                FileContains(matcher=expected),
-            )
+        reverse_file_name = "zone.0.168.192.in-addr.arpa"
+        expected_GEN_direct = dns_zone_config.get_GENERATE_directives(
+            dynamic_network,
+            domain,
+            DomainInfo(
+                IPNetwork("192.168.0.0/24"),
+                "0.168.192.in-addr.arpa",
+            ),
+        )
+        with open(os.path.join(target_dir, reverse_file_name), "r") as fh:
+            contents = fh.read()
+        needles = [f"30 IN NS {ns_host_name}"] + [
+            f"$GENERATE {iterator_values} {reverse_dns} IN PTR {hostname}"
+            for iterator_values, reverse_dns, hostname in expected_GEN_direct
+        ]
+
+        for needle in needles:
+            self.assertIn(needle, contents)
 
     def test_writes_reverse_dns_zone_config_for_small_network(self):
         target_dir = patch_zone_file_config_path(self)
@@ -1136,97 +1098,6 @@ class TestDNSReverseZoneConfig(MAASTestCase):
             ],
         )
 
-    def test_dynamic_updates_are_only_sent_for_specific_domain_info(self):
-        patch_zone_file_config_path(self)
-        domain = factory.make_string()
-        network = IPNetwork("10.246.64.0/21")
-        subnetwork1 = IPNetwork("10.246.64.0/24")
-        subnetwork2 = IPNetwork("10.246.65.0/24")
-        ip1 = factory.pick_ip_in_network(subnetwork1)
-        ip2 = factory.pick_ip_in_network(subnetwork2)
-        hostname1 = f"{factory.make_string()}.{domain}"
-        hostname2 = f"{factory.make_string()}.{domain}"
-        fwd_updates = [
-            DynamicDNSUpdate(
-                operation="INSERT",
-                zone=domain,
-                name=hostname1,
-                rectype="A",
-                answer=ip1,
-            ),
-            DynamicDNSUpdate(
-                operation="INSERT",
-                zone=domain,
-                name=hostname2,
-                rectype="A",
-                answer=ip2,
-            ),
-        ]
-        rev_updates = [
-            DynamicDNSUpdate.as_reverse_record_update(update, network)
-            for update in fwd_updates
-        ]
-        # gets changed to a /24 and any other space in the original
-        # subnet is split into a separate zone for a given /24
-        zone = DNSReverseZoneConfig(
-            domain,
-            serial=random.randint(1, 100),
-            network=network,
-            dynamic_updates=rev_updates,
-        )
-
-        run_command = self.patch(actions, "run_command")
-        zone.write_config()
-        zone.write_config()
-
-        expected_stdin1 = "\n".join(
-            [
-                "server localhost",
-                "zone 64.246.10.in-addr.arpa",
-                f"update add {IPAddress(ip1).reverse_dns} {zone.default_ttl} PTR {hostname1}",
-                f"update add 64.246.10.in-addr.arpa {zone.default_ttl} SOA 64.246.10.in-addr.arpa. nobody.example.com. {zone.serial} 600 1800 604800 {zone.default_ttl}",
-                "send\n",
-            ]
-        )
-
-        expected_stdin2 = "\n".join(
-            [
-                "server localhost",
-                "zone 65.246.10.in-addr.arpa",
-                f"update add {IPAddress(ip2).reverse_dns} {zone.default_ttl} PTR {hostname2}",
-                f"update add 65.246.10.in-addr.arpa {zone.default_ttl} SOA 65.246.10.in-addr.arpa. nobody.example.com. {zone.serial} 600 1800 604800 {zone.default_ttl}",
-                "send\n",
-            ]
-        )
-
-        expected_stdin3 = "\n".join(
-            [
-                "server localhost",
-                "zone 71.246.10.in-addr.arpa",
-                f"update add 71.246.10.in-addr.arpa {zone.default_ttl} SOA 71.246.10.in-addr.arpa. nobody.example.com. {zone.serial} 600 1800 604800 {zone.default_ttl}",
-                "send\n",
-            ]
-        )
-
-        run_command.assert_any_call(
-            "nsupdate",
-            "-k",
-            get_nsupdate_key_path(),
-            stdin=expected_stdin1.encode("ascii"),
-        )
-        run_command.assert_any_call(
-            "nsupdate",
-            "-k",
-            get_nsupdate_key_path(),
-            stdin=expected_stdin2.encode("ascii"),
-        )
-        run_command.assert_any_call(
-            "nsupdate",
-            "-k",
-            get_nsupdate_key_path(),
-            stdin=expected_stdin3.encode("ascii"),
-        )
-
 
 class TestDNSReverseZoneConfig_GetGenerateDirectives(MAASTestCase):
     """Tests for `DNSReverseZoneConfig.get_GENERATE_directives()`."""
diff --git a/src/provisioningserver/dns/zoneconfig.py b/src/provisioningserver/dns/zoneconfig.py
index 2e37e19..cf8a8ef 100644
--- a/src/provisioningserver/dns/zoneconfig.py
+++ b/src/provisioningserver/dns/zoneconfig.py
@@ -413,30 +413,11 @@ class DNSReverseZoneConfig(DomainConfigBase):
         self._network = kwargs.pop("network", None)
         self._dynamic_ranges = kwargs.pop("dynamic_ranges", [])
         self._rfc2317_ranges = kwargs.pop("rfc2317_ranges", [])
-        self._exclude = kwargs.pop("exclude", set())
-        zone_info = self.compose_zone_info(
-            self._network, exclude=self._exclude
-        )
+        zone_info = self.compose_zone_info(self._network)
         super().__init__(domain, zone_info=zone_info, **kwargs)
 
     @classmethod
-    def _skip_if_overlaps(cls, first, base, step, network, exclude):
-        for other_network in exclude:
-            if (
-                first in other_network
-                and network.prefixlen < other_network.prefixlen
-            ):  # allow the more specific overlapping subnet to create the zone config
-                try:
-                    base += 1
-                    first += step
-                except IndexError:
-                    # IndexError occurs when we go from 255.255.255.255 to
-                    # 0.0.0.0.  If we hit that, we're all fine and done.
-                    break
-        return (first, base)
-
-    @classmethod
-    def compose_zone_info(cls, network, exclude=()):
+    def compose_zone_info(cls, network):
         """Return the names of the reverse zones."""
         # Generate the name of the reverse zone file:
         # Use netaddr's reverse_dns() to get the reverse IP name
@@ -444,9 +425,7 @@ class DNSReverseZoneConfig(DomainConfigBase):
         # octets of that name (i.e. drop the octets that will be specified in
         # the zone file).
         # returns a list of (IPNetwork, zone_name, zonefile_path) tuples
-        info = []
         first = IPAddress(network.first)
-        last = IPAddress(network.last)
         if first.version == 6:
             # IPv6.
             # 2001:89ab::/19 yields 8.1.0.0.2.ip6.arpa, and the full list
@@ -488,40 +467,23 @@ class DNSReverseZoneConfig(DomainConfigBase):
             split_zone = first.reverse_dns.split(".")
             zone_rest = ".".join(split_zone[rest_limit:-1])
             base = int(split_zone[rest_limit - 1])
-        while first <= last:
-            (first, base) = cls._skip_if_overlaps(
-                first, base, step, network, exclude
-            )
-            if first > last:
-                # if the excluding subnet pushes the base IP beyond the bounds of the generating subnet, we've reached the end and return early
-                return info
-
-            # Rest_limit has bounds of 1..labelcount+1 (5 or 33).
-            # If we're stripping any elements, then we just want base.name.
-            if rest_limit > 1:
-                if first.version == 6:
-                    new_zone = f"{base:x}.{zone_rest}"
-                else:
-                    new_zone = "%d.%s" % (base, zone_rest)
-            # We didn't actually strip any elemnts, so base goes back with
-            # the prefixlen attached.
-            elif first.version == 6:
-                new_zone = "%x-%d.%s" % (base, network.prefixlen, zone_rest)
+
+        # Rest_limit has bounds of 1..labelcount+1 (5 or 33).
+        # If we're stripping any elements, then we just want base.name.
+        if rest_limit > 1:
+            if first.version == 6:
+                new_zone = f"{base:x}.{zone_rest}"
             else:
-                new_zone = "%d-%d.%s" % (base, network.prefixlen, zone_rest)
-            info.append(
-                DomainInfo(
-                    IPNetwork("%s/%d" % (first, subnet_prefix)), new_zone
-                )
-            )
-            base += 1
-            try:
-                first += step
-            except IndexError:
-                # IndexError occurs when we go from 255.255.255.255 to
-                # 0.0.0.0.  If we hit that, we're all fine and done.
-                break
-        return info
+                new_zone = f"{base:d}.{zone_rest}"
+        # We didn't actually strip any elemnts, so base goes back with
+        # the prefixlen attached.
+        elif first.version == 6:
+            new_zone = f"{base:x}-{network.prefixlen:d}.{zone_rest}"
+        else:
+            new_zone = f"{base:d}-{network.prefixlen:d}.{zone_rest}"
+        return [
+            DomainInfo(IPNetwork(f"{first}/{subnet_prefix:d}"), new_zone),
+        ]
 
     @classmethod
     def get_PTR_mapping(cls, mapping, network):