ipfw_WF2Q+

1. Jika anda ingin menimplementasikan WF2Q+ dengan ipfw di mesin dengan tujuan:

- Sharing bandwidth antar client misalnya untuk ratio 1:4.
- Sharing bandwidth evenly/rata diantara client tersebut (Tapi bukan garansi/CIR).
- Adanya bandwidth peak/burst diantara client jika client yg lain idle.

2. Untuk sharing bandwidth dengan ratio 1:4 bisa anda kelompokan client anda dalam satu group misalnya:

- Host A, B, C, D diberi bandwidth rebutan/sharing sebesar 128 Kbit/s, dengan IP Address:
* Host A : 192.168.0.1/32
* Host B : 192.168.0.2/32
* Host C : 192.168.0.3/32
* Host D : 192.168.0.4/32

Asumsi subnet yg anda pilih /24 atau 255.255.255.0, jika anda ingin menggunakan subnetting juga itu lebih bagus.

3. Bikin rule di /etc/rc.firewall dan letakan sebelom rule permit/deny:

ipcl_grup01="192.168.0.0/24{1,2,3,4}"
bw_share01="128Kbit/s"
bw_down_share01="128Kbit/s"
bw_up_share01="64Kbit/s"
ifint="inside_interface"

# Sample format 1 - Limiting downstream saja.
${fwcmd} add 1 queue 1 ip from any to ${ipcl_group01} out via ${ifint} // Downstream
${fwcmd} queue 1 config weight 50 queue 4 pipe 1 mask dst-ip 0xffffffff
${fwcmd} pipe 1 config queue 4 bw ${bw_down_share01}

# Sampel format 2 - Limiting upstream saja.
${fwcmd} add 1 queue 1 ip from ${ipcl_group01} to any in  via ${ifint} // Upstream
${fwcmd} queue 1 config weight 50 queue 4 pipe 1 mask src-ip 0xffffffff
${fwcmd} pipe 1 config queue 4 bw ${bw_up_share01}

# Sample format 3 - Limiting downstream/upstream menjadi satu flow.
${fwcmd} add 1 queue 1 ip from any to ${ipcl_group01} out via ${ifint} // Downstream
${fwcmd} add 2 queue 1 ip from ${ipcl_group01} to any in  via ${ifint} // Upstream
${fwcmd} queue 1 config weight 50 queue 4 pipe 1 mask all
${fwcmd} pipe 1 config queue 4 bw ${bw_share01}

# Sample format 4 - Limiting upstream/downstream dengan masing2 flow terpisah.
${fwcmd} add 1 queue 1 ip from any to ${ipcl_group01} out via ${ifint} // Downstream
${fwcmd} add 2 queue 2 ip from ${ipcl_group01} to any in  via ${ifint} // Upstream
${fwcmd} queue 1 config weight 50 queue 4 pipe 1 mask dst-ip 0xffffffff
${fwcmd} queue 2 config weight 50 queue 4 pipe 2 mask src-ip 0xffffffff
${fwcmd} pipe 1 config queue 4 bw ${bw_down_share01}
${fwcmd} pipe 2 config queue 4 bw ${bw_up_share01}

WF2Q+ merupakan varian dari sistem quering policy, dan jangan lupa setelah di assign via queue mesti terhubung ke pipe.

Keterangan:
- queue [Dibagian rule : ${fwcmd} add 1 queue...] : Assign untuk rule WF2Q+.
- weight                                          : Nilei pembanding flow quering (Bukan priority).
                                                    Default 1, allow [1 s/d 100].
- queue [Dibagian rule : ${fwcmd} queue 1 config weight 50 queue...] : Ukuran/jumlah dari "queue/slot" sbg pembanding terhadap jumlah bandwidth. Default 50.
- queue [Dibagian rule : ${fwcmd} pipe 1 config queue...] : Ukuran/jumlah dari "queue/slot" sbg pembanding terhadap jumlah bandwidth. Default 50
- pipe : Assign rule untuk ukuran bandwidth yg terkoneksi.
- mask dst-ip/src-ip : Digunakan untuk masking IP Address/subneting dan port. "dst-ip" digunakan untuk "downstream", "src-ip" digunakan untuk "upstream" dari sample rule diatas (Tergantung dari posisi IP client/port). 0xffffffff adalah value subnet, sama dengan "0.0.0.0/0" (Match all IP Address). Untuk port default "0x0000" artinya tidak menspesifikan/pembatasan port.

4. Perhitungan:

bw_perclient = (w_client / w_jumlah_) * bw_total

Sample diatas perclient mempunyai weight masing2 50, total bw 128 Kbit/s. Katakanlah untuk host A bisa dikalkulasikan sbb:

bw_host_A = (50 / (50*4)) * 128 Kbit/s
          = (50 / 200) * 128 Kbit/s
          = 32 Kbit/s

Jika semua host aktif maka dummynet akan berusaha membagi rata sejumlah 32 Kbit/s per hostnya. Nah contoh diatas mempunyai weight yg sama besarnya, gimana kalo contohnya begini:

w_host_A = 30
w_host_B = 50
w_host_C = 50
w_host_D = 50

Maka bisa kita kalkulasikan bw yg didapat oleh host A dan host B sbb:

bw_host_A = (30 / (30+50+50+50)) * 128 Kbit/s
          = (30 / 180) * 128 Kbit/s
          = 21.333 Kbit/s

bw_host_B = (50 / (30+50+50+50)) * 128 Kbit/s
          = (50 / 180) * 128 Kbit/s
          = 35.55 Kbit/s

Contoh lain:

w_host_A = 10
w_host_B = 20
w_host_C = 30
w_host_D = 40

bw_host_A = (10 / (10+20+30+40)) * 128 Kbit/s
          = (10 / 100) * 128 Kbit/s
          = 12.8 Kbit/s

bw_host_B = (20 / (10+20+30+40)) * 128 Kbit/s
          = (20 / 100) * 128 Kbit/s
          = 25.6 Kbit/s

Perhitungan queue slot. Dalam hal ini queue di rule diatas adalah 4, maka bisa dikalkulasikan:

bw_perclient = bw_total/slot_queue

Dari sample diatas bisa dihitung untuk host A sbb:

bw_host_A = 128 Kbit/s / 4 
          = 32 Kbit/s

Jika semua host aktif maka dummynet akan berusaha membagi rata bandwidth 32 Kbit/s per slot-nya (1 slot = 32 Kbit/s). IMHO, queue slot mendingan disesuaikan dengan jumlah client yg share, contoh diatas 1:4 berarti queue slot-nya

4. Jika kita rubah misalnya queue slot menjadi 8 slot maka ada kemungkinan host A akan menggunakan lebih dari 1 slot, artinya bisa cenderung ngerebut slot jatah host lain.

root:~# uname -srnm
FreeBSD gw-core-introuter.kumprang.com 4.10-STABLE i386
root:~# ipfw queue show
00001:  24.000 Kbit/s    0 ms   50 sl. 1 queues (1 buckets) droptail
   mask: 0x00 0x00000000/0x0000 -> 0x00000000/0x0000
BKT Prot ___Source IP/port____ ____Dest. IP/port____ Tot_pkt/bytes Pkt/Byte Drp
  0 tcp      74.6.68.227/42040   202.146.228.9/80    5535  3192733  0   0   0
00002:  68.000 Kbit/s    0 ms    6 sl. 0 queues (1 buckets) droptail
   mask: 0x00 0x00000000/0x0000 -> 0x00000000/0x0000
00003:  36.000 Kbit/s    0 ms    6 sl. 0 queues (1 buckets) droptail
   mask: 0x00 0x00000000/0x0000 -> 0x00000000/0x0000
q00001: weight 50 pipe 2    6 sl. 6 queues (64 buckets) droptail
   mask: 0x00 0x00000000/0x0000 -> 0xffffffff/0x0000
BKT Prot ___Source IP/port____ ____Dest. IP/port____ Tot_pkt/bytes Pkt/Byte Drp
 17 ip           0.0.0.0/0         192.168.1.1/0     81105 53885327  0   0  2960
 26 ip           0.0.0.0/0        192.168.1.10/0     121939 96279102  0  0  3719
 27 ip           0.0.0.0/0        192.168.1.11/0     134476 96276870  0  0  6141
 28 ip           0.0.0.0/0        192.168.1.12/0     35325 17986730  0   0  1243
 29 ip           0.0.0.0/0        192.168.1.13/0     43479 35034555  0   0  1247
 34 ip           0.0.0.0/0        192.168.1.50/0     154963 152289033  0  0 8521
q00002: weight 50 pipe 3    6 sl. 6 queues (64 buckets) droptail
   mask: 0x00 0xffffffff/0x0000 -> 0x00000000/0x0000
BKT Prot ___Source IP/port____ ____Dest. IP/port____ Tot_pkt/bytes Pkt/Byte Drp
 12 ip      192.168.1.50/0             0.0.0.0/0     128724 17526438  0  0  211
 42 ip       192.168.1.1/0             0.0.0.0/0     71625  8097141  0   0  592
 48 ip      192.168.1.12/0             0.0.0.0/0     28546  2747603  0   0  131
 50 ip      192.168.1.13/0             0.0.0.0/0     32582  3594117  0   0  29
 60 ip      192.168.1.10/0             0.0.0.0/0     102737 10325047  0  0  73
 62 ip      192.168.1.11/0             0.0.0.0/0     89624  8851578  0   0  100

Kolom paling kanan pertanda paket yg sudah didrop, uji gampangnya lihat saja jika kita download gede2an (pake getright/flashget) pasti banyak yg didrop sesuai dengan perhitungan diatas. Dan silahkan coba download dengan cara dilimit di client (pake getright/flashget misalnya) sesuei dengan perhitungan diatas, nah gimana hasilnya tuh :-).

Sistem kerjanya, andaikata host A menggunakan bandwidth melebihi kapasitas sharing bandwidth bedasarkan perhitungan diatas dan host B pada saat bersamaan mulai ngeload bandwidth (katakanlah mulai ngeclick browser) maka host A akan didrop secara random untuk memberikan kesempatan kepada host B sampai kedudukannya seimbang (katakanlah jika bandwidth 128 Kbit/s maka host A akan mendapatkan 64 Kbit/s dan host B akan mendapatkan 64 Kbit/s), dan ketika host B tidak ngeload bandwidth (idle) maka host A akan mendapatkan bandwidth 128 Kbit/s kembali.