up to 126<\/td> 7<\/td> 126<\/td> \/25<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\nWhat VLSM is, and what it is not<\/h2>\n\n VLSM means using more than one subnet mask within the same classful network. Splitting 192.168.10.0\/24 into a \/25, two \/26s, and a \/30 is VLSM. Using different masks on different networks is just ordinary classless addressing, not VLSM. There is no IOS command that turns VLSM on; it happens automatically when you assign different masks to interfaces inside one network.<\/p>\n\n
The catch the exam tests is routing-protocol support. A protocol can only carry VLSM if it advertises the mask with every route. Classful RIPv1 does not, so it cannot.<\/p>\n\n\nRouting protocol<\/th> Supports VLSM?<\/th> Why<\/th><\/tr><\/thead> RIPv1<\/td> No<\/td> Classful: does not send the mask, auto-summarizes at classful boundaries<\/td><\/tr> RIPv2<\/td> Yes<\/td> Sends the mask with each route<\/td><\/tr> OSPFv2<\/td> Yes<\/td> Classless: mask carried per route<\/td><\/tr> EIGRP<\/td> Yes<\/td> Classless: mask carried per route<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\nAllocate the largest subnet first<\/h2>\n\n The one rule that prevents most VLSM mistakes: allocate the subnet with the most hosts first, then the next largest, down to the \/30 links last. A large subnet needs a large contiguous block aligned to its mask boundary. If you hand out small subnets first, you can chop up the address space so no aligned block is left for the big one. Place the biggest rooms first; the closets fit in the space that remains.<\/p>\n\n
A VLSM design worked end to end<\/h2>\n\n Take 10.0.0.0\/24 and four segments: LAN-A needs 100 hosts, LAN-B needs 60, LAN-C needs 20, and a WAN link needs 2. Sort them largest to smallest, choose each mask from the host-requirement rule, then allocate from 10.0.0.0 upward, each subnet starting right after the previous one’s broadcast.<\/p>\n\n
LAN-A (100 hosts) takes a \/25, which starts at 10.0.0.0 and ends at 10.0.0.127. LAN-B (60) takes a \/26 starting at the next free address, 10.0.0.128. LAN-C (20) takes a \/27 at 10.0.0.192. The WAN link (2) takes a \/30 at 10.0.0.224. Here is the full allocation:<\/p>\n\n\nSegment<\/th> Hosts<\/th> Mask<\/th> Subnet ID<\/th> Usable range<\/th> Broadcast<\/th><\/tr><\/thead> LAN-A<\/td> 100<\/td> \/25<\/td> 10.0.0.0<\/td> 10.0.0.1 to 10.0.0.126<\/td> 10.0.0.127<\/td><\/tr> LAN-B<\/td> 60<\/td> \/26<\/td> 10.0.0.128<\/td> 10.0.0.129 to 10.0.0.190<\/td> 10.0.0.191<\/td><\/tr> LAN-C<\/td> 20<\/td> \/27<\/td> 10.0.0.192<\/td> 10.0.0.193 to 10.0.0.222<\/td> 10.0.0.223<\/td><\/tr> WAN<\/td> 2<\/td> \/30<\/td> 10.0.0.224<\/td> 10.0.0.225 to 10.0.0.226<\/td> 10.0.0.227<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\nFour segments fit inside a single \/24 with room to spare, and not one address is wasted on the WAN link. Fixed-length subnetting would have forced every segment onto a \/25 and run out of space after two.<\/p>\n\n
Check for overlapping subnets<\/h2>\n\n Two subnets overlap when one’s address range falls inside another’s. The check is three steps: compute each subnet ID, compute its broadcast (subnet ID plus 2 to the power of the host bits, minus 1), then confirm the next subnet’s ID is greater than the previous broadcast. In the design above, each broadcast (.127, .191, .223, .227) is lower than the next subnet ID (.128, .192, .224), so nothing overlaps.<\/p>\n\n
The classic mistake: sizing LAN-C as 10.0.0.96\/27 instead of 10.0.0.192\/27. That \/27 spans 10.0.0.96 to 10.0.0.127, which sits inside LAN-A’s 10.0.0.0\/25 range (10.0.0.0 to 10.0.0.127). The two overlap, and IOS rejects the second address with an “overlaps with” error. Always check the new subnet’s range against every subnet already assigned.<\/p>\n\n
Add a subnet to an existing design<\/h2>\n\n Requirements change, and VLSM is built for it. Suppose LAN-D appears later and needs 10 hosts. Ten hosts needs 14 usable, which is a \/28. Find the lowest \/28 that does not overlap anything already used. The \/28 blocks fall on multiples of 16: 10.0.0.192 and 10.0.0.208 sit inside LAN-C’s \/27 (10.0.0.192 to 10.0.0.223), and 10.0.0.224 holds the WAN \/30. The first \/28 that is fully free is therefore 10.0.0.240.<\/p>\n\n\nSegment<\/th> Hosts<\/th> Mask<\/th> Subnet ID<\/th> Usable range<\/th> Broadcast<\/th><\/tr><\/thead> LAN-D<\/td> 10<\/td> \/28<\/td> 10.0.0.240<\/td> 10.0.0.241 to 10.0.0.254<\/td> 10.0.0.255<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\nLAN-D slots into the gap between the WAN link and the end of the \/24 without disturbing any existing subnet. That is the whole point of planning largest-first: the leftover space stays usable.<\/p>\n\n
Confirm VLSM in the routing table<\/h2>\n\n Once the five subnets are live on a router, show ip route<\/code> groups them under their classful parent and prints a header line that proves VLSM is active:<\/p>\n\n\n10.0.0.0\/8 is variably subnetted, 5 subnets, 5 masks<\/code><\/pre>\n\n\nRead it literally: five subnets of the 10.0.0.0 network are installed, and they use five different mask lengths (\/25, \/26, \/27, \/28, and \/30). The counts track whatever is actually configured, so before LAN-D was added the same line would read “4 subnets, 4 masks”. The phrase “variably subnetted” is the routing table confirming VLSM is in use. If a network is ever summarized back to \/8, a classful protocol such as RIPv1 is the usual cause.<\/p>\n\n
Practice VLSM<\/h2>\n\n VLSM is a calculation skill, so drill it. Use the trainer for the underlying network and broadcast math, then the quiz for the VLSM-specific decisions: mask choice by host count, allocation order, overlap, and protocol support.<\/p>\n\n