| module openconfig-interfaces { |
| |
| // namespace |
| namespace "http://openconfig.net/yang/interfaces"; |
| |
| prefix "oc-if"; |
| |
| // import some basic types |
| import ietf-interfaces { |
| prefix ietf-if; |
| } |
| import ietf-yang-types { |
| prefix yang; |
| } |
| import openconfig-extensions { |
| prefix oc-ext; |
| revision-date "2015-10-09"; |
| } |
| |
| // import tailf-common {prefix "tailf";} |
| // tailf:export netconf; |
| // tailf:export rest; |
| |
| // meta |
| organization "OpenConfig working group"; |
| |
| contact |
| "OpenConfig working group |
| netopenconfig@googlegroups.com"; |
| |
| description |
| "Model for managing network interfaces and subinterfaces. This |
| module also defines convenience types / groupings for other |
| models to create references to interfaces: |
| base-interface-ref (type) - reference to a base interface |
| interface-ref (grouping) - container for reference to a |
| interface + subinterface |
| interface-ref-state (grouping) - container for read-only |
| (opstate) reference to interface + subinterface |
| This model reuses data items defined in the IETF YANG model for |
| interfaces described by RFC 7223 with an alternate structure |
| (particularly for operational state data) and and with |
| additional configuration items."; |
| |
| oc-ext:openconfig-version "1.0.2"; |
| |
| revision "2016-05-26" { |
| description |
| "OpenConfig public release"; |
| reference "1.0.2"; |
| } |
| |
| |
| // typedef statements |
| |
| typedef base-interface-ref { |
| type leafref { |
| path "/oc-if:interfaces/oc-if:interface/oc-if:name"; |
| } |
| description |
| "Reusable type for by-name reference to a base interface. |
| This type may be used in cases where ability to reference |
| a subinterface is not required."; |
| } |
| |
| typedef interface-id { |
| type string; |
| description |
| "User-defined identifier for an interface, generally used to |
| name a interface reference. The id can be arbitrary but a |
| useful convention is to use a combination of base interface |
| name and subinterface index."; |
| } |
| |
| // grouping statements |
| |
| grouping interface-ref-common { |
| description |
| "Reference leafrefs to interface / subinterface"; |
| |
| leaf interface { |
| type leafref { |
| path "/oc-if:interfaces/oc-if:interface/oc-if:name"; |
| } |
| description |
| "Reference to a base interface. If a reference to a |
| subinterface is required, this leaf must be specified |
| to indicate the base interface."; |
| } |
| |
| leaf subinterface { |
| type leafref { |
| path "/oc-if:interfaces/" + |
| "oc-if:interface[oc-if:name=current()/../interface]/" + |
| "oc-if:subinterfaces/oc-if:subinterface/oc-if:index"; |
| } |
| description |
| "Reference to a subinterface -- this requires the base |
| interface to be specified using the interface leaf in |
| this container. If only a reference to a base interface |
| is requuired, this leaf should not be set."; |
| } |
| } |
| |
| grouping interface-ref-state-container { |
| description |
| "Reusable opstate w/container for a reference to an |
| interface or subinterface"; |
| |
| container state { |
| config false; |
| description |
| "Operational state for interface-ref"; |
| |
| uses interface-ref-common; |
| } |
| } |
| |
| grouping interface-ref { |
| description |
| "Reusable definition for a reference to an interface or |
| subinterface"; |
| |
| container interface-ref { |
| description |
| "Reference to an interface or subinterface"; |
| |
| container config { |
| description |
| "Configured reference to interface / subinterface"; |
| |
| uses interface-ref-common; |
| } |
| |
| uses interface-ref-state-container; |
| } |
| } |
| |
| grouping interface-ref-state { |
| description |
| "Reusable opstate w/container for a reference to an |
| interface or subinterface"; |
| |
| container interface-ref { |
| description |
| "Reference to an interface or subinterface"; |
| |
| uses interface-ref-state-container; |
| } |
| } |
| |
| |
| grouping interface-common-config { |
| description |
| "Configuration data data nodes common to physical interfaces |
| and subinterfaces"; |
| |
| leaf name { |
| type string; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The name of the interface. |
| A device MAY restrict the allowed values for this leaf, |
| possibly depending on the type of the interface. |
| For system-controlled interfaces, this leaf is the |
| device-specific name of the interface. The 'config false' |
| list interfaces/interface[name]/state contains the currently |
| existing interfaces on the device. |
| If a client tries to create configuration for a |
| system-controlled interface that is not present in the |
| corresponding state list, the server MAY reject |
| the request if the implementation does not support |
| pre-provisioning of interfaces or if the name refers to |
| an interface that can never exist in the system. A |
| NETCONF server MUST reply with an rpc-error with the |
| error-tag 'invalid-value' in this case. |
| The IETF model in RFC 7223 provides YANG features for the |
| following (i.e., pre-provisioning and arbitrary-names), |
| however they are omitted here: |
| If the device supports pre-provisioning of interface |
| configuration, the 'pre-provisioning' feature is |
| advertised. |
| If the device allows arbitrarily named user-controlled |
| interfaces, the 'arbitrary-names' feature is advertised. |
| When a configured user-controlled interface is created by |
| the system, it is instantiated with the same name in the |
| /interfaces/interface[name]/state list."; |
| reference |
| "RFC 7223: A YANG Data Model for Interface Management"; |
| } |
| |
| leaf description { |
| type string; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| A textual description of the interface. |
| A server implementation MAY map this leaf to the ifAlias |
| MIB object. Such an implementation needs to use some |
| mechanism to handle the differences in size and characters |
| allowed between this leaf and ifAlias. The definition of |
| such a mechanism is outside the scope of this document. |
| Since ifAlias is defined to be stored in non-volatile |
| storage, the MIB implementation MUST map ifAlias to the |
| value of 'description' in the persistently stored |
| datastore. |
| Specifically, if the device supports ':startup', when |
| ifAlias is read the device MUST return the value of |
| 'description' in the 'startup' datastore, and when it is |
| written, it MUST be written to the 'running' and 'startup' |
| datastores. Note that it is up to the implementation to |
| decide whether to modify this single leaf in 'startup' or |
| perform an implicit copy-config from 'running' to |
| 'startup'. |
| If the device does not support ':startup', ifAlias MUST |
| be mapped to the 'description' leaf in the 'running' |
| datastore."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifAlias"; |
| } |
| |
| leaf enabled { |
| type boolean; |
| default "true"; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| This leaf contains the configured, desired state of the |
| interface. |
| Systems that implement the IF-MIB use the value of this |
| leaf in the 'running' datastore to set |
| IF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry |
| has been initialized, as described in RFC 2863. |
| Changes in this leaf in the 'running' datastore are |
| reflected in ifAdminStatus, but if ifAdminStatus is |
| changed over SNMP, this leaf is not affected."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifAdminStatus"; |
| } |
| |
| } |
| |
| grouping interface-phys-config { |
| description |
| "Configuration data for physical interfaces"; |
| |
| leaf type { |
| type identityref { |
| base ietf-if:interface-type; |
| } |
| mandatory true; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The type of the interface. |
| When an interface entry is created, a server MAY |
| initialize the type leaf with a valid value, e.g., if it |
| is possible to derive the type from the name of the |
| interface. |
| If a client tries to set the type of an interface to a |
| value that can never be used by the system, e.g., if the |
| type is not supported or if the type does not match the |
| name of the interface, the server MUST reject the request. |
| A NETCONF server MUST reply with an rpc-error with the |
| error-tag 'invalid-value' in this case."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifType"; |
| } |
| |
| leaf mtu { |
| type uint16; |
| description |
| "Set the max transmission unit size in octets |
| for the physical interface. If this is not set, the mtu is |
| set to the operational default -- e.g., 1514 bytes on an |
| Ethernet interface."; |
| } |
| |
| uses interface-common-config; |
| } |
| |
| grouping interface-phys-holdtime-config { |
| description |
| "Configuration data for interface hold-time settings -- |
| applies to physical interfaces."; |
| |
| leaf up { |
| type uint32; |
| units milliseconds; |
| default 0; |
| description |
| "Dampens advertisement when the interface |
| transitions from down to up. A zero value means dampening |
| is turned off, i.e., immediate notification."; |
| } |
| |
| leaf down { |
| type uint32; |
| units milliseconds; |
| default 0; |
| description |
| "Dampens advertisement when the interface transitions from |
| up to down. A zero value means dampening is turned off, |
| i.e., immediate notification."; |
| } |
| } |
| |
| grouping interface-phys-holdtime-state { |
| description |
| "Operational state data for interface hold-time."; |
| } |
| |
| grouping interface-phys-holdtime-top { |
| description |
| "Top-level grouping for setting link transition |
| dampening on physical and other types of interfaces."; |
| |
| container hold-time { |
| description |
| "Top-level container for hold-time settings to enable |
| dampening advertisements of interface transitions."; |
| |
| container config { |
| description |
| "Configuration data for interface hold-time settings."; |
| |
| uses interface-phys-holdtime-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for interface hold-time."; |
| |
| uses interface-phys-holdtime-config; |
| uses interface-phys-holdtime-state; |
| } |
| } |
| } |
| |
| grouping interface-common-state { |
| description |
| "Operational state data (in addition to intended configuration) |
| at the global level for this interface"; |
| |
| leaf ifindex { |
| type uint32; |
| description |
| "System assigned number for each interface. Corresponds to |
| ifIndex object in SNMP Interface MIB"; |
| reference |
| "RFC 2863 - The Interfaces Group MIB"; |
| } |
| |
| leaf admin-status { |
| type enumeration { |
| enum UP { |
| description |
| "Ready to pass packets."; |
| } |
| enum DOWN { |
| description |
| "Not ready to pass packets and not in some test mode."; |
| } |
| enum TESTING { |
| //TODO: This is generally not supported as a configured |
| //admin state, though it's in the standard interfaces MIB. |
| //Consider removing it. |
| description |
| "In some test mode."; |
| } |
| } |
| //TODO:consider converting to an identity to have the |
| //flexibility to remove some values defined by RFC 7223 that |
| //are not used or not implemented consistently. |
| mandatory true; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The desired state of the interface. In RFC 7223 this leaf |
| has the same read semantics as ifAdminStatus. Here, it |
| reflects the administrative state as set by enabling or |
| disabling the interface."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifAdminStatus"; |
| } |
| |
| leaf oper-status { |
| type enumeration { |
| enum UP { |
| value 1; |
| description |
| "Ready to pass packets."; |
| } |
| enum DOWN { |
| value 2; |
| description |
| "The interface does not pass any packets."; |
| } |
| enum TESTING { |
| value 3; |
| description |
| "In some test mode. No operational packets can |
| be passed."; |
| } |
| enum UNKNOWN { |
| value 4; |
| description |
| "Status cannot be determined for some reason."; |
| } |
| enum DORMANT { |
| value 5; |
| description |
| "Waiting for some external event."; |
| } |
| enum NOT_PRESENT { |
| value 6; |
| description |
| "Some component (typically hardware) is missing."; |
| } |
| enum LOWER_LAYER_DOWN { |
| value 7; |
| description |
| "Down due to state of lower-layer interface(s)."; |
| } |
| } |
| //TODO:consider converting to an identity to have the |
| //flexibility to remove some values defined by RFC 7223 that |
| //are not used or not implemented consistently. |
| mandatory true; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The current operational state of the interface. |
| This leaf has the same semantics as ifOperStatus."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifOperStatus"; |
| } |
| |
| leaf last-change { |
| type yang:timeticks; |
| description |
| "Date and time of the last state change of the interface |
| (e.g., up-to-down transition). This corresponds to the |
| ifLastChange object in the standard interface MIB."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifLastChange"; |
| } |
| |
| } |
| |
| |
| grouping interface-counters-state { |
| description |
| "Operational state representing interface counters |
| and statistics. Some of these are adapted from RFC 7223"; |
| |
| //TODO: we may need to break this list of counters into those |
| //that would appear for physical vs. subinterface or logical |
| //interfaces. For now, just replicating the full stats |
| //grouping to both interface and subinterface. |
| |
| container counters { |
| description |
| "A collection of interface-related statistics objects."; |
| |
| reference |
| "RFC 7223 - A YANG Data Model for Interface |
| Management"; |
| |
| leaf in-octets { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The total number of octets received on the interface, |
| including framing characters. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifHCInOctets"; |
| } |
| |
| leaf in-unicast-pkts { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The number of packets, delivered by this sub-layer to a |
| higher (sub-)layer, that were not addressed to a |
| multicast or broadcast address at this sub-layer. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifHCInUcastPkts"; |
| } |
| |
| leaf in-broadcast-pkts { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The number of packets, delivered by this sub-layer to a |
| higher (sub-)layer, that were addressed to a broadcast |
| address at this sub-layer. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - |
| ifHCInBroadcastPkts"; |
| } |
| |
| leaf in-multicast-pkts { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The number of packets, delivered by this sub-layer to a |
| higher (sub-)layer, that were addressed to a multicast |
| address at this sub-layer. For a MAC-layer protocol, |
| this includes both Group and Functional addresses. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - |
| ifHCInMulticastPkts"; |
| } |
| |
| leaf in-discards { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| The number of inbound packets that were chosen to be |
| discarded even though no errors had been detected to |
| prevent their being deliverable to a higher-layer |
| protocol. One possible reason for discarding such a |
| packet could be to free up buffer space. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| |
| |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifInDiscards"; |
| } |
| |
| leaf in-errors { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| For packet-oriented interfaces, the number of inbound |
| packets that contained errors preventing them from being |
| deliverable to a higher-layer protocol. For character- |
| oriented or fixed-length interfaces, the number of |
| inbound transmission units that contained errors |
| preventing them from being deliverable to a higher-layer |
| protocol. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifInErrors"; |
| } |
| |
| leaf in-unknown-protos { |
| type yang:counter32; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| For packet-oriented interfaces, the number of packets |
| received via the interface that were discarded because |
| of an unknown or unsupported protocol. For |
| character-oriented or fixed-length interfaces that |
| support protocol multiplexing, the number of |
| transmission units received via the interface that were |
| discarded because of an unknown or unsupported protocol. |
| For any interface that does not support protocol |
| multiplexing, this counter is not present. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifInUnknownProtos"; |
| } |
| |
| leaf out-octets { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| The total number of octets transmitted out of the |
| interface, including framing characters. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifHCOutOctets"; |
| } |
| |
| leaf out-unicast-pkts { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The total number of packets that higher-level protocols |
| requested be transmitted, and that were not addressed |
| to a multicast or broadcast address at this sub-layer, |
| including those that were discarded or not sent. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifHCOutUcastPkts"; |
| } |
| |
| leaf out-broadcast-pkts { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| The total number of packets that higher-level protocols |
| requested be transmitted, and that were addressed to a |
| broadcast address at this sub-layer, including those |
| that were discarded or not sent. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - |
| ifHCOutBroadcastPkts"; |
| } |
| |
| |
| leaf out-multicast-pkts { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| The total number of packets that higher-level protocols |
| requested be transmitted, and that were addressed to a |
| multicast address at this sub-layer, including those |
| that were discarded or not sent. For a MAC-layer |
| protocol, this includes both Group and Functional |
| addresses. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - |
| ifHCOutMulticastPkts"; |
| } |
| |
| leaf out-discards { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| The number of outbound packets that were chosen to be |
| discarded even though no errors had been detected to |
| prevent their being transmitted. One possible reason |
| for discarding such a packet could be to free up buffer |
| space. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifOutDiscards"; |
| } |
| |
| leaf out-errors { |
| type yang:counter64; |
| description |
| "[adapted from IETF interfaces model (RFC 7223)] |
| Changed the counter type to counter64. |
| For packet-oriented interfaces, the number of outbound |
| packets that could not be transmitted because of errors. |
| For character-oriented or fixed-length interfaces, the |
| number of outbound transmission units that could not be |
| transmitted because of errors. |
| Discontinuities in the value of this counter can occur |
| at re-initialization of the management system, and at |
| other times as indicated by the value of |
| 'discontinuity-time'."; |
| reference |
| "RFC 2863: The Interfaces Group MIB - ifOutErrors"; |
| } |
| |
| leaf last-clear { |
| type yang:date-and-time; |
| description |
| "Indicates the last time the interface counters were |
| cleared."; |
| } |
| } |
| } |
| |
| // data definition statements |
| |
| grouping sub-unnumbered-config { |
| description |
| "Configuration data for unnumbered subinterfaces"; |
| |
| leaf enabled { |
| type boolean; |
| default false; |
| description |
| "Indicates that the subinterface is unnumbered. By default |
| the subinterface is numbered, i.e., expected to have an |
| IP address configuration."; |
| } |
| } |
| |
| grouping sub-unnumbered-state { |
| description |
| "Operational state data unnumbered subinterfaces"; |
| } |
| |
| grouping sub-unnumbered-top { |
| description |
| "Top-level grouping unnumbered subinterfaces"; |
| |
| container unnumbered { |
| description |
| "Top-level container for setting unnumbered interfaces. |
| Includes reference the interface that provides the |
| address information"; |
| |
| container config { |
| description |
| "Configuration data for unnumbered interface"; |
| |
| uses sub-unnumbered-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for unnumbered interfaces"; |
| |
| uses sub-unnumbered-config; |
| uses sub-unnumbered-state; |
| } |
| |
| uses oc-if:interface-ref; |
| } |
| } |
| |
| grouping subinterfaces-config { |
| description |
| "Configuration data for subinterfaces"; |
| |
| leaf index { |
| type uint32; |
| default 0; |
| description |
| "The index of the subinterface, or logical interface number. |
| On systems with no support for subinterfaces, or not using |
| subinterfaces, this value should default to 0, i.e., the |
| default subinterface."; |
| } |
| |
| uses interface-common-config; |
| |
| } |
| |
| grouping subinterfaces-state { |
| description |
| "Operational state data for subinterfaces"; |
| |
| uses interface-common-state; |
| uses interface-counters-state; |
| } |
| |
| grouping subinterfaces-top { |
| description |
| "Subinterface data for logical interfaces associated with a |
| given interface"; |
| |
| container subinterfaces { |
| description |
| "Enclosing container for the list of subinterfaces associated |
| with a physical interface"; |
| |
| list subinterface { |
| key "index"; |
| |
| description |
| "The list of subinterfaces (logical interfaces) associated |
| with a physical interface"; |
| |
| leaf index { |
| type leafref { |
| path "../config/index"; |
| } |
| description |
| "The index number of the subinterface -- used to address |
| the logical interface"; |
| } |
| |
| container config { |
| description |
| "Configurable items at the subinterface level"; |
| |
| uses subinterfaces-config; |
| } |
| |
| container state { |
| |
| config false; |
| description |
| "Operational state data for logical interfaces"; |
| |
| uses subinterfaces-config; |
| uses subinterfaces-state; |
| } |
| } |
| } |
| } |
| |
| grouping interfaces-top { |
| description |
| "Top-level grouping for interface configuration and |
| operational state data"; |
| |
| container interfaces { |
| description |
| "Top level container for interfaces, including configuration |
| and state data."; |
| |
| |
| list interface { |
| key "name"; |
| |
| description |
| "The list of named interfaces on the device."; |
| |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description |
| "References the configured name of the interface"; |
| //TODO: need to consider whether this should actually |
| //reference the name in the state subtree, which |
| //presumably would be the system-assigned name, or the |
| //configured name. Points to the config/name now |
| //because of YANG 1.0 limitation that the list |
| //key must have the same "config" as the list, and |
| //also can't point to a non-config node. |
| } |
| |
| container config { |
| description |
| "Configurable items at the global, physical interface |
| level"; |
| |
| uses interface-phys-config; |
| } |
| |
| container state { |
| |
| config false; |
| description |
| "Operational state data at the global interface level"; |
| |
| uses interface-phys-config; |
| uses interface-common-state; |
| uses interface-counters-state; |
| } |
| |
| uses interface-phys-holdtime-top; |
| uses subinterfaces-top; |
| } |
| } |
| } |
| |
| uses interfaces-top; |
| |
| |
| } |