Gitiles
Code Review Sign In
gerrit.opencord.org / voltha / 353af1266839cdf6cb76b20e6c26fac849f0e8a7 / . / netopeer / voltha-transapi / voltha.yang
blob: 78642daafc4080eb9b066aa1bc01597a21763e07 [file] [log] [blame]
Zack Williams41513bf2018-07-07 20:08:35 -0700[diff] [blame]1/*
2 * Copyright 2017-present Open Networking Foundation
3
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7
8 * http://www.apache.org/licenses/LICENSE-2.0
9
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Stephane Barbarie14088962017-06-01 16:56:55 -0400[diff] [blame]16
17module voltha {
18
19
20
21
22
23 namespace "urn:opencord:params:xml:ns:voltha:voltha";
24 prefix voltha;
25
26 organization "CORD";
27 contact
28 " Any name";
29
30 description
31 "";
32
33 revision "2016-11-15" {
34 description "Initial revision.";
35 reference "reference";
36 }
37
38
39 grouping DeviceGroup {
40 description
41 "";
42 leaf id {
43 type string;
44 description
45 "";
46 }
47
48 list logical_devices {
49 key "id";
50 uses LogicalDevice;
51
52 description
53 "";
54 }
55
56 list devices {
57 key "id";
58 uses Device;
59
60 description
61 "";
62 }
63
64
65
66 }
67
68 grouping DeviceGroups {
69 description
70 "";
71 list items {
72 key "id";
73 uses DeviceGroup;
74
75 description
76 "";
77 }
78
79
80
81 }
82
83 typedef AlarmFilterRuleKey {
84 type enumeration {
85 enum id {
86 description "";
87 }
88 enum type {
89 description "";
90 }
91 enum severity {
92 description "";
93 }
94 enum resource_id {
95 description "";
96 }
97 enum category {
98 description "";
99 }
100 enum device_id {
101 description "";
102 }
103 }
104 description
105 "";
106 }
107
108 grouping AlarmFilterRule {
109 description
110 "";
111 leaf key {
112 type AlarmFilterRuleKey;
113
114 description
115 "";
116 }
117
118 leaf value {
119 type string;
120 description
121 "";
122 }
123
124
125
126 }
127
128 grouping AlarmFilter {
129 description
130 "";
131 leaf id {
132 type string;
133 description
134 "";
135 }
136
137 list rules {
138 key "key";
139 uses AlarmFilterRule;
140
141 description
142 "";
143 }
144
145
146
147 }
148
149 grouping AlarmFilters {
150 description
151 "";
152 list filters {
153 key "id";
154 uses AlarmFilter;
155
156 description
157 "";
158 }
159
160
161
162 }
163
164 container VolthaInstance {
165 description
166 "Top-level (root) node for a Voltha Instance";
167 leaf instance_id {
168 type string;
169 description
170 "";
171 }
172
173 leaf version {
174 type string;
175 description
176 "";
177 }
178
179 leaf log_level {
180 type LogLevel;
181
182 description
183 "";
184 }
185
186 container health {
187 uses HealthStatus;
188
189 description
190 "";
191 }
192
193 list adapters {
194 key "id";
195 uses Adapter;
196
197 description
198 "";
199 }
200
201 list logical_devices {
202 key "id";
203 uses LogicalDevice;
204
205 description
206 "";
207 }
208
209 list devices {
210 key "id";
211 uses Device;
212
213 description
214 "";
215 }
216
217 list device_types {
218 key "id";
219 uses DeviceType;
220
221 description
222 "";
223 }
224
225 list device_groups {
226 key "id";
227 uses DeviceGroup;
228
229 description
230 "";
231 }
232
233 list alarm_filters {
234 key "id";
235 uses AlarmFilter;
236
237 description
238 "";
239 }
240
241
242
243 }
244
245 container VolthaInstances {
246 description
247 "";
248 list items {
249 key "items";
250 leaf items {
251 type string;
252 description
253 "";
254 }
255 description
256 "";
257 }
258
259
260
261 }
262
263 container Voltha {
264 description
265 "Voltha representing the entire Voltha cluster";
266 leaf version {
267 type string;
268 description
269 "";
270 }
271
272 leaf log_level {
273 type LogLevel;
274
275 description
276 "";
277 }
278
279 list instances {
280 key "instance_id";
281 uses VolthaInstance_grouping;
282 description
283 "";
284 }
285
286 list adapters {
287 key "id";
288 uses Adapter;
289
290 description
291 "";
292 }
293
294 list logical_devices {
295 key "id";
296 uses LogicalDevice;
297
298 description
299 "";
300 }
301
302 list devices {
303 key "id";
304 uses Device;
305
306 description
307 "";
308 }
309
310 list device_groups {
311 key "id";
312 uses DeviceGroup;
313
314 description
315 "";
316 }
317
318
319
320 }
321
322 grouping VolthaInstance_grouping {
323 description
324 "Top-level (root) node for a Voltha Instance";
325 leaf instance_id {
326 type string;
327 description
328 "";
329 }
330
331 leaf version {
332 type string;
333 description
334 "";
335 }
336
337 leaf log_level {
338 type LogLevel;
339
340 description
341 "";
342 }
343
344 container health {
345 uses HealthStatus;
346
347 description
348 "";
349 }
350
351 list adapters {
352 key "id";
353 uses Adapter;
354
355 description
356 "";
357 }
358
359 list logical_devices {
360 key "id";
361 uses LogicalDevice;
362
363 description
364 "";
365 }
366
367 list devices {
368 key "id";
369 uses Device;
370
371 description
372 "";
373 }
374
375 list device_types {
376 key "id";
377 uses DeviceType;
378
379 description
380 "";
381 }
382
383 list device_groups {
384 key "id";
385 uses DeviceGroup;
386
387 description
388 "";
389 }
390
391 list alarm_filters {
392 key "id";
393 uses AlarmFilter;
394
395 description
396 "";
397 }
398
399
400
401 }
402
403 grouping VolthaInstances_grouping {
404 description
405 "";
406 list items {
407 key "items";
408 leaf items {
409 type string;
410 description
411 "";
412 }
413 description
414 "";
415 }
416
417
418
419 }
420
421 grouping Voltha_grouping {
422 description
423 "Voltha representing the entire Voltha cluster";
424 leaf version {
425 type string;
426 description
427 "";
428 }
429
430 leaf log_level {
431 type LogLevel;
432
433 description
434 "";
435 }
436
437 list instances {
438 key "instance_id";
439 uses VolthaInstance_grouping;
440 description
441 "";
442 }
443
444 list adapters {
445 key "id";
446 uses Adapter;
447
448 description
449 "";
450 }
451
452 list logical_devices {
453 key "id";
454 uses LogicalDevice;
455
456 description
457 "";
458 }
459
460 list devices {
461 key "id";
462 uses Device;
463
464 description
465 "";
466 }
467
468 list device_groups {
469 key "id";
470 uses DeviceGroup;
471
472 description
473 "";
474 }
475
476
477
478 }
479
480 grouping AdapterConfig {
481 description
482 "";
483 leaf log_level {
484 type LogLevel;
485
486 description
487 "Common adapter config attributes here";
488 }
489
490 container additional_config {
491 uses Any;
492
493 description
494 "Custom (vendor-specific) configuration attributes";
495 }
496
497
498
499 }
500
501 grouping Adapter {
502 description
503 "Adapter (software plugin)";
504 leaf id {
505 type string;
506 description
507 "Unique name of adapter, matching the python packate name under
508 voltha adapters.";
509 }
510
511 leaf vendor {
512 type string;
513 description
514 "";
515 }
516
517 leaf version {
518 type string;
519 description
520 "";
521 }
522
523 container config {
524 uses AdapterConfig;
525
526 description
527 "Adapter configuration";
528 }
529
530 container additional_description {
531 uses Any;
532
533 description
534 "Custom descriptors and custom configuration";
535 }
536
537 list logical_device_ids {
538 key "logical_device_ids";
539 leaf logical_device_ids {
540 type string;
541 description
542 "Logical devices owned ";
543 }
544 description
545 "Logical devices owned ";
546 }
547
548
549
550 }
551
552 grouping Adapters {
553 description
554 "";
555 list items {
556 key "id";
557 uses Adapter;
558
559 description
560 "";
561 }
562
563
564
565 }
566
567 grouping Any {
568 description
569 "`Any` contains an arbitrary serialized protocol buffer message along with a
570 URL that describes the type of the serialized message.
571
572 Protobuf library provides support to pack unpack Any values in the form
573 of utility functions or additional generated methods of the Any type.
574
575 Example 1: Pack and unpack a message in C++.
576
577 Foo foo = ...;
578 Any any;
579 any.PackFrom(foo);
580 ...
581 if (any.UnpackTo(&foo))
582 ...
583
584
585 Example 2: Pack and unpack a message in Java.
586
587 Foo foo = ...;
588 Any any = Any.pack(foo);
589 ...
590 if (any.is(Foo.class))
591 foo = any.unpack(Foo.class);
592
593
594 Example 3: Pack and unpack a message in Python.
595
596 foo = Foo(...)
597 any = Any()
598 any.Pack(foo)
599 ...
600 if any.Is(Foo.DESCRIPTOR):
601 any.Unpack(foo)
602 ...
603
604 The pack methods provided by protobuf library will by default use
605 'type.googleapis.com full.type.name' as the type URL and the unpack
606 methods only use the fully qualified type name after the last ' '
607 in the type URL, for example foo.bar.com x y.z will yield type
608 name y.z .
609
610
611 JSON
612 ====
613 The JSON representation of an `Any` value uses the regular
614 representation of the deserialized, embedded message, with an
615 additional field `@type` which contains the type URL. Example:
616
617 package google.profile;
618 message Person
619 string first_name = 1;
620 string last_name = 2;
621
622
623
624 @type : type.googleapis.com google.profile.Person ,
625 firstName : string ,
626 lastName : string
627
628
629 If the embedded message type is well-known and has a custom JSON
630 representation, that representation will be embedded adding a field
631 `value` which holds the custom JSON in addition to the `@type`
632 field. Example (for message google.protobuf.Duration ):
633
634
635 @type : type.googleapis.com google.protobuf.Duration ,
636 value : 1.212s
637 ";
638 leaf type_url {
639 type string;
640 description
641 "A URL resource name whose content describes the type of the
642 serialized protocol buffer message.
643
644 For URLs which use the scheme `http`, `https`, or no scheme, the
645 following restrictions and interpretations apply:
646
647 If no scheme is provided, `https` is assumed.
648 The last segment of the URL's path must represent the fully
649 qualified name of the type (as in `path google.protobuf.Duration`).
650 The name should be in a canonical form (e.g., leading . is
651 not accepted).
652 An HTTP GET on the URL must yield a google.protobuf.Type
653 value in binary format, or produce an error.
654 Applications are allowed to cache lookup results based on the
655 URL, or have them precompiled into a binary to avoid any
656 lookup. Therefore, binary compatibility needs to be preserved
657 on changes to types. (Use versioned type names to manage
658 breaking changes.)
659
660 Schemes other than `http`, `https` (or the empty scheme) might be
661 used with implementation specific semantics.";
662 }
663
664 leaf value {
665 type binary;
666 description
667 "Must be a valid serialized protocol buffer of the above specified type.";
668 }
669
670
671
672 }
673
674 typedef LogLevel {
675 type enumeration {
676 enum DEBUG {
677 description "";
678 }
679 enum INFO {
680 description "";
681 }
682 enum WARNING {
683 description "";
684 }
685 enum ERROR {
686 description "";
687 }
688 enum CRITICAL {
689 description "";
690 }
691 }
692 description
693 "Logging verbosity level";
694 }
695 typedef AdminState {
696 type enumeration {
697 enum UNKNOWN {
698 description "";
699 }
700 enum PREPROVISIONED {
701 description "";
702 }
703 enum ENABLED {
704 description "";
705 }
706 enum DISABLED {
707 description "";
708 }
709 }
710 description
711 "Administrative State";
712 }
713 typedef OperStatus {
714 type enumeration {
715 enum UNKNOWN {
716 description "";
717 }
718 enum DISCOVERED {
719 description "";
720 }
721 enum ACTIVATING {
722 description "";
723 }
724 enum TESTING {
725 description "";
726 }
727 enum ACTIVE {
728 description "";
729 }
730 enum FAILED {
731 description "";
732 }
733 }
734 description
735 "Operational Status";
736 }
737 typedef ConnectStatus {
738 type enumeration {
739 enum UNKNOWN {
740 description "";
741 }
742 enum UNREACHABLE {
743 description "";
744 }
745 enum REACHABLE {
746 description "";
747 }
748 }
749 description
750 "Connectivity Status";
751 }
752
753 grouping ID {
754 description
755 "Convey a resource identifier";
756 leaf id {
757 type string;
758 description
759 "";
760 }
761
762
763
764 }
765
766 typedef PortType {
767 type enumeration {
768 enum UNKNOWN {
769 description "";
770 }
771 enum ETHERNET_NNI {
772 description "";
773 }
774 enum ETHERNET_UNI {
775 description "";
776 }
777 enum PON_OLT {
778 description "";
779 }
780 enum PON_ONU {
781 description "";
782 }
783 }
784 description
785 "";
786 }
787
788 grouping DeviceType {
789 description
790 "A Device Type";
791 leaf id {
792 type string;
793 description
794 "Unique name for the device type";
795 }
796
797 leaf adapter {
798 type string;
799 description
800 "Name of the adapter that handles device type";
801 }
802
803 leaf accepts_bulk_flow_update {
804 type boolean;
805 description
806 "Capabilitities";
807 }
808
809 leaf accepts_add_remove_flow_updates {
810 type boolean;
811 description
812 "";
813 }
814
815
816
817 }
818
819 grouping DeviceTypes {
820 description
821 "A plurality of device types";
822 list items {
823 key "id";
824 uses DeviceType;
825
826 description
827 "";
828 }
829
830
831
832 }
833
834 grouping PmConfig {
835 description
836 "";
837 leaf name {
838 type string;
839 description
840 "";
841 }
842
843 leaf type {
844 type PmType;
845 description
846 "";
847 }
848
849 leaf enabled {
850 type boolean;
851 description
852 "Whether or not this metric makes it to Kafka";
853 }
854
855 leaf sample_freq {
856 type uint32;
857 description
858 "Sample rate in 10ths of a second";
859 }
860
861
862
863 typedef PmType {
864 type enumeration {
865 enum COUNTER {
866 description "";
867 }
868 enum GUAGE {
869 description "";
870 }
871 enum STATE {
872 description "";
873 }
874 }
875 description
876 "";
877 }
878
879 }
880
881 grouping PmGroupConfig {
882 description
883 "";
884 leaf group_name {
885 type string;
886 description
887 "";
888 }
889
890 leaf group_freq {
891 type uint32;
892 description
893 "Frequency applicable to the grop";
894 }
895
896 leaf enabled {
897 type boolean;
898 description
899 "Enable disable group level only";
900 }
901
902 list metrics {
903 key "name";
904 uses PmConfig;
905
906 description
907 "";
908 }
909
910
911
912 }
913
914 grouping PmConfigs {
915 description
916 "";
917 leaf id {
918 type string;
919 description
920 "To work around a chameleon POST bug";
921 }
922
923 leaf default_freq {
924 type uint32;
925 description
926 "Default sample rate";
927 }
928
929 leaf grouped {
930 type boolean;
931 description
932 "Forces group names and group semantics";
933 }
934
935 leaf freq_override {
936 type boolean;
937 description
938 "Allows Pm to set an individual sample frequency";
939 }
940
941 list groups {
942 key "group_name";
943 uses PmGroupConfig;
944
945 description
946 "The groups if grouped is true";
947 }
948
949 list metrics {
950 key "name";
951 uses PmConfig;
952
953 description
954 "The metrics themselves if grouped is false.";
955 }
956
957
958
959 }
960
961 grouping PeerPort {
962 description
963 "";
964 leaf device_id {
965 type string;
966 description
967 "";
968 }
969
970 leaf port_no {
971 type uint32;
972 description
973 "";
974 }
975
976
977
978 }
979
980 grouping Port {
981 description
982 "";
983 leaf port_no {
984 type uint32;
985 description
986 "Device-unique port number";
987 }
988
989 leaf label {
990 type string;
991 description
992 "Arbitrary port label";
993 }
994
995 leaf type {
996 type PortType;
997 description
998 "Type of port";
999 }
1000
1001 leaf admin_state {
1002 type AdminState;
1003
1004 description
1005 "";
1006 }
1007
1008 leaf oper_status {
1009 type OperStatus;
1010
1011 description
1012 "";
1013 }
1014
1015 leaf device_id {
1016 type string;
1017 description
1018 "Unique .id of device that owns this port";
1019 }
1020
1021 list peers {
1022 key "device_id";
1023 uses PeerPort;
1024 description
1025 "";
1026 }
1027
1028
1029
1030 }
1031
1032 grouping Ports {
1033 description
1034 "";
1035 list items {
1036 key "port_no";
1037 uses Port;
1038
1039 description
1040 "";
1041 }
1042
1043
1044
1045 }
1046
1047 grouping ProxyAddress {
1048 description
1049 "";
1050 leaf device_id {
1051 type string;
1052 description
1053 "Which device to use as proxy to this device";
1054 }
1055
1056 leaf channel_id {
1057 type uint32;
1058 description
1059 "Sub-address within proxy";
1060 }
1061
1062 leaf onu_id {
1063 type uint32;
1064 description
1065 "onu identifier; optional";
1066 }
1067
1068 leaf onu_session_id {
1069 type uint32;
1070 description
1071 "session identifier for the ONU; optional";
1072 }
1073
1074
1075
1076 }
1077
1078 grouping Device {
1079 description
1080 "A Physical Device instance";
1081 leaf id {
1082 type string;
1083 description
1084 "Voltha's device identifier";
1085 }
1086
1087 leaf type {
1088 type string;
1089 description
1090 "Device type, refers to one of the registered device types";
1091 }
1092
1093 leaf root {
1094 type boolean;
1095 description
1096 "Is this device a root device. Each logical switch has one root
1097 device that is associated with the logical flow switch.";
1098 }
1099
1100 leaf parent_id {
1101 type string;
1102 description
1103 "Parent device id, in the device tree (for a root device, the parent_id
1104 is the logical_device.id)";
1105 }
1106
1107 leaf parent_port_no {
1108 type uint32;
1109 description
1110 "";
1111 }
1112
1113 leaf vendor {
1114 type string;
1115 description
1116 "Vendor, version, serial number, etc.";
1117 }
1118
1119 leaf model {
1120 type string;
1121 description
1122 "";
1123 }
1124
1125 leaf hardware_version {
1126 type string;
1127 description
1128 "";
1129 }
1130
1131 leaf firmware_version {
1132 type string;
1133 description
1134 "";
1135 }
1136
1137 leaf software_version {
1138 type string;
1139 description
1140 "";
1141 }
1142
1143 leaf serial_number {
1144 type string;
1145 description
1146 "";
1147 }
1148
1149 leaf adapter {
1150 type string;
1151 description
1152 "Addapter that takes care of device";
1153 }
1154
1155 leaf vlan {
1156 type uint32;
1157 description
1158 "Device contact on vlan (if 0, no vlan)";
1159 }
1160
1161 container proxy_address {
1162 uses ProxyAddress;
1163 description
1164 "";
1165 }
1166
1167 leaf admin_state {
1168 type AdminState;
1169
1170 description
1171 "";
1172 }
1173
1174 leaf oper_status {
1175 type OperStatus;
1176
1177 description
1178 "";
1179 }
1180
1181 leaf reason {
1182 type string;
1183 description
1184 "Used in FAILED state";
1185 }
1186
1187 leaf connect_status {
1188 type ConnectStatus;
1189
1190 description
1191 "";
1192 }
1193
1194 container custom {
1195 uses Any;
1196
1197 description
1198 "Device type specific attributes
1199TODO additional common attribute here";
1200 }
1201
1202 list ports {
1203 key "port_no";
1204 uses Port;
1205
1206 description
1207 "";
1208 }
1209
1210 container flows {
1211 uses Flows;
1212
1213 description
1214 "";
1215 }
1216
1217 container flow_groups {
1218 uses FlowGroups;
1219
1220 description
1221 "";
1222 }
1223
1224 container pm_configs {
1225 uses PmConfigs;
1226
1227 description
1228 "PmConfigs will eventually converted to a child node of the
1229 device to falicitata callbacks and to simplify manipulation.";
1230 }
1231
1232
1233
1234 choice choice_0 {
1235 case mac_address {
1236 leaf mac_address {
1237 type string;
1238 description
1239 "Device contact MAC address (format: xx:xx:xx:xx:xx:xx )";
1240 }
1241 }
1242 case ipv4_address {
1243 leaf ipv4_address {
1244 type string;
1245 description
1246 "Device contact IPv4 address (format: a.b.c.d or can use hostname too)";
1247 }
1248 }
1249 case ipv6_address {
1250 leaf ipv6_address {
1251 type string;
1252 description
1253 "Device contact IPv6 address using the canonical string form
1254 ( xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx )";
1255 }
1256 }
1257 case host_and_port {
1258 leaf host_and_port {
1259 type string;
1260 description
1261 "";
1262 }
1263 }
1264 }
1265
1266
1267 }
1268
1269 grouping Devices {
1270 description
1271 "";
1272 list items {
1273 key "id";
1274 uses Device;
1275
1276 description
1277 "";
1278 }
1279
1280
1281
1282 }
1283
1284
1285 grouping Empty {
1286 description
1287 "A generic empty message that you can re-use to avoid defining duplicated
1288 empty messages in your APIs. A typical example is to use it as the request
1289 or the response type of an API method. For instance:
1290
1291 service Foo
1292 rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
1293
1294
1295 The JSON representation for `Empty` is empty JSON object ` `.";
1296
1297
1298 }
1299
1300
1301 grouping HealthStatus {
1302 description
1303 "Encode health status of a Voltha instance";
1304 leaf state {
1305 type HealthState;
1306 description
1307 "Current state of health of this Voltha instance";
1308 }
1309
1310
1311
1312 typedef HealthState {
1313 type enumeration {
1314 enum HEALTHY {
1315 description "";
1316 }
1317 enum OVERLOADED {
1318 description "";
1319 }
1320 enum DYING {
1321 description "";
1322 }
1323 }
1324 description
1325 "Health states";
1326 }
1327
1328 }
1329
1330 grouping LogicalPort {
1331 description
1332 "";
1333 leaf id {
1334 type string;
1335 description
1336 "";
1337 }
1338
1339 container ofp_port {
1340 uses ofp_port;
1341
1342 description
1343 "";
1344 }
1345
1346 leaf device_id {
1347 type string;
1348 description
1349 "";
1350 }
1351
1352 leaf device_port_no {
1353 type uint32;
1354 description
1355 "";
1356 }
1357
1358 leaf root_port {
1359 type boolean;
1360 description
1361 "";
1362 }
1363
1364
1365
1366 }
1367
1368 grouping LogicalPorts {
1369 description
1370 "";
1371 list items {
1372 key "id";
1373 uses LogicalPort;
1374
1375 description
1376 "";
1377 }
1378
1379
1380
1381 }
1382
1383 grouping LogicalDevice {
1384 description
1385 "";
1386 leaf id {
1387 type string;
1388 description
1389 "unique id of logical device";
1390 }
1391
1392 leaf datapath_id {
1393 type uint64;
1394 description
1395 "unique datapath id for the logical device (used by the SDN controller)";
1396 }
1397
1398 container desc {
1399 uses ofp_desc;
1400
1401 description
1402 "device description";
1403 }
1404
1405 container switch_features {
1406 uses ofp_switch_features;
1407
1408 description
1409 "device features";
1410 }
1411
1412 leaf root_device_id {
1413 type string;
1414 description
1415 "name of the root device anchoring logical device";
1416 }
1417
1418 list ports {
1419 key "id";
1420 uses LogicalPort;
1421
1422 description
1423 "logical device ports";
1424 }
1425
1426 container flows {
1427 uses Flows;
1428
1429 description
1430 "flows configured on the logical device";
1431 }
1432
1433 container flow_groups {
1434 uses FlowGroups;
1435
1436 description
1437 "flow groups configured on the logical device";
1438 }
1439
1440
1441
1442 }
1443
1444 grouping LogicalDevices {
1445 description
1446 "";
1447 list items {
1448 key "id";
1449 uses LogicalDevice;
1450
1451 description
1452 "";
1453 }
1454
1455
1456
1457 }
1458
1459
1460 typedef Access {
1461 type enumeration {
1462 enum CONFIG {
1463 description "";
1464 }
1465 enum READ_ONLY {
1466 description "";
1467 }
1468 enum REAL_TIME {
1469 description "";
1470 }
1471 }
1472 description
1473 "";
1474 }
1475
1476 container ChildNode {
1477 description
1478 "";
1479 leaf key {
1480 type string;
1481 description
1482 "";
1483 }
1484
1485
1486
1487 }
1488
1489 typedef ofp_port_no {
1490 type enumeration {
1491 enum OFPP_INVALID {
1492 description "";
1493 }
1494 enum OFPP_MAX {
1495 description "";
1496 }
1497 enum OFPP_IN_PORT {
1498 description "";
1499 }
1500 enum OFPP_TABLE {
1501 description "";
1502 }
1503 enum OFPP_NORMAL {
1504 description "";
1505 }
1506 enum OFPP_FLOOD {
1507 description "";
1508 }
1509 enum OFPP_ALL {
1510 description "";
1511 }
1512 enum OFPP_CONTROLLER {
1513 description "";
1514 }
1515 enum OFPP_LOCAL {
1516 description "";
1517 }
1518 enum OFPP_ANY {
1519 description "";
1520 }
1521 }
1522 description
1523 "Port numbering. Ports are numbered starting from 1.Version number:
1524 OpenFlow versions released: 0x01 = 1.0 ; 0x02 = 1.1 ; 0x03 = 1.2
1525 0x04 = 1.3
1526The most significant bit in the version field is reserved and must
1527 be set to zero.
1528#define OFP_VERSION 0x04
1529#define PIPELINE_TABLES 64
1530#define OFP_MAX_TABLE_NAME_LEN 32
1531#define OFP_MAX_PORT_NAME_LEN 16
1532Official IANA registered port for OpenFlow.#define OFP_TCP_PORT 6653
1533#define OFP_SSL_PORT 6653
1534#define OFP_ETH_ALEN 6 Bytes in an Ethernet address. ";
1535 }
1536 typedef ofp_type {
1537 type enumeration {
1538 enum OFPT_HELLO {
1539 description "";
1540 }
1541 enum OFPT_ERROR {
1542 description "";
1543 }
1544 enum OFPT_ECHO_REQUEST {
1545 description "";
1546 }
1547 enum OFPT_ECHO_REPLY {
1548 description "";
1549 }
1550 enum OFPT_EXPERIMENTER {
1551 description "";
1552 }
1553 enum OFPT_FEATURES_REQUEST {
1554 description "";
1555 }
1556 enum OFPT_FEATURES_REPLY {
1557 description "";
1558 }
1559 enum OFPT_GET_CONFIG_REQUEST {
1560 description "";
1561 }
1562 enum OFPT_GET_CONFIG_REPLY {
1563 description "";
1564 }
1565 enum OFPT_SET_CONFIG {
1566 description "";
1567 }
1568 enum OFPT_PACKET_IN {
1569 description "";
1570 }
1571 enum OFPT_FLOW_REMOVED {
1572 description "";
1573 }
1574 enum OFPT_PORT_STATUS {
1575 description "";
1576 }
1577 enum OFPT_PACKET_OUT {
1578 description "";
1579 }
1580 enum OFPT_FLOW_MOD {
1581 description "";
1582 }
1583 enum OFPT_GROUP_MOD {
1584 description "";
1585 }
1586 enum OFPT_PORT_MOD {
1587 description "";
1588 }
1589 enum OFPT_TABLE_MOD {
1590 description "";
1591 }
1592 enum OFPT_MULTIPART_REQUEST {
1593 description "";
1594 }
1595 enum OFPT_MULTIPART_REPLY {
1596 description "";
1597 }
1598 enum OFPT_BARRIER_REQUEST {
1599 description "";
1600 }
1601 enum OFPT_BARRIER_REPLY {
1602 description "";
1603 }
1604 enum OFPT_QUEUE_GET_CONFIG_REQUEST {
1605 description "";
1606 }
1607 enum OFPT_QUEUE_GET_CONFIG_REPLY {
1608 description "";
1609 }
1610 enum OFPT_ROLE_REQUEST {
1611 description "";
1612 }
1613 enum OFPT_ROLE_REPLY {
1614 description "";
1615 }
1616 enum OFPT_GET_ASYNC_REQUEST {
1617 description "";
1618 }
1619 enum OFPT_GET_ASYNC_REPLY {
1620 description "";
1621 }
1622 enum OFPT_SET_ASYNC {
1623 description "";
1624 }
1625 enum OFPT_METER_MOD {
1626 description "";
1627 }
1628 }
1629 description
1630 "";
1631 }
1632 typedef ofp_hello_elem_type {
1633 type enumeration {
1634 enum OFPHET_INVALID {
1635 description "";
1636 }
1637 enum OFPHET_VERSIONBITMAP {
1638 description "";
1639 }
1640 }
1641 description
1642 "Hello elements types.";
1643 }
1644 typedef ofp_config_flags {
1645 type enumeration {
1646 enum OFPC_FRAG_NORMAL {
1647 description "";
1648 }
1649 enum OFPC_FRAG_DROP {
1650 description "";
1651 }
1652 enum OFPC_FRAG_REASM {
1653 description "";
1654 }
1655 enum OFPC_FRAG_MASK {
1656 description "";
1657 }
1658 }
1659 description
1660 "#define OFP_DEFAULT_MISS_SEND_LEN 128";
1661 }
1662 typedef ofp_table_config {
1663 type enumeration {
1664 enum OFPTC_INVALID {
1665 description "";
1666 }
1667 enum OFPTC_DEPRECATED_MASK {
1668 description "";
1669 }
1670 }
1671 description
1672 "Flags to configure the table. Reserved for future use.";
1673 }
1674 typedef ofp_table {
1675 type enumeration {
1676 enum OFPTT_INVALID {
1677 description "";
1678 }
1679 enum OFPTT_MAX {
1680 description "";
1681 }
1682 enum OFPTT_ALL {
1683 description "";
1684 }
1685 }
1686 description
1687 "Table numbering. Tables can use any number up to OFPT_MAX.";
1688 }
1689 typedef ofp_capabilities {
1690 type enumeration {
1691 enum OFPC_INVALID {
1692 description "";
1693 }
1694 enum OFPC_FLOW_STATS {
1695 description "";
1696 }
1697 enum OFPC_TABLE_STATS {
1698 description "";
1699 }
1700 enum OFPC_PORT_STATS {
1701 description "";
1702 }
1703 enum OFPC_GROUP_STATS {
1704 description "";
1705 }
1706 enum OFPC_IP_REASM {
1707 description "";
1708 }
1709 enum OFPC_QUEUE_STATS {
1710 description "";
1711 }
1712 enum OFPC_PORT_BLOCKED {
1713 description "";
1714 }
1715 }
1716 description
1717 "Capabilities supported by the datapath.";
1718 }
1719 typedef ofp_port_config {
1720 type enumeration {
1721 enum OFPPC_INVALID {
1722 description "";
1723 }
1724 enum OFPPC_PORT_DOWN {
1725 description "";
1726 }
1727 enum OFPPC_NO_RECV {
1728 description "";
1729 }
1730 enum OFPPC_NO_FWD {
1731 description "";
1732 }
1733 enum OFPPC_NO_PACKET_IN {
1734 description "";
1735 }
1736 }
1737 description
1738 "Flags to indicate behavior of the physical port. These flags are
1739 used in ofp_port to describe the current configuration. They are
1740 used in the ofp_port_mod message to configure the port's behavior.";
1741 }
1742 typedef ofp_port_state {
1743 type enumeration {
1744 enum OFPPS_INVALID {
1745 description "";
1746 }
1747 enum OFPPS_LINK_DOWN {
1748 description "";
1749 }
1750 enum OFPPS_BLOCKED {
1751 description "";
1752 }
1753 enum OFPPS_LIVE {
1754 description "";
1755 }
1756 }
1757 description
1758 "Current state of the physical port. These are not configurable from
1759 the controller.";
1760 }
1761 typedef ofp_port_features {
1762 type enumeration {
1763 enum OFPPF_INVALID {
1764 description "";
1765 }
1766 enum OFPPF_10MB_HD {
1767 description "";
1768 }
1769 enum OFPPF_10MB_FD {
1770 description "";
1771 }
1772 enum OFPPF_100MB_HD {
1773 description "";
1774 }
1775 enum OFPPF_100MB_FD {
1776 description "";
1777 }
1778 enum OFPPF_1GB_HD {
1779 description "";
1780 }
1781 enum OFPPF_1GB_FD {
1782 description "";
1783 }
1784 enum OFPPF_10GB_FD {
1785 description "";
1786 }
1787 enum OFPPF_40GB_FD {
1788 description "";
1789 }
1790 enum OFPPF_100GB_FD {
1791 description "";
1792 }
1793 enum OFPPF_1TB_FD {
1794 description "";
1795 }
1796 enum OFPPF_OTHER {
1797 description "";
1798 }
1799 enum OFPPF_COPPER {
1800 description "";
1801 }
1802 enum OFPPF_FIBER {
1803 description "";
1804 }
1805 enum OFPPF_AUTONEG {
1806 description "";
1807 }
1808 enum OFPPF_PAUSE {
1809 description "";
1810 }
1811 enum OFPPF_PAUSE_ASYM {
1812 description "";
1813 }
1814 }
1815 description
1816 "Features of ports available in a datapath.";
1817 }
1818 typedef ofp_port_reason {
1819 type enumeration {
1820 enum OFPPR_ADD {
1821 description "";
1822 }
1823 enum OFPPR_DELETE {
1824 description "";
1825 }
1826 enum OFPPR_MODIFY {
1827 description "";
1828 }
1829 }
1830 description
1831 "What changed about the physical port";
1832 }
1833 typedef ofp_match_type {
1834 type enumeration {
1835 enum OFPMT_STANDARD {
1836 description "";
1837 }
1838 enum OFPMT_OXM {
1839 description "";
1840 }
1841 }
1842 description
1843 "The match type indicates the match structure (set of fields that compose the
1844 match) in use. The match type is placed in the type field at the beginning
1845 of all match structures. The OpenFlow Extensible Match type corresponds
1846 to OXM TLV format described below and must be supported by all OpenFlow
1847 switches. Extensions that define other match types may be published on the
1848 ONF wiki. Support for extensions is optional.
1849## -------------------------- #### OpenFlow Extensible Match. #### -------------------------- ##";
1850 }
1851 typedef ofp_oxm_class {
1852 type enumeration {
1853 enum OFPXMC_NXM_0 {
1854 description "";
1855 }
1856 enum OFPXMC_NXM_1 {
1857 description "";
1858 }
1859 enum OFPXMC_OPENFLOW_BASIC {
1860 description "";
1861 }
1862 enum OFPXMC_EXPERIMENTER {
1863 description "";
1864 }
1865 }
1866 description
1867 "OXM Class IDs.
1868 The high order bit differentiate reserved classes from member classes.
1869 Classes 0x0000 to 0x7FFF are member classes, allocated by ONF.
1870 Classes 0x8000 to 0xFFFE are reserved classes, reserved for standardisation.
1871Components of a OXM TLV header.
1872 Those macros are not valid for the experimenter class, macros for the
1873 experimenter class will depend on the experimenter header used.#define OXM_HEADER__(CLASS, FIELD, HASMASK, LENGTH)
1874 (((CLASS) 16) | ((FIELD) 9) | ((HASMASK) 8) | (LENGTH))
1875#define OXM_HEADER(CLASS, FIELD, LENGTH)
1876 OXM_HEADER__(CLASS, FIELD, 0, LENGTH)
1877#define OXM_HEADER_W(CLASS, FIELD, LENGTH)
1878 OXM_HEADER__(CLASS, FIELD, 1, (LENGTH) 2)
1879#define OXM_CLASS(HEADER) ((HEADER) 16)
1880#define OXM_FIELD(HEADER) (((HEADER) 9) & 0x7f)
1881#define OXM_TYPE(HEADER) (((HEADER) 9) & 0x7fffff)
1882#define OXM_HASMASK(HEADER) (((HEADER) 8) & 1)
1883#define OXM_LENGTH(HEADER) ((HEADER) & 0xff)
1884
1885#define OXM_MAKE_WILD_HEADER(HEADER)
1886 OXM_HEADER_W(OXM_CLASS(HEADER), OXM_FIELD(HEADER), OXM_LENGTH(HEADER))";
1887 }
1888 typedef oxm_ofb_field_types {
1889 type enumeration {
1890 enum OFPXMT_OFB_IN_PORT {
1891 description "";
1892 }
1893 enum OFPXMT_OFB_IN_PHY_PORT {
1894 description "";
1895 }
1896 enum OFPXMT_OFB_METADATA {
1897 description "";
1898 }
1899 enum OFPXMT_OFB_ETH_DST {
1900 description "";
1901 }
1902 enum OFPXMT_OFB_ETH_SRC {
1903 description "";
1904 }
1905 enum OFPXMT_OFB_ETH_TYPE {
1906 description "";
1907 }
1908 enum OFPXMT_OFB_VLAN_VID {
1909 description "";
1910 }
1911 enum OFPXMT_OFB_VLAN_PCP {
1912 description "";
1913 }
1914 enum OFPXMT_OFB_IP_DSCP {
1915 description "";
1916 }
1917 enum OFPXMT_OFB_IP_ECN {
1918 description "";
1919 }
1920 enum OFPXMT_OFB_IP_PROTO {
1921 description "";
1922 }
1923 enum OFPXMT_OFB_IPV4_SRC {
1924 description "";
1925 }
1926 enum OFPXMT_OFB_IPV4_DST {
1927 description "";
1928 }
1929 enum OFPXMT_OFB_TCP_SRC {
1930 description "";
1931 }
1932 enum OFPXMT_OFB_TCP_DST {
1933 description "";
1934 }
1935 enum OFPXMT_OFB_UDP_SRC {
1936 description "";
1937 }
1938 enum OFPXMT_OFB_UDP_DST {
1939 description "";
1940 }
1941 enum OFPXMT_OFB_SCTP_SRC {
1942 description "";
1943 }
1944 enum OFPXMT_OFB_SCTP_DST {
1945 description "";
1946 }
1947 enum OFPXMT_OFB_ICMPV4_TYPE {
1948 description "";
1949 }
1950 enum OFPXMT_OFB_ICMPV4_CODE {
1951 description "";
1952 }
1953 enum OFPXMT_OFB_ARP_OP {
1954 description "";
1955 }
1956 enum OFPXMT_OFB_ARP_SPA {
1957 description "";
1958 }
1959 enum OFPXMT_OFB_ARP_TPA {
1960 description "";
1961 }
1962 enum OFPXMT_OFB_ARP_SHA {
1963 description "";
1964 }
1965 enum OFPXMT_OFB_ARP_THA {
1966 description "";
1967 }
1968 enum OFPXMT_OFB_IPV6_SRC {
1969 description "";
1970 }
1971 enum OFPXMT_OFB_IPV6_DST {
1972 description "";
1973 }
1974 enum OFPXMT_OFB_IPV6_FLABEL {
1975 description "";
1976 }
1977 enum OFPXMT_OFB_ICMPV6_TYPE {
1978 description "";
1979 }
1980 enum OFPXMT_OFB_ICMPV6_CODE {
1981 description "";
1982 }
1983 enum OFPXMT_OFB_IPV6_ND_TARGET {
1984 description "";
1985 }
1986 enum OFPXMT_OFB_IPV6_ND_SLL {
1987 description "";
1988 }
1989 enum OFPXMT_OFB_IPV6_ND_TLL {
1990 description "";
1991 }
1992 enum OFPXMT_OFB_MPLS_LABEL {
1993 description "";
1994 }
1995 enum OFPXMT_OFB_MPLS_TC {
1996 description "";
1997 }
1998 enum OFPXMT_OFB_MPLS_BOS {
1999 description "";
2000 }
2001 enum OFPXMT_OFB_PBB_ISID {
2002 description "";
2003 }
2004 enum OFPXMT_OFB_TUNNEL_ID {
2005 description "";
2006 }
2007 enum OFPXMT_OFB_IPV6_EXTHDR {
2008 description "";
2009 }
2010 }
2011 description
2012 "OXM Flow field types for OpenFlow basic class.";
2013 }
2014 typedef ofp_vlan_id {
2015 type enumeration {
2016 enum OFPVID_NONE {
2017 description "";
2018 }
2019 enum OFPVID_PRESENT {
2020 description "";
2021 }
2022 }
2023 description
2024 "The VLAN id is 12-bits, so we can use the entire 16 bits to indicate
2025 special conditions.";
2026 }
2027 typedef ofp_ipv6exthdr_flags {
2028 type enumeration {
2029 enum OFPIEH_INVALID {
2030 description "";
2031 }
2032 enum OFPIEH_NONEXT {
2033 description "";
2034 }
2035 enum OFPIEH_ESP {
2036 description "";
2037 }
2038 enum OFPIEH_AUTH {
2039 description "";
2040 }
2041 enum OFPIEH_DEST {
2042 description "";
2043 }
2044 enum OFPIEH_FRAG {
2045 description "";
2046 }
2047 enum OFPIEH_ROUTER {
2048 description "";
2049 }
2050 enum OFPIEH_HOP {
2051 description "";
2052 }
2053 enum OFPIEH_UNREP {
2054 description "";
2055 }
2056 enum OFPIEH_UNSEQ {
2057 description "";
2058 }
2059 }
2060 description
2061 "Bit definitions for IPv6 Extension Header pseudo-field.#define OFP_VLAN_NONE OFPVID_NONE";
2062 }
2063 typedef ofp_action_type {
2064 type enumeration {
2065 enum OFPAT_OUTPUT {
2066 description "";
2067 }
2068 enum OFPAT_COPY_TTL_OUT {
2069 description "";
2070 }
2071 enum OFPAT_COPY_TTL_IN {
2072 description "";
2073 }
2074 enum OFPAT_SET_MPLS_TTL {
2075 description "";
2076 }
2077 enum OFPAT_DEC_MPLS_TTL {
2078 description "";
2079 }
2080 enum OFPAT_PUSH_VLAN {
2081 description "";
2082 }
2083 enum OFPAT_POP_VLAN {
2084 description "";
2085 }
2086 enum OFPAT_PUSH_MPLS {
2087 description "";
2088 }
2089 enum OFPAT_POP_MPLS {
2090 description "";
2091 }
2092 enum OFPAT_SET_QUEUE {
2093 description "";
2094 }
2095 enum OFPAT_GROUP {
2096 description "";
2097 }
2098 enum OFPAT_SET_NW_TTL {
2099 description "";
2100 }
2101 enum OFPAT_DEC_NW_TTL {
2102 description "";
2103 }
2104 enum OFPAT_SET_FIELD {
2105 description "";
2106 }
2107 enum OFPAT_PUSH_PBB {
2108 description "";
2109 }
2110 enum OFPAT_POP_PBB {
2111 description "";
2112 }
2113 enum OFPAT_EXPERIMENTER {
2114 description "";
2115 }
2116 }
2117 description
2118 "## ----------------- #### OpenFlow Actions. #### ----------------- ##";
2119 }
2120 typedef ofp_controller_max_len {
2121 type enumeration {
2122 enum OFPCML_INVALID {
2123 description "";
2124 }
2125 enum OFPCML_MAX {
2126 description "";
2127 }
2128 enum OFPCML_NO_BUFFER {
2129 description "";
2130 }
2131 }
2132 description
2133 "";
2134 }
2135 typedef ofp_instruction_type {
2136 type enumeration {
2137 enum OFPIT_INVALID {
2138 description "";
2139 }
2140 enum OFPIT_GOTO_TABLE {
2141 description "";
2142 }
2143 enum OFPIT_WRITE_METADATA {
2144 description "";
2145 }
2146 enum OFPIT_WRITE_ACTIONS {
2147 description "";
2148 }
2149 enum OFPIT_APPLY_ACTIONS {
2150 description "";
2151 }
2152 enum OFPIT_CLEAR_ACTIONS {
2153 description "";
2154 }
2155 enum OFPIT_METER {
2156 description "";
2157 }
2158 enum OFPIT_EXPERIMENTER {
2159 description "";
2160 }
2161 }
2162 description
2163 "## ---------------------- #### OpenFlow Instructions. #### ---------------------- ##";
2164 }
2165 typedef ofp_flow_mod_command {
2166 type enumeration {
2167 enum OFPFC_ADD {
2168 description "";
2169 }
2170 enum OFPFC_MODIFY {
2171 description "";
2172 }
2173 enum OFPFC_MODIFY_STRICT {
2174 description "";
2175 }
2176 enum OFPFC_DELETE {
2177 description "";
2178 }
2179 enum OFPFC_DELETE_STRICT {
2180 description "";
2181 }
2182 }
2183 description
2184 "## --------------------------- #### OpenFlow Flow Modification. #### --------------------------- ##";
2185 }
2186 typedef ofp_flow_mod_flags {
2187 type enumeration {
2188 enum OFPFF_INVALID {
2189 description "";
2190 }
2191 enum OFPFF_SEND_FLOW_REM {
2192 description "";
2193 }
2194 enum OFPFF_CHECK_OVERLAP {
2195 description "";
2196 }
2197 enum OFPFF_RESET_COUNTS {
2198 description "";
2199 }
2200 enum OFPFF_NO_PKT_COUNTS {
2201 description "";
2202 }
2203 enum OFPFF_NO_BYT_COUNTS {
2204 description "";
2205 }
2206 }
2207 description
2208 "Value used in idle_timeout and hard_timeout to indicate that the entry
2209 is permanent.#define OFP_FLOW_PERMANENT 0
2210By default, choose a priority in the middle.#define OFP_DEFAULT_PRIORITY 0x8000";
2211 }
2212 typedef ofp_group {
2213 type enumeration {
2214 enum OFPG_INVALID {
2215 description "";
2216 }
2217 enum OFPG_MAX {
2218 description "";
2219 }
2220 enum OFPG_ALL {
2221 description "";
2222 }
2223 enum OFPG_ANY {
2224 description "";
2225 }
2226 }
2227 description
2228 "Group numbering. Groups can use any number up to OFPG_MAX.";
2229 }
2230 typedef ofp_group_mod_command {
2231 type enumeration {
2232 enum OFPGC_ADD {
2233 description "";
2234 }
2235 enum OFPGC_MODIFY {
2236 description "";
2237 }
2238 enum OFPGC_DELETE {
2239 description "";
2240 }
2241 }
2242 description
2243 "Group commands";
2244 }
2245 typedef ofp_group_type {
2246 type enumeration {
2247 enum OFPGT_ALL {
2248 description "";
2249 }
2250 enum OFPGT_SELECT {
2251 description "";
2252 }
2253 enum OFPGT_INDIRECT {
2254 description "";
2255 }
2256 enum OFPGT_FF {
2257 description "";
2258 }
2259 }
2260 description
2261 "Group types. Values in the range 128; 255 are reserved for experimental
2262 use.";
2263 }
2264 typedef ofp_packet_in_reason {
2265 type enumeration {
2266 enum OFPR_NO_MATCH {
2267 description "";
2268 }
2269 enum OFPR_ACTION {
2270 description "";
2271 }
2272 enum OFPR_INVALID_TTL {
2273 description "";
2274 }
2275 }
2276 description
2277 "Why is this packet being sent to the controller?";
2278 }
2279 typedef ofp_flow_removed_reason {
2280 type enumeration {
2281 enum OFPRR_IDLE_TIMEOUT {
2282 description "";
2283 }
2284 enum OFPRR_HARD_TIMEOUT {
2285 description "";
2286 }
2287 enum OFPRR_DELETE {
2288 description "";
2289 }
2290 enum OFPRR_GROUP_DELETE {
2291 description "";
2292 }
2293 enum OFPRR_METER_DELETE {
2294 description "";
2295 }
2296 }
2297 description
2298 "Why was this flow removed?";
2299 }
2300 typedef ofp_meter {
2301 type enumeration {
2302 enum OFPM_ZERO {
2303 description "";
2304 }
2305 enum OFPM_MAX {
2306 description "";
2307 }
2308 enum OFPM_SLOWPATH {
2309 description "";
2310 }
2311 enum OFPM_CONTROLLER {
2312 description "";
2313 }
2314 enum OFPM_ALL {
2315 description "";
2316 }
2317 }
2318 description
2319 "Meter numbering. Flow meters can use any number up to OFPM_MAX.";
2320 }
2321 typedef ofp_meter_band_type {
2322 type enumeration {
2323 enum OFPMBT_INVALID {
2324 description "";
2325 }
2326 enum OFPMBT_DROP {
2327 description "";
2328 }
2329 enum OFPMBT_DSCP_REMARK {
2330 description "";
2331 }
2332 enum OFPMBT_EXPERIMENTER {
2333 description "";
2334 }
2335 }
2336 description
2337 "Meter band types";
2338 }
2339 typedef ofp_meter_mod_command {
2340 type enumeration {
2341 enum OFPMC_ADD {
2342 description "";
2343 }
2344 enum OFPMC_MODIFY {
2345 description "";
2346 }
2347 enum OFPMC_DELETE {
2348 description "";
2349 }
2350 }
2351 description
2352 "Meter commands";
2353 }
2354 typedef ofp_meter_flags {
2355 type enumeration {
2356 enum OFPMF_INVALID {
2357 description "";
2358 }
2359 enum OFPMF_KBPS {
2360 description "";
2361 }
2362 enum OFPMF_PKTPS {
2363 description "";
2364 }
2365 enum OFPMF_BURST {
2366 description "";
2367 }
2368 enum OFPMF_STATS {
2369 description "";
2370 }
2371 }
2372 description
2373 "Meter configuration flags";
2374 }
2375 typedef ofp_error_type {
2376 type enumeration {
2377 enum OFPET_HELLO_FAILED {
2378 description "";
2379 }
2380 enum OFPET_BAD_REQUEST {
2381 description "";
2382 }
2383 enum OFPET_BAD_ACTION {
2384 description "";
2385 }
2386 enum OFPET_BAD_INSTRUCTION {
2387 description "";
2388 }
2389 enum OFPET_BAD_MATCH {
2390 description "";
2391 }
2392 enum OFPET_FLOW_MOD_FAILED {
2393 description "";
2394 }
2395 enum OFPET_GROUP_MOD_FAILED {
2396 description "";
2397 }
2398 enum OFPET_PORT_MOD_FAILED {
2399 description "";
2400 }
2401 enum OFPET_TABLE_MOD_FAILED {
2402 description "";
2403 }
2404 enum OFPET_QUEUE_OP_FAILED {
2405 description "";
2406 }
2407 enum OFPET_SWITCH_CONFIG_FAILED {
2408 description "";
2409 }
2410 enum OFPET_ROLE_REQUEST_FAILED {
2411 description "";
2412 }
2413 enum OFPET_METER_MOD_FAILED {
2414 description "";
2415 }
2416 enum OFPET_TABLE_FEATURES_FAILED {
2417 description "";
2418 }
2419 enum OFPET_EXPERIMENTER {
2420 description "";
2421 }
2422 }
2423 description
2424 "Values for 'type' in ofp_error_message. These values are immutable: they
2425 will not change in future versions of the protocol (although new values may
2426 be added).";
2427 }
2428 typedef ofp_hello_failed_code {
2429 type enumeration {
2430 enum OFPHFC_INCOMPATIBLE {
2431 description "";
2432 }
2433 enum OFPHFC_EPERM {
2434 description "";
2435 }
2436 }
2437 description
2438 "ofp_error_msg 'code' values for OFPET_HELLO_FAILED. 'data' contains an
2439 ASCII text string that may give failure details.";
2440 }
2441 typedef ofp_bad_request_code {
2442 type enumeration {
2443 enum OFPBRC_BAD_VERSION {
2444 description "";
2445 }
2446 enum OFPBRC_BAD_TYPE {
2447 description "";
2448 }
2449 enum OFPBRC_BAD_MULTIPART {
2450 description "";
2451 }
2452 enum OFPBRC_BAD_EXPERIMENTER {
2453 description "";
2454 }
2455 enum OFPBRC_BAD_EXP_TYPE {
2456 description "";
2457 }
2458 enum OFPBRC_EPERM {
2459 description "";
2460 }
2461 enum OFPBRC_BAD_LEN {
2462 description "";
2463 }
2464 enum OFPBRC_BUFFER_EMPTY {
2465 description "";
2466 }
2467 enum OFPBRC_BUFFER_UNKNOWN {
2468 description "";
2469 }
2470 enum OFPBRC_BAD_TABLE_ID {
2471 description "";
2472 }
2473 enum OFPBRC_IS_SLAVE {
2474 description "";
2475 }
2476 enum OFPBRC_BAD_PORT {
2477 description "";
2478 }
2479 enum OFPBRC_BAD_PACKET {
2480 description "";
2481 }
2482 enum OFPBRC_MULTIPART_BUFFER_OVERFLOW {
2483 description "";
2484 }
2485 }
2486 description
2487 "ofp_error_msg 'code' values for OFPET_BAD_REQUEST. 'data' contains at least
2488 the first 64 bytes of the failed request.";
2489 }
2490 typedef ofp_bad_action_code {
2491 type enumeration {
2492 enum OFPBAC_BAD_TYPE {
2493 description "";
2494 }
2495 enum OFPBAC_BAD_LEN {
2496 description "";
2497 }
2498 enum OFPBAC_BAD_EXPERIMENTER {
2499 description "";
2500 }
2501 enum OFPBAC_BAD_EXP_TYPE {
2502 description "";
2503 }
2504 enum OFPBAC_BAD_OUT_PORT {
2505 description "";
2506 }
2507 enum OFPBAC_BAD_ARGUMENT {
2508 description "";
2509 }
2510 enum OFPBAC_EPERM {
2511 description "";
2512 }
2513 enum OFPBAC_TOO_MANY {
2514 description "";
2515 }
2516 enum OFPBAC_BAD_QUEUE {
2517 description "";
2518 }
2519 enum OFPBAC_BAD_OUT_GROUP {
2520 description "";
2521 }
2522 enum OFPBAC_MATCH_INCONSISTENT {
2523 description "";
2524 }
2525 enum OFPBAC_UNSUPPORTED_ORDER {
2526 description "";
2527 }
2528 enum OFPBAC_BAD_TAG {
2529 description "";
2530 }
2531 enum OFPBAC_BAD_SET_TYPE {
2532 description "";
2533 }
2534 enum OFPBAC_BAD_SET_LEN {
2535 description "";
2536 }
2537 enum OFPBAC_BAD_SET_ARGUMENT {
2538 description "";
2539 }
2540 }
2541 description
2542 "ofp_error_msg 'code' values for OFPET_BAD_ACTION. 'data' contains at least
2543 the first 64 bytes of the failed request.";
2544 }
2545 typedef ofp_bad_instruction_code {
2546 type enumeration {
2547 enum OFPBIC_UNKNOWN_INST {
2548 description "";
2549 }
2550 enum OFPBIC_UNSUP_INST {
2551 description "";
2552 }
2553 enum OFPBIC_BAD_TABLE_ID {
2554 description "";
2555 }
2556 enum OFPBIC_UNSUP_METADATA {
2557 description "";
2558 }
2559 enum OFPBIC_UNSUP_METADATA_MASK {
2560 description "";
2561 }
2562 enum OFPBIC_BAD_EXPERIMENTER {
2563 description "";
2564 }
2565 enum OFPBIC_BAD_EXP_TYPE {
2566 description "";
2567 }
2568 enum OFPBIC_BAD_LEN {
2569 description "";
2570 }
2571 enum OFPBIC_EPERM {
2572 description "";
2573 }
2574 }
2575 description
2576 "ofp_error_msg 'code' values for OFPET_BAD_INSTRUCTION. 'data' contains at
2577 least the first 64 bytes of the failed request.";
2578 }
2579 typedef ofp_bad_match_code {
2580 type enumeration {
2581 enum OFPBMC_BAD_TYPE {
2582 description "";
2583 }
2584 enum OFPBMC_BAD_LEN {
2585 description "";
2586 }
2587 enum OFPBMC_BAD_TAG {
2588 description "";
2589 }
2590 enum OFPBMC_BAD_DL_ADDR_MASK {
2591 description "";
2592 }
2593 enum OFPBMC_BAD_NW_ADDR_MASK {
2594 description "";
2595 }
2596 enum OFPBMC_BAD_WILDCARDS {
2597 description "";
2598 }
2599 enum OFPBMC_BAD_FIELD {
2600 description "";
2601 }
2602 enum OFPBMC_BAD_VALUE {
2603 description "";
2604 }
2605 enum OFPBMC_BAD_MASK {
2606 description "";
2607 }
2608 enum OFPBMC_BAD_PREREQ {
2609 description "";
2610 }
2611 enum OFPBMC_DUP_FIELD {
2612 description "";
2613 }
2614 enum OFPBMC_EPERM {
2615 description "";
2616 }
2617 }
2618 description
2619 "ofp_error_msg 'code' values for OFPET_BAD_MATCH. 'data' contains at least
2620 the first 64 bytes of the failed request.";
2621 }
2622 typedef ofp_flow_mod_failed_code {
2623 type enumeration {
2624 enum OFPFMFC_UNKNOWN {
2625 description "";
2626 }
2627 enum OFPFMFC_TABLE_FULL {
2628 description "";
2629 }
2630 enum OFPFMFC_BAD_TABLE_ID {
2631 description "";
2632 }
2633 enum OFPFMFC_OVERLAP {
2634 description "";
2635 }
2636 enum OFPFMFC_EPERM {
2637 description "";
2638 }
2639 enum OFPFMFC_BAD_TIMEOUT {
2640 description "";
2641 }
2642 enum OFPFMFC_BAD_COMMAND {
2643 description "";
2644 }
2645 enum OFPFMFC_BAD_FLAGS {
2646 description "";
2647 }
2648 }
2649 description
2650 "ofp_error_msg 'code' values for OFPET_FLOW_MOD_FAILED. 'data' contains
2651 at least the first 64 bytes of the failed request.";
2652 }
2653 typedef ofp_group_mod_failed_code {
2654 type enumeration {
2655 enum OFPGMFC_GROUP_EXISTS {
2656 description "";
2657 }
2658 enum OFPGMFC_INVALID_GROUP {
2659 description "";
2660 }
2661 enum OFPGMFC_WEIGHT_UNSUPPORTED {
2662 description "";
2663 }
2664 enum OFPGMFC_OUT_OF_GROUPS {
2665 description "";
2666 }
2667 enum OFPGMFC_OUT_OF_BUCKETS {
2668 description "";
2669 }
2670 enum OFPGMFC_CHAINING_UNSUPPORTED {
2671 description "";
2672 }
2673 enum OFPGMFC_WATCH_UNSUPPORTED {
2674 description "";
2675 }
2676 enum OFPGMFC_LOOP {
2677 description "";
2678 }
2679 enum OFPGMFC_UNKNOWN_GROUP {
2680 description "";
2681 }
2682 enum OFPGMFC_CHAINED_GROUP {
2683 description "";
2684 }
2685 enum OFPGMFC_BAD_TYPE {
2686 description "";
2687 }
2688 enum OFPGMFC_BAD_COMMAND {
2689 description "";
2690 }
2691 enum OFPGMFC_BAD_BUCKET {
2692 description "";
2693 }
2694 enum OFPGMFC_BAD_WATCH {
2695 description "";
2696 }
2697 enum OFPGMFC_EPERM {
2698 description "";
2699 }
2700 }
2701 description
2702 "ofp_error_msg 'code' values for OFPET_GROUP_MOD_FAILED. 'data' contains
2703 at least the first 64 bytes of the failed request.";
2704 }
2705 typedef ofp_port_mod_failed_code {
2706 type enumeration {
2707 enum OFPPMFC_BAD_PORT {
2708 description "";
2709 }
2710 enum OFPPMFC_BAD_HW_ADDR {
2711 description "";
2712 }
2713 enum OFPPMFC_BAD_CONFIG {
2714 description "";
2715 }
2716 enum OFPPMFC_BAD_ADVERTISE {
2717 description "";
2718 }
2719 enum OFPPMFC_EPERM {
2720 description "";
2721 }
2722 }
2723 description
2724 "ofp_error_msg 'code' values for OFPET_PORT_MOD_FAILED. 'data' contains
2725 at least the first 64 bytes of the failed request.";
2726 }
2727 typedef ofp_table_mod_failed_code {
2728 type enumeration {
2729 enum OFPTMFC_BAD_TABLE {
2730 description "";
2731 }
2732 enum OFPTMFC_BAD_CONFIG {
2733 description "";
2734 }
2735 enum OFPTMFC_EPERM {
2736 description "";
2737 }
2738 }
2739 description
2740 "ofp_error_msg 'code' values for OFPET_TABLE_MOD_FAILED. 'data' contains
2741 at least the first 64 bytes of the failed request.";
2742 }
2743 typedef ofp_queue_op_failed_code {
2744 type enumeration {
2745 enum OFPQOFC_BAD_PORT {
2746 description "";
2747 }
2748 enum OFPQOFC_BAD_QUEUE {
2749 description "";
2750 }
2751 enum OFPQOFC_EPERM {
2752 description "";
2753 }
2754 }
2755 description
2756 "ofp_error msg 'code' values for OFPET_QUEUE_OP_FAILED. 'data' contains
2757 at least the first 64 bytes of the failed request";
2758 }
2759 typedef ofp_switch_config_failed_code {
2760 type enumeration {
2761 enum OFPSCFC_BAD_FLAGS {
2762 description "";
2763 }
2764 enum OFPSCFC_BAD_LEN {
2765 description "";
2766 }
2767 enum OFPSCFC_EPERM {
2768 description "";
2769 }
2770 }
2771 description
2772 "ofp_error_msg 'code' values for OFPET_SWITCH_CONFIG_FAILED. 'data' contains
2773 at least the first 64 bytes of the failed request.";
2774 }
2775 typedef ofp_role_request_failed_code {
2776 type enumeration {
2777 enum OFPRRFC_STALE {
2778 description "";
2779 }
2780 enum OFPRRFC_UNSUP {
2781 description "";
2782 }
2783 enum OFPRRFC_BAD_ROLE {
2784 description "";
2785 }
2786 }
2787 description
2788 "ofp_error_msg 'code' values for OFPET_ROLE_REQUEST_FAILED. 'data' contains
2789 at least the first 64 bytes of the failed request.";
2790 }
2791 typedef ofp_meter_mod_failed_code {
2792 type enumeration {
2793 enum OFPMMFC_UNKNOWN {
2794 description "";
2795 }
2796 enum OFPMMFC_METER_EXISTS {
2797 description "";
2798 }
2799 enum OFPMMFC_INVALID_METER {
2800 description "";
2801 }
2802 enum OFPMMFC_UNKNOWN_METER {
2803 description "";
2804 }
2805 enum OFPMMFC_BAD_COMMAND {
2806 description "";
2807 }
2808 enum OFPMMFC_BAD_FLAGS {
2809 description "";
2810 }
2811 enum OFPMMFC_BAD_RATE {
2812 description "";
2813 }
2814 enum OFPMMFC_BAD_BURST {
2815 description "";
2816 }
2817 enum OFPMMFC_BAD_BAND {
2818 description "";
2819 }
2820 enum OFPMMFC_BAD_BAND_VALUE {
2821 description "";
2822 }
2823 enum OFPMMFC_OUT_OF_METERS {
2824 description "";
2825 }
2826 enum OFPMMFC_OUT_OF_BANDS {
2827 description "";
2828 }
2829 }
2830 description
2831 "ofp_error_msg 'code' values for OFPET_METER_MOD_FAILED. 'data' contains
2832 at least the first 64 bytes of the failed request.";
2833 }
2834 typedef ofp_table_features_failed_code {
2835 type enumeration {
2836 enum OFPTFFC_BAD_TABLE {
2837 description "";
2838 }
2839 enum OFPTFFC_BAD_METADATA {
2840 description "";
2841 }
2842 enum OFPTFFC_BAD_TYPE {
2843 description "";
2844 }
2845 enum OFPTFFC_BAD_LEN {
2846 description "";
2847 }
2848 enum OFPTFFC_BAD_ARGUMENT {
2849 description "";
2850 }
2851 enum OFPTFFC_EPERM {
2852 description "";
2853 }
2854 }
2855 description
2856 "ofp_error_msg 'code' values for OFPET_TABLE_FEATURES_FAILED. 'data' contains
2857 at least the first 64 bytes of the failed request.";
2858 }
2859 typedef ofp_multipart_type {
2860 type enumeration {
2861 enum OFPMP_DESC {
2862 description "";
2863 }
2864 enum OFPMP_FLOW {
2865 description "";
2866 }
2867 enum OFPMP_AGGREGATE {
2868 description "";
2869 }
2870 enum OFPMP_TABLE {
2871 description "";
2872 }
2873 enum OFPMP_PORT_STATS {
2874 description "";
2875 }
2876 enum OFPMP_QUEUE {
2877 description "";
2878 }
2879 enum OFPMP_GROUP {
2880 description "";
2881 }
2882 enum OFPMP_GROUP_DESC {
2883 description "";
2884 }
2885 enum OFPMP_GROUP_FEATURES {
2886 description "";
2887 }
2888 enum OFPMP_METER {
2889 description "";
2890 }
2891 enum OFPMP_METER_CONFIG {
2892 description "";
2893 }
2894 enum OFPMP_METER_FEATURES {
2895 description "";
2896 }
2897 enum OFPMP_TABLE_FEATURES {
2898 description "";
2899 }
2900 enum OFPMP_PORT_DESC {
2901 description "";
2902 }
2903 enum OFPMP_EXPERIMENTER {
2904 description "";
2905 }
2906 }
2907 description
2908 "";
2909 }
2910 typedef ofp_multipart_request_flags {
2911 type enumeration {
2912 enum OFPMPF_REQ_INVALID {
2913 description "";
2914 }
2915 enum OFPMPF_REQ_MORE {
2916 description "";
2917 }
2918 }
2919 description
2920 "Backward compatibility with 1.3.1 - avoid breaking the API.#define ofp_multipart_types ofp_multipart_type";
2921 }
2922 typedef ofp_multipart_reply_flags {
2923 type enumeration {
2924 enum OFPMPF_REPLY_INVALID {
2925 description "";
2926 }
2927 enum OFPMPF_REPLY_MORE {
2928 description "";
2929 }
2930 }
2931 description
2932 "";
2933 }
2934 typedef ofp_table_feature_prop_type {
2935 type enumeration {
2936 enum OFPTFPT_INSTRUCTIONS {
2937 description "";
2938 }
2939 enum OFPTFPT_INSTRUCTIONS_MISS {
2940 description "";
2941 }
2942 enum OFPTFPT_NEXT_TABLES {
2943 description "";
2944 }
2945 enum OFPTFPT_NEXT_TABLES_MISS {
2946 description "";
2947 }
2948 enum OFPTFPT_WRITE_ACTIONS {
2949 description "";
2950 }
2951 enum OFPTFPT_WRITE_ACTIONS_MISS {
2952 description "";
2953 }
2954 enum OFPTFPT_APPLY_ACTIONS {
2955 description "";
2956 }
2957 enum OFPTFPT_APPLY_ACTIONS_MISS {
2958 description "";
2959 }
2960 enum OFPTFPT_MATCH {
2961 description "";
2962 }
2963 enum OFPTFPT_WILDCARDS {
2964 description "";
2965 }
2966 enum OFPTFPT_WRITE_SETFIELD {
2967 description "";
2968 }
2969 enum OFPTFPT_WRITE_SETFIELD_MISS {
2970 description "";
2971 }
2972 enum OFPTFPT_APPLY_SETFIELD {
2973 description "";
2974 }
2975 enum OFPTFPT_APPLY_SETFIELD_MISS {
2976 description "";
2977 }
2978 enum OFPTFPT_EXPERIMENTER {
2979 description "";
2980 }
2981 enum OFPTFPT_EXPERIMENTER_MISS {
2982 description "";
2983 }
2984 }
2985 description
2986 "Table Feature property types.
2987 Low order bit cleared indicates a property for a regular Flow Entry.
2988 Low order bit set indicates a property for the Table-Miss Flow Entry.";
2989 }
2990 typedef ofp_group_capabilities {
2991 type enumeration {
2992 enum OFPGFC_INVALID {
2993 description "";
2994 }
2995 enum OFPGFC_SELECT_WEIGHT {
2996 description "";
2997 }
2998 enum OFPGFC_SELECT_LIVENESS {
2999 description "";
3000 }
3001 enum OFPGFC_CHAINING {
3002 description "";
3003 }
3004 enum OFPGFC_CHAINING_CHECKS {
3005 description "";
3006 }
3007 }
3008 description
3009 "Group configuration flagsBackward compatibility with 1.3.1 - avoid breaking the API.#define ofp_group_desc_stats ofp_group_desc";
3010 }
3011 typedef ofp_queue_properties {
3012 type enumeration {
3013 enum OFPQT_INVALID {
3014 description "";
3015 }
3016 enum OFPQT_MIN_RATE {
3017 description "";
3018 }
3019 enum OFPQT_MAX_RATE {
3020 description "";
3021 }
3022 enum OFPQT_EXPERIMENTER {
3023 description "";
3024 }
3025 }
3026 description
3027 "All ones is used to indicate all queues in a port (for stats retrieval).#define OFPQ_ALL 0xffffffff
3028Min rate 1000 means not configured.#define OFPQ_MIN_RATE_UNCFG 0xffff
3029Max rate 1000 means not configured.#define OFPQ_MAX_RATE_UNCFG 0xffff";
3030 }
3031 typedef ofp_controller_role {
3032 type enumeration {
3033 enum OFPCR_ROLE_NOCHANGE {
3034 description "";
3035 }
3036 enum OFPCR_ROLE_EQUAL {
3037 description "";
3038 }
3039 enum OFPCR_ROLE_MASTER {
3040 description "";
3041 }
3042 enum OFPCR_ROLE_SLAVE {
3043 description "";
3044 }
3045 }
3046 description
3047 "Controller roles.Configures the role of the sending controller. The default role is:
3048
3049 - Equal (OFPCR_ROLE_EQUAL), which allows the controller access to all
3050 OpenFlow features. All controllers have equal responsibility.
3051
3052 The other possible roles are a related pair:
3053
3054 - Master (OFPCR_ROLE_MASTER) is equivalent to Equal, except that there
3055 may be at most one Master controller at a time: when a controller
3056 configures itself as Master, any existing Master is demoted to the
3057 Slave role.
3058
3059 - Slave (OFPCR_ROLE_SLAVE) allows the controller read-only access to
3060 OpenFlow features. In particular attempts to modify the flow table
3061 will be rejected with an OFPBRC_EPERM error.
3062
3063 Slave controllers do not receive OFPT_PACKET_IN or OFPT_FLOW_REMOVED
3064 messages, but they do receive OFPT_PORT_STATUS messages.";
3065 }
3066
3067 container ofp_header {
3068 description
3069 "Header on all OpenFlow packets.";
3070 leaf version {
3071 type uint32;
3072 description
3073 "OFP_VERSION.";
3074 }
3075
3076 leaf type {
3077 type ofp_type;
3078
3079 description
3080 "One of the OFPT_ constants.";
3081 }
3082
3083 leaf xid {
3084 type uint32;
3085 description
3086 "Transaction id associated with this packet.
3087Replies use the same id as was in the request
3088to facilitate pairing.";
3089 }
3090
3091
3092
3093 }
3094
3095 grouping ofp_hello_elem_header {
3096 description
3097 "Common header for all Hello Elements";
3098 leaf type {
3099 type ofp_hello_elem_type;
3100
3101 description
3102 "One of OFPHET_ .";
3103 }
3104
3105
3106
3107 choice choice_0 {
3108 case versionbitmap {
3109 container versionbitmap {
3110 uses ofp_hello_elem_versionbitmap;
3111
3112 description
3113 "";
3114 }
3115 }
3116 }
3117
3118
3119 }
3120
3121 grouping ofp_hello_elem_versionbitmap {
3122 description
3123 "Version bitmap Hello Element";
3124 list bitmaps {
3125 key "bitmaps";
3126 leaf bitmaps {
3127 type uint32;
3128 description
3129 "List of bitmaps - supported versions";
3130 }
3131 description
3132 "List of bitmaps - supported versions";
3133 }
3134
3135
3136
3137 }
3138
3139 container ofp_hello {
3140 description
3141 "OFPT_HELLO. This message includes zero or more hello elements having
3142 variable size. Unknown elements types must be ignored skipped, to allow
3143 for future extensions.ofp_header header;";
3144 list elements {
3145 key "type";
3146 uses ofp_hello_elem_header;
3147
3148 description
3149 "Hello element list0 or more";
3150 }
3151
3152
3153
3154 }
3155
3156 container ofp_switch_config {
3157 description
3158 "Switch configuration.";
3159 leaf flags {
3160 type uint32;
3161 description
3162 "ofp_header header;
3163Bitmap of OFPC_ flags.";
3164 }
3165
3166 leaf miss_send_len {
3167 type uint32;
3168 description
3169 "Max bytes of packet that datapath
3170should send to the controller. See
3171ofp_controller_max_len for valid values.";
3172 }
3173
3174
3175
3176 }
3177
3178 container ofp_table_mod {
3179 description
3180 "Configure Modify behavior of a flow table";
3181 leaf table_id {
3182 type uint32;
3183 description
3184 "ofp_header header;
3185ID of the table, OFPTT_ALL indicates all tables";
3186 }
3187
3188 leaf config {
3189 type uint32;
3190 description
3191 "Bitmap of OFPTC_ flags";
3192 }
3193
3194
3195
3196 }
3197
3198 grouping ofp_port {
3199 description
3200 "Description of a port";
3201 leaf port_no {
3202 type uint32;
3203 description
3204 "";
3205 }
3206
3207 list hw_addr {
3208 key "hw_addr";
3209 leaf hw_addr {
3210 type uint32;
3211 description
3212 " OFP_ETH_ALEN ;";
3213 }
3214 description
3215 " OFP_ETH_ALEN ;";
3216 }
3217
3218 leaf name {
3219 type string;
3220 description
3221 "Null-terminated";
3222 }
3223
3224 leaf config {
3225 type uint32;
3226 description
3227 "Bitmap of OFPPC_ flags.";
3228 }
3229
3230 leaf state {
3231 type uint32;
3232 description
3233 "Bitmap of OFPPS_ flags.";
3234 }
3235
3236 leaf curr {
3237 type uint32;
3238 description
3239 "Bitmaps of OFPPF_ that describe features. All bits zeroed if
3240 unsupported or unavailable.Current features.";
3241 }
3242
3243 leaf advertised {
3244 type uint32;
3245 description
3246 "Features being advertised by the port.";
3247 }
3248
3249 leaf supported {
3250 type uint32;
3251 description
3252 "Features supported by the port.";
3253 }
3254
3255 leaf peer {
3256 type uint32;
3257 description
3258 "Features advertised by peer.";
3259 }
3260
3261 leaf curr_speed {
3262 type uint32;
3263 description
3264 "Current port bitrate in kbps.";
3265 }
3266
3267 leaf max_speed {
3268 type uint32;
3269 description
3270 "Max port bitrate in kbps";
3271 }
3272
3273
3274
3275 }
3276
3277 grouping ofp_switch_features {
3278 description
3279 "Switch features.";
3280 leaf datapath_id {
3281 type uint64;
3282 description
3283 "ofp_header header;
3284Datapath unique ID. The lower 48-bits are for
3285a MAC address, while the upper 16-bits are
3286implementer-defined.";
3287 }
3288
3289 leaf n_buffers {
3290 type uint32;
3291 description
3292 "Max packets buffered at once.";
3293 }
3294
3295 leaf n_tables {
3296 type uint32;
3297 description
3298 "Number of tables supported by datapath.";
3299 }
3300
3301 leaf auxiliary_id {
3302 type uint32;
3303 description
3304 "Identify auxiliary connections";
3305 }
3306
3307 leaf capabilities {
3308 type uint32;
3309 description
3310 "Features.Bitmap of support ofp_capabilities .";
3311 }
3312
3313
3314
3315 }
3316
3317 grouping ofp_port_status {
3318 description
3319 "A physical port has changed in the datapath";
3320 leaf reason {
3321 type ofp_port_reason;
3322
3323 description
3324 "ofp_header header;
3325One of OFPPR_ .";
3326 }
3327
3328 container desc {
3329 uses ofp_port;
3330
3331 description
3332 "";
3333 }
3334
3335
3336
3337 }
3338
3339 container ofp_port_mod {
3340 description
3341 "Modify behavior of the physical port";
3342 leaf port_no {
3343 type uint32;
3344 description
3345 "ofp_header header;";
3346 }
3347
3348 list hw_addr {
3349 key "hw_addr";
3350 leaf hw_addr {
3351 type uint32;
3352 description
3353 " OFP_ETH_ALEN ;";
3354 }
3355 description
3356 " OFP_ETH_ALEN ;";
3357 }
3358
3359 leaf config {
3360 type uint32;
3361 description
3362 "The hardware address is not
3363configurable. This is used to
3364sanity-check the request, so it must
3365be the same as returned in an
3366ofp_port struct.Bitmap of OFPPC_ flags.";
3367 }
3368
3369 leaf mask {
3370 type uint32;
3371 description
3372 "Bitmap of OFPPC_ flags to be changed.";
3373 }
3374
3375 leaf advertise {
3376 type uint32;
3377 description
3378 "Bitmap of OFPPF_ . Zero all bits to prevent
3379any action taking place.";
3380 }
3381
3382
3383
3384 }
3385
3386 grouping ofp_match {
3387 description
3388 "Fields to match against flows";
3389 leaf type {
3390 type ofp_match_type;
3391
3392 description
3393 "One of OFPMT_ ";
3394 }
3395
3396 list oxm_fields {
3397 key "oxm_class";
3398 uses ofp_oxm_field;
3399
3400 description
3401 "0 or more";
3402 }
3403
3404
3405
3406 }
3407
3408 grouping ofp_oxm_field {
3409 description
3410 "OXM Flow match fields";
3411 leaf oxm_class {
3412 type ofp_oxm_class;
3413
3414 description
3415 "";
3416 }
3417
3418
3419
3420 choice choice_0 {
3421 case ofb_field {
3422 container ofb_field {
3423 uses ofp_oxm_ofb_field;
3424
3425 description
3426 "2 and 3 reserved for NXM_0 and NXM-1 OXM classes";
3427 }
3428 }
3429 case experimenter_field {
3430 container experimenter_field {
3431 uses ofp_oxm_experimenter_field;
3432
3433 description
3434 "";
3435 }
3436 }
3437 }
3438
3439
3440 }
3441
3442 grouping ofp_oxm_ofb_field {
3443 description
3444 "OXM OpenFlow Basic Match Field";
3445 leaf type {
3446 type oxm_ofb_field_types;
3447
3448 description
3449 "";
3450 }
3451
3452 leaf has_mask {
3453 type boolean;
3454 description
3455 "";
3456 }
3457
3458
3459
3460 choice choice_0 {
3461 case port {
3462 leaf port {
3463 type uint32;
3464 description
3465 "#define OXM_OF_IN_PORT OXM_HEADER (0x8000, OFPXMT_OFB_IN_PORT, 4)
3466Used for OFPXMT_OFB_IN_PORTOpenFlow port on which the packet was received.
3467 May be a physical port, a logical port, or the reserved port OFPP_LOCAL
3468
3469 Prereqs: None.
3470
3471 Format: 32-bit integer in network byte order.
3472
3473 Masking: Not maskable.";
3474 }
3475 }
3476 case physical_port {
3477 leaf physical_port {
3478 type uint32;
3479 description
3480 "#define OXM_OF_IN_PHY_PORT OXM_HEADER (0x8000, OFPXMT_OFB_IN_PHY_PORT, 4)
3481Used for OFPXMT_OF_IN_PHY_PORTPhysical port on which the packet was received.
3482
3483 Consider a packet received on a tunnel interface defined over a link
3484 aggregation group (LAG) with two physical port members. If the tunnel
3485 interface is the logical port bound to OpenFlow. In this case,
3486 OFPXMT_OF_IN_PORT is the tunnel's port number and OFPXMT_OF_IN_PHY_PORT is
3487 the physical port number of the LAG on which the tunnel is configured.
3488
3489 When a packet is received directly on a physical port and not processed by a
3490 logical port, OFPXMT_OF_IN_PORT and OFPXMT_OF_IN_PHY_PORT have the same
3491 value.
3492
3493 This field is usually not available in a regular match and only available
3494 in ofp_packet_in messages when it's different from OXM_OF_IN_PORT.
3495
3496 Prereqs: OXM_OF_IN_PORT must be present.
3497
3498 Format: 32-bit integer in network byte order.
3499
3500 Masking: Not maskable.";
3501 }
3502 }
3503 case table_metadata {
3504 leaf table_metadata {
3505 type uint64;
3506 description
3507 "#define OXM_OF_METADATA OXM_HEADER (0x8000, OFPXMT_OFB_METADATA, 8)
3508#define OXM_OF_METADATA_W OXM_HEADER_W(0x8000, OFPXMT_OFB_METADATA, 8)
3509Used for OFPXMT_OFB_METADATATable metadata.
3510
3511 Prereqs: None.
3512
3513 Format: 64-bit integer in network byte order.
3514
3515 Masking: Arbitrary masks.";
3516 }
3517 }
3518 case eth_dst {
3519 leaf eth_dst {
3520 type binary;
3521 description
3522 "#define OXM_OF_ETH_DST OXM_HEADER (0x8000, OFPXMT_OFB_ETH_DST, 6)
3523#define OXM_OF_ETH_DST_W OXM_HEADER_W(0x8000, OFPXMT_OFB_ETH_DST, 6)
3524#define OXM_OF_ETH_SRC OXM_HEADER (0x8000, OFPXMT_OFB_ETH_SRC, 6)
3525#define OXM_OF_ETH_SRC_W OXM_HEADER_W(0x8000, OFPXMT_OFB_ETH_SRC, 6)
3526Used for OFPXMT_OFB_ETH_DST (exactly 6 bytes)Source or destination address in Ethernet header.
3527
3528 Prereqs: None.
3529
3530 Format: 48-bit Ethernet MAC address.
3531
3532 Masking: Arbitrary masks.";
3533 }
3534 }
3535 case eth_src {
3536 leaf eth_src {
3537 type binary;
3538 description
3539 "Used for OFPXMT_OFB_ETH_SRC (exactly 6 bytes)";
3540 }
3541 }
3542 case eth_type {
3543 leaf eth_type {
3544 type uint32;
3545 description
3546 "#define OXM_OF_ETH_TYPE OXM_HEADER (0x8000, OFPXMT_OFB_ETH_TYPE,2)
3547Used for OFPXMT_OFB_ETH_TYPEPacket's Ethernet type.
3548
3549 Prereqs: None.
3550
3551 Format: 16-bit integer in network byte order.
3552
3553 Masking: Not maskable.";
3554 }
3555 }
3556 case vlan_vid {
3557 leaf vlan_vid {
3558 type uint32;
3559 description
3560 "#define OXM_OF_VLAN_VID OXM_HEADER (0x8000, OFPXMT_OFB_VLAN_VID, 2)
3561#define OXM_OF_VLAN_VID_W OXM_HEADER_W(0x8000, OFPXMT_OFB_VLAN_VID, 2)
3562Used for OFPXMT_OFB_VLAN_VID802.1Q VID.
3563
3564 For a packet with an 802.1Q header, this is the VLAN-ID (VID) from the
3565 outermost tag, with the CFI bit forced to 1. For a packet with no 802.1Q
3566 header, this has value OFPVID_NONE.
3567
3568 Prereqs: None.
3569
3570 Format: 16-bit integer in network byte order with bit 13 indicating
3571 presence of VLAN header and 3 most-significant bits forced to 0.
3572 Only the lower 13 bits have meaning.
3573
3574 Masking: Arbitrary masks.
3575
3576 This field can be used in various ways:
3577
3578 - If it is not constrained at all, the nx_match matches packets without
3579 an 802.1Q header or with an 802.1Q header that has any VID value.
3580
3581 - Testing for an exact match with 0x0 matches only packets without
3582 an 802.1Q header.
3583
3584 - Testing for an exact match with a VID value with CFI=1 matches packets
3585 that have an 802.1Q header with a specified VID.
3586
3587 - Testing for an exact match with a nonzero VID value with CFI=0 does
3588 not make sense. The switch may reject this combination.
3589
3590 - Testing with nxm_value=0, nxm_mask=0x0fff matches packets with no 802.1Q
3591 header or with an 802.1Q header with a VID of 0.
3592
3593 - Testing with nxm_value=0x1000, nxm_mask=0x1000 matches packets with
3594 an 802.1Q header that has any VID value.";
3595 }
3596 }
3597 case vlan_pcp {
3598 leaf vlan_pcp {
3599 type uint32;
3600 description
3601 "#define OXM_OF_VLAN_PCP OXM_HEADER (0x8000, OFPXMT_OFB_VLAN_PCP, 1)
3602Used for OFPXMT_OFB_VLAN_PCP802.1Q PCP.
3603
3604 For a packet with an 802.1Q header, this is the VLAN-PCP from the
3605 outermost tag. For a packet with no 802.1Q header, this has value
3606 0.
3607
3608 Prereqs: OXM_OF_VLAN_VID must be different from OFPVID_NONE.
3609
3610 Format: 8-bit integer with 5 most-significant bits forced to 0.
3611 Only the lower 3 bits have meaning.
3612
3613 Masking: Not maskable.";
3614 }
3615 }
3616 case ip_dscp {
3617 leaf ip_dscp {
3618 type uint32;
3619 description
3620 "#define OXM_OF_IP_DSCP OXM_HEADER (0x8000, OFPXMT_OFB_IP_DSCP, 1)
3621Used for OFPXMT_OFB_IP_DSCPThe Diff Serv Code Point (DSCP) bits of the IP header.
3622 Part of the IPv4 ToS field or the IPv6 Traffic Class field.
3623
3624 Prereqs: OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
3625
3626 Format: 8-bit integer with 2 most-significant bits forced to 0.
3627 Only the lower 6 bits have meaning.
3628
3629 Masking: Not maskable.";
3630 }
3631 }
3632 case ip_ecn {
3633 leaf ip_ecn {
3634 type uint32;
3635 description
3636 "#define OXM_OF_IP_ECN OXM_HEADER (0x8000, OFPXMT_OFB_IP_ECN, 1)
3637Used for OFPXMT_OFB_IP_ECNThe ECN bits of the IP header.
3638 Part of the IPv4 ToS field or the IPv6 Traffic Class field.
3639
3640 Prereqs: OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
3641
3642 Format: 8-bit integer with 6 most-significant bits forced to 0.
3643 Only the lower 2 bits have meaning.
3644
3645 Masking: Not maskable.";
3646 }
3647 }
3648 case ip_proto {
3649 leaf ip_proto {
3650 type uint32;
3651 description
3652 "#define OXM_OF_IP_PROTO OXM_HEADER (0x8000, OFPXMT_OFB_IP_PROTO, 1)
3653Used for OFPXMT_OFB_IP_PROTOThe protocol byte in the IP header.
3654
3655 Prereqs: OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
3656
3657 Format: 8-bit integer.
3658
3659 Masking: Not maskable.";
3660 }
3661 }
3662 case ipv4_src {
3663 leaf ipv4_src {
3664 type uint32;
3665 description
3666 "#define OXM_OF_IPV4_SRC OXM_HEADER (0x8000, OFPXMT_OFB_IPV4_SRC, 4)
3667#define OXM_OF_IPV4_SRC_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV4_SRC, 4)
3668#define OXM_OF_IPV4_DST OXM_HEADER (0x8000, OFPXMT_OFB_IPV4_DST, 4)
3669#define OXM_OF_IPV4_DST_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV4_DST, 4)
3670Used for OFPXMT_OFB_IPV4_SRCThe source or destination address in the IP header.
3671
3672 Prereqs: OXM_OF_ETH_TYPE must match 0x0800 exactly.
3673
3674 Format: 32-bit integer in network byte order.
3675
3676 Masking: Arbitrary masks.";
3677 }
3678 }
3679 case ipv4_dst {
3680 leaf ipv4_dst {
3681 type uint32;
3682 description
3683 "Used for OFPXMT_OFB_IPV4_DST";
3684 }
3685 }
3686 case tcp_src {
3687 leaf tcp_src {
3688 type uint32;
3689 description
3690 "#define OXM_OF_TCP_SRC OXM_HEADER (0x8000, OFPXMT_OFB_TCP_SRC, 2)
3691#define OXM_OF_TCP_DST OXM_HEADER (0x8000, OFPXMT_OFB_TCP_DST, 2)
3692Used for OFPXMT_OFB_TCP_SRCThe source or destination port in the TCP header.
3693
3694 Prereqs:
3695 OXM_OF_ETH_TYPE must be either 0x0800 or 0x86dd.
3696 OXM_OF_IP_PROTO must match 6 exactly.
3697
3698 Format: 16-bit integer in network byte order.
3699
3700 Masking: Not maskable.";
3701 }
3702 }
3703 case tcp_dst {
3704 leaf tcp_dst {
3705 type uint32;
3706 description
3707 "Used for OFPXMT_OFB_TCP_DST";
3708 }
3709 }
3710 case udp_src {
3711 leaf udp_src {
3712 type uint32;
3713 description
3714 "#define OXM_OF_UDP_SRC OXM_HEADER (0x8000, OFPXMT_OFB_UDP_SRC, 2)
3715#define OXM_OF_UDP_DST OXM_HEADER (0x8000, OFPXMT_OFB_UDP_DST, 2)
3716Used for OFPXMT_OFB_UDP_SRCThe source or destination port in the UDP header.
3717
3718 Prereqs:
3719 OXM_OF_ETH_TYPE must match either 0x0800 or 0x86dd.
3720 OXM_OF_IP_PROTO must match 17 exactly.
3721
3722 Format: 16-bit integer in network byte order.
3723
3724 Masking: Not maskable.";
3725 }
3726 }
3727 case udp_dst {
3728 leaf udp_dst {
3729 type uint32;
3730 description
3731 "Used for OFPXMT_OFB_UDP_DST";
3732 }
3733 }
3734 case sctp_src {
3735 leaf sctp_src {
3736 type uint32;
3737 description
3738 "#define OXM_OF_SCTP_SRC OXM_HEADER (0x8000, OFPXMT_OFB_SCTP_SRC, 2)
3739#define OXM_OF_SCTP_DST OXM_HEADER (0x8000, OFPXMT_OFB_SCTP_DST, 2)
3740Used for OFPXMT_OFB_SCTP_SRCThe source or destination port in the SCTP header.
3741
3742 Prereqs:
3743 OXM_OF_ETH_TYPE must match either 0x0800 or 0x86dd.
3744 OXM_OF_IP_PROTO must match 132 exactly.
3745
3746 Format: 16-bit integer in network byte order.
3747
3748 Masking: Not maskable.";
3749 }
3750 }
3751 case sctp_dst {
3752 leaf sctp_dst {
3753 type uint32;
3754 description
3755 "Used for OFPXMT_OFB_SCTP_DST";
3756 }
3757 }
3758 case icmpv4_type {
3759 leaf icmpv4_type {
3760 type uint32;
3761 description
3762 "#define OXM_OF_ICMPV4_TYPE OXM_HEADER (0x8000, OFPXMT_OFB_ICMPV4_TYPE, 1)
3763#define OXM_OF_ICMPV4_CODE OXM_HEADER (0x8000, OFPXMT_OFB_ICMPV4_CODE, 1)
3764Used for OFPXMT_OFB_ICMPV4_TYPEThe type or code in the ICMP header.
3765
3766 Prereqs:
3767 OXM_OF_ETH_TYPE must match 0x0800 exactly.
3768 OXM_OF_IP_PROTO must match 1 exactly.
3769
3770 Format: 8-bit integer.
3771
3772 Masking: Not maskable.";
3773 }
3774 }
3775 case icmpv4_code {
3776 leaf icmpv4_code {
3777 type uint32;
3778 description
3779 "Used for OFPXMT_OFB_ICMPV4_CODE";
3780 }
3781 }
3782 case arp_op {
3783 leaf arp_op {
3784 type uint32;
3785 description
3786 "#define OXM_OF_ARP_OP OXM_HEADER (0x8000, OFPXMT_OFB_ARP_OP, 2)
3787Used for OFPXMT_OFB_ARP_OPARP opcode.
3788
3789 For an Ethernet+IP ARP packet, the opcode in the ARP header. Always 0
3790 otherwise.
3791
3792 Prereqs: OXM_OF_ETH_TYPE must match 0x0806 exactly.
3793
3794 Format: 16-bit integer in network byte order.
3795
3796 Masking: Not maskable.";
3797 }
3798 }
3799 case arp_spa {
3800 leaf arp_spa {
3801 type uint32;
3802 description
3803 "#define OXM_OF_ARP_SPA OXM_HEADER (0x8000, OFPXMT_OFB_ARP_SPA, 4)
3804#define OXM_OF_ARP_SPA_W OXM_HEADER_W(0x8000, OFPXMT_OFB_ARP_SPA, 4)
3805#define OXM_OF_ARP_TPA OXM_HEADER (0x8000, OFPXMT_OFB_ARP_TPA, 4)
3806#define OXM_OF_ARP_TPA_W OXM_HEADER_W(0x8000, OFPXMT_OFB_ARP_TPA, 4)
3807For OFPXMT_OFB_ARP_SPAFor an Ethernet+IP ARP packet, the source or target protocol address
3808 in the ARP header. Always 0 otherwise.
3809
3810 Prereqs: OXM_OF_ETH_TYPE must match 0x0806 exactly.
3811
3812 Format: 32-bit integer in network byte order.
3813
3814 Masking: Arbitrary masks.";
3815 }
3816 }
3817 case arp_tpa {
3818 leaf arp_tpa {
3819 type uint32;
3820 description
3821 "For OFPXMT_OFB_ARP_TPA";
3822 }
3823 }
3824 case arp_sha {
3825 leaf arp_sha {
3826 type binary;
3827 description
3828 "#define OXM_OF_ARP_SHA OXM_HEADER (0x8000, OFPXMT_OFB_ARP_SHA, 6)
3829#define OXM_OF_ARP_SHA_W OXM_HEADER_W (0x8000, OFPXMT_OFB_ARP_SHA, 6)
3830#define OXM_OF_ARP_THA OXM_HEADER (0x8000, OFPXMT_OFB_ARP_THA, 6)
3831#define OXM_OF_ARP_THA_W OXM_HEADER_W (0x8000, OFPXMT_OFB_ARP_THA, 6)
3832For OFPXMT_OFB_ARP_SHA (6 bytes)For an Ethernet+IP ARP packet, the source or target hardware address
3833 in the ARP header. Always 0 otherwise.
3834
3835 Prereqs: OXM_OF_ETH_TYPE must match 0x0806 exactly.
3836
3837 Format: 48-bit Ethernet MAC address.
3838
3839 Masking: Not maskable.";
3840 }
3841 }
3842 case arp_tha {
3843 leaf arp_tha {
3844 type binary;
3845 description
3846 "For OFPXMT_OFB_ARP_THA (6 bytes)";
3847 }
3848 }
3849 case ipv6_src {
3850 leaf ipv6_src {
3851 type binary;
3852 description
3853 "#define OXM_OF_IPV6_SRC OXM_HEADER (0x8000, OFPXMT_OFB_IPV6_SRC, 16)
3854#define OXM_OF_IPV6_SRC_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_SRC, 16)
3855#define OXM_OF_IPV6_DST OXM_HEADER (0x8000, OFPXMT_OFB_IPV6_DST, 16)
3856#define OXM_OF_IPV6_DST_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_DST, 16)
3857For OFPXMT_OFB_IPV6_SRCThe source or destination address in the IPv6 header.
3858
3859 Prereqs: OXM_OF_ETH_TYPE must match 0x86dd exactly.
3860
3861 Format: 128-bit IPv6 address.
3862
3863 Masking: Arbitrary masks.";
3864 }
3865 }
3866 case ipv6_dst {
3867 leaf ipv6_dst {
3868 type binary;
3869 description
3870 "For OFPXMT_OFB_IPV6_DST";
3871 }
3872 }
3873 case ipv6_flabel {
3874 leaf ipv6_flabel {
3875 type uint32;
3876 description
3877 "#define OXM_OF_IPV6_FLABEL OXM_HEADER (0x8000, OFPXMT_OFB_IPV6_FLABEL, 4)
3878#define OXM_OF_IPV6_FLABEL_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_FLABEL, 4)
3879For OFPXMT_OFB_IPV6_FLABELThe IPv6 Flow Label
3880
3881 Prereqs:
3882 OXM_OF_ETH_TYPE must match 0x86dd exactly
3883
3884 Format: 32-bit integer with 12 most-significant bits forced to 0.
3885 Only the lower 20 bits have meaning.
3886
3887 Masking: Arbitrary masks.";
3888 }
3889 }
3890 case icmpv6_type {
3891 leaf icmpv6_type {
3892 type uint32;
3893 description
3894 "#define OXM_OF_ICMPV6_TYPE OXM_HEADER (0x8000, OFPXMT_OFB_ICMPV6_TYPE, 1)
3895#define OXM_OF_ICMPV6_CODE OXM_HEADER (0x8000, OFPXMT_OFB_ICMPV6_CODE, 1)
3896For OFPXMT_OFB_ICMPV6_TYPEThe type or code in the ICMPv6 header.
3897
3898 Prereqs:
3899 OXM_OF_ETH_TYPE must match 0x86dd exactly.
3900 OXM_OF_IP_PROTO must match 58 exactly.
3901
3902 Format: 8-bit integer.
3903
3904 Masking: Not maskable.";
3905 }
3906 }
3907 case icmpv6_code {
3908 leaf icmpv6_code {
3909 type uint32;
3910 description
3911 "For OFPXMT_OFB_ICMPV6_CODE";
3912 }
3913 }
3914 case ipv6_nd_target {
3915 leaf ipv6_nd_target {
3916 type binary;
3917 description
3918 "#define OXM_OF_IPV6_ND_TARGET OXM_HEADER
3919 (0x8000, OFPXMT_OFB_IPV6_ND_TARGET, 16)
3920For OFPXMT_OFB_IPV6_ND_TARGETThe target address in an IPv6 Neighbor Discovery message.
3921
3922 Prereqs:
3923 OXM_OF_ETH_TYPE must match 0x86dd exactly.
3924 OXM_OF_IP_PROTO must match 58 exactly.
3925 OXM_OF_ICMPV6_TYPE must be either 135 or 136.
3926
3927 Format: 128-bit IPv6 address.
3928
3929 Masking: Not maskable.";
3930 }
3931 }
3932 case ipv6_nd_ssl {
3933 leaf ipv6_nd_ssl {
3934 type binary;
3935 description
3936 "#define OXM_OF_IPV6_ND_SLL OXM_HEADER (0x8000, OFPXMT_OFB_IPV6_ND_SLL, 6)
3937For OFPXMT_OFB_IPV6_ND_SLLThe source link-layer address option in an IPv6 Neighbor Discovery
3938 message.
3939
3940 Prereqs:
3941 OXM_OF_ETH_TYPE must match 0x86dd exactly.
3942 OXM_OF_IP_PROTO must match 58 exactly.
3943 OXM_OF_ICMPV6_TYPE must be exactly 135.
3944
3945 Format: 48-bit Ethernet MAC address.
3946
3947 Masking: Not maskable.";
3948 }
3949 }
3950 case ipv6_nd_tll {
3951 leaf ipv6_nd_tll {
3952 type binary;
3953 description
3954 "#define OXM_OF_IPV6_ND_TLL OXM_HEADER (0x8000, OFPXMT_OFB_IPV6_ND_TLL, 6)
3955For OFPXMT_OFB_IPV6_ND_TLLThe target link-layer address option in an IPv6 Neighbor Discovery
3956 message.
3957
3958 Prereqs:
3959 OXM_OF_ETH_TYPE must match 0x86dd exactly.
3960 OXM_OF_IP_PROTO must match 58 exactly.
3961 OXM_OF_ICMPV6_TYPE must be exactly 136.
3962
3963 Format: 48-bit Ethernet MAC address.
3964
3965 Masking: Not maskable.";
3966 }
3967 }
3968 case mpls_label {
3969 leaf mpls_label {
3970 type uint32;
3971 description
3972 "#define OXM_OF_MPLS_LABEL OXM_HEADER (0x8000, OFPXMT_OFB_MPLS_LABEL, 4)
3973For OFPXMT_OFB_MPLS_LABELThe LABEL in the first MPLS shim header.
3974
3975 Prereqs:
3976 OXM_OF_ETH_TYPE must match 0x8847 or 0x8848 exactly.
3977
3978 Format: 32-bit integer in network byte order with 12 most-significant
3979 bits forced to 0. Only the lower 20 bits have meaning.
3980
3981 Masking: Not maskable.";
3982 }
3983 }
3984 case mpls_tc {
3985 leaf mpls_tc {
3986 type uint32;
3987 description
3988 "#define OXM_OF_MPLS_TC OXM_HEADER (0x8000, OFPXMT_OFB_MPLS_TC, 1)
3989For OFPXMT_OFB_MPLS_TCThe TC in the first MPLS shim header.
3990
3991 Prereqs:
3992 OXM_OF_ETH_TYPE must match 0x8847 or 0x8848 exactly.
3993
3994 Format: 8-bit integer with 5 most-significant bits forced to 0.
3995 Only the lower 3 bits have meaning.
3996
3997 Masking: Not maskable.";
3998 }
3999 }
4000 case mpls_bos {
4001 leaf mpls_bos {
4002 type uint32;
4003 description
4004 "#define OXM_OF_MPLS_BOS OXM_HEADER (0x8000, OFPXMT_OFB_MPLS_BOS, 1)
4005For OFPXMT_OFB_MPLS_BOSThe BoS bit in the first MPLS shim header.
4006
4007 Prereqs:
4008 OXM_OF_ETH_TYPE must match 0x8847 or 0x8848 exactly.
4009
4010 Format: 8-bit integer with 7 most-significant bits forced to 0.
4011 Only the lowest bit have a meaning.
4012
4013 Masking: Not maskable.";
4014 }
4015 }
4016 case pbb_isid {
4017 leaf pbb_isid {
4018 type uint32;
4019 description
4020 "#define OXM_OF_PBB_ISID OXM_HEADER (0x8000, OFPXMT_OFB_PBB_ISID, 3)
4021#define OXM_OF_PBB_ISID_W OXM_HEADER_W(0x8000, OFPXMT_OFB_PBB_ISID, 3)
4022For OFPXMT_OFB_PBB_ISIDIEEE 802.1ah I-SID.
4023
4024 For a packet with a PBB header, this is the I-SID from the
4025 outermost service tag.
4026
4027 Prereqs:
4028 OXM_OF_ETH_TYPE must match 0x88E7 exactly.
4029
4030 Format: 24-bit integer in network byte order.
4031
4032 Masking: Arbitrary masks.";
4033 }
4034 }
4035 case tunnel_id {
4036 leaf tunnel_id {
4037 type uint64;
4038 description
4039 "#define OXM_OF_TUNNEL_ID OXM_HEADER (0x8000, OFPXMT_OFB_TUNNEL_ID, 8)
4040#define OXM_OF_TUNNEL_ID_W OXM_HEADER_W(0x8000, OFPXMT_OFB_TUNNEL_ID, 8)
4041For OFPXMT_OFB_TUNNEL_IDLogical Port Metadata.
4042
4043 Metadata associated with a logical port.
4044 If the logical port performs encapsulation and decapsulation, this
4045 is the demultiplexing field from the encapsulation header.
4046 For example, for a packet received via GRE tunnel including a (32-bit) key,
4047 the key is stored in the low 32-bits and the high bits are zeroed.
4048 For a MPLS logical port, the low 20 bits represent the MPLS Label.
4049 For a VxLAN logical port, the low 24 bits represent the VNI.
4050 If the packet is not received through a logical port, the value is 0.
4051
4052 Prereqs: None.
4053
4054 Format: 64-bit integer in network byte order.
4055
4056 Masking: Arbitrary masks.";
4057 }
4058 }
4059 case ipv6_exthdr {
4060 leaf ipv6_exthdr {
4061 type uint32;
4062 description
4063 "#define OXM_OF_IPV6_EXTHDR OXM_HEADER (0x8000, OFPXMT_OFB_IPV6_EXTHDR, 2)
4064#define OXM_OF_IPV6_EXTHDR_W OXM_HEADER_W(0x8000, OFPXMT_OFB_IPV6_EXTHDR, 2)
4065For OFPXMT_OFB_IPV6_EXTHDRThe IPv6 Extension Header pseudo-field.
4066
4067 Prereqs:
4068 OXM_OF_ETH_TYPE must match 0x86dd exactly
4069
4070 Format: 16-bit integer with 7 most-significant bits forced to 0.
4071 Only the lower 9 bits have meaning.
4072
4073 Masking: Maskable.";
4074 }
4075 }
4076 }
4077 choice choice_1 {
4078 case table_metadata_mask {
4079 leaf table_metadata_mask {
4080 type uint64;
4081 description
4082 "For OFPXMT_OFB_METADATA";
4083 }
4084 }
4085 case eth_dst_mask {
4086 leaf eth_dst_mask {
4087 type binary;
4088 description
4089 "For OFPXMT_OFB_ETH_DST (exactly 6 bytes)";
4090 }
4091 }
4092 case eth_src_mask {
4093 leaf eth_src_mask {
4094 type binary;
4095 description
4096 "For OFPXMT_OFB_ETH_SRC (exactly 6 bytes)";
4097 }
4098 }
4099 case vlan_vid_mask {
4100 leaf vlan_vid_mask {
4101 type uint32;
4102 description
4103 "For OFPXMT_OFB_VLAN_VID";
4104 }
4105 }
4106 case ipv4_src_mask {
4107 leaf ipv4_src_mask {
4108 type uint32;
4109 description
4110 "For OFPXMT_OFB_IPV4_SRC";
4111 }
4112 }
4113 case ipv4_dst_mask {
4114 leaf ipv4_dst_mask {
4115 type uint32;
4116 description
4117 "For OFPXMT_OFB_IPV4_DST";
4118 }
4119 }
4120 case arp_spa_mask {
4121 leaf arp_spa_mask {
4122 type uint32;
4123 description
4124 "For OFPXMT_OFB_ARP_SPA";
4125 }
4126 }
4127 case arp_tpa_mask {
4128 leaf arp_tpa_mask {
4129 type uint32;
4130 description
4131 "For OFPXMT_OFB_ARP_TPA";
4132 }
4133 }
4134 case ipv6_src_mask {
4135 leaf ipv6_src_mask {
4136 type binary;
4137 description
4138 "For OFPXMT_OFB_IPV6_SRC";
4139 }
4140 }
4141 case ipv6_dst_mask {
4142 leaf ipv6_dst_mask {
4143 type binary;
4144 description
4145 "For OFPXMT_OFB_IPV6_DST";
4146 }
4147 }
4148 case ipv6_flabel_mask {
4149 leaf ipv6_flabel_mask {
4150 type uint32;
4151 description
4152 "For OFPXMT_OFB_IPV6_FLABEL";
4153 }
4154 }
4155 case pbb_isid_mask {
4156 leaf pbb_isid_mask {
4157 type uint32;
4158 description
4159 "For OFPXMT_OFB_PBB_ISID";
4160 }
4161 }
4162 case tunnel_id_mask {
4163 leaf tunnel_id_mask {
4164 type uint64;
4165 description
4166 "For OFPXMT_OFB_TUNNEL_ID";
4167 }
4168 }
4169 case ipv6_exthdr_mask {
4170 leaf ipv6_exthdr_mask {
4171 type uint32;
4172 description
4173 "For OFPXMT_OFB_IPV6_EXTHDR";
4174 }
4175 }
4176 }
4177
4178
4179 }
4180
4181 grouping ofp_oxm_experimenter_field {
4182 description
4183 "Header for OXM experimenter match fields.
4184 The experimenter class should not use OXM_HEADER() macros for defining
4185 fields due to this extra header.";
4186 leaf oxm_header {
4187 type uint32;
4188 description
4189 "oxm_class = OFPXMC_EXPERIMENTER";
4190 }
4191
4192 leaf experimenter {
4193 type uint32;
4194 description
4195 "Experimenter ID which takes the same
4196form as in struct ofp_experimenter_header.";
4197 }
4198
4199
4200
4201 }
4202
4203 grouping ofp_action {
4204 description
4205 "Action header that is common to all actions. The length includes the
4206 header and any padding used to make the action 64-bit aligned.
4207 NB: The length of an action must always be a multiple of eight.";
4208 leaf type {
4209 type ofp_action_type;
4210
4211 description
4212 "One of OFPAT_ .";
4213 }
4214
4215
4216
4217 choice choice_0 {
4218 case output {
4219 container output {
4220 uses ofp_action_output;
4221
4222 description
4223 "";
4224 }
4225 }
4226 case mpls_ttl {
4227 container mpls_ttl {
4228 uses ofp_action_mpls_ttl;
4229
4230 description
4231 "";
4232 }
4233 }
4234 case push {
4235 container push {
4236 uses ofp_action_push;
4237
4238 description
4239 "";
4240 }
4241 }
4242 case pop_mpls {
4243 container pop_mpls {
4244 uses ofp_action_pop_mpls;
4245
4246 description
4247 "";
4248 }
4249 }
4250 case group {
4251 container group {
4252 uses ofp_action_group;
4253
4254 description
4255 "";
4256 }
4257 }
4258 case nw_ttl {
4259 container nw_ttl {
4260 uses ofp_action_nw_ttl;
4261
4262 description
4263 "";
4264 }
4265 }
4266 case set_field {
4267 container set_field {
4268 uses ofp_action_set_field;
4269f
4270 description
4271 "";
4272 }
4273 }
4274 case experimenter {
4275 container experimenter {
4276 uses ofp_action_experimenter;
4277
4278 description
4279 "";
4280 }
4281 }
4282 }
4283
4284
4285 }
4286
4287 grouping ofp_action_output {
4288 description
4289 "Action structure for OFPAT_OUTPUT, which sends packets out 'port'.
4290 When the 'port' is the OFPP_CONTROLLER, 'max_len' indicates the max
4291 number of bytes to send. A 'max_len' of zero means no bytes of the
4292 packet should be sent. A 'max_len' of OFPCML_NO_BUFFER means that
4293 the packet is not buffered and the complete packet is to be sent to
4294 the controller.";
4295 leaf port {
4296 type uint32;
4297 description
4298 "Output port.";
4299 }
4300
4301 leaf max_len {
4302 type uint32;
4303 description
4304 "Max length to send to controller.";
4305 }
4306
4307
4308
4309 }
4310
4311 grouping ofp_action_mpls_ttl {
4312 description
4313 "Action structure for OFPAT_SET_MPLS_TTL.";
4314 leaf mpls_ttl {
4315 type uint32;
4316 description
4317 "MPLS TTL";
4318 }
4319
4320
4321
4322 }
4323
4324 grouping ofp_action_push {
4325 description
4326 "Action structure for OFPAT_PUSH_VLAN MPLS PBB.";
4327 leaf ethertype {
4328 type uint32;
4329 description
4330 "Ethertype";
4331 }
4332
4333
4334
4335 }
4336
4337 grouping ofp_action_pop_mpls {
4338 description
4339 "Action structure for OFPAT_POP_MPLS.";
4340 leaf ethertype {
4341 type uint32;
4342 description
4343 "Ethertype";
4344 }
4345
4346
4347
4348 }
4349
4350 grouping ofp_action_group {
4351 description
4352 "Action structure for OFPAT_GROUP.";
4353 leaf group_id {
4354 type uint32;
4355 description
4356 "Group identifier.";
4357 }
4358
4359
4360
4361 }
4362
4363 grouping ofp_action_nw_ttl {
4364 description
4365 "Action structure for OFPAT_SET_NW_TTL.";
4366 leaf nw_ttl {
4367 type uint32;
4368 description
4369 "IP TTL";
4370 }
4371
4372
4373
4374 }
4375
4376 grouping ofp_action_set_field {
4377 description
4378 "Action structure for OFPAT_SET_FIELD.";
4379 container field {
4380 uses ofp_oxm_field;
4381
4382 description
4383 "";
4384 }
4385
4386
4387
4388 }
4389
4390 grouping ofp_action_experimenter {
4391 description
4392 "Action header for OFPAT_EXPERIMENTER.
4393 The rest of the body is experimenter-defined.";
4394 leaf experimenter {
4395 type uint32;
4396 description
4397 "Experimenter ID which takes the same
4398form as in struct
4399ofp_experimenter_header.";
4400 }
4401
4402 leaf data {
4403 type binary;
4404 description
4405 "";
4406 }
4407
4408
4409
4410 }
4411
4412 grouping ofp_instruction {
4413 description
4414 "Instruction header that is common to all instructions. The length includes
4415 the header and any padding used to make the instruction 64-bit aligned.
4416 NB: The length of an instruction must always be a multiple of eight.";
4417 leaf type {
4418 type uint32;
4419 description
4420 "Instruction type";
4421 }
4422
4423
4424
4425 choice choice_0 {
4426 case goto_table {
4427 container goto_table {
4428 uses ofp_instruction_goto_table;
4429
4430 description
4431 "";
4432 }
4433 }
4434 case write_metadata {
4435 container write_metadata {
4436 uses ofp_instruction_write_metadata;
4437
4438 description
4439 "";
4440 }
4441 }
4442 case actions {
4443 container actions {
4444 uses ofp_instruction_actions;
4445
4446 description
4447 "";
4448 }
4449 }
4450 case meter {
4451 container meter {
4452 uses ofp_instruction_meter;
4453
4454 description
4455 "";
4456 }
4457 }
4458 case experimenter {
4459 container experimenter {
4460 uses ofp_instruction_experimenter;
4461
4462 description
4463 "";
4464 }
4465 }
4466 }
4467
4468
4469 }
4470
4471 grouping ofp_instruction_goto_table {
4472 description
4473 "Instruction structure for OFPIT_GOTO_TABLE";
4474 leaf table_id {
4475 type uint32;
4476 description
4477 "Set next table in the lookup pipeline";
4478 }
4479
4480
4481
4482 }
4483
4484 grouping ofp_instruction_write_metadata {
4485 description
4486 "Instruction structure for OFPIT_WRITE_METADATA";
4487 leaf metadata {
4488 type uint64;
4489 description
4490 "Metadata value to write";
4491 }
4492
4493 leaf metadata_mask {
4494 type uint64;
4495 description
4496 "Metadata write bitmask";
4497 }
4498
4499
4500
4501 }
4502
4503 grouping ofp_instruction_actions {
4504 description
4505 "Instruction structure for OFPIT_WRITE APPLY CLEAR_ACTIONS";
4506 list actions {
4507 key "type";
4508 uses ofp_action;
4509
4510 description
4511 "0 or more actions associated
4512with OFPIT_WRITE_ACTIONS and
4513OFPIT_APPLY_ACTIONS";
4514 }
4515
4516
4517
4518 }
4519
4520 grouping ofp_instruction_meter {
4521 description
4522 "Instruction structure for OFPIT_METER";
4523 leaf meter_id {
4524 type uint32;
4525 description
4526 "Meter instance.";
4527 }
4528
4529
4530
4531 }
4532
4533 grouping ofp_instruction_experimenter {
4534 description
4535 "Instruction structure for experimental instructions";
4536 leaf experimenter {
4537 type uint32;
4538 description
4539 "Experimenter ID which takes the same form
4540as in struct ofp_experimenter_header.";
4541 }
4542
4543 leaf data {
4544 type binary;
4545 description
4546 "Experimenter-defined arbitrary additional data.";
4547 }
4548
4549
4550
4551 }
4552
4553 grouping ofp_flow_mod {
4554 description
4555 "Flow setup and teardown (controller - datapath).";
4556 leaf cookie {
4557 type uint64;
4558 description
4559 "ofp_header header;
4560Opaque controller-issued identifier.";
4561 }
4562
4563 leaf cookie_mask {
4564 type uint64;
4565 description
4566 "Mask used to restrict the cookie bits
4567that must match when the command is
4568OFPFC_MODIFY or OFPFC_DELETE . A value
4569of 0 indicates no restriction.";
4570 }
4571
4572 leaf table_id {
4573 type uint32;
4574 description
4575 "ID of the table to put the flow in.
4576For OFPFC_DELETE_ commands, OFPTT_ALL
4577can also be used to delete matching
4578flows from all tables.";
4579 }
4580
4581 leaf command {
4582 type ofp_flow_mod_command;
4583
4584 description
4585 "One of OFPFC_ .";
4586 }
4587
4588 leaf idle_timeout {
4589 type uint32;
4590 description
4591 "Idle time before discarding (seconds).";
4592 }
4593
4594 leaf hard_timeout {
4595 type uint32;
4596 description
4597 "Max time before discarding (seconds).";
4598 }
4599
4600 leaf priority {
4601 type uint32;
4602 description
4603 "Priority level of flow entry.";
4604 }
4605
4606 leaf buffer_id {
4607 type uint32;
4608 description
4609 "Buffered packet to apply to, or
4610OFP_NO_BUFFER.
4611Not meaningful for OFPFC_DELETE .";
4612 }
4613
4614 leaf out_port {
4615 type uint32;
4616 description
4617 "For OFPFC_DELETE commands, require
4618matching entries to include this as an
4619output port. A value of OFPP_ANY
4620indicates no restriction.";
4621 }
4622
4623 leaf out_group {
4624 type uint32;
4625 description
4626 "For OFPFC_DELETE commands, require
4627matching entries to include this as an
4628output group. A value of OFPG_ANY
4629indicates no restriction.";
4630 }
4631
4632 leaf flags {
4633 type uint32;
4634 description
4635 "Bitmap of OFPFF_ flags.";
4636 }
4637
4638 container match {
4639 uses ofp_match;
4640
4641 description
4642 "Fields to match. Variable size.";
4643 }
4644
4645 list instructions {
4646 key "type";
4647 uses ofp_instruction;
4648
4649 description
4650 "0 or more.";
4651 }
4652
4653
4654
4655 }
4656
4657 grouping ofp_bucket {
4658 description
4659 "Bucket for use in groups.";
4660 leaf weight {
4661 type uint32;
4662 description
4663 "Relative weight of bucket. Only
4664defined for select groups.";
4665 }
4666
4667 leaf watch_port {
4668 type uint32;
4669 description
4670 "Port whose state affects whether this
4671bucket is live. Only required for fast
4672failover groups.";
4673 }
4674
4675 leaf watch_group {
4676 type uint32;
4677 description
4678 "Group whose state affects whether this
4679bucket is live. Only required for fast
4680failover groups.";
4681 }
4682
4683 list actions {
4684 key "type";
4685 uses ofp_action;
4686
4687 description
4688 "";
4689 }
4690
4691
4692
4693 }
4694
4695 grouping ofp_group_mod {
4696 description
4697 "Group setup and teardown (controller - datapath).";
4698 leaf command {
4699 type ofp_group_mod_command;
4700
4701 description
4702 "ofp_header header;
4703One of OFPGC_ .";
4704 }
4705
4706 leaf type {
4707 type ofp_group_type;
4708
4709 description
4710 "One of OFPGT_ .";
4711 }
4712
4713 leaf group_id {
4714 type uint32;
4715 description
4716 "Group identifier.";
4717 }
4718
4719 list buckets {
4720 key "weight";
4721 uses ofp_bucket;
4722
4723 description
4724 "";
4725 }
4726
4727
4728
4729 }
4730
4731 grouping ofp_packet_out {
4732 description
4733 "Send packet (controller - datapath).Special buffer-id to indicate 'no buffer'#define OFP_NO_BUFFER 0xffffffff";
4734 leaf buffer_id {
4735 type uint32;
4736 description
4737 "ofp_header header;
4738ID assigned by datapath (OFP_NO_BUFFER
4739if none).";
4740 }
4741
4742 leaf in_port {
4743 type uint32;
4744 description
4745 "Packet's input port or OFPP_CONTROLLER.";
4746 }
4747
4748 list actions {
4749 key "type";
4750 uses ofp_action;
4751
4752 description
4753 "Action list - 0 or more.";
4754 }
4755
4756 leaf data {
4757 type binary;
4758 description
4759 "The variable size action list is optionally followed by packet data.
4760 This data is only present and meaningful if buffer_id == -1.Packet data.";
4761 }
4762
4763
4764
4765 }
4766
4767 grouping ofp_packet_in {
4768 description
4769 "Packet received on port (datapath - controller).";
4770 leaf buffer_id {
4771 type uint32;
4772 description
4773 "ofp_header header;
4774ID assigned by datapath.";
4775 }
4776
4777 leaf reason {
4778 type ofp_packet_in_reason;
4779
4780 description
4781 "Reason packet is being sent";
4782 }
4783
4784 leaf table_id {
4785 type uint32;
4786 description
4787 "ID of the table that was looked up";
4788 }
4789
4790 leaf cookie {
4791 type uint64;
4792 description
4793 "Cookie of the flow entry that was looked up.";
4794 }
4795
4796 container match {
4797 uses ofp_match;
4798
4799 description
4800 "Packet metadata. Variable size.";
4801 }
4802
4803 leaf data {
4804 type binary;
4805 description
4806 "Ethernet frame";
4807 }
4808
4809
4810
4811 }
4812
4813 container ofp_flow_removed {
4814 description
4815 "Flow removed (datapath - controller).";
4816 leaf cookie {
4817 type uint64;
4818 description
4819 "ofp_header header;
4820Opaque controller-issued identifier.";
4821 }
4822
4823 leaf priority {
4824 type uint32;
4825 description
4826 "Priority level of flow entry.";
4827 }
4828
4829 leaf reason {
4830 type ofp_flow_removed_reason;
4831
4832 description
4833 "One of OFPRR_ .";
4834 }
4835
4836 leaf table_id {
4837 type uint32;
4838 description
4839 "ID of the table";
4840 }
4841
4842 leaf duration_sec {
4843 type uint32;
4844 description
4845 "Time flow was alive in seconds.";
4846 }
4847
4848 leaf duration_nsec {
4849 type uint32;
4850 description
4851 "Time flow was alive in nanoseconds beyond
4852duration_sec.";
4853 }
4854
4855 leaf idle_timeout {
4856 type uint32;
4857 description
4858 "Idle timeout from original flow mod.";
4859 }
4860
4861 leaf hard_timeout {
4862 type uint32;
4863 description
4864 "Hard timeout from original flow mod.";
4865 }
4866
4867 leaf packet_count {
4868 type uint64;
4869 description
4870 "";
4871 }
4872
4873 leaf byte_count {
4874 type uint64;
4875 description
4876 "";
4877 }
4878
4879 container match {
4880 uses ofp_match;
4881
4882 description
4883 "Description of fields. Variable size.";
4884 }
4885
4886
4887
4888 }
4889
4890 grouping ofp_meter_band_header {
4891 description
4892 "Common header for all meter bands";
4893 leaf type {
4894 type ofp_meter_band_type;
4895
4896 description
4897 "One of OFPMBT_ .";
4898 }
4899
4900 leaf len {
4901 type uint32;
4902 description
4903 "Length in bytes of this band.";
4904 }
4905
4906 leaf rate {
4907 type uint32;
4908 description
4909 "Rate for this band.";
4910 }
4911
4912 leaf burst_size {
4913 type uint32;
4914 description
4915 "Size of bursts.";
4916 }
4917
4918
4919
4920 }
4921
4922 container ofp_meter_band_drop {
4923 description
4924 "OFPMBT_DROP band - drop packets";
4925 leaf type {
4926 type uint32;
4927 description
4928 "OFPMBT_DROP.";
4929 }
4930
4931 leaf len {
4932 type uint32;
4933 description
4934 "Length in bytes of this band.";
4935 }
4936
4937 leaf rate {
4938 type uint32;
4939 description
4940 "Rate for dropping packets.";
4941 }
4942
4943 leaf burst_size {
4944 type uint32;
4945 description
4946 "Size of bursts.";
4947 }
4948
4949
4950
4951 }
4952
4953 container ofp_meter_band_dscp_remark {
4954 description
4955 "OFPMBT_DSCP_REMARK band - Remark DSCP in the IP header";
4956 leaf type {
4957 type uint32;
4958 description
4959 "OFPMBT_DSCP_REMARK.";
4960 }
4961
4962 leaf len {
4963 type uint32;
4964 description
4965 "Length in bytes of this band.";
4966 }
4967
4968 leaf rate {
4969 type uint32;
4970 description
4971 "Rate for remarking packets.";
4972 }
4973
4974 leaf burst_size {
4975 type uint32;
4976 description
4977 "Size of bursts.";
4978 }
4979
4980 leaf prec_level {
4981 type uint32;
4982 description
4983 "Number of drop precedence level to add.";
4984 }
4985
4986
4987
4988 }
4989
4990 container ofp_meter_band_experimenter {
4991 description
4992 "OFPMBT_EXPERIMENTER band - Experimenter type.
4993 The rest of the band is experimenter-defined.";
4994 leaf type {
4995 type ofp_meter_band_type;
4996
4997 description
4998 "One of OFPMBT_ .";
4999 }
5000
5001 leaf len {
5002 type uint32;
5003 description
5004 "Length in bytes of this band.";
5005 }
5006
5007 leaf rate {
5008 type uint32;
5009 description
5010 "Rate for this band.";
5011 }
5012
5013 leaf burst_size {
5014 type uint32;
5015 description
5016 "Size of bursts.";
5017 }
5018
5019 leaf experimenter {
5020 type uint32;
5021 description
5022 "Experimenter ID which takes the
5023same form as in struct
5024ofp_experimenter_header.";
5025 }
5026
5027
5028
5029 }
5030
5031 container ofp_meter_mod {
5032 description
5033 "Meter configuration. OFPT_METER_MOD.";
5034 leaf command {
5035 type ofp_meter_mod_command;
5036
5037 description
5038 "ofp_header header = 1;
5039One of OFPMC_ .";
5040 }
5041
5042 leaf flags {
5043 type uint32;
5044 description
5045 "Bitmap of OFPMF_ flags.";
5046 }
5047
5048 leaf meter_id {
5049 type uint32;
5050 description
5051 "Meter instance.";
5052 }
5053
5054 list bands {
5055 key "type";
5056 uses ofp_meter_band_header;
5057
5058 description
5059 "The band list length is
5060inferred from the length field
5061in the header.";
5062 }
5063
5064
5065
5066 }
5067
5068 container ofp_error_msg {
5069 description
5070 "OFPT_ERROR: Error message (datapath - controller).";
5071 leaf type {
5072 type uint32;
5073 description
5074 "ofp_header header;";
5075 }
5076
5077 leaf code {
5078 type uint32;
5079 description
5080 "";
5081 }
5082
5083 leaf data {
5084 type binary;
5085 description
5086 "Variable-length data. Interpreted based
5087on the type and code. No padding.";
5088 }
5089
5090
5091
5092 }
5093
5094 container ofp_error_experimenter_msg {
5095 description
5096 "OFPET_EXPERIMENTER: Error message (datapath - controller).ofp_header header;";
5097 leaf type {
5098 type uint32;
5099 description
5100 "OFPET_EXPERIMENTER.";
5101 }
5102
5103 leaf exp_type {
5104 type uint32;
5105 description
5106 "Experimenter defined.";
5107 }
5108
5109 leaf experimenter {
5110 type uint32;
5111 description
5112 "Experimenter ID which takes the same form
5113as in struct ofp_experimenter_header.";
5114 }
5115
5116 leaf data {
5117 type binary;
5118 description
5119 "Variable-length data. Interpreted based
5120on the type and code. No padding.";
5121 }
5122
5123
5124
5125 }
5126
5127 container ofp_multipart_request {
5128 description
5129 "";
5130 leaf type {
5131 type ofp_multipart_type;
5132
5133 description
5134 "ofp_header header;
5135One of the OFPMP_ constants.";
5136 }
5137
5138 leaf flags {
5139 type uint32;
5140 description
5141 "OFPMPF_REQ_ flags.";
5142 }
5143
5144 leaf body {
5145 type binary;
5146 description
5147 "Body of the request. 0 or more bytes.";
5148 }
5149
5150
5151
5152 }
5153
5154 container ofp_multipart_reply {
5155 description
5156 "";
5157 leaf type {
5158 type ofp_multipart_type;
5159
5160 description
5161 "ofp_header header;
5162One of the OFPMP_ constants.";
5163 }
5164
5165 leaf flags {
5166 type uint32;
5167 description
5168 "OFPMPF_REPLY_ flags.";
5169 }
5170
5171 leaf body {
5172 type binary;
5173 description
5174 "Body of the reply. 0 or more bytes.";
5175 }
5176
5177
5178
5179 }
5180
5181 grouping ofp_desc {
5182 description
5183 "Body of reply to OFPMP_DESC request. Each entry is a NULL-terminated
5184 ASCII string.#define DESC_STR_LEN 256
5185#define SERIAL_NUM_LEN 32";
5186 leaf mfr_desc {
5187 type string;
5188 description
5189 "Manufacturer description.";
5190 }
5191
5192 leaf hw_desc {
5193 type string;
5194 description
5195 "Hardware description.";
5196 }
5197
5198 leaf sw_desc {
5199 type string;
5200 description
5201 "Software description.";
5202 }
5203
5204 leaf serial_num {
5205 type string;
5206 description
5207 "Serial number.";
5208 }
5209
5210 leaf dp_desc {
5211 type string;
5212 description
5213 "Human readable description of datapath.";
5214 }
5215
5216
5217
5218 }
5219
5220 container ofp_flow_stats_request {
5221 description
5222 "Body for ofp_multipart_request of type OFPMP_FLOW.";
5223 leaf table_id {
5224 type uint32;
5225 description
5226 "ID of table to read (from ofp_table_stats),
5227OFPTT_ALL for all tables.";
5228 }
5229
5230 leaf out_port {
5231 type uint32;
5232 description
5233 "Require matching entries to include this
5234as an output port. A value of OFPP_ANY
5235indicates no restriction.";
5236 }
5237
5238 leaf out_group {
5239 type uint32;
5240 description
5241 "Require matching entries to include this
5242as an output group. A value of OFPG_ANY
5243indicates no restriction.";
5244 }
5245
5246 leaf cookie {
5247 type uint64;
5248 description
5249 "Require matching entries to contain this
5250cookie value";
5251 }
5252
5253 leaf cookie_mask {
5254 type uint64;
5255 description
5256 "Mask used to restrict the cookie bits that
5257must match. A value of 0 indicates
5258no restriction.";
5259 }
5260
5261 container match {
5262 uses ofp_match;
5263
5264 description
5265 "Fields to match. Variable size.";
5266 }
5267
5268
5269
5270 }
5271
5272 grouping ofp_flow_stats {
5273 description
5274 "Body of reply to OFPMP_FLOW request.";
5275 leaf id {
5276 type uint64;
5277 description
5278 "Unique ID of flow within device.";
5279 }
5280
5281 leaf table_id {
5282 type uint32;
5283 description
5284 "ID of table flow came from.";
5285 }
5286
5287 leaf duration_sec {
5288 type uint32;
5289 description
5290 "Time flow has been alive in seconds.";
5291 }
5292
5293 leaf duration_nsec {
5294 type uint32;
5295 description
5296 "Time flow has been alive in nanoseconds
5297beyond duration_sec.";
5298 }
5299
5300 leaf priority {
5301 type uint32;
5302 description
5303 "Priority of the entry.";
5304 }
5305
5306 leaf idle_timeout {
5307 type uint32;
5308 description
5309 "Number of seconds idle before expiration.";
5310 }
5311
5312 leaf hard_timeout {
5313 type uint32;
5314 description
5315 "Number of seconds before expiration.";
5316 }
5317
5318 leaf flags {
5319 type uint32;
5320 description
5321 "Bitmap of OFPFF_ flags.";
5322 }
5323
5324 leaf cookie {
5325 type uint64;
5326 description
5327 "Opaque controller-issued identifier.";
5328 }
5329
5330 leaf packet_count {
5331 type uint64;
5332 description
5333 "Number of packets in flow.";
5334 }
5335
5336 leaf byte_count {
5337 type uint64;
5338 description
5339 "Number of bytes in flow.";
5340 }
5341
5342 container match {
5343 uses ofp_match;
5344
5345 description
5346 "Description of fields. Variable size.";
5347 }
5348
5349 list instructions {
5350 key "type";
5351 uses ofp_instruction;
5352
5353 description
5354 "Instruction set
5355(0 or more)";
5356 }
5357
5358
5359
5360 }
5361
5362 container ofp_aggregate_stats_request {
5363 description
5364 "Body for ofp_multipart_request of type OFPMP_AGGREGATE.";
5365 leaf table_id {
5366 type uint32;
5367 description
5368 "ID of table to read (from ofp_table_stats)
5369OFPTT_ALL for all tables.";
5370 }
5371
5372 leaf out_port {
5373 type uint32;
5374 description
5375 "Require matching entries to include this
5376as an output port. A value of OFPP_ANY
5377indicates no restriction.";
5378 }
5379
5380 leaf out_group {
5381 type uint32;
5382 description
5383 "Require matching entries to include this
5384as an output group. A value of OFPG_ANY
5385indicates no restriction.";
5386 }
5387
5388 leaf cookie {
5389 type uint64;
5390 description
5391 "Require matching entries to contain this
5392cookie value";
5393 }
5394
5395 leaf cookie_mask {
5396 type uint64;
5397 description
5398 "Mask used to restrict the cookie bits that
5399must match. A value of 0 indicates
5400no restriction.";
5401 }
5402
5403 container match {
5404 uses ofp_match;
5405
5406 description
5407 "Fields to match. Variable size.";
5408 }
5409
5410
5411
5412 }
5413
5414 container ofp_aggregate_stats_reply {
5415 description
5416 "Body of reply to OFPMP_AGGREGATE request.";
5417 leaf packet_count {
5418 type uint64;
5419 description
5420 "Number of packets in flows.";
5421 }
5422
5423 leaf byte_count {
5424 type uint64;
5425 description
5426 "Number of bytes in flows.";
5427 }
5428
5429 leaf flow_count {
5430 type uint32;
5431 description
5432 "Number of flows.";
5433 }
5434
5435
5436
5437 }
5438
5439 grouping ofp_table_feature_property {
5440 description
5441 "Common header for all Table Feature Properties";
5442 leaf type {
5443 type ofp_table_feature_prop_type;
5444
5445 description
5446 "One of OFPTFPT_ .";
5447 }
5448
5449
5450
5451 choice choice_0 {
5452 case instructions {
5453 container instructions {
5454 uses ofp_table_feature_prop_instructions;
5455
5456 description
5457 "";
5458 }
5459 }
5460 case next_tables {
5461 container next_tables {
5462 uses ofp_table_feature_prop_next_tables;
5463
5464 description
5465 "";
5466 }
5467 }
5468 case actions {
5469 container actions {
5470 uses ofp_table_feature_prop_actions;
5471
5472 description
5473 "";
5474 }
5475 }
5476 case oxm {
5477 container oxm {
5478 uses ofp_table_feature_prop_oxm;
5479
5480 description
5481 "";
5482 }
5483 }
5484 case experimenter {
5485 container experimenter {
5486 uses ofp_table_feature_prop_experimenter;
5487
5488 description
5489 "";
5490 }
5491 }
5492 }
5493
5494
5495 }
5496
5497 grouping ofp_table_feature_prop_instructions {
5498 description
5499 "Instructions property";
5500 list instructions {
5501 key "type";
5502 uses ofp_instruction;
5503
5504 description
5505 "One of OFPTFPT_INSTRUCTIONS,
5506OFPTFPT_INSTRUCTIONS_MISS.List of instructions";
5507 }
5508
5509
5510
5511 }
5512
5513 grouping ofp_table_feature_prop_next_tables {
5514 description
5515 "Next Tables property";
5516 list next_table_ids {
5517 key "next_table_ids";
5518 leaf next_table_ids {
5519 type uint32;
5520 description
5521 "One of OFPTFPT_NEXT_TABLES,
5522OFPTFPT_NEXT_TABLES_MISS.List of table ids.";
5523 }
5524 description
5525 "One of OFPTFPT_NEXT_TABLES,
5526OFPTFPT_NEXT_TABLES_MISS.List of table ids.";
5527 }
5528
5529
5530
5531 }
5532
5533 grouping ofp_table_feature_prop_actions {
5534 description
5535 "Actions property";
5536 list actions {
5537 key "type";
5538 uses ofp_action;
5539
5540 description
5541 "One of OFPTFPT_WRITE_ACTIONS,
5542OFPTFPT_WRITE_ACTIONS_MISS,
5543OFPTFPT_APPLY_ACTIONS,
5544OFPTFPT_APPLY_ACTIONS_MISS.List of actions";
5545 }
5546
5547
5548
5549 }
5550
5551 grouping ofp_table_feature_prop_oxm {
5552 description
5553 "Match, Wildcard or Set-Field propertyOne of OFPTFPT_MATCH,
5554OFPTFPT_WILDCARDS,
5555OFPTFPT_WRITE_SETFIELD,
5556OFPTFPT_WRITE_SETFIELD_MISS,
5557OFPTFPT_APPLY_SETFIELD,
5558OFPTFPT_APPLY_SETFIELD_MISS.";
5559 list oxm_ids {
5560 key "oxm_ids";
5561 leaf oxm_ids {
5562 type uint32;
5563 description
5564 "TODO is this a uint32???Array of OXM headers";
5565 }
5566 description
5567 "TODO is this a uint32???Array of OXM headers";
5568 }
5569
5570
5571
5572 }
5573
5574 grouping ofp_table_feature_prop_experimenter {
5575 description
5576 "Experimenter table feature property";
5577 leaf experimenter {
5578 type uint32;
5579 description
5580 "One of OFPTFPT_EXPERIMENTER,
5581OFPTFPT_EXPERIMENTER_MISS.Experimenter ID which takes the same
5582form as in struct
5583ofp_experimenter_header.";
5584 }
5585
5586 leaf exp_type {
5587 type uint32;
5588 description
5589 "Experimenter defined.";
5590 }
5591
5592 list experimenter_data {
5593 key "experimenter_data";
5594 leaf experimenter_data {
5595 type uint32;
5596 description
5597 "";
5598 }
5599 description
5600 "";
5601 }
5602
5603
5604
5605 }
5606
5607 container ofp_table_features {
5608 description
5609 "Body for ofp_multipart_request of type OFPMP_TABLE_FEATURES.
5610 Body of reply to OFPMP_TABLE_FEATURES request.";
5611 leaf table_id {
5612 type uint32;
5613 description
5614 "Identifier of table. Lower numbered tables
5615are consulted first.";
5616 }
5617
5618 leaf name {
5619 type string;
5620 description
5621 "";
5622 }
5623
5624 leaf metadata_match {
5625 type uint64;
5626 description
5627 "Bits of metadata table can match.";
5628 }
5629
5630 leaf metadata_write {
5631 type uint64;
5632 description
5633 "Bits of metadata table can write.";
5634 }
5635
5636 leaf config {
5637 type uint32;
5638 description
5639 "Bitmap of OFPTC_ values";
5640 }
5641
5642 leaf max_entries {
5643 type uint32;
5644 description
5645 "Max number of entries supported.";
5646 }
5647
5648 list properties {
5649 key "type";
5650 uses ofp_table_feature_property;
5651
5652 description
5653 "Table Feature Property list";
5654 }
5655
5656
5657
5658 }
5659
5660 container ofp_table_stats {
5661 description
5662 "Body of reply to OFPMP_TABLE request.";
5663 leaf table_id {
5664 type uint32;
5665 description
5666 "Identifier of table. Lower numbered tables
5667are consulted first.";
5668 }
5669
5670 leaf active_count {
5671 type uint32;
5672 description
5673 "Number of active entries.";
5674 }
5675
5676 leaf lookup_count {
5677 type uint64;
5678 description
5679 "Number of packets looked up in table.";
5680 }
5681
5682 leaf matched_count {
5683 type uint64;
5684 description
5685 "Number of packets that hit table.";
5686 }
5687
5688
5689
5690 }
5691
5692 container ofp_port_stats_request {
5693 description
5694 "Body for ofp_multipart_request of type OFPMP_PORT.";
5695 leaf port_no {
5696 type uint32;
5697 description
5698 "OFPMP_PORT message must request statistics
5699 either for a single port (specified in
5700 port_no) or for all ports (if port_no ==
5701 OFPP_ANY).";
5702 }
5703
5704
5705
5706 }
5707
5708 container ofp_port_stats {
5709 description
5710 "Body of reply to OFPMP_PORT request. If a counter is unsupported, set
5711 the field to all ones.";
5712 leaf port_no {
5713 type uint32;
5714 description
5715 "";
5716 }
5717
5718 leaf rx_packets {
5719 type uint64;
5720 description
5721 "Number of received packets.";
5722 }
5723
5724 leaf tx_packets {
5725 type uint64;
5726 description
5727 "Number of transmitted packets.";
5728 }
5729
5730 leaf rx_bytes {
5731 type uint64;
5732 description
5733 "Number of received bytes.";
5734 }
5735
5736 leaf tx_bytes {
5737 type uint64;
5738 description
5739 "Number of transmitted bytes.";
5740 }
5741
5742 leaf rx_dropped {
5743 type uint64;
5744 description
5745 "Number of packets dropped by RX.";
5746 }
5747
5748 leaf tx_dropped {
5749 type uint64;
5750 description
5751 "Number of packets dropped by TX.";
5752 }
5753
5754 leaf rx_errors {
5755 type uint64;
5756 description
5757 "Number of receive errors. This is a super-set
5758of more specific receive errors and should be
5759greater than or equal to the sum of all
5760rx_ _err values.";
5761 }
5762
5763 leaf tx_errors {
5764 type uint64;
5765 description
5766 "Number of transmit errors. This is a super-set
5767of more specific transmit errors and should be
5768greater than or equal to the sum of all
5769tx_ _err values (none currently defined.)";
5770 }
5771
5772 leaf rx_frame_err {
5773 type uint64;
5774 description
5775 "Number of frame alignment errors.";
5776 }
5777
5778 leaf rx_over_err {
5779 type uint64;
5780 description
5781 "Number of packets with RX overrun.";
5782 }
5783
5784 leaf rx_crc_err {
5785 type uint64;
5786 description
5787 "Number of CRC errors.";
5788 }
5789
5790 leaf collisions {
5791 type uint64;
5792 description
5793 "Number of collisions.";
5794 }
5795
5796 leaf duration_sec {
5797 type uint32;
5798 description
5799 "Time port has been alive in seconds.";
5800 }
5801
5802 leaf duration_nsec {
5803 type uint32;
5804 description
5805 "Time port has been alive in nanoseconds
5806beyond duration_sec.";
5807 }
5808
5809
5810
5811 }
5812
5813 container ofp_group_stats_request {
5814 description
5815 "Body of OFPMP_GROUP request.";
5816 leaf group_id {
5817 type uint32;
5818 description
5819 "All groups if OFPG_ALL.";
5820 }
5821
5822
5823
5824 }
5825
5826 grouping ofp_bucket_counter {
5827 description
5828 "Used in group stats replies.";
5829 leaf packet_count {
5830 type uint64;
5831 description
5832 "Number of packets processed by bucket.";
5833 }
5834
5835 leaf byte_count {
5836 type uint64;
5837 description
5838 "Number of bytes processed by bucket.";
5839 }
5840
5841
5842
5843 }
5844
5845 grouping ofp_group_stats {
5846 description
5847 "Body of reply to OFPMP_GROUP request.";
5848 leaf group_id {
5849 type uint32;
5850 description
5851 "Group identifier.";
5852 }
5853
5854 leaf ref_count {
5855 type uint32;
5856 description
5857 "Number of flows or groups that directly
5858forward to this group.";
5859 }
5860
5861 leaf packet_count {
5862 type uint64;
5863 description
5864 "Number of packets processed by group.";
5865 }
5866
5867 leaf byte_count {
5868 type uint64;
5869 description
5870 "Number of bytes processed by group.";
5871 }
5872
5873 leaf duration_sec {
5874 type uint32;
5875 description
5876 "Time group has been alive in seconds.";
5877 }
5878
5879 leaf duration_nsec {
5880 type uint32;
5881 description
5882 "Time group has been alive in nanoseconds
5883beyond duration_sec.";
5884 }
5885
5886 list bucket_stats {
5887 key "packet_count";
5888 uses ofp_bucket_counter;
5889
5890 description
5891 "One counter set per
5892bucket.";
5893 }
5894
5895
5896
5897 }
5898
5899 grouping ofp_group_desc {
5900 description
5901 "Body of reply to OFPMP_GROUP_DESC request.";
5902 leaf type {
5903 type ofp_group_type;
5904
5905 description
5906 "One of OFPGT_ .";
5907 }
5908
5909 leaf group_id {
5910 type uint32;
5911 description
5912 "Group identifier.";
5913 }
5914
5915 list buckets {
5916 key "weight";
5917 uses ofp_bucket;
5918
5919 description
5920 "List of buckets - 0 or more.";
5921 }
5922
5923
5924
5925 }
5926
5927 grouping ofp_group_entry {
5928 description
5929 "";
5930 leaf type {
5931 type ofp_group_type;
5932
5933 description
5934 "One of OFPGT_ .";
5935 }
5936
5937 leaf group_id {
5938 type uint32;
5939 description
5940 "Group identifier.";
5941 }
5942
5943 list buckets {
5944 key "weight";
5945 uses ofp_bucket;
5946
5947 description
5948 "List of buckets - 0 or more.";
5949 }
5950
5951 container stats {
5952 uses ofp_group_stats;
5953
5954 description
5955 "";
5956 }
5957
5958
5959
5960 }
5961
5962 container ofp_group_features {
5963 description
5964 "Body of reply to OFPMP_GROUP_FEATURES request. Group features.";
5965 leaf types {
5966 type uint32;
5967 description
5968 "Bitmap of (1 OFPGT_ ) values supported.";
5969 }
5970
5971 leaf capabilities {
5972 type uint32;
5973 description
5974 "Bitmap of OFPGFC_ capability supported.";
5975 }
5976
5977 list max_groups {
5978 key "max_groups";
5979 leaf max_groups {
5980 type uint32;
5981 description
5982 "Maximum number of groups for each type.";
5983 }
5984 description
5985 "Maximum number of groups for each type.";
5986 }
5987
5988 list actions {
5989 key "actions";
5990 leaf actions {
5991 type uint32;
5992 description
5993 "Bitmaps of (1 OFPAT_ ) values
5994supported.";
5995 }
5996 description
5997 "Bitmaps of (1 OFPAT_ ) values
5998supported.";
5999 }
6000
6001
6002
6003 }
6004
6005 container ofp_meter_multipart_request {
6006 description
6007 "Body of OFPMP_METER and OFPMP_METER_CONFIG requests.";
6008 leaf meter_id {
6009 type uint32;
6010 description
6011 "Meter instance, or OFPM_ALL.";
6012 }
6013
6014
6015
6016 }
6017
6018 grouping ofp_meter_band_stats {
6019 description
6020 "Statistics for each meter band";
6021 leaf packet_band_count {
6022 type uint64;
6023 description
6024 "Number of packets in band.";
6025 }
6026
6027 leaf byte_band_count {
6028 type uint64;
6029 description
6030 "Number of bytes in band.";
6031 }
6032
6033
6034
6035 }
6036
6037 container ofp_meter_stats {
6038 description
6039 "Body of reply to OFPMP_METER request. Meter statistics.";
6040 leaf meter_id {
6041 type uint32;
6042 description
6043 "Meter instance.";
6044 }
6045
6046 leaf flow_count {
6047 type uint32;
6048 description
6049 "Number of flows bound to meter.";
6050 }
6051
6052 leaf packet_in_count {
6053 type uint64;
6054 description
6055 "Number of packets in input.";
6056 }
6057
6058 leaf byte_in_count {
6059 type uint64;
6060 description
6061 "Number of bytes in input.";
6062 }
6063
6064 leaf duration_sec {
6065 type uint32;
6066 description
6067 "Time meter has been alive in seconds.";
6068 }
6069
6070 leaf duration_nsec {
6071 type uint32;
6072 description
6073 "Time meter has been alive in nanoseconds
6074beyond duration_sec.";
6075 }
6076
6077 list band_stats {
6078 key "packet_band_count";
6079 uses ofp_meter_band_stats;
6080
6081 description
6082 "The band_stats length is
6083inferred from the length field.";
6084 }
6085
6086
6087
6088 }
6089
6090 container ofp_meter_config {
6091 description
6092 "Body of reply to OFPMP_METER_CONFIG request. Meter configuration.";
6093 leaf flags {
6094 type uint32;
6095 description
6096 "All OFPMF_ that apply.";
6097 }
6098
6099 leaf meter_id {
6100 type uint32;
6101 description
6102 "Meter instance.";
6103 }
6104
6105 list bands {
6106 key "type";
6107 uses ofp_meter_band_header;
6108
6109 description
6110 "The bands length is
6111inferred from the length field.";
6112 }
6113
6114
6115
6116 }
6117
6118 container ofp_meter_features {
6119 description
6120 "Body of reply to OFPMP_METER_FEATURES request. Meter features.";
6121 leaf max_meter {
6122 type uint32;
6123 description
6124 "Maximum number of meters.";
6125 }
6126
6127 leaf band_types {
6128 type uint32;
6129 description
6130 "Bitmaps of (1 OFPMBT_ ) values supported.";
6131 }
6132
6133 leaf capabilities {
6134 type uint32;
6135 description
6136 "Bitmaps of ofp_meter_flags .";
6137 }
6138
6139 leaf max_bands {
6140 type uint32;
6141 description
6142 "Maximum bands per meters";
6143 }
6144
6145 leaf max_color {
6146 type uint32;
6147 description
6148 "Maximum color value";
6149 }
6150
6151
6152
6153 }
6154
6155 container ofp_experimenter_multipart_header {
6156 description
6157 "Body for ofp_multipart_request reply of type OFPMP_EXPERIMENTER.";
6158 leaf experimenter {
6159 type uint32;
6160 description
6161 "Experimenter ID which takes the same form
6162as in struct ofp_experimenter_header.";
6163 }
6164
6165 leaf exp_type {
6166 type uint32;
6167 description
6168 "Experimenter defined.";
6169 }
6170
6171 leaf data {
6172 type binary;
6173 description
6174 "Experimenter-defined arbitrary additional data.";
6175 }
6176
6177
6178
6179 }
6180
6181 container ofp_experimenter_header {
6182 description
6183 "Experimenter extension.";
6184 leaf experimenter {
6185 type uint32;
6186 description
6187 "ofp_header header; Type OFPT_EXPERIMENTER.
6188Experimenter ID:
6189 - MSB 0: low-order bytes are IEEE OUI.
6190 - MSB != 0: defined by ONF.";
6191 }
6192
6193 leaf exp_type {
6194 type uint32;
6195 description
6196 "Experimenter defined.";
6197 }
6198
6199 leaf data {
6200 type binary;
6201 description
6202 "Experimenter-defined arbitrary additional data.";
6203 }
6204
6205
6206
6207 }
6208
6209 grouping ofp_queue_prop_header {
6210 description
6211 "Common description for a queue.";
6212 leaf property {
6213 type uint32;
6214 description
6215 "One of OFPQT_.";
6216 }
6217
6218 leaf len {
6219 type uint32;
6220 description
6221 "Length of property, including this header.";
6222 }
6223
6224
6225
6226 }
6227
6228 container ofp_queue_prop_min_rate {
6229 description
6230 "Min-Rate queue property description.";
6231 container prop_header {
6232 uses ofp_queue_prop_header;
6233
6234 description
6235 "prop: OFPQT_MIN, len: 16.";
6236 }
6237
6238 leaf rate {
6239 type uint32;
6240 description
6241 "In 1 10 of a percent = 0; 1000 - disabled.";
6242 }
6243
6244
6245
6246 }
6247
6248 container ofp_queue_prop_max_rate {
6249 description
6250 "Max-Rate queue property description.";
6251 container prop_header {
6252 uses ofp_queue_prop_header;
6253
6254 description
6255 "prop: OFPQT_MAX, len: 16.";
6256 }
6257
6258 leaf rate {
6259 type uint32;
6260 description
6261 "In 1 10 of a percent = 0; 1000 - disabled.";
6262 }
6263
6264
6265
6266 }
6267
6268 container ofp_queue_prop_experimenter {
6269 description
6270 "Experimenter queue property description.";
6271 container prop_header {
6272 uses ofp_queue_prop_header;
6273
6274 description
6275 "prop: OFPQT_EXPERIMENTER";
6276 }
6277
6278 leaf experimenter {
6279 type uint32;
6280 description
6281 "Experimenter ID which takes the same
6282form as in struct
6283ofp_experimenter_header.";
6284 }
6285
6286 leaf data {
6287 type binary;
6288 description
6289 "Experimenter defined data.";
6290 }
6291
6292
6293
6294 }
6295
6296 grouping ofp_packet_queue {
6297 description
6298 "Full description for a queue.";
6299 leaf queue_id {
6300 type uint32;
6301 description
6302 "id for the specific queue.";
6303 }
6304
6305 leaf port {
6306 type uint32;
6307 description
6308 "Port this queue is attached to.";
6309 }
6310
6311 list properties {
6312 key "property";
6313 uses ofp_queue_prop_header;
6314
6315 description
6316 "List of properties.";
6317 }
6318
6319
6320
6321 }
6322
6323 container ofp_queue_get_config_request {
6324 description
6325 "Query for port queue configuration.";
6326 leaf port {
6327 type uint32;
6328 description
6329 "ofp_header header;
6330Port to be queried. Should refer
6331to a valid physical port (i.e. = OFPP_MAX),
6332or OFPP_ANY to request all configured
6333queues.";
6334 }
6335
6336
6337
6338 }
6339
6340 container ofp_queue_get_config_reply {
6341 description
6342 "Queue configuration for a given port.";
6343 leaf port {
6344 type uint32;
6345 description
6346 "ofp_header header;";
6347 }
6348
6349 list queues {
6350 key "queue_id";
6351 uses ofp_packet_queue;
6352
6353 description
6354 "List of configured queues.";
6355 }
6356
6357
6358
6359 }
6360
6361 container ofp_action_set_queue {
6362 description
6363 "OFPAT_SET_QUEUE action struct: send packets to given queue on port.";
6364 leaf type {
6365 type uint32;
6366 description
6367 "OFPAT_SET_QUEUE.";
6368 }
6369
6370 leaf queue_id {
6371 type uint32;
6372 description
6373 "Queue id for the packets.";
6374 }
6375
6376
6377
6378 }
6379
6380 container ofp_queue_stats_request {
6381 description
6382 "";
6383 leaf port_no {
6384 type uint32;
6385 description
6386 "All ports if OFPP_ANY.";
6387 }
6388
6389 leaf queue_id {
6390 type uint32;
6391 description
6392 "All queues if OFPQ_ALL.";
6393 }
6394
6395
6396
6397 }
6398
6399 container ofp_queue_stats {
6400 description
6401 "";
6402 leaf port_no {
6403 type uint32;
6404 description
6405 "";
6406 }
6407
6408 leaf queue_id {
6409 type uint32;
6410 description
6411 "Queue i.d";
6412 }
6413
6414 leaf tx_bytes {
6415 type uint64;
6416 description
6417 "Number of transmitted bytes.";
6418 }
6419
6420 leaf tx_packets {
6421 type uint64;
6422 description
6423 "Number of transmitted packets.";
6424 }
6425
6426 leaf tx_errors {
6427 type uint64;
6428 description
6429 "Number of packets dropped due to overrun.";
6430 }
6431
6432 leaf duration_sec {
6433 type uint32;
6434 description
6435 "Time queue has been alive in seconds.";
6436 }
6437
6438 leaf duration_nsec {
6439 type uint32;
6440 description
6441 "Time queue has been alive in nanoseconds
6442beyond duration_sec.";
6443 }
6444
6445
6446
6447 }
6448
6449 container ofp_role_request {
6450 description
6451 "Role request and reply message.";
6452 leaf role {
6453 type ofp_controller_role;
6454
6455 description
6456 "ofp_header header; Type OFPT_ROLE_REQUEST OFPT_ROLE_REPLY.
6457One of OFPCR_ROLE_ .";
6458 }
6459
6460 leaf generation_id {
6461 type uint64;
6462 description
6463 "Master Election Generation Id";
6464 }
6465
6466
6467
6468 }
6469
6470 container ofp_async_config {
6471 description
6472 "Asynchronous message configuration.";
6473 list packet_in_mask {
6474 key "packet_in_mask";
6475 leaf packet_in_mask {
6476 type uint32;
6477 description
6478 "ofp_header header; OFPT_GET_ASYNC_REPLY or OFPT_SET_ASYNC.
6479Bitmasks of OFPR_ values.";
6480 }
6481 description
6482 "ofp_header header; OFPT_GET_ASYNC_REPLY or OFPT_SET_ASYNC.
6483Bitmasks of OFPR_ values.";
6484 }
6485
6486 list port_status_mask {
6487 key "port_status_mask";
6488 leaf port_status_mask {
6489 type uint32;
6490 description
6491 "Bitmasks of OFPPR_ values.";
6492 }
6493 description
6494 "Bitmasks of OFPPR_ values.";
6495 }
6496
6497 list flow_removed_mask {
6498 key "flow_removed_mask";
6499 leaf flow_removed_mask {
6500 type uint32;
6501 description
6502 "Bitmasks of OFPRR_ values.";
6503 }
6504 description
6505 "Bitmasks of OFPRR_ values.";
6506 }
6507
6508
6509
6510 }
6511
6512 grouping FlowTableUpdate {
6513 description
6514 "ADDITIONAL VOLTHA SPECIFIC MESSAGE TYPES, AIDING RPC CALLS";
6515 leaf id {
6516 type string;
6517 description
6518 "Device.id or LogicalDevice.id";
6519 }
6520
6521 container flow_mod {
6522 uses ofp_flow_mod;
6523
6524 description
6525 "";
6526 }
6527
6528
6529
6530 }
6531
6532 grouping FlowGroupTableUpdate {
6533 description
6534 "";
6535 leaf id {
6536 type string;
6537 description
6538 "Device.id or LogicalDevice.id";
6539 }
6540
6541 container group_mod {
6542 uses ofp_group_mod;
6543
6544 description
6545 "";
6546 }
6547
6548
6549
6550 }
6551
6552 grouping Flows {
6553 description
6554 "";
6555 list items {
6556 key "id";
6557 uses ofp_flow_stats;
6558
6559 description
6560 "";
6561 }
6562
6563
6564
6565 }
6566
6567 grouping FlowGroups {
6568 description
6569 "";
6570 list items {
6571 key "type";
6572 uses ofp_group_entry;
6573
6574 description
6575 "";
6576 }
6577
6578
6579
6580 }
6581
6582 grouping PacketIn {
6583 description
6584 "";
6585 leaf id {
6586 type string;
6587 description
6588 "LogicalDevice.id";
6589 }
6590
6591 container packet_in {
6592 uses ofp_packet_in;
6593
6594 description
6595 "";
6596 }
6597
6598
6599
6600 }
6601
6602 grouping PacketOut {
6603 description
6604 "";
6605 leaf id {
6606 type string;
6607 description
6608 "LogicalDevice.id";
6609 }
6610
6611 container packet_out {
6612 uses ofp_packet_out;
6613
6614 description
6615 "";
6616 }
6617
6618
6619
6620 }
6621
6622 grouping ChangeEvent {
6623 description
6624 "";
6625 leaf id {
6626 type string;
6627 description
6628 "LogicalDevice.id";
6629 }
6630
6631
6632
6633 choice choice_0 {
6634 case port_status {
6635 container port_status {
6636 uses ofp_port_status;
6637
6638 description
6639 "";
6640 }
6641 }
6642 }
6643
6644
6645 }
6646
6647
6648 /* Health related services" */
6649 rpc HealthService-GetHealthStatus {
6650 description
6651 "Return current health status of a Voltha instance";
6652 input {
6653 uses Empty;
6654
6655 }
6656 output {
6657 uses HealthStatus;
6658
6659 }
6660 }
6661
6662 /* Cluster-wide Voltha APIs
6663
6664 These APIs are potentially dispatched to the leader of the Voltha cluster,
6665 to a specific Voltha instance which owns the given device or logical device." */
6666 rpc VolthaGlobalService-GetVoltha {
6667 description
6668 "Get high level information on the Voltha cluster";
6669 input {
6670 uses Empty;
6671
6672 }
6673 output {
6674 uses Voltha_grouping;
6675 }
6676 }
6677
6678 rpc VolthaGlobalService-ListVolthaInstances {
6679 description
6680 "List all Voltha cluster instances";
6681 input {
6682 uses Empty;
6683
6684 }
6685 output {
6686 uses VolthaInstances_grouping;
6687 }
6688 }
6689
6690 rpc VolthaGlobalService-GetVolthaInstance {
6691 description
6692 "Get details on a Voltha cluster instance";
6693 input {
6694 uses ID;
6695
6696 }
6697 output {
6698 uses VolthaInstance_grouping;
6699 }
6700 }
6701
6702 rpc VolthaGlobalService-ListLogicalDevices {
6703 description
6704 "List all logical devices managed by the Voltha cluster";
6705 input {
6706 uses Empty;
6707
6708 }
6709 output {
6710 uses LogicalDevices;
6711
6712 }
6713 }
6714
6715 rpc VolthaGlobalService-GetLogicalDevice {
6716 description
6717 "Get additional information on a given logical device";
6718 input {
6719 uses ID;
6720
6721 }
6722 output {
6723 uses LogicalDevice;
6724
6725 }
6726 }
6727
6728 rpc VolthaGlobalService-ListLogicalDevicePorts {
6729 description
6730 "List ports of a logical device";
6731 input {
6732 uses ID;
6733
6734 }
6735 output {
6736 uses LogicalPorts;
6737
6738 }
6739 }
6740
6741 rpc VolthaGlobalService-ListLogicalDeviceFlows {
6742 description
6743 "List all flows of a logical device";
6744 input {
6745 uses ID;
6746
6747 }
6748 output {
6749 uses Flows;
6750
6751 }
6752 }
6753
6754 rpc VolthaGlobalService-UpdateLogicalDeviceFlowTable {
6755 description
6756 "Update flow table for logical device";
6757 input {
6758 uses FlowTableUpdate;
6759
6760 }
6761 output {
6762 uses Empty;
6763
6764 }
6765 }
6766
6767 rpc VolthaGlobalService-ListLogicalDeviceFlowGroups {
6768 description
6769 "List all flow groups of a logical device";
6770 input {
6771 uses ID;
6772
6773 }
6774 output {
6775 uses FlowGroups;
6776
6777 }
6778 }
6779
6780 rpc VolthaGlobalService-UpdateLogicalDeviceFlowGroupTable {
6781 description
6782 "Update group table for device";
6783 input {
6784 uses FlowGroupTableUpdate;
6785
6786 }
6787 output {
6788 uses Empty;
6789
6790 }
6791 }
6792
6793 rpc VolthaGlobalService-ListDevices {
6794 description
6795 "List all physical devices controlled by the Voltha cluster";
6796 input {
6797 uses Empty;
6798
6799 }
6800 output {
6801 uses Devices;
6802
6803 }
6804 }
6805
6806 rpc VolthaGlobalService-GetDevice {
6807 description
6808 "Get more information on a given physical device";
6809 input {
6810 uses ID;
6811
6812 }
6813 output {
6814 uses Device;
6815
6816 }
6817 }
6818
6819 rpc VolthaGlobalService-CreateDevice {
6820 description
6821 "Pre-provision a new physical device";
6822 input {
6823 uses Device;
6824
6825 }
6826 output {
6827 uses Device;
6828
6829 }
6830 }
6831
6832 rpc VolthaGlobalService-EnableDevice {
6833 description
6834 "Enable a device. If the device was in pre-provisioned state then it
6835 will tansition to ENABLED state. If it was is DISABLED state then it
6836 will tansition to ENABLED state as well.";
6837 input {
6838 uses ID;
6839
6840 }
6841 output {
6842 uses Empty;
6843
6844 }
6845 }
6846
6847 rpc VolthaGlobalService-DisableDevice {
6848 description
6849 "Disable a device";
6850 input {
6851 uses ID;
6852
6853 }
6854 output {
6855 uses Empty;
6856
6857 }
6858 }
6859
6860 rpc VolthaGlobalService-RebootDevice {
6861 description
6862 "Reboot a device";
6863 input {
6864 uses ID;
6865
6866 }
6867 output {
6868 uses Empty;
6869
6870 }
6871 }
6872
6873 rpc VolthaGlobalService-DeleteDevice {
6874 description
6875 "Delete a device";
6876 input {
6877 uses ID;
6878
6879 }
6880 output {
6881 uses Empty;
6882
6883 }
6884 }
6885
6886 rpc VolthaGlobalService-ListDevicePorts {
6887 description
6888 "List ports of a device";
6889 input {
6890 uses ID;
6891
6892 }
6893 output {
6894 uses Ports;
6895
6896 }
6897 }
6898
6899 rpc VolthaGlobalService-ListDevicePmConfigs {
6900 description
6901 "List pm config of a device";
6902 input {
6903 uses ID;
6904
6905 }
6906 output {
6907 uses PmConfigs;
6908
6909 }
6910 }
6911
6912 rpc VolthaGlobalService-UpdateDevicePmConfigs {
6913 description
6914 "Update the pm config of a device";
6915 input {
6916 uses PmConfigs;
6917
6918 }
6919 output {
6920 uses Empty;
6921
6922 }
6923 }
6924
6925 rpc VolthaGlobalService-ListDeviceFlows {
6926 description
6927 "List all flows of a device";
6928 input {
6929 uses ID;
6930
6931 }
6932 output {
6933 uses Flows;
6934
6935 }
6936 }
6937
6938 rpc VolthaGlobalService-ListDeviceFlowGroups {
6939 description
6940 "List all flow groups of a device";
6941 input {
6942 uses ID;
6943
6944 }
6945 output {
6946 uses FlowGroups;
6947
6948 }
6949 }
6950
6951 rpc VolthaGlobalService-ListDeviceTypes {
6952 description
6953 "List device types known to Voltha";
6954 input {
6955 uses Empty;
6956
6957 }
6958 output {
6959 uses DeviceTypes;
6960
6961 }
6962 }
6963
6964 rpc VolthaGlobalService-GetDeviceType {
6965 description
6966 "Get additional information on a device type";
6967 input {
6968 uses ID;
6969
6970 }
6971 output {
6972 uses DeviceType;
6973
6974 }
6975 }
6976
6977 rpc VolthaGlobalService-ListDeviceGroups {
6978 description
6979 "List all device sharding groups";
6980 input {
6981 uses Empty;
6982
6983 }
6984 output {
6985 uses DeviceGroups;
6986
6987 }
6988 }
6989
6990 rpc VolthaGlobalService-GetDeviceGroup {
6991 description
6992 "Get additional information on a device group";
6993 input {
6994 uses ID;
6995
6996 }
6997 output {
6998 uses DeviceGroup;
6999
7000 }
7001 }
7002
7003 rpc VolthaGlobalService-CreateAlarmFilter {
7004 description
7005 "";
7006 input {
7007 uses AlarmFilter;
7008
7009 }
7010 output {
7011 uses AlarmFilter;
7012
7013 }
7014 }
7015
7016 rpc VolthaGlobalService-GetAlarmFilter {
7017 description
7018 "";
7019 input {
7020 uses ID;
7021
7022 }
7023 output {
7024 uses AlarmFilter;
7025
7026 }
7027 }
7028
7029 rpc VolthaGlobalService-UpdateAlarmFilter {
7030 description
7031 "";
7032 input {
7033 uses AlarmFilter;
7034
7035 }
7036 output {
7037 uses AlarmFilter;
7038
7039 }
7040 }
7041
7042 rpc VolthaGlobalService-DeleteAlarmFilter {
7043 description
7044 "";
7045 input {
7046 uses ID;
7047
7048 }
7049 output {
7050 uses Empty;
7051
7052 }
7053 }
7054
7055 rpc VolthaGlobalService-ListAlarmFilters {
7056 description
7057 "";
7058 input {
7059 uses Empty;
7060
7061 }
7062 output {
7063 uses AlarmFilters;
7064
7065 }
7066 }
7067
7068
7069 /* Per-instance APIs
7070
7071 These APIs are always served locally by the Voltha instance on which the
7072 call is made." */
7073 rpc VolthaLocalService-GetVolthaInstance {
7074 description
7075 "Get information on this Voltha instance";
7076 input {
7077 uses Empty;
7078
7079 }
7080 output {
7081 uses VolthaInstance_grouping;
7082 }
7083 }
7084
7085 rpc VolthaLocalService-GetHealth {
7086 description
7087 "Get the health state of the Voltha instance";
7088 input {
7089 uses Empty;
7090
7091 }
7092 output {
7093 uses HealthStatus;
7094
7095 }
7096 }
7097
7098 rpc VolthaLocalService-ListAdapters {
7099 description
7100 "List all active adapters (plugins) in this Voltha instance";
7101 input {
7102 uses Empty;
7103
7104 }
7105 output {
7106 uses Adapters;
7107
7108 }
7109 }
7110
7111 rpc VolthaLocalService-ListLogicalDevices {
7112 description
7113 "List all logical devices managed by this Voltha instance";
7114 input {
7115 uses Empty;
7116
7117 }
7118 output {
7119 uses LogicalDevices;
7120
7121 }
7122 }
7123
7124 rpc VolthaLocalService-GetLogicalDevice {
7125 description
7126 "Get additional information on given logical device";
7127 input {
7128 uses ID;
7129
7130 }
7131 output {
7132 uses LogicalDevice;
7133
7134 }
7135 }
7136
7137 rpc VolthaLocalService-ListLogicalDevicePorts {
7138 description
7139 "List ports of a logical device";
7140 input {
7141 uses ID;
7142
7143 }
7144 output {
7145 uses LogicalPorts;
7146
7147 }
7148 }
7149
7150 rpc VolthaLocalService-ListLogicalDeviceFlows {
7151 description
7152 "List all flows of a logical device";
7153 input {
7154 uses ID;
7155
7156 }
7157 output {
7158 uses Flows;
7159
7160 }
7161 }
7162
7163 rpc VolthaLocalService-UpdateLogicalDeviceFlowTable {
7164 description
7165 "Update flow table for logical device";
7166 input {
7167 uses FlowTableUpdate;
7168
7169 }
7170 output {
7171 uses Empty;
7172
7173 }
7174 }
7175
7176 rpc VolthaLocalService-ListLogicalDeviceFlowGroups {
7177 description
7178 "List all flow groups of a logical device";
7179 input {
7180 uses ID;
7181
7182 }
7183 output {
7184 uses FlowGroups;
7185
7186 }
7187 }
7188
7189 rpc VolthaLocalService-UpdateLogicalDeviceFlowGroupTable {
7190 description
7191 "Update group table for logical device";
7192 input {
7193 uses FlowGroupTableUpdate;
7194
7195 }
7196 output {
7197 uses Empty;
7198
7199 }
7200 }
7201
7202 rpc VolthaLocalService-ListDevices {
7203 description
7204 "List all physical devices managed by this Voltha instance";
7205 input {
7206 uses Empty;
7207
7208 }
7209 output {
7210 uses Devices;
7211
7212 }
7213 }
7214
7215 rpc VolthaLocalService-GetDevice {
7216 description
7217 "Get additional information on this device";
7218 input {
7219 uses ID;
7220
7221 }
7222 output {
7223 uses Device;
7224
7225 }
7226 }
7227
7228 rpc VolthaLocalService-CreateDevice {
7229 description
7230 "Pre-provision a new physical device";
7231 input {
7232 uses Device;
7233
7234 }
7235 output {
7236 uses Device;
7237
7238 }
7239 }
7240
7241 rpc VolthaLocalService-EnableDevice {
7242 description
7243 "Enable a device. If the device was in pre-provisioned state then it
7244 will tansition to ENABLED state. If it was is DISABLED state then it
7245 will tansition to ENABLED state as well.";
7246 input {
7247 uses ID;
7248
7249 }
7250 output {
7251 uses Empty;
7252
7253 }
7254 }
7255
7256 rpc VolthaLocalService-DisableDevice {
7257 description
7258 "Disable a device";
7259 input {
7260 uses ID;
7261
7262 }
7263 output {
7264 uses Empty;
7265
7266 }
7267 }
7268
7269 rpc VolthaLocalService-RebootDevice {
7270 description
7271 "Reboot a device";
7272 input {
7273 uses ID;
7274
7275 }
7276 output {
7277 uses Empty;
7278
7279 }
7280 }
7281
7282 rpc VolthaLocalService-DeleteDevice {
7283 description
7284 "Delete a device";
7285 input {
7286 uses ID;
7287
7288 }
7289 output {
7290 uses Empty;
7291
7292 }
7293 }
7294
7295 rpc VolthaLocalService-ListDevicePorts {
7296 description
7297 "List ports of a device";
7298 input {
7299 uses ID;
7300
7301 }
7302 output {
7303 uses Ports;
7304
7305 }
7306 }
7307
7308 rpc VolthaLocalService-ListDevicePmConfigs {
7309 description
7310 "List pm config of a device";
7311 input {
7312 uses ID;
7313
7314 }
7315 output {
7316 uses PmConfigs;
7317
7318 }
7319 }
7320
7321 rpc VolthaLocalService-UpdateDevicePmConfigs {
7322 description
7323 "Update the pm config of a device";
7324 input {
7325 uses PmConfigs;
7326
7327 }
7328 output {
7329 uses Empty;
7330
7331 }
7332 }
7333
7334 rpc VolthaLocalService-ListDeviceFlows {
7335 description
7336 "List all flows of a device";
7337 input {
7338 uses ID;
7339
7340 }
7341 output {
7342 uses Flows;
7343
7344 }
7345 }
7346
7347 rpc VolthaLocalService-ListDeviceFlowGroups {
7348 description
7349 "List all flow groups of a device";
7350 input {
7351 uses ID;
7352
7353 }
7354 output {
7355 uses FlowGroups;
7356
7357 }
7358 }
7359
7360 rpc VolthaLocalService-ListDeviceTypes {
7361 description
7362 "List device types know to Voltha instance";
7363 input {
7364 uses Empty;
7365
7366 }
7367 output {
7368 uses DeviceTypes;
7369
7370 }
7371 }
7372
7373 rpc VolthaLocalService-GetDeviceType {
7374 description
7375 "Get additional information on given device type";
7376 input {
7377 uses ID;
7378
7379 }
7380 output {
7381 uses DeviceType;
7382
7383 }
7384 }
7385
7386 rpc VolthaLocalService-ListDeviceGroups {
7387 description
7388 "List device sharding groups managed by this Voltha instance";
7389 input {
7390 uses Empty;
7391
7392 }
7393 output {
7394 uses DeviceGroups;
7395
7396 }
7397 }
7398
7399 rpc VolthaLocalService-GetDeviceGroup {
7400 description
7401 "Get more information on given device shard";
7402 input {
7403 uses ID;
7404
7405 }
7406 output {
7407 uses DeviceGroup;
7408
7409 }
7410 }
7411
7412 rpc VolthaLocalService-StreamPacketsOut {
7413 description
7414 "Stream control packets to the dataplane
7415This does not have an HTTP representation";
7416 input {
7417 uses PacketOut;
7418
7419 }
7420 output {
7421 uses Empty;
7422
7423 }
7424 }
7425
7426 rpc VolthaLocalService-ReceivePacketsIn {
7427 description
7428 "Receive control packet stream
7429This does not have an HTTP representation";
7430 input {
7431 uses Empty;
7432
7433 }
7434 output {
7435 uses PacketIn;
7436
7437 }
7438 }
7439
7440 rpc VolthaLocalService-ReceiveChangeEvents {
7441 description
7442 "This does not have an HTTP representation";
7443 input {
7444 uses Empty;
7445
7446 }
7447 output {
7448 uses ChangeEvent;
7449
7450 }
7451 }
7452
7453 rpc VolthaLocalService-CreateAlarmFilter {
7454 description
7455 "";
7456 input {
7457 uses AlarmFilter;
7458
7459 }
7460 output {
7461 uses AlarmFilter;
7462
7463 }
7464 }
7465
7466 rpc VolthaLocalService-GetAlarmFilter {
7467 description
7468 "";
7469 input {
7470 uses ID;
7471
7472 }
7473 output {
7474 uses AlarmFilter;
7475
7476 }
7477 }
7478
7479 rpc VolthaLocalService-UpdateAlarmFilter {
7480 description
7481 "";
7482 input {
7483 uses AlarmFilter;
7484
7485 }
7486 output {
7487 uses AlarmFilter;
7488
7489 }
7490 }
7491
7492 rpc VolthaLocalService-DeleteAlarmFilter {
7493 description
7494 "";
7495 input {
7496 uses ID;
7497
7498 }
7499 output {
7500 uses Empty;
7501
7502 }
7503 }
7504
7505 rpc VolthaLocalService-ListAlarmFilters {
7506 description
7507 "";
7508 input {
7509 uses Empty;
7510
7511 }
7512 output {
7513 uses AlarmFilters;
7514
7515 }
7516 }
7517
7518
7519}