summaryrefslogtreecommitdiffstats
path: root/vpp-classifier/api/src/main/yang/policer.yang
blob: 6379671289a54c1ffd86ab990b59218a95dec0c2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
module policer {

    yang-version 1;
    namespace "urn:opendaylight:params:xml:ns:yang:policer";
    prefix "policer";

    description
        "VPP specific configuration of policer messages. Mapped to policer API:
         https://git.fd.io/vpp/tree/src/vnet/policer/policer.api

         Partially based on
         https://tools.ietf.org/html/draft-asechoud-netmod-qos-model-02";

    reference
        "https://docs.fd.io/vpp/17.04/clicmd_src_vnet_policer.html";

    revision "2017-03-15" {
        description "Initial revision of policer model";
    }

    import ietf-inet-types {
      prefix inet;
    }

    typedef policer-ref {
        type leafref {
            path "/policers/policer/name";
        }
        description
            "This type is used by data models that need to reference
            configured policer.";
    }

    typedef color-classfier {
        type enumeration {
            enum conform-color;
            enum exceed-color;
        }
        default conform-color;
    }

    typedef meter-type {
        type enumeration {
            enum 1r2c;
            enum 1r3c;
            enum 2r3c-2698;
            enum 2r3c-4115;
            enum 2r3c-mef5cf1;
        }
        default 1r2c;
    }

    typedef policer-round-type {
        type enumeration {
            enum closest;
            enum up;
            enum down;
        }
        default closest;
    }

    typedef policer-rate-type {
        type enumeration {
            enum kbps;
            enum pps;
        }
        default kbps;
    }

    // adapted from draft-asechoud-netmod-qos-model-02
    identity meter-action-type {
      description
        "action type in a meter";
    }

    identity meter-action-drop {
      base meter-action-type;
      description
        "drop action type in a meter";
    }

    identity meter-action-mark-dscp {
      base meter-action-type;
      description
        "dscp mark and transmit action type in a meter";
    }

    identity meter-action-transmit {
      base meter-action-type;
      description
        "transmit action type in a meter";
    }

    typedef vpp-dscp-type {
        description
            "DSCP field values supported by VPP";
        type enumeration {
            enum CS0 {
                value 0;
            }
            enum CS1 {
                value 8;
            }
            enum AF11 {
                value 10;
            }
            enum AF12 {
                value 12;
            }
            enum AF13 {
                value 14;
            }
            enum CS2 {
                value 16;
            }
            enum AF21 {
                value 18;
            }
            enum AF22 {
                value 20;
            }
            enum AF23 {
                value 22;
            }
            enum CS3 {
                value 24;
            }
            enum AF31 {
                value 26;
            }
            enum AF32 {
                value 28;
            }
            enum AF33 {
                value 30;
            }
            enum CS4 {
                value 32;
            }
            enum AF41 {
                value 34;
            }
            enum AF42 {
                value 36;
            }
            enum AF43 {
                value 38;
            }
            enum CS5 {
                value 40;
            }
            enum EF {
                value 46;
            }
            enum CS6 {
                value 48;
            }
            enum CS7 {
                value 50;
            }
        }
        default CS0;
    }

    typedef dscp-type {
        type union {
            type vpp-dscp-type;
            type inet:dscp;
        }
    }

    grouping meter-action-params {
      description
        "meter action parameters";
      leaf meter-action-type {
        mandatory true;
        type identityref {
          base meter-action-type;
        }
        description
          "meter action type";
      }
      leaf dscp {
        when "../meter-action-type = meter-action-mark-dscp";
        type dscp-type;
        description
          "dscp marking";
      }
    }

    grouping policer-base-attributes {
        leaf cir {
            type uint32;
        }
        leaf eir {
            type uint32;
        }
        leaf cb {
            type uint64;
            description "Committed Burst";
        }
        leaf eb {
            type uint64;
            description "Excess or Peak Bursnatt";
        }
        leaf rate-type {
            type policer-rate-type;
        }
        leaf round-type {
            type policer-round-type;
        }
        leaf type {
            type meter-type;
            description "policer algorithm";
        }
        leaf color-aware {
            type boolean;
        }
        container conform-action {
            presence "Defines conform action";
            uses meter-action-params;
        }
        container exceed-action {
            presence "Defines exceed action";
            uses meter-action-params;
        }
        container violate-action {
            presence "Defines violate action";
            uses meter-action-params;
        }
    }

    grouping policer-operational-attributes {
        leaf single-rate {
            type boolean;
        }
        leaf scale {
            type uint32;
        }
        leaf cir-tokens-per-period {
            type uint32;
        }
        leaf pir_tokens-per-period {
            type uint32;
        }
        leaf current-limit {
            type uint32;
        }
        leaf current-bucket {
            type uint32;
        }
        leaf extended-limit {
            type uint32;
        }
        leaf extended-bucket {
            type uint32;
        }
        leaf last-update-time {
            type uint64;
        }
    }

    container policers {
        list policer {
            key name;
            leaf name {
                type string {
                    length 1..63;
                }
            }
            uses policer-base-attributes;
        }
    }

    container policers-state {
        list policer {
            key name;
            leaf name {
                type string {
                    length 1..63;
                }
            }
            uses policer-base-attributes;
            uses policer-operational-attributes;
        }
    }
}