github.com/vishvananda/netlink@v1.3.0/qdisc_test.go (about)

     1  //go:build linux
     2  // +build linux
     3  
     4  package netlink
     5  
     6  import (
     7  	"testing"
     8  )
     9  
    10  func TestTbfAddDel(t *testing.T) {
    11  	tearDown := setUpNetlinkTest(t)
    12  	defer tearDown()
    13  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
    14  		t.Fatal(err)
    15  	}
    16  	link, err := LinkByName("foo")
    17  	if err != nil {
    18  		t.Fatal(err)
    19  	}
    20  	if err := LinkSetUp(link); err != nil {
    21  		t.Fatal(err)
    22  	}
    23  	qdisc := &Tbf{
    24  		QdiscAttrs: QdiscAttrs{
    25  			LinkIndex: link.Attrs().Index,
    26  			Handle:    MakeHandle(1, 0),
    27  			Parent:    HANDLE_ROOT,
    28  		},
    29  		Rate:   131072,
    30  		Limit:  1220703,
    31  		Buffer: 16793,
    32  	}
    33  	if err := QdiscAdd(qdisc); err != nil {
    34  		t.Fatal(err)
    35  	}
    36  	qdiscs, err := SafeQdiscList(link)
    37  	if err != nil {
    38  		t.Fatal(err)
    39  	}
    40  	if len(qdiscs) != 1 {
    41  		t.Fatal("Failed to add qdisc")
    42  	}
    43  	tbf, ok := qdiscs[0].(*Tbf)
    44  	if !ok {
    45  		t.Fatal("Qdisc is the wrong type")
    46  	}
    47  	if tbf.Rate != qdisc.Rate {
    48  		t.Fatal("Rate doesn't match")
    49  	}
    50  	if tbf.Limit != qdisc.Limit {
    51  		t.Fatal("Limit doesn't match")
    52  	}
    53  	if tbf.Buffer != qdisc.Buffer {
    54  		t.Fatal("Buffer doesn't match")
    55  	}
    56  	if err := QdiscDel(qdisc); err != nil {
    57  		t.Fatal(err)
    58  	}
    59  	qdiscs, err = SafeQdiscList(link)
    60  	if err != nil {
    61  		t.Fatal(err)
    62  	}
    63  	if len(qdiscs) != 0 {
    64  		t.Fatal("Failed to remove qdisc")
    65  	}
    66  }
    67  
    68  func TestHtbAddDel(t *testing.T) {
    69  	tearDown := setUpNetlinkTest(t)
    70  	defer tearDown()
    71  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
    72  		t.Fatal(err)
    73  	}
    74  	link, err := LinkByName("foo")
    75  	if err != nil {
    76  		t.Fatal(err)
    77  	}
    78  	if err := LinkSetUp(link); err != nil {
    79  		t.Fatal(err)
    80  	}
    81  
    82  	attrs := QdiscAttrs{
    83  		LinkIndex: link.Attrs().Index,
    84  		Handle:    MakeHandle(1, 0),
    85  		Parent:    HANDLE_ROOT,
    86  	}
    87  
    88  	qdisc := NewHtb(attrs)
    89  	qdisc.Rate2Quantum = 5
    90  	directQlen := uint32(10)
    91  	qdisc.DirectQlen = &directQlen
    92  	if err := QdiscAdd(qdisc); err != nil {
    93  		t.Fatal(err)
    94  	}
    95  
    96  	qdiscs, err := SafeQdiscList(link)
    97  	if err != nil {
    98  		t.Fatal(err)
    99  	}
   100  	if len(qdiscs) != 1 {
   101  		t.Fatal("Failed to add qdisc")
   102  	}
   103  	htb, ok := qdiscs[0].(*Htb)
   104  	if !ok {
   105  		t.Fatal("Qdisc is the wrong type")
   106  	}
   107  	if htb.Defcls != qdisc.Defcls {
   108  		t.Fatal("Defcls doesn't match")
   109  	}
   110  	if htb.Rate2Quantum != qdisc.Rate2Quantum {
   111  		t.Fatal("Rate2Quantum doesn't match")
   112  	}
   113  	if htb.Debug != qdisc.Debug {
   114  		t.Fatal("Debug doesn't match")
   115  	}
   116  	if htb.DirectQlen == nil || *htb.DirectQlen != directQlen {
   117  		t.Fatalf("DirectQlen doesn't match. Expected %d, got %v", directQlen, htb.DirectQlen)
   118  	}
   119  	if err := QdiscDel(qdisc); err != nil {
   120  		t.Fatal(err)
   121  	}
   122  	qdiscs, err = SafeQdiscList(link)
   123  	if err != nil {
   124  		t.Fatal(err)
   125  	}
   126  	if len(qdiscs) != 0 {
   127  		t.Fatal("Failed to remove qdisc")
   128  	}
   129  }
   130  
   131  func TestSfqAddDel(t *testing.T) {
   132  	tearDown := setUpNetlinkTestWithKModule(t, "sch_sfq")
   133  	defer tearDown()
   134  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   135  		t.Fatal(err)
   136  	}
   137  	link, err := LinkByName("foo")
   138  	if err != nil {
   139  		t.Fatal(err)
   140  	}
   141  	if err := LinkSetUp(link); err != nil {
   142  		t.Fatal(err)
   143  	}
   144  
   145  	attrs := QdiscAttrs{
   146  		LinkIndex: link.Attrs().Index,
   147  		Handle:    MakeHandle(1, 0),
   148  		Parent:    HANDLE_ROOT,
   149  	}
   150  
   151  	qdisc := Sfq{
   152  		QdiscAttrs: attrs,
   153  		Quantum:    2,
   154  		Perturb:    11,
   155  		Limit:      123,
   156  		Divisor:    4,
   157  	}
   158  	if err := QdiscAdd(&qdisc); err != nil {
   159  		t.Fatal(err)
   160  	}
   161  
   162  	qdiscs, err := SafeQdiscList(link)
   163  	if err != nil {
   164  		t.Fatal(err)
   165  	}
   166  	if len(qdiscs) != 1 {
   167  		t.Fatal("Failed to add qdisc")
   168  	}
   169  	sfq, ok := qdiscs[0].(*Sfq)
   170  	if !ok {
   171  		t.Fatal("Qdisc is the wrong type")
   172  	}
   173  	if sfq.Quantum != qdisc.Quantum {
   174  		t.Fatal("Quantum doesn't match")
   175  	}
   176  	if sfq.Perturb != qdisc.Perturb {
   177  		t.Fatal("Perturb doesn't match")
   178  	}
   179  	if sfq.Limit != qdisc.Limit {
   180  		t.Fatal("Limit doesn't match")
   181  	}
   182  	if sfq.Divisor != qdisc.Divisor {
   183  		t.Fatal("Divisor doesn't match")
   184  	}
   185  	if err := QdiscDel(&qdisc); err != nil {
   186  		t.Fatal(err)
   187  	}
   188  	qdiscs, err = SafeQdiscList(link)
   189  	if err != nil {
   190  		t.Fatal(err)
   191  	}
   192  	if len(qdiscs) != 0 {
   193  		t.Fatal("Failed to remove qdisc")
   194  	}
   195  }
   196  
   197  func TestPrioAddDel(t *testing.T) {
   198  	tearDown := setUpNetlinkTest(t)
   199  	defer tearDown()
   200  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   201  		t.Fatal(err)
   202  	}
   203  	link, err := LinkByName("foo")
   204  	if err != nil {
   205  		t.Fatal(err)
   206  	}
   207  	if err := LinkSetUp(link); err != nil {
   208  		t.Fatal(err)
   209  	}
   210  	qdisc := NewPrio(QdiscAttrs{
   211  		LinkIndex: link.Attrs().Index,
   212  		Handle:    MakeHandle(1, 0),
   213  		Parent:    HANDLE_ROOT,
   214  	})
   215  	if err := QdiscAdd(qdisc); err != nil {
   216  		t.Fatal(err)
   217  	}
   218  	qdiscs, err := SafeQdiscList(link)
   219  	if err != nil {
   220  		t.Fatal(err)
   221  	}
   222  	if len(qdiscs) != 1 {
   223  		t.Fatal("Failed to add qdisc")
   224  	}
   225  	_, ok := qdiscs[0].(*Prio)
   226  	if !ok {
   227  		t.Fatal("Qdisc is the wrong type")
   228  	}
   229  	if err := QdiscDel(qdisc); err != nil {
   230  		t.Fatal(err)
   231  	}
   232  	qdiscs, err = SafeQdiscList(link)
   233  	if err != nil {
   234  		t.Fatal(err)
   235  	}
   236  	if len(qdiscs) != 0 {
   237  		t.Fatal("Failed to remove qdisc")
   238  	}
   239  }
   240  
   241  func TestTbfAddHtbReplaceDel(t *testing.T) {
   242  	tearDown := setUpNetlinkTest(t)
   243  	defer tearDown()
   244  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   245  		t.Fatal(err)
   246  	}
   247  	link, err := LinkByName("foo")
   248  	if err != nil {
   249  		t.Fatal(err)
   250  	}
   251  	if err := LinkSetUp(link); err != nil {
   252  		t.Fatal(err)
   253  	}
   254  
   255  	// Add
   256  	attrs := QdiscAttrs{
   257  		LinkIndex: link.Attrs().Index,
   258  		Handle:    MakeHandle(1, 0),
   259  		Parent:    HANDLE_ROOT,
   260  	}
   261  	qdisc := &Tbf{
   262  		QdiscAttrs: attrs,
   263  		Rate:       131072,
   264  		Limit:      1220703,
   265  		Buffer:     16793,
   266  	}
   267  	if err := QdiscAdd(qdisc); err != nil {
   268  		t.Fatal(err)
   269  	}
   270  	qdiscs, err := SafeQdiscList(link)
   271  	if err != nil {
   272  		t.Fatal(err)
   273  	}
   274  	if len(qdiscs) != 1 {
   275  		t.Fatal("Failed to add qdisc")
   276  	}
   277  	tbf, ok := qdiscs[0].(*Tbf)
   278  	if !ok {
   279  		t.Fatal("Qdisc is the wrong type")
   280  	}
   281  	if tbf.Rate != qdisc.Rate {
   282  		t.Fatal("Rate doesn't match")
   283  	}
   284  	if tbf.Limit != qdisc.Limit {
   285  		t.Fatal("Limit doesn't match")
   286  	}
   287  	if tbf.Buffer != qdisc.Buffer {
   288  		t.Fatal("Buffer doesn't match")
   289  	}
   290  	// Replace
   291  	// For replace to work, the handle MUST be different that the running one
   292  	attrs.Handle = MakeHandle(2, 0)
   293  	qdisc2 := NewHtb(attrs)
   294  	qdisc2.Rate2Quantum = 5
   295  	if err := QdiscReplace(qdisc2); err != nil {
   296  		t.Fatal(err)
   297  	}
   298  
   299  	qdiscs, err = SafeQdiscList(link)
   300  	if err != nil {
   301  		t.Fatal(err)
   302  	}
   303  	if len(qdiscs) != 1 {
   304  		t.Fatal("Failed to add qdisc")
   305  	}
   306  	htb, ok := qdiscs[0].(*Htb)
   307  	if !ok {
   308  		t.Fatal("Qdisc is the wrong type")
   309  	}
   310  	if htb.Defcls != qdisc2.Defcls {
   311  		t.Fatal("Defcls doesn't match")
   312  	}
   313  	if htb.Rate2Quantum != qdisc2.Rate2Quantum {
   314  		t.Fatal("Rate2Quantum doesn't match")
   315  	}
   316  	if htb.Debug != qdisc2.Debug {
   317  		t.Fatal("Debug doesn't match")
   318  	}
   319  
   320  	if err := QdiscDel(qdisc2); err != nil {
   321  		t.Fatal(err)
   322  	}
   323  	qdiscs, err = SafeQdiscList(link)
   324  	if err != nil {
   325  		t.Fatal(err)
   326  	}
   327  	if len(qdiscs) != 0 {
   328  		t.Fatal("Failed to remove qdisc")
   329  	}
   330  }
   331  
   332  func TestTbfAddTbfChangeDel(t *testing.T) {
   333  	tearDown := setUpNetlinkTest(t)
   334  	defer tearDown()
   335  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   336  		t.Fatal(err)
   337  	}
   338  	link, err := LinkByName("foo")
   339  	if err != nil {
   340  		t.Fatal(err)
   341  	}
   342  	if err := LinkSetUp(link); err != nil {
   343  		t.Fatal(err)
   344  	}
   345  
   346  	// Add
   347  	attrs := QdiscAttrs{
   348  		LinkIndex: link.Attrs().Index,
   349  		Handle:    MakeHandle(1, 0),
   350  		Parent:    HANDLE_ROOT,
   351  	}
   352  	qdisc := &Tbf{
   353  		QdiscAttrs: attrs,
   354  		Rate:       131072,
   355  		Limit:      1220703,
   356  		Buffer:     16793,
   357  	}
   358  	if err := QdiscAdd(qdisc); err != nil {
   359  		t.Fatal(err)
   360  	}
   361  	qdiscs, err := SafeQdiscList(link)
   362  	if err != nil {
   363  		t.Fatal(err)
   364  	}
   365  	if len(qdiscs) != 1 {
   366  		t.Fatal("Failed to add qdisc")
   367  	}
   368  	tbf, ok := qdiscs[0].(*Tbf)
   369  	if !ok {
   370  		t.Fatal("Qdisc is the wrong type")
   371  	}
   372  	if tbf.Rate != qdisc.Rate {
   373  		t.Fatal("Rate doesn't match")
   374  	}
   375  	if tbf.Limit != qdisc.Limit {
   376  		t.Fatal("Limit doesn't match")
   377  	}
   378  	if tbf.Buffer != qdisc.Buffer {
   379  		t.Fatal("Buffer doesn't match")
   380  	}
   381  	// Change
   382  	// For change to work, the handle MUST not change
   383  	qdisc.Rate = 23456
   384  	if err := QdiscChange(qdisc); err != nil {
   385  		t.Fatal(err)
   386  	}
   387  
   388  	qdiscs, err = SafeQdiscList(link)
   389  	if err != nil {
   390  		t.Fatal(err)
   391  	}
   392  	if len(qdiscs) != 1 {
   393  		t.Fatal("Failed to add qdisc")
   394  	}
   395  	tbf, ok = qdiscs[0].(*Tbf)
   396  	if !ok {
   397  		t.Fatal("Qdisc is the wrong type")
   398  	}
   399  	if tbf.Rate != qdisc.Rate {
   400  		t.Fatal("Rate doesn't match")
   401  	}
   402  	if tbf.Limit != qdisc.Limit {
   403  		t.Fatal("Limit doesn't match")
   404  	}
   405  	if tbf.Buffer != qdisc.Buffer {
   406  		t.Fatal("Buffer doesn't match")
   407  	}
   408  
   409  	if err := QdiscDel(qdisc); err != nil {
   410  		t.Fatal(err)
   411  	}
   412  	qdiscs, err = SafeQdiscList(link)
   413  	if err != nil {
   414  		t.Fatal(err)
   415  	}
   416  	if len(qdiscs) != 0 {
   417  		t.Fatal("Failed to remove qdisc")
   418  	}
   419  }
   420  
   421  func TestFqAddChangeDel(t *testing.T) {
   422  	minKernelRequired(t, 3, 11)
   423  
   424  	tearDown := setUpNetlinkTest(t)
   425  	defer tearDown()
   426  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   427  		t.Fatal(err)
   428  	}
   429  	link, err := LinkByName("foo")
   430  	if err != nil {
   431  		t.Fatal(err)
   432  	}
   433  	if err := LinkSetUp(link); err != nil {
   434  		t.Fatal(err)
   435  	}
   436  	qdisc := &Fq{
   437  		QdiscAttrs: QdiscAttrs{
   438  			LinkIndex: link.Attrs().Index,
   439  			Handle:    MakeHandle(1, 0),
   440  			Parent:    HANDLE_ROOT,
   441  		},
   442  		FlowPacketLimit: 123,
   443  		Pacing:          0,
   444  	}
   445  	if err := QdiscAdd(qdisc); err != nil {
   446  		t.Fatal(err)
   447  	}
   448  	qdiscs, err := SafeQdiscList(link)
   449  	if err != nil {
   450  		t.Fatal(err)
   451  	}
   452  	if len(qdiscs) != 1 {
   453  		t.Fatal("Failed to add qdisc")
   454  	}
   455  	fq, ok := qdiscs[0].(*Fq)
   456  	if !ok {
   457  		t.Fatal("Qdisc is the wrong type")
   458  	}
   459  	if fq.FlowPacketLimit != qdisc.FlowPacketLimit {
   460  		t.Fatal("Flow Packet Limit does not match")
   461  	}
   462  	if fq.Pacing != qdisc.Pacing {
   463  		t.Fatal("Pacing does not match")
   464  	}
   465  
   466  	if err := QdiscDel(qdisc); err != nil {
   467  		t.Fatal(err)
   468  	}
   469  	qdiscs, err = SafeQdiscList(link)
   470  	if err != nil {
   471  		t.Fatal(err)
   472  	}
   473  	if len(qdiscs) != 0 {
   474  		t.Fatal("Failed to remove qdisc")
   475  	}
   476  }
   477  
   478  func TestFqHorizon(t *testing.T) {
   479  	minKernelRequired(t, 5, 7)
   480  
   481  	tearDown := setUpNetlinkTest(t)
   482  	defer tearDown()
   483  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   484  		t.Fatal(err)
   485  	}
   486  	link, err := LinkByName("foo")
   487  	if err != nil {
   488  		t.Fatal(err)
   489  	}
   490  	if err := LinkSetUp(link); err != nil {
   491  		t.Fatal(err)
   492  	}
   493  	qdisc := &Fq{
   494  		QdiscAttrs: QdiscAttrs{
   495  			LinkIndex: link.Attrs().Index,
   496  			Handle:    MakeHandle(1, 0),
   497  			Parent:    HANDLE_ROOT,
   498  		},
   499  		Horizon:           1000,
   500  		HorizonDropPolicy: HORIZON_DROP_POLICY_CAP,
   501  	}
   502  	if err := QdiscAdd(qdisc); err != nil {
   503  		t.Fatal(err)
   504  	}
   505  	qdiscs, err := SafeQdiscList(link)
   506  	if err != nil {
   507  		t.Fatal(err)
   508  	}
   509  	if len(qdiscs) != 1 {
   510  		t.Fatal("Failed to add qdisc")
   511  	}
   512  	fq, ok := qdiscs[0].(*Fq)
   513  	if !ok {
   514  		t.Fatal("Qdisc is the wrong type")
   515  	}
   516  	if fq.Horizon != qdisc.Horizon {
   517  		t.Fatal("Horizon does not match")
   518  	}
   519  	if fq.HorizonDropPolicy != qdisc.HorizonDropPolicy {
   520  		t.Fatal("HorizonDropPolicy does not match")
   521  	}
   522  
   523  	if err := QdiscDel(qdisc); err != nil {
   524  		t.Fatal(err)
   525  	}
   526  	qdiscs, err = SafeQdiscList(link)
   527  	if err != nil {
   528  		t.Fatal(err)
   529  	}
   530  	if len(qdiscs) != 0 {
   531  		t.Fatal("Failed to remove qdisc")
   532  	}
   533  }
   534  
   535  func TestFqCodelAddChangeDel(t *testing.T) {
   536  	minKernelRequired(t, 3, 4)
   537  
   538  	tearDown := setUpNetlinkTest(t)
   539  	defer tearDown()
   540  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   541  		t.Fatal(err)
   542  	}
   543  	link, err := LinkByName("foo")
   544  	if err != nil {
   545  		t.Fatal(err)
   546  	}
   547  	if err := LinkSetUp(link); err != nil {
   548  		t.Fatal(err)
   549  	}
   550  	qdisc := &FqCodel{
   551  		QdiscAttrs: QdiscAttrs{
   552  			LinkIndex: link.Attrs().Index,
   553  			Handle:    MakeHandle(1, 0),
   554  			Parent:    HANDLE_ROOT,
   555  		},
   556  		ECN:     1,
   557  		Quantum: 9000,
   558  	}
   559  	if err := QdiscAdd(qdisc); err != nil {
   560  		t.Fatal(err)
   561  	}
   562  	qdiscs, err := SafeQdiscList(link)
   563  	if err != nil {
   564  		t.Fatal(err)
   565  	}
   566  	if len(qdiscs) != 1 {
   567  		t.Fatal("Failed to add qdisc")
   568  	}
   569  	fqcodel, ok := qdiscs[0].(*FqCodel)
   570  	if !ok {
   571  		t.Fatal("Qdisc is the wrong type")
   572  	}
   573  	if fqcodel.Quantum != qdisc.Quantum {
   574  		t.Fatal("Quantum does not match")
   575  	}
   576  
   577  	if err := QdiscDel(qdisc); err != nil {
   578  		t.Fatal(err)
   579  	}
   580  	qdiscs, err = SafeQdiscList(link)
   581  	if err != nil {
   582  		t.Fatal(err)
   583  	}
   584  	if len(qdiscs) != 0 {
   585  		t.Fatal("Failed to remove qdisc")
   586  	}
   587  }
   588  
   589  func TestIngressAddDel(t *testing.T) {
   590  	tearDown := setUpNetlinkTest(t)
   591  	defer tearDown()
   592  	if err := LinkAdd(&Ifb{LinkAttrs{Name: "foo"}}); err != nil {
   593  		t.Fatal(err)
   594  	}
   595  	link, err := LinkByName("foo")
   596  	if err != nil {
   597  		t.Fatal(err)
   598  	}
   599  	ingressBlock := new(uint32)
   600  	*ingressBlock = 8
   601  	qdisc := &Ingress{
   602  		QdiscAttrs: QdiscAttrs{
   603  			LinkIndex:    link.Attrs().Index,
   604  			Parent:       HANDLE_INGRESS,
   605  			IngressBlock: ingressBlock,
   606  		},
   607  	}
   608  	err = QdiscAdd(qdisc)
   609  	if err != nil {
   610  		t.Fatal("Failed to add qdisc")
   611  	}
   612  	qdiscs, err := SafeQdiscList(link)
   613  	if err != nil {
   614  		t.Fatal("Failed to list qdisc")
   615  	}
   616  	if len(qdiscs) != 1 {
   617  		t.Fatal("Failed to add qdisc")
   618  	}
   619  	if *qdiscs[0].Attrs().IngressBlock != *ingressBlock {
   620  		t.Fatal("IngressBlock does not match")
   621  	}
   622  	if qdiscs[0].Attrs().Statistics == nil {
   623  		t.Fatal("Statistics is nil")
   624  	}
   625  	if qdiscs[0].Attrs().Statistics.Basic.Bytes != 0 || qdiscs[0].Attrs().Statistics.Basic.Packets != 0 {
   626  		t.Fatal("Statistics is not zero")
   627  	}
   628  	if err = QdiscDel(qdisc); err != nil {
   629  		t.Fatal(err)
   630  	}
   631  	qdiscs, err = SafeQdiscList(link)
   632  	if err != nil {
   633  		t.Fatal(err)
   634  	}
   635  	if len(qdiscs) != 0 {
   636  		t.Fatal("Failed to remove qdisc")
   637  	}
   638  }