qdisc_linux.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668
  1. package netlink
  2. import (
  3. "fmt"
  4. "io/ioutil"
  5. "strconv"
  6. "strings"
  7. "syscall"
  8. "github.com/vishvananda/netlink/nl"
  9. "golang.org/x/sys/unix"
  10. )
  11. // NOTE function is here because it uses other linux functions
  12. func NewNetem(attrs QdiscAttrs, nattrs NetemQdiscAttrs) *Netem {
  13. var limit uint32 = 1000
  14. var lossCorr, delayCorr, duplicateCorr uint32
  15. var reorderProb, reorderCorr uint32
  16. var corruptProb, corruptCorr uint32
  17. latency := nattrs.Latency
  18. loss := Percentage2u32(nattrs.Loss)
  19. gap := nattrs.Gap
  20. duplicate := Percentage2u32(nattrs.Duplicate)
  21. jitter := nattrs.Jitter
  22. // Correlation
  23. if latency > 0 && jitter > 0 {
  24. delayCorr = Percentage2u32(nattrs.DelayCorr)
  25. }
  26. if loss > 0 {
  27. lossCorr = Percentage2u32(nattrs.LossCorr)
  28. }
  29. if duplicate > 0 {
  30. duplicateCorr = Percentage2u32(nattrs.DuplicateCorr)
  31. }
  32. // FIXME should validate values(like loss/duplicate are percentages...)
  33. latency = time2Tick(latency)
  34. if nattrs.Limit != 0 {
  35. limit = nattrs.Limit
  36. }
  37. // Jitter is only value if latency is > 0
  38. if latency > 0 {
  39. jitter = time2Tick(jitter)
  40. }
  41. reorderProb = Percentage2u32(nattrs.ReorderProb)
  42. reorderCorr = Percentage2u32(nattrs.ReorderCorr)
  43. if reorderProb > 0 {
  44. // ERROR if lantency == 0
  45. if gap == 0 {
  46. gap = 1
  47. }
  48. }
  49. corruptProb = Percentage2u32(nattrs.CorruptProb)
  50. corruptCorr = Percentage2u32(nattrs.CorruptCorr)
  51. return &Netem{
  52. QdiscAttrs: attrs,
  53. Latency: latency,
  54. DelayCorr: delayCorr,
  55. Limit: limit,
  56. Loss: loss,
  57. LossCorr: lossCorr,
  58. Gap: gap,
  59. Duplicate: duplicate,
  60. DuplicateCorr: duplicateCorr,
  61. Jitter: jitter,
  62. ReorderProb: reorderProb,
  63. ReorderCorr: reorderCorr,
  64. CorruptProb: corruptProb,
  65. CorruptCorr: corruptCorr,
  66. }
  67. }
  68. // QdiscDel will delete a qdisc from the system.
  69. // Equivalent to: `tc qdisc del $qdisc`
  70. func QdiscDel(qdisc Qdisc) error {
  71. return pkgHandle.QdiscDel(qdisc)
  72. }
  73. // QdiscDel will delete a qdisc from the system.
  74. // Equivalent to: `tc qdisc del $qdisc`
  75. func (h *Handle) QdiscDel(qdisc Qdisc) error {
  76. return h.qdiscModify(unix.RTM_DELQDISC, 0, qdisc)
  77. }
  78. // QdiscChange will change a qdisc in place
  79. // Equivalent to: `tc qdisc change $qdisc`
  80. // The parent and handle MUST NOT be changed.
  81. func QdiscChange(qdisc Qdisc) error {
  82. return pkgHandle.QdiscChange(qdisc)
  83. }
  84. // QdiscChange will change a qdisc in place
  85. // Equivalent to: `tc qdisc change $qdisc`
  86. // The parent and handle MUST NOT be changed.
  87. func (h *Handle) QdiscChange(qdisc Qdisc) error {
  88. return h.qdiscModify(unix.RTM_NEWQDISC, 0, qdisc)
  89. }
  90. // QdiscReplace will replace a qdisc to the system.
  91. // Equivalent to: `tc qdisc replace $qdisc`
  92. // The handle MUST change.
  93. func QdiscReplace(qdisc Qdisc) error {
  94. return pkgHandle.QdiscReplace(qdisc)
  95. }
  96. // QdiscReplace will replace a qdisc to the system.
  97. // Equivalent to: `tc qdisc replace $qdisc`
  98. // The handle MUST change.
  99. func (h *Handle) QdiscReplace(qdisc Qdisc) error {
  100. return h.qdiscModify(
  101. unix.RTM_NEWQDISC,
  102. unix.NLM_F_CREATE|unix.NLM_F_REPLACE,
  103. qdisc)
  104. }
  105. // QdiscAdd will add a qdisc to the system.
  106. // Equivalent to: `tc qdisc add $qdisc`
  107. func QdiscAdd(qdisc Qdisc) error {
  108. return pkgHandle.QdiscAdd(qdisc)
  109. }
  110. // QdiscAdd will add a qdisc to the system.
  111. // Equivalent to: `tc qdisc add $qdisc`
  112. func (h *Handle) QdiscAdd(qdisc Qdisc) error {
  113. return h.qdiscModify(
  114. unix.RTM_NEWQDISC,
  115. unix.NLM_F_CREATE|unix.NLM_F_EXCL,
  116. qdisc)
  117. }
  118. func (h *Handle) qdiscModify(cmd, flags int, qdisc Qdisc) error {
  119. req := h.newNetlinkRequest(cmd, flags|unix.NLM_F_ACK)
  120. base := qdisc.Attrs()
  121. msg := &nl.TcMsg{
  122. Family: nl.FAMILY_ALL,
  123. Ifindex: int32(base.LinkIndex),
  124. Handle: base.Handle,
  125. Parent: base.Parent,
  126. }
  127. req.AddData(msg)
  128. // When deleting don't bother building the rest of the netlink payload
  129. if cmd != unix.RTM_DELQDISC {
  130. if err := qdiscPayload(req, qdisc); err != nil {
  131. return err
  132. }
  133. }
  134. _, err := req.Execute(unix.NETLINK_ROUTE, 0)
  135. return err
  136. }
  137. func qdiscPayload(req *nl.NetlinkRequest, qdisc Qdisc) error {
  138. req.AddData(nl.NewRtAttr(nl.TCA_KIND, nl.ZeroTerminated(qdisc.Type())))
  139. options := nl.NewRtAttr(nl.TCA_OPTIONS, nil)
  140. switch qdisc := qdisc.(type) {
  141. case *Prio:
  142. tcmap := nl.TcPrioMap{
  143. Bands: int32(qdisc.Bands),
  144. Priomap: qdisc.PriorityMap,
  145. }
  146. options = nl.NewRtAttr(nl.TCA_OPTIONS, tcmap.Serialize())
  147. case *Tbf:
  148. opt := nl.TcTbfQopt{}
  149. opt.Rate.Rate = uint32(qdisc.Rate)
  150. opt.Peakrate.Rate = uint32(qdisc.Peakrate)
  151. opt.Limit = qdisc.Limit
  152. opt.Buffer = qdisc.Buffer
  153. options.AddRtAttr(nl.TCA_TBF_PARMS, opt.Serialize())
  154. if qdisc.Rate >= uint64(1<<32) {
  155. options.AddRtAttr(nl.TCA_TBF_RATE64, nl.Uint64Attr(qdisc.Rate))
  156. }
  157. if qdisc.Peakrate >= uint64(1<<32) {
  158. options.AddRtAttr(nl.TCA_TBF_PRATE64, nl.Uint64Attr(qdisc.Peakrate))
  159. }
  160. if qdisc.Peakrate > 0 {
  161. options.AddRtAttr(nl.TCA_TBF_PBURST, nl.Uint32Attr(qdisc.Minburst))
  162. }
  163. case *Htb:
  164. opt := nl.TcHtbGlob{}
  165. opt.Version = qdisc.Version
  166. opt.Rate2Quantum = qdisc.Rate2Quantum
  167. opt.Defcls = qdisc.Defcls
  168. // TODO: Handle Debug properly. For now default to 0
  169. opt.Debug = qdisc.Debug
  170. opt.DirectPkts = qdisc.DirectPkts
  171. options.AddRtAttr(nl.TCA_HTB_INIT, opt.Serialize())
  172. // options.AddRtAttr(nl.TCA_HTB_DIRECT_QLEN, opt.Serialize())
  173. case *Hfsc:
  174. opt := nl.TcHfscOpt{}
  175. opt.Defcls = qdisc.Defcls
  176. options = nl.NewRtAttr(nl.TCA_OPTIONS, opt.Serialize())
  177. case *Netem:
  178. opt := nl.TcNetemQopt{}
  179. opt.Latency = qdisc.Latency
  180. opt.Limit = qdisc.Limit
  181. opt.Loss = qdisc.Loss
  182. opt.Gap = qdisc.Gap
  183. opt.Duplicate = qdisc.Duplicate
  184. opt.Jitter = qdisc.Jitter
  185. options = nl.NewRtAttr(nl.TCA_OPTIONS, opt.Serialize())
  186. // Correlation
  187. corr := nl.TcNetemCorr{}
  188. corr.DelayCorr = qdisc.DelayCorr
  189. corr.LossCorr = qdisc.LossCorr
  190. corr.DupCorr = qdisc.DuplicateCorr
  191. if corr.DelayCorr > 0 || corr.LossCorr > 0 || corr.DupCorr > 0 {
  192. options.AddRtAttr(nl.TCA_NETEM_CORR, corr.Serialize())
  193. }
  194. // Corruption
  195. corruption := nl.TcNetemCorrupt{}
  196. corruption.Probability = qdisc.CorruptProb
  197. corruption.Correlation = qdisc.CorruptCorr
  198. if corruption.Probability > 0 {
  199. options.AddRtAttr(nl.TCA_NETEM_CORRUPT, corruption.Serialize())
  200. }
  201. // Reorder
  202. reorder := nl.TcNetemReorder{}
  203. reorder.Probability = qdisc.ReorderProb
  204. reorder.Correlation = qdisc.ReorderCorr
  205. if reorder.Probability > 0 {
  206. options.AddRtAttr(nl.TCA_NETEM_REORDER, reorder.Serialize())
  207. }
  208. case *Ingress:
  209. // ingress filters must use the proper handle
  210. if qdisc.Attrs().Parent != HANDLE_INGRESS {
  211. return fmt.Errorf("Ingress filters must set Parent to HANDLE_INGRESS")
  212. }
  213. case *FqCodel:
  214. options.AddRtAttr(nl.TCA_FQ_CODEL_ECN, nl.Uint32Attr((uint32(qdisc.ECN))))
  215. if qdisc.Limit > 0 {
  216. options.AddRtAttr(nl.TCA_FQ_CODEL_LIMIT, nl.Uint32Attr((uint32(qdisc.Limit))))
  217. }
  218. if qdisc.Interval > 0 {
  219. options.AddRtAttr(nl.TCA_FQ_CODEL_INTERVAL, nl.Uint32Attr((uint32(qdisc.Interval))))
  220. }
  221. if qdisc.Flows > 0 {
  222. options.AddRtAttr(nl.TCA_FQ_CODEL_FLOWS, nl.Uint32Attr((uint32(qdisc.Flows))))
  223. }
  224. if qdisc.Quantum > 0 {
  225. options.AddRtAttr(nl.TCA_FQ_CODEL_QUANTUM, nl.Uint32Attr((uint32(qdisc.Quantum))))
  226. }
  227. case *Fq:
  228. options.AddRtAttr(nl.TCA_FQ_RATE_ENABLE, nl.Uint32Attr((uint32(qdisc.Pacing))))
  229. if qdisc.Buckets > 0 {
  230. options.AddRtAttr(nl.TCA_FQ_BUCKETS_LOG, nl.Uint32Attr((uint32(qdisc.Buckets))))
  231. }
  232. if qdisc.LowRateThreshold > 0 {
  233. options.AddRtAttr(nl.TCA_FQ_LOW_RATE_THRESHOLD, nl.Uint32Attr((uint32(qdisc.LowRateThreshold))))
  234. }
  235. if qdisc.Quantum > 0 {
  236. options.AddRtAttr(nl.TCA_FQ_QUANTUM, nl.Uint32Attr((uint32(qdisc.Quantum))))
  237. }
  238. if qdisc.InitialQuantum > 0 {
  239. options.AddRtAttr(nl.TCA_FQ_INITIAL_QUANTUM, nl.Uint32Attr((uint32(qdisc.InitialQuantum))))
  240. }
  241. if qdisc.FlowRefillDelay > 0 {
  242. options.AddRtAttr(nl.TCA_FQ_FLOW_REFILL_DELAY, nl.Uint32Attr((uint32(qdisc.FlowRefillDelay))))
  243. }
  244. if qdisc.FlowPacketLimit > 0 {
  245. options.AddRtAttr(nl.TCA_FQ_FLOW_PLIMIT, nl.Uint32Attr((uint32(qdisc.FlowPacketLimit))))
  246. }
  247. if qdisc.FlowMaxRate > 0 {
  248. options.AddRtAttr(nl.TCA_FQ_FLOW_MAX_RATE, nl.Uint32Attr((uint32(qdisc.FlowMaxRate))))
  249. }
  250. if qdisc.FlowDefaultRate > 0 {
  251. options.AddRtAttr(nl.TCA_FQ_FLOW_DEFAULT_RATE, nl.Uint32Attr((uint32(qdisc.FlowDefaultRate))))
  252. }
  253. default:
  254. options = nil
  255. }
  256. if options != nil {
  257. req.AddData(options)
  258. }
  259. return nil
  260. }
  261. // QdiscList gets a list of qdiscs in the system.
  262. // Equivalent to: `tc qdisc show`.
  263. // The list can be filtered by link.
  264. func QdiscList(link Link) ([]Qdisc, error) {
  265. return pkgHandle.QdiscList(link)
  266. }
  267. // QdiscList gets a list of qdiscs in the system.
  268. // Equivalent to: `tc qdisc show`.
  269. // The list can be filtered by link.
  270. func (h *Handle) QdiscList(link Link) ([]Qdisc, error) {
  271. req := h.newNetlinkRequest(unix.RTM_GETQDISC, unix.NLM_F_DUMP)
  272. index := int32(0)
  273. if link != nil {
  274. base := link.Attrs()
  275. h.ensureIndex(base)
  276. index = int32(base.Index)
  277. }
  278. msg := &nl.TcMsg{
  279. Family: nl.FAMILY_ALL,
  280. Ifindex: index,
  281. }
  282. req.AddData(msg)
  283. msgs, err := req.Execute(unix.NETLINK_ROUTE, unix.RTM_NEWQDISC)
  284. if err != nil {
  285. return nil, err
  286. }
  287. var res []Qdisc
  288. for _, m := range msgs {
  289. msg := nl.DeserializeTcMsg(m)
  290. attrs, err := nl.ParseRouteAttr(m[msg.Len():])
  291. if err != nil {
  292. return nil, err
  293. }
  294. // skip qdiscs from other interfaces
  295. if link != nil && msg.Ifindex != index {
  296. continue
  297. }
  298. base := QdiscAttrs{
  299. LinkIndex: int(msg.Ifindex),
  300. Handle: msg.Handle,
  301. Parent: msg.Parent,
  302. Refcnt: msg.Info,
  303. }
  304. var qdisc Qdisc
  305. qdiscType := ""
  306. for _, attr := range attrs {
  307. switch attr.Attr.Type {
  308. case nl.TCA_KIND:
  309. qdiscType = string(attr.Value[:len(attr.Value)-1])
  310. switch qdiscType {
  311. case "pfifo_fast":
  312. qdisc = &PfifoFast{}
  313. case "prio":
  314. qdisc = &Prio{}
  315. case "tbf":
  316. qdisc = &Tbf{}
  317. case "ingress":
  318. qdisc = &Ingress{}
  319. case "htb":
  320. qdisc = &Htb{}
  321. case "fq":
  322. qdisc = &Fq{}
  323. case "hfsc":
  324. qdisc = &Hfsc{}
  325. case "fq_codel":
  326. qdisc = &FqCodel{}
  327. case "netem":
  328. qdisc = &Netem{}
  329. default:
  330. qdisc = &GenericQdisc{QdiscType: qdiscType}
  331. }
  332. case nl.TCA_OPTIONS:
  333. switch qdiscType {
  334. case "pfifo_fast":
  335. // pfifo returns TcPrioMap directly without wrapping it in rtattr
  336. if err := parsePfifoFastData(qdisc, attr.Value); err != nil {
  337. return nil, err
  338. }
  339. case "prio":
  340. // prio returns TcPrioMap directly without wrapping it in rtattr
  341. if err := parsePrioData(qdisc, attr.Value); err != nil {
  342. return nil, err
  343. }
  344. case "tbf":
  345. data, err := nl.ParseRouteAttr(attr.Value)
  346. if err != nil {
  347. return nil, err
  348. }
  349. if err := parseTbfData(qdisc, data); err != nil {
  350. return nil, err
  351. }
  352. case "hfsc":
  353. if err := parseHfscData(qdisc, attr.Value); err != nil {
  354. return nil, err
  355. }
  356. case "htb":
  357. data, err := nl.ParseRouteAttr(attr.Value)
  358. if err != nil {
  359. return nil, err
  360. }
  361. if err := parseHtbData(qdisc, data); err != nil {
  362. return nil, err
  363. }
  364. case "fq":
  365. data, err := nl.ParseRouteAttr(attr.Value)
  366. if err != nil {
  367. return nil, err
  368. }
  369. if err := parseFqData(qdisc, data); err != nil {
  370. return nil, err
  371. }
  372. case "fq_codel":
  373. data, err := nl.ParseRouteAttr(attr.Value)
  374. if err != nil {
  375. return nil, err
  376. }
  377. if err := parseFqCodelData(qdisc, data); err != nil {
  378. return nil, err
  379. }
  380. case "netem":
  381. if err := parseNetemData(qdisc, attr.Value); err != nil {
  382. return nil, err
  383. }
  384. // no options for ingress
  385. }
  386. }
  387. }
  388. *qdisc.Attrs() = base
  389. res = append(res, qdisc)
  390. }
  391. return res, nil
  392. }
  393. func parsePfifoFastData(qdisc Qdisc, value []byte) error {
  394. pfifo := qdisc.(*PfifoFast)
  395. tcmap := nl.DeserializeTcPrioMap(value)
  396. pfifo.PriorityMap = tcmap.Priomap
  397. pfifo.Bands = uint8(tcmap.Bands)
  398. return nil
  399. }
  400. func parsePrioData(qdisc Qdisc, value []byte) error {
  401. prio := qdisc.(*Prio)
  402. tcmap := nl.DeserializeTcPrioMap(value)
  403. prio.PriorityMap = tcmap.Priomap
  404. prio.Bands = uint8(tcmap.Bands)
  405. return nil
  406. }
  407. func parseHtbData(qdisc Qdisc, data []syscall.NetlinkRouteAttr) error {
  408. native = nl.NativeEndian()
  409. htb := qdisc.(*Htb)
  410. for _, datum := range data {
  411. switch datum.Attr.Type {
  412. case nl.TCA_HTB_INIT:
  413. opt := nl.DeserializeTcHtbGlob(datum.Value)
  414. htb.Version = opt.Version
  415. htb.Rate2Quantum = opt.Rate2Quantum
  416. htb.Defcls = opt.Defcls
  417. htb.Debug = opt.Debug
  418. htb.DirectPkts = opt.DirectPkts
  419. case nl.TCA_HTB_DIRECT_QLEN:
  420. // TODO
  421. //htb.DirectQlen = native.uint32(datum.Value)
  422. }
  423. }
  424. return nil
  425. }
  426. func parseFqCodelData(qdisc Qdisc, data []syscall.NetlinkRouteAttr) error {
  427. native = nl.NativeEndian()
  428. fqCodel := qdisc.(*FqCodel)
  429. for _, datum := range data {
  430. switch datum.Attr.Type {
  431. case nl.TCA_FQ_CODEL_TARGET:
  432. fqCodel.Target = native.Uint32(datum.Value)
  433. case nl.TCA_FQ_CODEL_LIMIT:
  434. fqCodel.Limit = native.Uint32(datum.Value)
  435. case nl.TCA_FQ_CODEL_INTERVAL:
  436. fqCodel.Interval = native.Uint32(datum.Value)
  437. case nl.TCA_FQ_CODEL_ECN:
  438. fqCodel.ECN = native.Uint32(datum.Value)
  439. case nl.TCA_FQ_CODEL_FLOWS:
  440. fqCodel.Flows = native.Uint32(datum.Value)
  441. case nl.TCA_FQ_CODEL_QUANTUM:
  442. fqCodel.Quantum = native.Uint32(datum.Value)
  443. }
  444. }
  445. return nil
  446. }
  447. func parseHfscData(qdisc Qdisc, data []byte) error {
  448. Hfsc := qdisc.(*Hfsc)
  449. native = nl.NativeEndian()
  450. Hfsc.Defcls = native.Uint16(data)
  451. return nil
  452. }
  453. func parseFqData(qdisc Qdisc, data []syscall.NetlinkRouteAttr) error {
  454. native = nl.NativeEndian()
  455. fq := qdisc.(*Fq)
  456. for _, datum := range data {
  457. switch datum.Attr.Type {
  458. case nl.TCA_FQ_BUCKETS_LOG:
  459. fq.Buckets = native.Uint32(datum.Value)
  460. case nl.TCA_FQ_LOW_RATE_THRESHOLD:
  461. fq.LowRateThreshold = native.Uint32(datum.Value)
  462. case nl.TCA_FQ_QUANTUM:
  463. fq.Quantum = native.Uint32(datum.Value)
  464. case nl.TCA_FQ_RATE_ENABLE:
  465. fq.Pacing = native.Uint32(datum.Value)
  466. case nl.TCA_FQ_INITIAL_QUANTUM:
  467. fq.InitialQuantum = native.Uint32(datum.Value)
  468. case nl.TCA_FQ_ORPHAN_MASK:
  469. // TODO
  470. case nl.TCA_FQ_FLOW_REFILL_DELAY:
  471. fq.FlowRefillDelay = native.Uint32(datum.Value)
  472. case nl.TCA_FQ_FLOW_PLIMIT:
  473. fq.FlowPacketLimit = native.Uint32(datum.Value)
  474. case nl.TCA_FQ_PLIMIT:
  475. fq.PacketLimit = native.Uint32(datum.Value)
  476. case nl.TCA_FQ_FLOW_MAX_RATE:
  477. fq.FlowMaxRate = native.Uint32(datum.Value)
  478. case nl.TCA_FQ_FLOW_DEFAULT_RATE:
  479. fq.FlowDefaultRate = native.Uint32(datum.Value)
  480. }
  481. }
  482. return nil
  483. }
  484. func parseNetemData(qdisc Qdisc, value []byte) error {
  485. netem := qdisc.(*Netem)
  486. opt := nl.DeserializeTcNetemQopt(value)
  487. netem.Latency = opt.Latency
  488. netem.Limit = opt.Limit
  489. netem.Loss = opt.Loss
  490. netem.Gap = opt.Gap
  491. netem.Duplicate = opt.Duplicate
  492. netem.Jitter = opt.Jitter
  493. data, err := nl.ParseRouteAttr(value[nl.SizeofTcNetemQopt:])
  494. if err != nil {
  495. return err
  496. }
  497. for _, datum := range data {
  498. switch datum.Attr.Type {
  499. case nl.TCA_NETEM_CORR:
  500. opt := nl.DeserializeTcNetemCorr(datum.Value)
  501. netem.DelayCorr = opt.DelayCorr
  502. netem.LossCorr = opt.LossCorr
  503. netem.DuplicateCorr = opt.DupCorr
  504. case nl.TCA_NETEM_CORRUPT:
  505. opt := nl.DeserializeTcNetemCorrupt(datum.Value)
  506. netem.CorruptProb = opt.Probability
  507. netem.CorruptCorr = opt.Correlation
  508. case nl.TCA_NETEM_REORDER:
  509. opt := nl.DeserializeTcNetemReorder(datum.Value)
  510. netem.ReorderProb = opt.Probability
  511. netem.ReorderCorr = opt.Correlation
  512. }
  513. }
  514. return nil
  515. }
  516. func parseTbfData(qdisc Qdisc, data []syscall.NetlinkRouteAttr) error {
  517. native = nl.NativeEndian()
  518. tbf := qdisc.(*Tbf)
  519. for _, datum := range data {
  520. switch datum.Attr.Type {
  521. case nl.TCA_TBF_PARMS:
  522. opt := nl.DeserializeTcTbfQopt(datum.Value)
  523. tbf.Rate = uint64(opt.Rate.Rate)
  524. tbf.Peakrate = uint64(opt.Peakrate.Rate)
  525. tbf.Limit = opt.Limit
  526. tbf.Buffer = opt.Buffer
  527. case nl.TCA_TBF_RATE64:
  528. tbf.Rate = native.Uint64(datum.Value[0:8])
  529. case nl.TCA_TBF_PRATE64:
  530. tbf.Peakrate = native.Uint64(datum.Value[0:8])
  531. case nl.TCA_TBF_PBURST:
  532. tbf.Minburst = native.Uint32(datum.Value[0:4])
  533. }
  534. }
  535. return nil
  536. }
  537. const (
  538. TIME_UNITS_PER_SEC = 1000000
  539. )
  540. var (
  541. tickInUsec float64
  542. clockFactor float64
  543. hz float64
  544. )
  545. func initClock() {
  546. data, err := ioutil.ReadFile("/proc/net/psched")
  547. if err != nil {
  548. return
  549. }
  550. parts := strings.Split(strings.TrimSpace(string(data)), " ")
  551. if len(parts) < 3 {
  552. return
  553. }
  554. var vals [3]uint64
  555. for i := range vals {
  556. val, err := strconv.ParseUint(parts[i], 16, 32)
  557. if err != nil {
  558. return
  559. }
  560. vals[i] = val
  561. }
  562. // compatibility
  563. if vals[2] == 1000000000 {
  564. vals[0] = vals[1]
  565. }
  566. clockFactor = float64(vals[2]) / TIME_UNITS_PER_SEC
  567. tickInUsec = float64(vals[0]) / float64(vals[1]) * clockFactor
  568. hz = float64(vals[0])
  569. }
  570. func TickInUsec() float64 {
  571. if tickInUsec == 0.0 {
  572. initClock()
  573. }
  574. return tickInUsec
  575. }
  576. func ClockFactor() float64 {
  577. if clockFactor == 0.0 {
  578. initClock()
  579. }
  580. return clockFactor
  581. }
  582. func Hz() float64 {
  583. if hz == 0.0 {
  584. initClock()
  585. }
  586. return hz
  587. }
  588. func time2Tick(time uint32) uint32 {
  589. return uint32(float64(time) * TickInUsec())
  590. }
  591. func tick2Time(tick uint32) uint32 {
  592. return uint32(float64(tick) / TickInUsec())
  593. }
  594. func time2Ktime(time uint32) uint32 {
  595. return uint32(float64(time) * ClockFactor())
  596. }
  597. func ktime2Time(ktime uint32) uint32 {
  598. return uint32(float64(ktime) / ClockFactor())
  599. }
  600. func burst(rate uint64, buffer uint32) uint32 {
  601. return uint32(float64(rate) * float64(tick2Time(buffer)) / TIME_UNITS_PER_SEC)
  602. }
  603. func latency(rate uint64, limit, buffer uint32) float64 {
  604. return TIME_UNITS_PER_SEC*(float64(limit)/float64(rate)) - float64(tick2Time(buffer))
  605. }
  606. func Xmittime(rate uint64, size uint32) float64 {
  607. return TickInUsec() * TIME_UNITS_PER_SEC * (float64(size) / float64(rate))
  608. }