Lesson 207 took one packet across the WAN and timed every routing protocol on the way. This lesson asks what happens when a box dies, when the link fills up, and when the building outgrows one floor. I carry the same topology through the whole lesson: the branch laptop and the branch voice phone, the HQ server at 10.20.2.20, the subnets from Lesson 207. First I kill the active gateway and watch the standby take over. Then I fill the link with a bulk transfer and watch the voice call survive it, or not, depending on whether QoS is on. Then I compare two-tier, three-tier, and spine-leaf with real oversubscription math, and I treat time itself as a design dependency. By the end you will have run a failover lab, a congested-link QoS lab, and a design exercise where you pick the shape of a data centre and defend it with numbers. The gateway is not a single point of failure. The voice call is not at the mercy of the backup job. And the design is a choice you can show your work for.
Difficulty: Advanced · Know this first: Lesson 207 - Routing Beyond OSPF; Lesson 184 - Network Switching and Routing; F12 - Networks: Two Computers Talking
Every hop charges rent in milliseconds. The bar below is a worked example for this lesson's scenario, not a measurement from a live system, but the shape is honest: the standby gateway takes over in about 3 seconds, the voice packet keeps its EF mark, and a congested link makes voice wait behind bulk. Step through the lesson or switch the scenario and watch the bar change.
Extra diagram · from scratch to master
Start with a branch phone and a virtual gateway. Add one stop at a time until the server answers, or the dead gateway drops the packet.
The budget bar above shows three fixed stories. This simulator lets you write your own. Move a slider and watch the access switch, the LACP bundle, and the answer back change in the budget bar, in the hop timings, and in the total. The numbers are a teaching example, not live measurements. The shape is the lesson: the member links that are up, the bulk traffic filling the link, and the spine paths carrying the load decide how slow the trip feels.
How many member links are up in the bundle. Each member is 1 Gbps. One flow never splits across members, so one member up means the bulk transfer and the voice call share one link.
Share of the link the bulk transfer is filling. Every 10 percent of bulk adds about 0.5 ms at the access switch, about 3.6 ms at the bundle, and about 3.5 ms on the way back.
How many spine switches share the fabric load. Each extra spine cuts the fabric wait. One spine waits about 12 ms. Four spines wait about 3 ms.
Try this: (1) Set member links to 1, bulk traffic to 100, spines to 1. The access switch is about 8 ms, the bundle about 44 ms, the answer about 60 ms, and the total is about 153 ms. (2) Set member links to 4, bulk traffic to 0, spines to 4. The access switch is about 3 ms, the bundle about 2 ms, the answer about 25 ms, and the total is about 62 ms. Same trip. Only the member links, the bulk traffic, and the spines changed.
Three questions. No score is saved anywhere — this is just you against the material.
Here is the shaper from the QoS lab below, with the numbers blanked out. Fill in the blanks, then run the check. The check looks for the five numbers that define a token bucket: the rate in bits per second, the interval, the burst in bytes, the burst in bits, and the voice guarantee. The checker ran every number with Python before it was written, so the answers are exact.
Try breaking it on purpose: write 10000000 as the rate, or write 12500 as the burst in bytes. Run the check and watch it fail. Then press Reset and fill in the right numbers. The Go deeper section has the full token-bucket math to check against.
Expected output when it passes: The shaper runs at 100000000 bits per second with a 10 ms interval, so the burst is 125000 bytes, which is 1000000 bits, and voice keeps its 10 Mbps guarantee. The checker verified the token bucket the same way, and every number passed.
I take the same trip four times here. First I make the gateway survive a dead router. Then I share the load across two gateways and two links. Then I protect the voice call on a full link. Last I pick the shape of the whole data centre and keep its clock honest.
Definition: HSRP and VRRP both give two routers one virtual gateway address. HSRP is the older one: one router is active, one is standby, and the standby watches hello packets. The default hello is 3 seconds and the default hold time is 10 seconds, so the takeover takes about 10 seconds. Tune them to hello 1 second and hold 3 seconds and the takeover takes about 3 seconds. VRRP is the open standard that does the same job: one router is master, the rest are backup, and the master sends an advertisement every 1 second by default. The master-down interval is three advertisements plus a skew that favours the highest priority, which works out to about 3.6 seconds with priority 100. I checked the VRRP number with Python before I wrote it down. Preempt decides whether a recovered router takes the job back: with preempt on, the higher priority router returns to active when it comes back. Without it, the standby keeps the job until it dies.
Types:
Uses: I use this on every gateway that matters, which is every gateway. Try it now: in Packet Tracer, configure HSRP on GW-1 and GW-2 with the virtual address 10.20.4.1, run show standby brief, then shut GW-1 and keep pinging. Write down how long the pings fail. Then tune the timers to hello 1 and hold 3 and run it again. Practice the failover lab.
Dimensions: At low scale one pair of gateways is enough, because the failure is one router. What breaks is a failure the protocol cannot see: a dead uplink behind a live gateway, where the hello packets still flow and the active router keeps answering while its path is gone. It costs a track on the uplink, so the gateway steps down when its path dies, not only when the router dies.
Definition: GLBP is HSRP with load sharing. One router is the active virtual gateway, and it hands out a different virtual MAC address to each member router, so the traffic spreads across all of them instead of waiting on one. The active virtual gateway answers the ARP requests and gives each host a different member to use. LACP is the same idea for links: it bundles member links into one logical link, negotiates with the other end, and spreads flows across the members by hash. Two 1 Gbps members carry 2 Gbps in total, and one member failing leaves 1 Gbps. A single flow tops out at 1 Gbps, because the hash pins it to one member. GLBP keeps its hello at 3 seconds and its hold time at 10 seconds, the same shape as HSRP, and it adds a redirect timer of 600 seconds and a timeout of 7200 seconds for a failed forwarder.
Types:
Uses: I use this when one gateway or one link is the bottleneck, which is every branch that grew past its first design. Try it now: in Packet Tracer, configure GLBP on GW-1 and GW-2, run show glbp brief, and watch both routers forward. Then configure the LACP bundle between the access switch and the core, run show etherchannel summary, and shut one member. Watch the traffic stay up on the member that is left. Practice GLBP and LACP in the Packet Tracer lab.
Dimensions: As the load grows, the hash is the thing that breaks first: two heavy flows can land on the same member while the other member idles, because the hash sees addresses, not load. What breaks is a bundle that looks full on one member and empty on the other. It costs a hash input that spreads the real flows, and a second bundle when the flows outgrow one.
Definition: QoS is four steps in order. Classification sorts the traffic: voice, video, bulk, best effort. Marking writes the class into the packet as a DSCP value: EF is 46 for voice, AF31 is 26 for signalling, CS0 is 0 for traffic nobody marked. Queuing decides who waits: a priority queue sends EF first, and the rest share what is left. Policing drops what is over the rate, right now, with no waiting. Shaping holds what is over the rate in a buffer and sends it later, smoothed out. The token bucket is the math behind shaping: a rate CIR of 100 Mbps and an interval Tc of 10 ms gives a burst Bc of 125,000 bytes. I checked that number with Python before I wrote it down. On a congested 100 Mbps link with 150 Mbps of bulk and 10 Mbps of voice, one queue loses 37.5 percent of everything, voice included. With EF guaranteed its 10 Mbps, voice loses nothing and bulk takes a 40 percent loss instead. That is the congested-link lab, and the number is the point.
Types:
Uses: I use this whenever voice shares a link with anything else, which is every link. Try it now: in Packet Tracer, mark the voice traffic EF on the access switch, build a policy map that gives EF a priority queue of 10 Mbps, and run the bulk transfer. Watch the voice call stay clean while the bulk transfer slows down. Then turn QoS off and run it again. Watch the call break up. Practice the QoS lab.
Dimensions: At ten times the traffic, the marking is the thing that breaks first: one unmarked flow in the priority queue ruins the queue for the voice that earned it. What breaks is trust at the edge: a device that marks its own bulk traffic EF gets voice treatment for a backup job. It costs marking at the access switch you control, and trusting nothing the endpoint claims.
Definition: At this level the network is one design, not four protocols. Two-tier is access plus core: 48 access ports at 1 Gbps feed 2 uplinks at 10 Gbps, which is 48 Gbps into 20 Gbps, an oversubscription of 2.4 to 1. Three-tier adds aggregation between them: the access to aggregation ratio stays 2.4 to 1, and four aggregation switches at 20 Gbps feed a core at 2 times 40 Gbps, which is 80 Gbps into 80 Gbps, a ratio of 1 to 1. Spine-leaf is leaves plus spines: one leaf with 48 ports at 10 Gbps feeds 4 uplinks at 100 Gbps, which is 480 Gbps into 400 Gbps, a ratio of 1.2 to 1, and 8 leaves at 400 Gbps each need 3,200 Gbps of spine capacity. I checked every ratio with Python before I wrote it down. The network types map the same way: a PAN covers about 10 metres, a LAN covers a building, a MAN covers a city, a SAN is the storage network behind the servers. The media pick follows the distance: copper twisted pair carries 10 Gbps for 100 metres, multimode fibre carries 10 Gbps for 400 metres, single-mode fibre carries 100 Gbps for 10 kilometres, and wireless carries the last step to the phone. The hardware ladder is hub, switch, modem: a hub repeats everything to everyone, a switch forwards only to the right port, a modem translates between the media. Time is a design dependency: NTP keeps the clocks together, SNTP is the lighter client that asks and trusts, and a clock that drifts breaks logs, certificates, and Kerberos, which allows 5 minutes of skew and no more. The resolvers are a choice too: OpenDNS at 208.67.222.222 and Quad9 at 9.9.9.9, picked by what they filter, not by habit.
Types:
Uses: I use this when a floor plan lands on my desk, or when I review a design I did not build. Try it now: take the design exercise below and build it in Packet Tracer on the same topology. Then run the Python checker from this lesson against your own numbers, and write the one paragraph that defends the shape you picked.
Dimensions: At a hundred times the size, the design is the difference between a network that grows and a network that has to be rebuilt. What breaks is the ratio nobody measured: an access layer that outgrew its uplinks, and a clock that drifted until the certificates stopped working. It costs measurement: the ratio on paper before the build, and the clock checked before the outage.
The HSRP config, in full. Do this in Packet Tracer, on GW-1 and GW-2, on the same topology from the lab. Expected output: show standby brief shows GW-1 active and GW-2 standby, and the virtual address is 10.20.4.1 on both. The standby 1 priority 110 line matters: 110 beats 90, so GW-1 is active while it lives. The standby 1 preempt line matters too: without it GW-1 stays standby after it recovers, and the job never goes back.
enable
configure terminal
interface gigabitethernet0/0
ip address 10.20.4.2 255.255.255.128
standby 1 ip 10.20.4.1
standby 1 priority 110
standby 1 preempt
standby 1 timers 1 3
end
The VRRP config, in full. Do this in Packet Tracer, on GW-1 and GW-2, replacing the HSRP config. Expected output: show vrrp brief shows one master and one backup, and the virtual address is 10.20.4.1. The vrrp 1 priority 110 line matters for the same reason the HSRP priority did. VRRP is the open standard: the same shape, no vendor lock, and the master-down interval is three advertisements plus the skew, about 3.6 seconds with priority 100.
enable
configure terminal
interface gigabitethernet0/0
ip address 10.20.4.2 255.255.255.128
vrrp 1 ip 10.20.4.1
vrrp 1 priority 110
vrrp 1 preempt
end
The GLBP config, in full. Do this in Packet Tracer, on GW-1 and GW-2, replacing the VRRP config. Expected output: show glbp brief shows one active virtual gateway and two virtual forwarders, and both routers forward traffic. The glbp 1 priority 110 line picks the active virtual gateway. The glbp 1 load-balancing round-robin line is the difference from HSRP: the traffic spreads across both routers instead of waiting on one.
enable
configure terminal
interface gigabitethernet0/0
ip address 10.20.4.2 255.255.255.128
glbp 1 ip 10.20.4.1
glbp 1 priority 110
glbp 1 preempt
glbp 1 load-balancing round-robin
end
The LACP config, in full. Do this in Packet Tracer, on the access switch and the core switch. Expected output: show etherchannel summary shows two member ports in the bundle, both up, protocol LACP. The channel-group 1 mode active line matters: active negotiates, and on never does. If one end is active and the other is on, the bundle never forms and the port suspends.
enable
configure terminal
interface range gigabitethernet0/1 - 2
channel-group 1 mode active
exit
interface port-channel1
switchport mode trunk
end
The QoS policy, in full. Do this in Packet Tracer, on the access switch. Expected output: show policy-map interface shows the voice class in the priority queue and the bulk class in the shaped queue. The priority percent 10 line gives voice 10 Mbps of the 100 Mbps link, first, before anything else. The shape average 100000000 line caps the whole link at 100 Mbps so the queueing is honest.
enable
configure terminal
class-map match-any VOICE
match dscp ef
exit
policy-map WAN-OUT
class VOICE
priority percent 10
class class-default
shape average 100000000
fair-queue
end
The failover math, worked and checked in code. HSRP with the default timers holds for 10 seconds. Tuned to hello 1 and hold 3, it holds for 3 seconds. A ping every second loses about as many pings as the hold time in seconds. A voice call at 50 packets a second loses 50 packets per second of hold time. I ran this Python on this machine. Expected output, exactly as it ran:
$ python3 -c "
def hsrp_downtime(hold):
return hold
print('HSRP default downtime (s):', hsrp_downtime(10))
print('HSRP tuned downtime (s):', hsrp_downtime(3))
print('pings lost, default, 1 per s:', hsrp_downtime(10) * 1)
print('pings lost, tuned, 1 per s:', hsrp_downtime(3) * 1)
print('voice packets lost, default, 50 per s:', hsrp_downtime(10) * 50)
print('voice packets lost, tuned, 50 per s:', hsrp_downtime(3) * 50)"
HSRP default downtime (s): 10
HSRP tuned downtime (s): 3
pings lost, default, 1 per s: 10
pings lost, tuned, 1 per s: 3
voice packets lost, default, 50 per s: 500
voice packets lost, tuned, 50 per s: 150
The VRRP master-down interval, worked and checked in code. The interval is three advertisements plus a skew of 256 minus the priority, over 256 seconds. With priority 100 and a 1 second advertisement, that is 3 plus 156 over 256, which is about 3.6 seconds. I ran this Python on this machine. Expected output, exactly as it ran:
$ python3 -c "
def vrrp_master_down(advert, priority):
return 3 * advert + (256 - priority) / 256
print('VRRP master-down, priority 100 (s):', round(vrrp_master_down(1, 100), 4))
print('VRRP master-down, priority 200 (s):', round(vrrp_master_down(1, 200), 4))"
VRRP master-down, priority 100 (s): 3.6094
VRRP master-down, priority 200 (s): 3.2188
The token bucket, worked and checked in code. The burst Bc is the rate CIR times the interval Tc, divided by 8 to turn bits into bytes. At 100 Mbps with a 10 ms interval, the burst is 125,000 bytes, which is 1,000,000 bits. At the same rate with a 25 ms interval, the burst is 312,500 bytes. I ran this Python on this machine. Expected output, exactly as it ran:
$ python3 -c "
def bc_bytes(cir_bps, tc_ms):
return int(cir_bps * (tc_ms / 1000) / 8)
print('Bc, 100 Mbps, 10 ms (bytes):', bc_bytes(100000000, 10))
print('Bc, 100 Mbps, 10 ms (bits):', bc_bytes(100000000, 10) * 8)
print('Bc, 100 Mbps, 25 ms (bytes):', bc_bytes(100000000, 25))"
Bc, 100 Mbps, 10 ms (bytes): 125000
Bc, 100 Mbps, 10 ms (bits): 1000000
Bc, 100 Mbps, 25 ms (bytes): 312500
The congested link, worked and checked in code. The link carries 100 Mbps. Bulk offers 150 Mbps and voice offers 10 Mbps, so 160 Mbps arrives for a 100 Mbps link. One queue loses 60 of 160, which is 37.5 percent of everything, voice included. With EF guaranteed 10 Mbps, voice loses nothing, and bulk gets the 90 Mbps that is left, so bulk loses 60 of 150, which is 40 percent. I ran this Python on this machine. Expected output, exactly as it ran:
$ python3 -c "
cap, bulk, voice = 100, 150, 10
print('offered (Mbps):', bulk + voice)
print('FIFO loss (pct):', round((bulk + voice - cap) / (bulk + voice) * 100, 1))
print('voice loss with EF (pct):', 0)
print('bulk loss with EF (pct):', round((bulk - (cap - voice)) / bulk * 100, 1))"
offered (Mbps): 160
FIFO loss (pct): 37.5
voice loss with EF (pct): 0
bulk loss with EF (pct): 40.0
The oversubscription math, worked and checked in code. Two-tier: 48 access ports at 1 Gbps feed 2 uplinks at 10 Gbps, 48 into 20, a ratio of 2.4 to 1. Three-tier: the access ratio stays 2.4 to 1, and four aggregation switches at 20 Gbps feed a core at 2 times 40 Gbps, 80 into 80, a ratio of 1 to 1. Spine-leaf: one leaf with 48 ports at 10 Gbps feeds 4 uplinks at 100 Gbps, 480 into 400, a ratio of 1.2 to 1, and 8 leaves at 400 Gbps each need 3,200 Gbps of spine capacity. I ran this Python on this machine. Expected output, exactly as it ran:
$ python3 -c "
print('two-tier ratio:', round(48 * 1 / (2 * 10), 1))
print('three-tier access ratio:', round(48 * 1 / (2 * 10), 1))
print('three-tier core ratio:', round(4 * 20 / (2 * 40), 1))
print('spine-leaf ratio:', round(48 * 10 / (4 * 100), 1))
print('spine capacity needed (Gbps):', 8 * 4 * 100)"
two-tier ratio: 2.4
three-tier access ratio: 2.4
three-tier core ratio: 1.0
spine-leaf ratio: 1.2
spine capacity needed (Gbps): 3200
The NTP offset, worked and checked in code. The delay is the round trip minus the server processing time. The offset is the average of the two one-way estimates. With the four timestamps 0, 12, 18, and 30 milliseconds, the delay is 24 ms and the offset is 0 ms. With a second set, 0, 50, 52, and 70 milliseconds, the delay is 68 ms and the offset is 16 ms, so the client clock is 16 ms behind. I ran this Python on this machine. Expected output, exactly as it ran:
$ python3 -c "
def ntp(t0, t1, t2, t3):
delay = (t3 - t0) - (t2 - t1)
offset = ((t1 - t0) + (t2 - t3)) / 2
return delay, offset
print('set 1 delay, offset (ms):', ntp(0, 12, 18, 30))
print('set 2 delay, offset (ms):', ntp(0, 50, 52, 70))"
set 1 delay, offset (ms): (24, 0.0)
set 2 delay, offset (ms): (68, 16.0)
Time as a design dependency. NTP keeps the clocks together, and SNTP is the lighter client: it asks the server once and trusts the answer, where full NTP keeps a history and steers the clock gently. A clock that drifts breaks three things. The logs stop lining up, so an incident across two boxes reads out of order. The certificates stop working, because a certificate has a start date and an end date and a wrong clock reads both wrong. Kerberos stops working, because it allows 5 minutes of skew and no more, and a ticket from the future is rejected. Do this: on a lab machine, run chronyc tracking and read the offset. Then stop the time service, wait an hour, and run it again. Watch the offset grow. Then start the service and watch it shrink. The fix for a broken login is sometimes the clock, not the password.
Transmission media, extending the F12 sentence. Copper twisted pair is the office cable: cheap, easy to fix, 10 Gbps for 100 metres. Coax is the TV cable: one thick core, further than twisted pair, still the last run into some homes. Fibre is glass and light: multimode OM4 carries 10 Gbps for 400 metres, single-mode OS2 carries 100 Gbps for 10 kilometres, and the undersea cables between continents are fibre. Wireless is radio: no cable to trip over, and the air is shared, so walls, distance, and neighbours all slow it down. Pick by distance and place. Inside a building, copper. Between buildings on a campus, fibre. To a phone in your hand, wireless. When a link is slow, I ask which medium it is on first, because the fix for a bad cable is not the fix for a weak radio signal.
The network-type map. A PAN covers about 10 metres: the phone, the headset, the watch. A LAN covers a building: the office, the floor, the lab. A MAN covers a city: the campus, the metro fibre ring. A WAN covers the world: the branch to HQ link from Lesson 207. A SAN is the odd one out: it is not a size, it is a job, the storage network behind the servers, usually Fibre Channel at 16 or 32 Gbps, carrying disk traffic that must never wait behind office traffic. Do this: draw your own map. Put the phone, the laptop, the branch, the city ring, and the storage array on it, and label each one PAN, LAN, MAN, WAN, or SAN. If the storage array lands on the same network as the office laptops, that is a design finding, not a drawing error.
The hardware ladder. A hub repeats everything it hears to every port: every machine sees every packet, collisions are normal, and the whole hub shares one conversation. A switch forwards only to the right port: it learns which MAC lives where, and two pairs of machines can talk at once. A modem translates between media: it turns the signal on the line outside into the signal the network inside speaks, DSL to Ethernet, coax to Ethernet, fibre to Ethernet. Do this: if you still own a hub, plug two machines into it and watch the collision light. Then plug them into a switch and watch it stay dark. The ladder is hub, then switch, then modem at the edge, and each rung fixes what the one below could not.
The resolver choice. OpenDNS at 208.67.222.222 and 208.67.220.220, and Quad9 at 9.9.9.9 and 149.112.112.112, are both public resolvers you can point a lab machine at. OpenDNS filters by category and is the one I pick when the lab needs content filtering. Quad9 blocks known malicious domains and is the one I pick when the lab needs threat blocking. Do this: on a lab machine, run dig @9.9.9.9 example.com and dig @208.67.222.222 example.com, and compare the answer time. Then run speedtest and write down the download, the upload, and the ping. The speedtest number is the link. The dig number is the resolver. When a page is slow, the two numbers tell you which one to blame.
The common network issues drill. The table is the habit: issue, symptom, test, fix. The gateway is wrong: nothing leaves the subnet, the test is ip route, the fix is the default via line. DNS is wrong: names fail and addresses work, the test is dig against 9.9.9.9, the fix is the resolver address. The cable is bad: the link flaps, the test is the interface counters, the fix is a new cable. The duplex disagrees: the link is up and slow, the test is the interface speed and duplex, the fix is auto on both ends. The MTU is wrong: small packets pass and large ones die, the test is ping -M do -s 1472, the fix is the MTU on the tunnel. The clock drifted: logins fail and certificates read expired, the test is the NTP offset, the fix is the time service. Do this: pick one row, break it on purpose in the lab, and run the test. The drill is the skill. The table is only the prompt.
At 10x the size, the shape holds and the numbers grow: more gateway pairs, more bundle members, more leaves. At 100x, the design changes: the gateway pair becomes an anycast gateway, the bundle becomes a multi-chassis bundle across two switches, the QoS policy becomes one template pushed to every edge, and the time service becomes a pair of stratum servers with a rehearsed failover. The packet never stops being a packet. It just rides a bigger shape, and the checker is what keeps the shape honest.
A voice call broke up every time the nightly backup ran, and nothing was down. Every ping answered. Every link was up. The backup finished on time, every night. The call was the only thing that suffered, and it suffered every night at the same hour. The helpdesk tickets all said the same thing: the phones are bad. The phones were not bad. They were last in the queue.
Three things. First, voice gets a mark and a queue on every link it shares, because a call that shares a queue with a backup is a call that loses. Second, every new link gets a congestion test before it goes live: fill it with bulk, make a call, and listen. Third, the runbook for a bad call starts at the queue, not the phone. A phone that works at noon and breaks at 19:00 is a scheduling problem, not a hardware problem. Try it now: run show policy-map interface on your access switch and read the drops on the voice class. If the drops are zero and the call still breaks up, the mark never happened.
Design the network for a new three-floor office: 120 users per floor, 40 servers, 60 voice phones, 12 printers, and two WAN links to HQ, one fast and one slow. Size the subnets from 10.20.12.0/22, pick two-tier, three-tier, or spine-leaf, place the gateway pairs and the LACP bundles, write the QoS policy, and write the NTP plan. It passes when every subnet fits its need, the oversubscription ratio is written down and defended, the voice call survives the bulk transfer, and a dead gateway moves traffic in about 3 seconds.
Success looks like this: the users take a /23, the servers a /26, the voice phones a /26, the printers a /28, and each WAN link a /30, all inside 10.20.12.0/22 with 360 addresses spare. The shape is spine-leaf, because 360 users and 40 servers outgrow two-tier uplinks, and the leaf ratio is 1.2 to 1. The gateway pair uses 10.20.12.1 virtual, priority 110 and 90, hello 1 and hold 3, so the pings fail for about 3 seconds. Voice is marked EF and keeps 10 Mbps, and the bulk transfer takes the loss when the link fills.
If your users subnet does not fit 360 hosts, the /24 from this lesson is too small: 254 usable hosts cannot hold 360, and the next size up is a /23. If the shape you picked has no ratio written down, the pick is a guess: go back and do the math. If the voice call still breaks up with QoS on, the mark never happened: check the access port before you check the queue.