draft-ietf-forces-model-05.txt   draft-ietf-forces-model-06.txt 
Internet Draft L. Yang Internet Draft L. Yang
Expiration: August 2005 Intel Corp. Expiration: September 2006 Intel Corp.
File: draft-ietf-forces-model-05.txt J. Halpern File: draft-ietf-forces-model-06.txt J. Halpern
Working Group: ForCES Megisto Systems Working Group: ForCES Megisto Systems
R. Gopal R. Gopal
Nokia Nokia
A. DeKok A. DeKok
Infoblox, Inc. Infoblox, Inc.
Z. Haraszti Z. Haraszti
Clovis Solutions Clovis Solutions
S. Blake
Modular Networks
E. Deleganes E. Deleganes
Intel Corp. Intel Corp.
August 2005
ForCES Forwarding Element Model ForCES Forwarding Element Model
draft-ietf-forces-model-05.txt draft-ietf-forces-model-06.txt
Status of this Memo
By submitting this Internet-Draft, each author represents that any By submitting this Internet-Draft, each author represents that any
applicable patent or other IPR claims of which he or she is aware applicable patent or other IPR claims of which he or she is aware
have been or will be disclosed, and any of which he or have been or will be disclosed, and any of which he or she becomes
she becomes aware will be disclosed, in accordance with Section 6 aware will be disclosed, in accordance with Section 6 of BCP 79.
of BCP 79.
Status of this Memo Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF), its areas, and its working groups. Note that
other groups may also distribute working documents as Internet-
Drafts.
This document is an Internet-Draft and is in full conformance with Internet-Drafts are working documents of the Internet Engineering
all provisions of Section 10 of RFC2026. Internet-Drafts are Task Force (IETF), its areas, and its working groups. Note that
working documents of the Internet Engineering Task Force (IETF), other groups may also distribute working documents as Internet-
its areas, and its working groups. Note that other groups may Drafts.
also distribute working documents as Internet-Drafts.
Internet-Drafts are draft documents valid for a maximum of six Internet-Drafts are draft documents valid for a maximum of six
months and may be updated, replaced, or obsoleted by other months and may be updated, replaced, or obsoleted by other documents
documents at any time. It is inappropriate to use Internet-Drafts at any time. It is inappropriate to use Internet-Drafts as
as reference material or to cite them other than as ``work in reference material or to cite them other than a "work in progress."
progress.''
The list of current Internet-Drafts can be accessed at The list of current Internet-Drafts can be accessed at
http://www.ietf.org/ietf/1id-abstracts.txt. http://www.ietf.org/ietf/1id-abstracts.html.
The list of Internet-Draft Shadow Directories can be accessed at The list of Internet-Draft Shadow Directories can be accessed at
http://www.ietf.org/shadow.html. http://www.ietf.org/shadow.html.
Abstract Abstract
This document defines the forwarding element (FE) model used in This document defines the forwarding element (FE) model used in the
the Forwarding and Control Element Separation (ForCES) protocol. Forwarding and Control Element Separation (ForCES) protocol. The
The model represents the capabilities, state and configuration of model represents the capabilities, state and configuration of
forwarding elements within the context of the ForCES protocol, so forwarding elements within the context of the ForCES protocol, so
that control elements (CEs) can control the FEs accordingly. More that control elements (CEs) can control the FEs accordingly. More
specifically, the model describes the logical functions that are specifically, the model describes the logical functions that are
present in an FE, what capabilities these functions support, and present in an FE, what capabilities these functions support, and how
how these functions are or can be interconnected. This FE model these functions are or can be interconnected. This FE model is
is intended to satisfy the model requirements specified in the intended to satisfy the model requirements specified in the ForCES
ForCES requirements draft, RFC 3564 [1]. A list of the basic requirements draft, RFC 3564 [1]. A list of the basic logical
logical functional blocks (LFBs) is also defined in the LFB class functional blocks (LFBs) is also defined in the LFB class library to
library to aid the effort in defining individual LFBs. aid the effort in defining individual LFBs.
Table of Contents Table of Contents
Abstract...........................................................2 Abstract...........................................................1
1. Definitions.....................................................4 1. Definitions.....................................................4
2. Introduction....................................................6 2. Introduction....................................................5
2.1. Requirements on the FE model...............................6 2.1. Requirements on the FE model...............................6
2.2. The FE Model in Relation to FE Implementations.............7 2.2. The FE Model in Relation to FE Implementations.............6
2.3. The FE Model in Relation to the ForCES Protocol............7 2.3. The FE Model in Relation to the ForCES Protocol............7
2.4. Modeling Language for the FE Model.........................8 2.4. Modeling Language for the FE Model.........................7
2.5. Document Structure.........................................8 2.5. Document Structure.........................................8
3. FE Model Concepts...............................................8 3. FE Model Concepts...............................................8
3.1. FE Capability Model and State Model........................9 3.1. FE Capability Model and State Model........................8
3.2. LFB (Logical Functional Block) Modeling...................11 3.2. LFB (Logical Functional Block) Modeling...................11
3.2.1. LFB Outputs..........................................14 3.2.1. LFB Outputs..........................................13
3.2.2. LFB Inputs...........................................17 3.2.2. LFB Inputs...........................................16
3.2.3. Packet Type..........................................20 3.2.3. Packet Type..........................................19
3.2.4. Metadata.............................................21 3.2.4. Metadata.............................................19
3.2.5. LFB Events...........................................28 3.2.5. LFB Events...........................................26
3.2.6. LFB Element Properties...............................28 3.2.6. LFB Element Properties...............................27
3.2.7. LFB Versioning.......................................28 3.2.7. LFB Versioning.......................................27
3.2.8. LFB Inheritance......................................29 3.2.8. LFB Inheritance......................................27
3.3. FE Datapath Modeling......................................30 3.3. FE Datapath Modeling......................................28
3.3.1. Alternative Approaches for Modeling FE Datapaths.....30 3.3.1. Alternative Approaches for Modeling FE Datapaths.....29
3.3.2. Configuring the LFB Topology.........................35 3.3.2. Configuring the LFB Topology.........................33
4. Model and Schema for LFB Classes...............................39 4. Model and Schema for LFB Classes...............................37
4.1. Namespace.................................................39 4.1. Namespace.................................................37
4.2. <LFBLibrary> Element......................................39 4.2. <LFBLibrary> Element......................................37
4.3. <load> Element............................................41 4.3. <load> Element............................................39
4.4. <frameDefs> Element for Frame Type Declarations...........41 4.4. <frameDefs> Element for Frame Type Declarations...........39
4.5. <dataTypeDefs> Element for Data Type Definitions..........42 4.5. <dataTypeDefs> Element for Data Type Definitions..........40
4.5.1. <typeRef> Element for Aliasing Existing Data Types...44 4.5.1. <typeRef> Element for Aliasing Existing Data Types...42
4.5.2. <atomic> Element for Deriving New Atomic Types.......45 4.5.2. <atomic> Element for Deriving New Atomic Types.......42
4.5.3. <array> Element to Define Arrays.....................45 4.5.3. <array> Element to Define Arrays.....................43
4.5.4. <struct> Element to Define Structures................49 4.5.4. <struct> Element to Define Structures................47
4.5.5. <union> Element to Define Union Types................50 4.5.5. <union> Element to Define Union Types................48
4.5.6. Augmentations........................................51 4.5.6. Augmentations........................................48
4.6. <metadataDefs> Element for Metadata Definitions...........52 4.6. <metadataDefs> Element for Metadata Definitions...........49
4.7. <LFBClassDefs> Element for LFB Class Definitions..........53 4.7. <LFBClassDefs> Element for LFB Class Definitions..........50
4.7.1. <derivedFrom> Element to Express LFB Inheritance.....54 4.7.1. <derivedFrom> Element to Express LFB Inheritance.....52
4.7.2. <inputPorts> Element to Define LFB Inputs............55 4.7.2. <inputPorts> Element to Define LFB Inputs............52
4.7.3. <outputPorts> Element to Define LFB Outputs..........57 4.7.3. <outputPorts> Element to Define LFB Outputs..........55
4.7.4. <attributes> Element to Define LFB Operational 4.7.4. <attributes> Element to Define LFB Operational
Attributes..................................................59 Attributes..................................................56
4.7.5. <capabilities> Element to Define LFB Capability 4.7.5. <capabilities> Element to Define LFB Capability
Attributes..................................................62 Attributes..................................................59
4.7.6. <events> Element for LFB Notification Generation.....63 4.7.6. <events> Element for LFB Notification Generation.....60
4.7.7. <description> Element for LFB Operational 4.7.7. <description> Element for LFB Operational Specification
Specification...............................................67 ............................................................64
4.8. Properties................................................67 4.8. Properties................................................64
4.9. XML Schema for LFB Class Library Documents................70 4.9. XML Schema for LFB Class Library Documents................70
5. FE Attributes and Capabilities.................................81 5. FE Attributes and Capabilities.................................81
5.1. XML for FEObject Class definition.........................82 5.1. XML for FEObject Class definition.........................81
5.2. FE Capabilities...........................................88 5.2. FE Capabilities...........................................87
5.2.1. ModifiableLFBTopology................................89 5.2.1. ModifiableLFBTopology................................88
5.2.2. SupportedLFBs and SupportedLFBType...................89 5.2.2. SupportedLFBs and SupportedLFBType...................88
5.3. FEAttributes..............................................91 5.3. FEAttributes..............................................90
5.3.1. FEStatus.............................................91 5.3.1. FEStatus.............................................90
5.3.2. LFBSelectors and LFBSelectorType.....................91 5.3.2. LFBSelectors and LFBSelectorType.....................90
5.3.3. LFBTopology and LFBLinkType..........................92 5.3.3. LFBTopology and LFBLinkType..........................91
5.3.4. FENeighbors an FEConfiguredNeighborType..............92 5.3.4. FENeighbors an FEConfiguredNeighborType..............91
6. Satisfying the Requirements on FE Model........................93 6. Satisfying the Requirements on FE Model........................92
6.1. Port Functions............................................94 6.1. Port Functions............................................93
6.2. Forwarding Functions......................................94 6.2. Forwarding Functions......................................93
6.3. QoS Functions.............................................95 6.3. QoS Functions.............................................93
6.4. Generic Filtering Functions...............................95 6.4. Generic Filtering Functions...............................94
6.5. Vendor Specific Functions.................................95 6.5. Vendor Specific Functions.................................94
6.6. High-Touch Functions......................................95 6.6. High-Touch Functions......................................94
6.7. Security Functions........................................95 6.7. Security Functions........................................94
6.8. Off-loaded Functions......................................96 6.8. Off-loaded Functions......................................94
6.9. IPFLOW/PSAMP Functions....................................96 6.9. IPFLOW/PSAMP Functions....................................95
7. Using the FE model in the ForCES Protocol......................96 7. Using the FE model in the ForCES Protocol......................95
7.1. FE Topology Query.........................................98 7.1. FE Topology Query.........................................97
7.2. FE Capability Declarations...............................100 7.2. FE Capability Declarations................................98
7.3. LFB Topology and Topology Configurability Query..........100 7.3. LFB Topology and Topology Configurability Query...........98
7.4. LFB Capability Declarations..............................100 7.4. LFB Capability Declarations...............................98
7.5. State Query of LFB Attributes............................101 7.5. State Query of LFB Attributes.............................99
7.6. LFB Attribute Manipulation...............................102 7.6. LFB Attribute Manipulation...............................100
7.7. LFB Topology Re-configuration............................102 7.7. LFB Topology Re-configuration............................100
8. Example.......................................................103 8. Example.......................................................100
8.1. Data Handling............................................110 8.1. Data Handling............................................108
8.1.1. Setting up a DLCI...................................110 8.1.1. Setting up a DLCI...................................108
8.1.2. Error Handling......................................111 8.1.2. Error Handling......................................109
8.2. LFB Attributes...........................................112 8.2. LFB Attributes...........................................109
8.3. Capabilities.............................................112 8.3. Capabilities.............................................110
8.4. Events...................................................113 8.4. Events...................................................110
9. Acknowledgments...............................................114 9. Acknowledgments...............................................111
10. Security Considerations......................................114 10. Security Considerations......................................112
11. Normative References.........................................114 11. Normative References.........................................112
12. Informative References.......................................114 12. Informative References.......................................112
13. Authors' Addresses...........................................115 13. Authors' Addresses...........................................113
14. Intellectual Property Right..................................116 14. Intellectual Property Right..................................114
15. IANA consideration...........................................116 15. IANA consideration...........................................114
16. Copyright Statement..........................................116 16. Copyright Statement..........................................114
Conventions used in this document Conventions used in this document
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in document are to be interpreted as described in [RFC-2119].
this document are to be interpreted as described in [RFC-2119].
1. 1. Definitions
Definitions
Terminology associated with the ForCES requirements is defined in Terminology associated with the ForCES requirements is defined in
RFC 3564 [1] and is not copied here. The following list of RFC 3564 [1] and is not copied here. The following list of
terminology relevant to the FE model is defined in this section. terminology relevant to the FE model is defined in this section.
FE Model -- The FE model is designed to model the logical FE Model -- The FE model is designed to model the logical processing
processing functions of an FE. The FE model proposed in this functions of an FE. The FE model proposed in this document includes
document includes three components: the modeling of individual three components: the modeling of individual logical functional
logical functional blocks (LFB model), the logical interconnection blocks (LFB model), the logical interconnection between LFBs (LFB
between LFBs (LFB topology) and the FE level attributes, including topology) and the FE level attributes, including FE capabilities.
FE capabilities. The FE model provides the basis to define the The FE model provides the basis to define the information elements
information elements exchanged between the CE and the FE in the exchanged between the CE and the FE in the ForCES protocol.
ForCES protocol.
Datapath -- A conceptual path taken by packets within the Datapath -- A conceptual path taken by packets within the forwarding
forwarding plane inside an FE. Note that more than one datapath plane inside an FE. Note that more than one datapath can exist
can exist within an FE. within an FE.
LFB (Logical Functional Block) Class (or type) -- A template LFB (Logical Functional Block) Class (or type) -- A template that
representing a fine-grained, logically separable and well-defined representing a fine-grained, logically separable aspect of FE
packet processing operation in the datapath. LFB classes are the processing. Most LFBs relate to packet processing in the data path.
basic building blocks of the FE model. LFB classes are the basic building blocks of the FE model.
LFB Instance -- As a packet flows through an FE along a datapath, LFB Instance -- As a packet flows through an FE along a datapath, it
it flows through one or multiple LFB instances, where each LFB is flows through one or multiple LFB instances, where each LFB is an
an instance of a specific LFB class. Multiple instances of the instance of a specific LFB class. Multiple instances of the same
same LFB class can be present in an FE's datapath. Note that we LFB class can be present in an FE's datapath. Note that we often
often refer to LFBs without distinguishing between an LFB class refer to LFBs without distinguishing between an LFB class and LFB
and LFB instance when we believe the implied reference is obvious instance when we believe the implied reference is obvious for the
for the given context. given context.
LFB Model -- The LFB model describes the content and structures in LFB Model -- The LFB model describes the content and structures in
an LFB, plus the associated data definition. Four types of an LFB, plus the associated data definition. Four types of
information are defined in the LFB model. The core part of the information are defined in the LFB model. The core part of the LFB
LFB model is the LFB class definitions; the other three types model is the LFB class definitions; the other three types define the
define the associated data including common data types, supported associated data including common data types, supported frame formats
frame formats and metadata. and metadata.
LFB Metadata -- Metadata is used to communicate per-packet state LFB Metadata -- Metadata is used to communicate per-packet state
from one LFB to another, but is not sent across the network. The from one LFB to another, but is not sent across the network. The FE
FE model defines how such metadata is identified, produced and model defines how such metadata is identified, produced and consumed
consumed by the LFBs, but not how the per-packet state is by the LFBs, but not how the per-packet state is implemented within
implemented within actual hardware. actual hardware. Metadata is sent between the FE and the CE on
redirect packets.
LFB Attribute -- Operational parameters of the LFBs that must be LFB Attribute -- Operational parameters of the LFBs that must be
visible to the CEs are conceptualized in the FE model as the LFB visible to the CEs are conceptualized in the FE model as the LFB
attributes. The LFB attributes include: flags, single parameter attributes. The LFB attributes include: flags, single parameter
arguments, complex arguments, and tables that the CE can read arguments, complex arguments, and tables that the CE can read or/and
or/and write via the ForCES protocol. write via the ForCES protocol.
LFB Topology -- A representation of the logical interconnection LFB Topology -- A representation of the logical interconnection and
and the placement of LFB instances along the datapath within one the placement of LFB instances along the datapath within one FE.
FE. Sometimes this representation is called intra-FE topology, to Sometimes this representation is called intra-FE topology, to be
be distinguished from inter-FE topology. LFB topology is outside distinguished from inter-FE topology. LFB topology is outside of
of the LFB model, but is part of the FE model. the LFB model, but is part of the FE model.
FE Topology -- A representation of how multiple FEs within a FE Topology -- A representation of how multiple FEs within a single
single NE are interconnected. Sometimes this is called inter-FE NE are interconnected. Sometimes this is called inter-FE topology,
topology, to be distinguished from intra-FE topology (i.e., LFB to be distinguished from intra-FE topology (i.e., LFB topology). An
topology). An individual FE might not have the global knowledge individual FE might not have the global knowledge of the full FE
of the full FE topology, but the local view of its connectivity topology, but the local view of its connectivity with other FEs is
with other FEs is considered to be part of the FE model. The FE considered to be part of the FE model. The FE topology is
topology is discovered by the ForCES base protocol or by some discovered by the ForCES base protocol or by some other means.
other means.
Inter-FE Topology -- See FE Topology. Inter-FE Topology -- See FE Topology.
Intra-FE Topology -- See LFB Topology. Intra-FE Topology -- See LFB Topology.
LFB class library -- A set of LFB classes that has been identified LFB class library -- A set of LFB classes that has been identified
as the most common functions found in most FEs and hence should be as the most common functions found in most FEs and hence should be
defined first by the ForCES Working Group. defined first by the ForCES Working Group.
2. 2. Introduction
Introduction
RFC 3746 [2] specifies a framework by which control elements (CEs) RFC 3746 [2] specifies a framework by which control elements (CEs)
can configure and manage one or more separate forwarding elements can configure and manage one or more separate forwarding elements
(FEs) within a networking element (NE) using the ForCES protocol. (FEs) within a networking element (NE) using the ForCES protocol.
The ForCES architecture allows Forwarding Elements of varying The ForCES architecture allows Forwarding Elements of varying
functionality to participate in a ForCES network element. The functionality to participate in a ForCES network element. The
implication of this varying functionality is that CEs can make implication of this varying functionality is that CEs can make only
only minimal assumptions about the functionality provided by FEs minimal assumptions about the functionality provided by FEs in an
in an NE. Before CEs can configure and control the forwarding NE. Before CEs can configure and control the forwarding behavior of
behavior of FEs, CEs need to query and discover the capabilities FEs, CEs need to query and discover the capabilities and states of
and states of their FEs. RFC 3654 [1] mandates that the their FEs. RFC 3654 [1] mandates that the capabilities, states and
capabilities, states and configuration information be expressed in configuration information be expressed in the form of an FE model.
the form of an FE model.
RFC 3444 [11] observed that information models (IMs) and data RFC 3444 [11] observed that information models (IMs) and data models
models (DMs) are different because they serve different purposes. (DMs) are different because they serve different purposes. "The
"The main purpose of an IM is to model managed objects at a main purpose of an IM is to model managed objects at a conceptual
conceptual level, independent of any specific implementations or level, independent of any specific implementations or protocols
protocols used". "DMs, conversely, are defined at a lower level used". "DMs, conversely, are defined at a lower level of
of abstraction and include many details. They are intended for abstraction and include many details. They are intended for
implementors and include protocol-specific constructs." Sometimes implementors and include protocol-specific constructs." Sometimes
it is difficult to draw a clear line between the two. The FE it is difficult to draw a clear line between the two. The FE model
model described in this document is primarily an information described in this document is primarily an information model, but
model, but also includes some aspects of a data model, such as also includes some aspects of a data model, such as explicit
explicit definitions of the LFB class schema and FE schema. It is definitions of the LFB class schema and FE schema. It is expected
expected that this FE model will be used as the basis to define that this FE model will be used as the basis to define the payload
the payload for information exchange between the CE and FE in the for information exchange between the CE and FE in the ForCES
ForCES protocol. protocol.
2.1. Requirements on the FE model 2.1. Requirements on the FE model
RFC 3654 [1] defines requirements that must be satisfied by a RFC 3654 [1] defines requirements that must be satisfied by a ForCES
ForCES FE model. To summarize, an FE model must define: FE model. To summarize, an FE model must define:
. Logically separable and distinct packet forwarding operations . Logically separable and distinct packet forwarding operations
in an FE datapath (logical functional blocks or LFBs); in an FE datapath (logical functional blocks or LFBs);
. The possible topological relationships (and hence the . The possible topological relationships (and hence the sequence
sequence of packet forwarding operations) between the various of packet forwarding operations) between the various LFBs;
LFBs;
. The possible operational capabilities (e.g., capacity limits, . The possible operational capabilities (e.g., capacity limits,
constraints, optional features, granularity of configuration) constraints, optional features, granularity of configuration)
of each type of LFB; of each type of LFB;
. The possible configurable parameters (i.e., attributes) of . The possible configurable parameters (i.e., attributes) of each
each type of LFB; type of LFB;
. Metadata that may be exchanged between LFBs. . Metadata that may be exchanged between LFBs.
2.2. The FE Model in Relation to FE Implementations 2.2. The FE Model in Relation to FE Implementations
The FE model proposed here is based on an abstraction of distinct The FE model proposed here is based on an abstraction of distinct
logical functional blocks (LFBs), which are interconnected in a logical functional blocks (LFBs), which are interconnected in a
directed graph, and receive, process, modify, and transmit packets directed graph, and receive, process, modify, and transmit packets
along with metadata. The FE model should be designed such that along with metadata. The FE model should be designed such that
different implementations of the forwarding datapath can be different implementations of the forwarding datapath can be
logically mapped onto the model with the functionality and logically mapped onto the model with the functionality and sequence
sequence of operations correctly captured. However, the model is of operations correctly captured. However, the model is not
not intended to directly address how a particular implementation intended to directly address how a particular implementation maps to
maps to an LFB topology. It is left to the forwarding plane an LFB topology. It is left to the forwarding plane vendors to
vendors to define how the FE functionality is represented using define how the FE functionality is represented using the FE model.
the FE model. Our goal is to design the FE model such that it is Our goal is to design the FE model such that it is flexible enough
flexible enough to accommodate most common implementations. to accommodate most common implementations.
The LFB topology model for a particular datapath implementation The LFB topology model for a particular datapath implementation must
MUST correctly capture the sequence of operations on the packet. correctly capture the sequence of operations on the packet.
Metadata generation by certain LFBs must always precede any use of Metadata generation by certain LFBs MUST always precede any use of
that metadata by subsequent LFBs in the topology graph; this is that metadata by subsequent LFBs in the topology graph; this is
required for logically consistent operation. Further, required for logically consistent operation. Further, modification
modification of packet fields that are subsequently used as inputs of packet fields that are subsequently used as inputs for further
for further processing must occur in the order specified in the processing MUST occur in the order specified in the model for that
model for that particular implementation to ensure correctness. particular implementation to ensure correctness.
2.3. The FE Model in Relation to the ForCES Protocol 2.3. The FE Model in Relation to the ForCES Protocol
The ForCES base protocol is used by the CEs and FEs to maintain The ForCES base protocol is used by the CEs and FEs to maintain the
the communication channel between the CEs and FEs. The ForCES communication channel between the CEs and FEs. The ForCES protocol
protocol may be used to query and discover the inter-FE topology. may be used to query and discover the inter-FE topology. The
The details of a particular datapath implementation inside an FE, details of a particular datapath implementation inside an FE,
including the LFB topology, along with the operational including the LFB topology, along with the operational capabilities
capabilities and attributes of each individual LFB, are conveyed and attributes of each individual LFB, are conveyed to the CE within
to the CE within information elements in the ForCES protocol. The information elements in the ForCES protocol. The model of an LFB
model of an LFB class should define all of the information that class should define all of the information that needs to be
needs to be exchanged between an FE and a CE for the proper exchanged between an FE and a CE for the proper configuration and
configuration and management of that LFB. management of that LFB.
Specifying the various payloads of the ForCES messages in a Specifying the various payloads of the ForCES messages in a
systematic fashion is difficult without a formal definition of the systematic fashion is difficult without a formal definition of the
objects being configured and managed (the FE and the LFBs within). objects being configured and managed (the FE and the LFBs within).
The FE Model document defines a set of classes and attributes for The FE Model document defines a set of classes and attributes for
describing and manipulating the state of the LFBs within an FE. describing and manipulating the state of the LFBs within an FE.
These class definitions themselves will generally not appear in These class definitions themselves will generally not appear in the
the ForCES protocol. Rather, ForCES protocol operations will ForCES protocol. Rather, ForCES protocol operations will reference
reference classes defined in this model, including relevant classes defined in this model, including relevant attributes and the
attributes and the defined operations. defined operations.
Section 7 provides more detailed discussion on how the FE model Section 7 provides more detailed discussion on how the FE model
should be used by the ForCES protocol. should be used by the ForCES protocol.
2.4. Modeling Language for the FE Model 2.4. Modeling Language for the FE Model
Even though not absolutely required, it is beneficial to use a Even though not absolutely required, it is beneficial to use a
formal data modeling language to represent the conceptual FE model formal data modeling language to represent the conceptual FE model
described in this document. Use of a formal language can help to described in this document. Use of a formal language can help to
enforce consistency and logical compatibility among LFBs. A full enforce consistency and logical compatibility among LFBs. A full
specification will be written using such a data modeling language. specification will be written using such a data modeling language.
The formal definition of the LFB classes may facilitate the The formal definition of the LFB classes may facilitate the eventual
eventual automation of some of the code generation process and the automation of some of the code generation process and the functional
functional validation of arbitrary LFB topologies. validation of arbitrary LFB topologies.
Human readability was the most important factor considered when Human readability was the most important factor considered when
selecting the specification language, whereas encoding, decoding selecting the specification language, whereas encoding, decoding and
and transmission performance was not a selection factor. The transmission performance was not a selection factor. The encoding
encoding method for over the wire transport is not dependent on method for over the wire transport is not dependent on the
the specification language chosen and is outside the scope of this specification language chosen and is outside the scope of this
document and up to the ForCES protocol to define. document and up to the ForCES protocol to define.
XML was chosen as the specification language in this document, XML was chosen as the specification language in this document,
because XML has the advantage of being both human and machine because XML has the advantage of being both human and machine
readable with widely available tools support. readable with widely available tools support.
2.5. Document Structure 2.5. Document Structure
Section 3 provides a conceptual overview of the FE model, laying Section 3 provides a conceptual overview of the FE model, laying the
the foundation for the more detailed discussion and specifications foundation for the more detailed discussion and specifications in
in the sections that follow. Section 4 and 5 constitute the core the sections that follow. Section 4 and 5 constitute the core of
of the FE model, detailing the two major components in the FE the FE model, detailing the two major components in the FE model:
model: LFB model and FE level attributes including capability and LFB model and FE level attributes including capability and LFB
LFB topology. Section 6 directly addresses the model requirements topology. Section 6 directly addresses the model requirements
imposed by the ForCES requirement draft [1] while Section 7 imposed by the ForCES requirement draft [1] while Section 7 explains
explains how the FE model should be used in the ForCES protocol. how the FE model should be used in the ForCES protocol.
3. 3. FE Model Concepts
FE Model Concepts
Some of the important concepts used throughout this document are Some of the important concepts used throughout this document are
introduced in this section. Section 3.1 explains the difference introduced in this section. Section 3.1 explains the difference
between a state model and a capability model, and describes how between a state model and a capability model, and describes how the
the two can be combined in the FE model. Section 3.2 introduces two can be combined in the FE model. Section 3.2 introduces the
the concept of LFBs (Logical Functional Blocks) as the basic concept of LFBs (Logical Functional Blocks) as the basic functional
functional building blocks in the FE model. Section 3.3 discusses building blocks in the FE model. Section 3.3 discusses the logical
the logical inter-connection and ordering between LFB instances inter-connection and ordering between LFB instances within an FE,
within an FE, that is, the LFB topology. that is, the LFB topology.
The FE model proposed in this document is comprised of two major The FE model proposed in this document is comprised of two major
components: the LFB model and FE level attributes, including FE components: the LFB model and FE level attributes, including FE
capabilities and LFB topology. The LFB model provides the content capabilities and LFB topology. The LFB model provides the content
and data structures to define each individual LFB class. FE and data structures to define each individual LFB class. FE
attributes provide information at the FE level, particularly the attributes provide information at the FE level, particularly the
capabilities of the FE at a coarse level. Part of the FE level capabilities of the FE at a coarse level. Part of the FE level
information is the LFB topology, which expresses the logical information is the LFB topology, which expresses the logical inter-
inter-connection between the LFB instances along the datapath(s) connection between the LFB instances along the datapath(s) within
within the FE. Details of these components are described in the FE. Details of these components are described in Section 4 and
Section 4 and 5. The intent of this section is to discuss these 5. The intent of this section is to discuss these concepts at the
concepts at the high level and lay the foundation for the detailed high level and lay the foundation for the detailed description in
description in the following sections. the following sections.
3.1. FE Capability Model and State Model 3.1. FE Capability Model and State Model
The ForCES FE model must describe both a capability and a state The ForCES FE model includes both a capability and a state model.
model. The FE capability model describes the capabilities and The FE capability model describes the capabilities and capacities of
capacities of an FE by specifying the variation in functions an FE by specifying the variation in functions supported and any
supported and any limitations. The FE state model describes the limitations. The FE state model describes the current state of the
current state of the FE, that is, the instantaneous values or FE, that is, the instantaneous values or operational behavior of the
operational behavior of the FE. FE.
Conceptually, the FE capability model tells the CE which states Conceptually, the FE capability model tells the CE which states are
are allowed on an FE, with capacity information indicating certain allowed on an FE, with capacity information indicating certain
quantitative limits or constraints. Thus, the CE has general quantitative limits or constraints. Thus, the CE has general
knowledge about configurations that are applicable to a particular knowledge about configurations that are applicable to a particular
FE. For example, an FE capability model may describe the FE at a FE. For example, an FE capability model may describe the FE at a
coarse level such as: coarse level such as:
. this FE can handle IPv4 and IPv6 forwarding; . this FE can handle IPv4 and IPv6 forwarding;
. this FE can perform classification on the following fields: . this FE can perform classification on the following fields:
source IP address, destination IP address, source port source IP address, destination IP address, source port number,
number, destination port number, etc; destination port number, etc;
. this FE can perform metering; . this FE can perform metering;
. this FE can handle up to N queues (capacity); . this FE can handle up to N queues (capacity);
. this FE can add and remove encapsulating headers of types . this FE can add and remove encapsulating headers of types
including IPSec, GRE, L2TP. including IPSec, GRE, L2TP.
While one could try and build an object model to fully represent While one could try and build an object model to fully represent the
the FE capabilities, other efforts found this to be a significant FE capabilities, other efforts found this to be a significant
undertaking. The main difficulty arises in describing detailed undertaking. The main difficulty arises in describing detailed
limits, such as the maximum number of classifiers, queues, buffer limits, such as the maximum number of classifiers, queues, buffer
pools, and meters the FE can provide. We believe that a good pools, and meters the FE can provide. We believe that a good
balance between simplicity and flexibility can be achieved for the balance between simplicity and flexibility can be achieved for the
FE model by combining coarse level capability reporting with an FE model by combining coarse level capability reporting with an
error reporting mechanism. That is, if the CE attempts to error reporting mechanism. That is, if the CE attempts to instruct
instruct the FE to set up some specific behavior it cannot the FE to set up some specific behavior it cannot support, the FE
support, the FE will return an error indicating the problem. will return an error indicating the problem. Examples of similar
Examples of similar approaches include DiffServ PIB [4] and approaches include DiffServ PIB [4] and Framework PIB [5].
Framework PIB [5].
One common and shared aspect of capability will be handled in a There is one common and shared aspect of capability that will be
separate fashion. For all elements of information, certain handled in a separate fashion. For all elements of information,
property information is needed. All elements need information as certain property information is needed. All elements need
to whether they are supported and if so whether the element is information as to whether they are supported and if so whether the
readable or writeable. Based on their type, many elements have element is readable or writeable. Based on their type, many
additional common properties (for example, arrays have their elements have additional common properties (for example, arrays have
current size.) There is a specific model and protocol mechanism their current size.) There is a specific model and protocol
for referencing this form of property information about elements mechanism for referencing this form of property information about
of the model. elements of the model.
The FE state model presents the snapshot view of the FE to the CE. The FE state model presents the snapshot view of the FE to the CE.
For example, using an FE state model, an FE may be described to For example, using an FE state model, an FE may be described to its
its corresponding CE as the following: corresponding CE as the following:
. on a given port, the packets are classified using a given . on a given port, the packets are classified using a given
classification filter; classification filter;
. the given classifier results in packets being metered in a . the given classifier results in packets being metered in a
certain way, and then marked in a certain way; certain way, and then marked in a certain way;
. the packets coming from specific markers are delivered into a . the packets coming from specific markers are delivered into a
shared queue for handling, while other packets are delivered shared queue for handling, while other packets are delivered to
to a different queue; a different queue;
. a specific scheduler with specific behavior and parameters . a specific scheduler with specific behavior and parameters will
will service these collected queues. service these collected queues.
Figure 1 shows the concepts of FE state, capabilities and Figure 1 shows the concepts of FE state, capabilities and
configuration in the context of CE-FE communication via the ForCES configuration in the context of CE-FE communication via the ForCES
protocol. protocol.
+-------+ +-------+ +-------+ +-------+
| | FE capabilities: what it can/cannot do. | | | | FE capabilities: what it can/cannot do. | |
| |<-----------------------------------------| | | |<-----------------------------------------| |
| | | | | | | |
| CE | FE state: what it is now. | FE | | CE | FE state: what it is now. | FE |
skipping to change at page 11, line 25 skipping to change at page 10, line 31
Figure 1. Illustration of FE state, capabilities and configuration Figure 1. Illustration of FE state, capabilities and configuration
exchange in the context of CE-FE communication via ForCES. exchange in the context of CE-FE communication via ForCES.
The concepts relating to LFBs, particularly capability at the LFB The concepts relating to LFBs, particularly capability at the LFB
level and LFB topology will be discussed in the rest of this level and LFB topology will be discussed in the rest of this
section. section.
Capability information at the LFB level is an integral part of the Capability information at the LFB level is an integral part of the
LFB model, and is modeled the same way as the other operational LFB model, and is modeled the same way as the other operational
parameters inside an LFB. For example, when certain features of parameters inside an LFB. For example, when certain features of an
an LFB class are optional, it must be possible for the CE to LFB class are optional, the CE MUST be able to determine whether
determine whether those optional features are supported by a given those optional features are supported by a given LFB instance. Such
LFB instance. Such capability information can be modeled as a capability information can be modeled as a read-only attribute in
read-only attribute in the LFB instance, see Section 4.7.5 for the LFB instance, see Section 4.7.5 for details.
details.
Capability information at the FE level may describe the LFB Capability information at the FE level may describe the LFB classes
classes that the FE can instantiate; the number of instances of that the FE can instantiate; the number of instances of each that
each that can be created; the topological (linkage) limitations can be created; the topological (linkage) limitations between these
between these LFB instances, etc. Section 5 defines the FE level LFB instances, etc. Section 5 defines the FE level attributes
attributes including capability information. including capability information.
Once the FE capability is described to the CE, the FE state Once the FE capability is described to the CE, the FE state
information can be represented by two levels. The first level is information can be represented by two levels. The first level is
the logically separable and distinct packet processing functions, the logically separable and distinct packet processing functions,
called Logical Functional Blocks (LFBs). The second level of called Logical Functional Blocks (LFBs). The second level of
information describes how these individual LFBs are ordered and information describes how these individual LFBs are ordered and
placed along the datapath to deliver a complete forwarding plane placed along the datapath to deliver a complete forwarding plane
service. The interconnection and ordering of the LFBs is called service. The interconnection and ordering of the LFBs is called LFB
LFB Topology. Section 3.2 discusses high level concepts around Topology. Section 3.2 discusses high level concepts around LFBs,
LFBs, whereas Section 3.3 discusses LFB topology issues. whereas Section 3.3 discusses LFB topology issues.
3.2. LFB (Logical Functional Block) Modeling 3.2. LFB (Logical Functional Block) Modeling
Each LFB performs a well-defined action or computation on the Each LFB performs a well-defined action or computation on the
packets passing through it. Upon completion of its prescribed packets passing through it. Upon completion of its prescribed
function, either the packets are modified in certain ways (e.g., function, either the packets are modified in certain ways (e.g.,
decapsulator, marker), or some results are generated and stored, decapsulator, marker), or some results are generated and stored,
often in the form of metadata (e.g., classifier). Each LFB often in the form of metadata (e.g., classifier). Each LFB
typically performs a single action. Classifiers, shapers and typically performs a single action. Classifiers, shapers and meters
meters are all examples of such LFBs. Modeling LFBs at such a are all examples of such LFBs. Modeling LFBs at such a fine
fine granularity allows us to use a small number of LFBs to granularity allows us to use a small number of LFBs to express the
express the higher-order FE functions (such as an IPv4 forwarder) higher-order FE functions (such as an IPv4 forwarder) precisely,
precisely, which in turn can describe more complex networking which in turn can describe more complex networking functions and
functions and vendor implementations of software and hardware. vendor implementations of software and hardware. These LFBs will be
These LFBs will be defined in detail in one or more documents. defined in detail in one or more documents.
An LFB has one or more inputs, each of which takes a packet P, and An LFB has one or more inputs, each of which takes a packet P, and
optionally metadata M; and produces one or more outputs, each of optionally metadata M; and produces one or more outputs, each of
which carries a packet P', and optionally metadata M'. Metadata which carries a packet P', and optionally metadata M'. Metadata is
is data associated with the packet in the network processing data associated with the packet in the network processing device
device (router, switch, etc.) and is passed from one LFB to the (router, switch, etc.) and is passed from one LFB to the next, but
next, but is not sent across the network. In general, multiple is not sent across the network. In general, multiple LFBs are
LFBs are contained in one FE, as shown in Figure 2, and all the contained in one FE, as shown in Figure 2, and all the LFBs share
LFBs share the same ForCES protocol termination point that the same ForCES protocol termination point that implements the
implements the ForCES protocol logic and maintains the ForCES protocol logic and maintains the communication channel to and
communication channel to and from the CE. from the CE.
+-----------+ +-----------+
| CE | | CE |
+-----------+ +-----------+
^ ^
| Fp reference point | Fp reference point
| |
+--------------------------|-----------------------------------+ +--------------------------|-----------------------------------+
| FE | | | FE | |
| v | | v |
skipping to change at page 13, line 38 skipping to change at page 12, line 38
| | | |
+--------------------------------------------------------------+ +--------------------------------------------------------------+
Figure 2. Generic LFB Diagram Figure 2. Generic LFB Diagram
An LFB, as shown in Figure 2, has inputs, outputs and attributes An LFB, as shown in Figure 2, has inputs, outputs and attributes
that can be queried and manipulated by the CE indirectly via an Fp that can be queried and manipulated by the CE indirectly via an Fp
reference point (defined in RFC 3746 [2]) and the ForCES protocol reference point (defined in RFC 3746 [2]) and the ForCES protocol
termination point. The horizontal axis is in the forwarding plane termination point. The horizontal axis is in the forwarding plane
for connecting the inputs and outputs of LFBs within the same FE. for connecting the inputs and outputs of LFBs within the same FE.
The vertical axis between the CE and the FE denotes the Fp The vertical axis between the CE and the FE denotes the Fp reference
reference point where bidirectional communication between the CE point where bidirectional communication between the CE and FE
and FE occurs: the CE to FE communication is for configuration, occurs: the CE to FE communication is for configuration, control and
control and packet injection while FE to CE communication is used packet injection while FE to CE communication is used for packet re-
for packet re-direction to the control plane, monitoring and direction to the control plane, monitoring and accounting
accounting information, errors, etc. Note that the interaction information, errors, etc. Note that the interaction between the CE
between the CE and the LFB is only abstract and indirect. The and the LFB is only abstract and indirect. The result of such an
result of such an interaction is for the CE to indirectly interaction is for the CE to indirectly manipulate the attributes of
manipulate the attributes of the LFB instances. the LFB instances.
A namespace is used to associate a unique name or ID with each LFB A namespace is used to associate a unique name or ID with each LFB
class. The namespace must be extensible so that a new LFB class class. The namespace MUST be extensible so that a new LFB class can
can be added later to accommodate future innovation in the be added later to accommodate future innovation in the forwarding
forwarding plane. plane.
LFB operation must be specified in the model to allow the CE to LFB operation is specified in the model to allow the CE to
understand the behavior of the forwarding datapath. For instance, understand the behavior of the forwarding datapath. For instance,
the CE must understand at what point in the datapath the IPv4 the CE must understand at what point in the datapath the IPv4 header
header TTL is decremented. That is, the CE needs to know if a TTL is decremented. That is, the CE needs to know if a control
control packet could be delivered to it either before or after packet could be delivered to it either before or after this point in
this point in the datapath. In addition, the CE must understand the datapath. In addition, the CE MUST understand where and what
where and what type of header modifications (e.g., tunnel header type of header modifications (e.g., tunnel header append or strip)
append or strip) are performed +by the FEs. Further, the CE must are performed by the FEs. Further, the CE MUST verify that the
verify that the various LFBs along a datapath within an FE are various LFBs along a datapath within an FE are compatible to link
compatible to link together. together.
There is value to vendors if the operation of LFB classes can be There is value to vendors if the operation of LFB classes can be
expressed in sufficient detail so that physical devices expressed in sufficient detail so that physical devices implementing
implementing different LFB functions can be integrated easily into different LFB functions can be integrated easily into an FE design.
an FE design. Therefore, a semi-formal specification is needed; Therefore, a semi-formal specification is needed; that is, a text
that is, a text description of the LFB operation (human readable), description of the LFB operation (human readable), but sufficiently
but sufficiently specific and unambiguous to allow conformance specific and unambiguous to allow conformance testing and efficient
testing and efficient design, so that interoperability between design, so that interoperability between different CEs and FEs can
different CEs and FEs can be achieved. be achieved.
The LFB class model specifies information such as: The LFB class model specifies information such as:
. number of inputs and outputs (and whether they are . number of inputs and outputs (and whether they are
configurable) configurable)
. metadata read/consumed from inputs; . metadata read/consumed from inputs;
. metadata produced at the outputs; . metadata produced at the outputs;
. packet type(s) accepted at the inputs and emitted at the . packet type(s) accepted at the inputs and emitted at the
outputs; outputs;
. packet content modifications (including encapsulation or . packet content modifications (including encapsulation or
decapsulation); decapsulation);
. packet routing criteria (when multiple outputs on an LFB are . packet routing criteria (when multiple outputs on an LFB are
present); present);
skipping to change at page 14, line 43 skipping to change at page 13, line 44
decapsulation); decapsulation);
. packet routing criteria (when multiple outputs on an LFB are . packet routing criteria (when multiple outputs on an LFB are
present); present);
. packet timing modifications; . packet timing modifications;
. packet flow ordering modifications; . packet flow ordering modifications;
. LFB capability information; . LFB capability information;
. Events that can be detected by the LFB, with notification to . Events that can be detected by the LFB, with notification to
the CE; the CE;
. LFB operational attributes, etc. . LFB operational attributes, etc.
Section 4 of this document provides a detailed discussion of the Section 4 of this document provides a detailed discussion of the LFB
LFB model with a formal specification of LFB class schema. The model with a formal specification of LFB class schema. The rest of
rest of Section 3.2 only intends to provide a conceptual overview Section 3.2 only intends to provide a conceptual overview of some
of some important issues in LFB modeling, without covering all the important issues in LFB modeling, without covering all the specific
specific details. details.
3.2.1. LFB Outputs 3.2.1. LFB Outputs
An LFB output is a conceptual port on an LFB that can send An LFB output is a conceptual port on an LFB that can send
information to another LFB. The information is typically a packet information to another LFB. The information is typically a packet
and its associated metadata, although in some cases it might and its associated metadata, although in some cases it might consist
consist of only metadata, i.e., with no packet data. of only metadata, i.e., with no packet data.
A single LFB output can be connected to only one LFB input. This A single LFB output can be connected to only one LFB input. This is
is required to make the packet flow through the LFB topology required to make the packet flow through the LFB topology
unambiguously. unambiguously.
Some LFBs will have a single output, as depicted in Figure 3.a. Some LFBs will have a single output, as depicted in Figure 3.a.
+---------------+ +-----------------+ +---------------+ +-----------------+
| | | | | | | |
| | | OUT +--> | | | OUT +-->
... OUT +--> ... | ... OUT +--> ... |
| | | EXCEPTIONOUT +--> | | | EXCEPTIONOUT +-->
| | | | | | | |
skipping to change at page 15, line 38 skipping to change at page 14, line 36
... OUT:2 +--> ... OUT:1 +--> ... OUT:2 +--> ... OUT:1 +-->
| ... +... | OUT:2 +--> | ... +... | OUT:2 +-->
| OUT:n +--> | ... +... | OUT:n +--> | ... +...
+---------------+ | OUT:n +--> +---------------+ | OUT:n +-->
+-----------------+ +-----------------+
c. One output group d. One output and one output group c. One output group d. One output and one output group
Figure 3. Examples of LFBs with various output combinations. Figure 3. Examples of LFBs with various output combinations.
To accommodate a non-trivial LFB topology, multiple LFB outputs To accommodate a non-trivial LFB topology, multiple LFB outputs are
are needed so that an LFB class can fork the datapath. Two needed so that an LFB class can fork the datapath. Two mechanisms
mechanisms are provided for forking: multiple singleton outputs are provided for forking: multiple singleton outputs and output
and output groups, which can be combined in the same LFB class. groups, which can be combined in the same LFB class.
Multiple separate singleton outputs are defined in an LFB class to Multiple separate singleton outputs are defined in an LFB class to
model a pre-determined number of semantically different outputs. model a pre-determined number of semantically different outputs.
That is, the number of outputs must be known when the LFB class is That is, the LFB class definition MUST include the number of
defined. Additional singleton outputs cannot be created at LFB outputs, implying the number of outputs is known when the LFB class
instantiation time, nor can they be created on the fly after the is defined. Additional singleton outputs cannot be created at LFB
LFB is instantiated. instantiation time, nor can they be created on the fly after the LFB
is instantiated.
For example, an IPv4 LPM (Longest-Prefix-Matching) LFB may have For example, an IPv4 LPM (Longest-Prefix-Matching) LFB may have one
one output(OUT) to send those packets for which the LPM look-up output(OUT) to send those packets for which the LPM look-up was
was successful, passing a META_ROUTEID as metadata; and have successful, passing a META_ROUTEID as metadata; and have another
another output (EXCEPTIONOUT) for sending exception packets when output (EXCEPTIONOUT) for sending exception packets when the LPM
the LPM look-up failed. This example is depicted in Figure 3.b. look-up failed. This example is depicted in Figure 3.b. Packets
Packets emitted by these two outputs not only require different emitted by these two outputs not only require different downstream
downstream treatment, but they are a result of two different treatment, but they are a result of two different conditions in the
conditions in the LFB and each output carries different metadata. LFB and each output carries different metadata. This concept
This concept assumes the number of distinct outputs is known when assumes the number of distinct outputs is known when the LFB class
the LFB class is defined. For each singleton output, the LFB class is defined. For each singleton output, the LFB class definition
definition defines the types of frames and metadata the output defines the types of frames and metadata the output emits.
emits.
An output group, on the other hand, is used to model the case An output group, on the other hand, is used to model the case where
where a flow of similar packets with an identical set of metadata a flow of similar packets with an identical set of metadata needs to
needs to be split into multiple paths. In this case, the number of be split into multiple paths. In this case, the number of such paths
such paths is not known when the LFB class is defined because it is not known when the LFB class is defined because it is not an
is not an inherent property of the LFB class. An output group inherent property of the LFB class. An output group consists of a
consists of a number of outputs, called the output instances of number of outputs, called the output instances of the group, where
the group, where all output instances share the same frame and all output instances share the same frame and metadata emission
metadata emission definitions (see Figure 3.c). Each output definitions (see Figure 3.c). Each output instance can connect to a
instance can connect to a different downstream LFB, just as if different downstream LFB, just as if they were separate singleton
they were separate singleton outputs, but the number of output outputs, but the number of output instances can differ between LFB
instances can differ between LFB instances of the same LFB class. instances of the same LFB class. The class definition may include a
The class definition may include a lower and/or an upper limit on lower and/or an upper limit on the number of outputs. In addition,
the number of outputs. In addition, for configurable FEs, the FE for configurable FEs, the FE capability information may define
capability information may define further limits on the number of further limits on the number of instances in specific output groups
instances in specific output groups for certain LFBs. The actual for certain LFBs. The actual number of output instances in a group
number of output instances in a group is an attribute of the LFB is an attribute of the LFB instance, which is read-only for static
instance, which is read-only for static topologies, and read-write topologies, and read-write for dynamic topologies. The output
for dynamic topologies. The output instances in a group are instances in a group are numbered sequentially, from 0 to N-1, and
numbered sequentially, from 0 to N-1, and are addressable from are addressable from within the LFB. The LFB has a built-in
within the LFB. The LFB has a built-in mechanism to select one mechanism to select one specific output instance for each packet.
specific output instance for each packet. This mechanism is This mechanism is described in the textual definition of the class
described in the textual definition of the class and is typically and is typically configurable via some attributes of the LFB.
configurable via some attributes of the LFB.
For example, consider a re-director LFB, whose sole purpose is to For example, consider a re-director LFB, whose sole purpose is to
direct packets to one of N downstream paths based on one of the direct packets to one of N downstream paths based on one of the
metadata associated with each arriving packet. Such an LFB is metadata associated with each arriving packet. Such an LFB is
fairly versatile and can be used in many different places in a fairly versatile and can be used in many different places in a
topology. For example, a redirector can be used to divide the topology. For example, a redirector can be used to divide the data
data path into an IPv4 and an IPv6 path based on a FRAMETYPE path into an IPv4 and an IPv6 path based on a FRAMETYPE metadata
metadata (N=2), or to fork into color specific paths after (N=2), or to fork into color specific paths after metering using the
metering using the COLOR metadata (red, yellow, green; N=3), etc. COLOR metadata (red, yellow, green; N=3), etc.
Using an output group in the above LFB class provides the desired Using an output group in the above LFB class provides the desired
flexibility to adapt each instance of this class to the required flexibility to adapt each instance of this class to the required
operation. The metadata to be used as a selector for the output operation. The metadata to be used as a selector for the output
instance is a property of the LFB. For each packet, the value of instance is a property of the LFB. For each packet, the value of
the specified metadata may be used as a direct index to the output the specified metadata may be used as a direct index to the output
instance. Alternatively, the LFB may have a configurable selector instance. Alternatively, the LFB may have a configurable selector
table that maps a metadata value to output instance. table that maps a metadata value to output instance.
Note that other LFBs may also use the output group concept to Note that other LFBs may also use the output group concept to build
build in similar adaptive forking capability. For example, a in similar adaptive forking capability. For example, a classifier
classifier LFB with one input and N outputs can be defined easily LFB with one input and N outputs can be defined easily by using the
by using the output group concept. Alternatively, a classifier output group concept. Alternatively, a classifier LFB with one
LFB with one singleton output in combination with an explicit N- singleton output in combination with an explicit N-output re-
output re-director LFB models the same processing behavior. The director LFB models the same processing behavior. The decision of
decision of whether to use the output group model for a certain whether to use the output group model for a certain LFB class is
LFB class is left to the LFB class designers. left to the LFB class designers.
The model allows the output group be combined with other singleton The model allows the output group to be combined with other
output(s) in the same class, as demonstrated in Figure 3.d. The singleton output(s) in the same class, as demonstrated in Figure
LFB here has two types of outputs, OUT, for normal packet output, 3.d. The LFB here has two types of outputs, OUT, for normal packet
and EXCEPTIONOUT for packets that triggered some exception. The output, and EXCEPTIONOUT for packets that triggered some exception.
normal OUT has multiple instances, thus, it is an output group. The normal OUT has multiple instances, thus, it is an output group.
In summary, the LFB class may define one output, multiple singleton
outputs, one or more output groups, or a combination thereof.
Multiple singleton outputs should be used when the LFB must provide
for forking the datapath, and at least one of the following
conditions hold:
In summary, the LFB class may define one output, multiple
singleton outputs, one or more output groups, or a combination
thereof. Multiple singleton outputs should be used when the LFB
must provide for forking the datapath, and at least one of the
following conditions hold:
. the number of downstream directions are inherent from the . the number of downstream directions are inherent from the
definition of the class and hence fixed; definition of the class and hence fixed;
. the frame type and set of metadata emitted on any of the . the frame type and set of metadata emitted on any of the
outputs are substantially different from what is emitted on outputs are substantially different from what is emitted on
the other outputs (i.e., they cannot share frame-type and the other outputs (i.e., they cannot share frame-type and
metadata definitions); metadata definitions);
An output group is appropriate when the LFB must provide for An output group is appropriate when the LFB must provide for forking
forking the datapath, and at least one of the following conditions the datapath, and at least one of the following conditions hold:
hold:
. the number of downstream directions is not known when the LFB . the number of downstream directions is not known when the LFB
class is defined; class is defined;
. the frame type and set of metadata emitted on these outputs . the frame type and set of metadata emitted on these outputs are
are sufficiently similar or ideally identical, such they can sufficiently similar or ideally identical, such they can share
share the same output definition. the same output definition.
3.2.2. LFB Inputs 3.2.2. LFB Inputs
An LFB input is a conceptual port on an LFB where the LFB can An LFB input is a conceptual port on an LFB where the LFB can
receive information from other LFBs. The information is typically receive information from other LFBs. The information is typically a
a packet and associated metadata, although in some cases it might packet and associated metadata, although in some cases it might
consist of only metadata, without any packet data. consist of only metadata, without any packet data.
For LFB instances that receive packets from more than one other For LFB instances that receive packets from more than one other LFB
LFB instance (fan-in). There are three ways to model fan-in, all instance (fan-in). There are three ways to model fan-in, all
supported by the LFB model and can be combined in the same LFB: supported by the LFB model and can be combined in the same LFB:
. Implicit multiplexing via a single input . Implicit multiplexing via a single input
. Explicit multiplexing via multiple singleton inputs . Explicit multiplexing via multiple singleton inputs
. Explicit multiplexing via a group of inputs (input group) . Explicit multiplexing via a group of inputs (input group)
The simplest form of multiplexing uses a singleton input (Figure The simplest form of multiplexing uses a singleton input (Figure
4.a). Most LFBs will have only one singleton input. Multiplexing 4.a). Most LFBs will have only one singleton input. Multiplexing
into a single input is possible because the model allows more than into a single input is possible because the model allows more than
one LFB output to connect to the same LFB input. This property one LFB output to connect to the same LFB input. This property
applies to any LFB input without any special provisions in the LFB applies to any LFB input without any special provisions in the LFB
class. Multiplexing into a single input is applicable when the class. Multiplexing into a single input is applicable when the
skipping to change at page 18, line 24 skipping to change at page 17, line 15
. Explicit multiplexing via a group of inputs (input group) . Explicit multiplexing via a group of inputs (input group)
The simplest form of multiplexing uses a singleton input (Figure The simplest form of multiplexing uses a singleton input (Figure
4.a). Most LFBs will have only one singleton input. Multiplexing 4.a). Most LFBs will have only one singleton input. Multiplexing
into a single input is possible because the model allows more than into a single input is possible because the model allows more than
one LFB output to connect to the same LFB input. This property one LFB output to connect to the same LFB input. This property
applies to any LFB input without any special provisions in the LFB applies to any LFB input without any special provisions in the LFB
class. Multiplexing into a single input is applicable when the class. Multiplexing into a single input is applicable when the
packets from the upstream LFBs are similar in frame-type and packets from the upstream LFBs are similar in frame-type and
accompanying metadata, and require similar processing. Note that accompanying metadata, and require similar processing. Note that
this model does not address how potential contention is handled this model does not address how potential contention is handled when
when multiple packets arrive simultaneously. If contention multiple packets arrive simultaneously. If contention handling
handling needs to be explicitly modeled, one of the other two needs to be explicitly modeled, one of the other two modeling
modeling solutions must be used. solutions must be used.
The second method to model fan-in uses individually defined The second method to model fan-in uses individually defined
singleton inputs (Figure 4.b). This model is meant for situations singleton inputs (Figure 4.b). This model is meant for situations
where the LFB needs to handle distinct types of packet streams, where the LFB needs to handle distinct types of packet streams,
requiring input-specific handling inside the LFB, and where the requiring input-specific handling inside the LFB, and where the
number of such distinct cases is known when the LFB class is number of such distinct cases is known when the LFB class is
defined. For example, a Layer 2 Decapsulation/Encapsulation LFB defined. For example, a Layer 2 Decapsulation/Encapsulation LFB may
may have two inputs, one for receiving Layer 2 frames for have two inputs, one for receiving Layer 2 frames for decapsulation,
decapsulation, and one for receiving Layer 3 frames for and one for receiving Layer 3 frames for encapsulation. This LFB
encapsulation. This LFB type expects different frames (L2 vs. L3) type expects different frames (L2 vs. L3) at its inputs, each with
at its inputs, each with different sets of metadata, and would different sets of metadata, and would thus apply different
thus apply different processing on frames arriving at these processing on frames arriving at these inputs. This model is
inputs. This model is capable of explicitly addressing packet capable of explicitly addressing packet contention by defining how
contention by defining how the LFB class handles the contending the LFB class handles the contending packets.
packets.
+--------------+ +------------------------+ +--------------+ +------------------------+
| LFB X +---+ | | | LFB X +---+ | |
+--------------+ | | | +--------------+ | | |
| | | | | |
+--------------+ v | | +--------------+ v | |
| LFB Y +---+-->|input Meter LFB | | LFB Y +---+-->|input Meter LFB |
+--------------+ ^ | | +--------------+ ^ | |
| | | | | |
+--------------+ | | | +--------------+ | | |
| LFB Z |---+ | | | LFB Z |---+ | |
+--------------+ +------------------------+ +--------------+ +------------------------+
(a) An LFB connects with multiple upstream LFBs via a single (a) An LFB connects with multiple upstream LFBs via a single input.
input.
+--------------+ +------------------------+ +--------------+ +------------------------+
| LFB X +---+ | | | LFB X +---+ | |
+--------------+ +-->|layer2 | +--------------+ +-->|layer2 |
+--------------+ | | +--------------+ | |
| LFB Y +------>|layer3 LFB | | LFB Y +------>|layer3 LFB |
+--------------+ +------------------------+ +--------------+ +------------------------+
(b) An LFB connects with multiple upstream LFBs via two separate (b) An LFB connects with multiple upstream LFBs via two separate
singleton inputs. singleton inputs.
skipping to change at page 19, line 43 skipping to change at page 18, line 28
| | | | | |
+--------------+ +-->|in:0 \ | +--------------+ +-->|in:0 \ |
| Queue LFB #2 +------>|in:1 | input group | | Queue LFB #2 +------>|in:1 | input group |
+--------------+ |... | | +--------------+ |... | |
+-->|in:N-1 / | +-->|in:N-1 / |
... | | | ... | | |
+--------------+ | | | +--------------+ | | |
| Queue LFB #N |---+ | Scheduler LFB | | Queue LFB #N |---+ | Scheduler LFB |
+--------------+ +------------------------+ +--------------+ +------------------------+
(c) A Scheduler LFB uses an input group to differentiate which (c) A Scheduler LFB uses an input group to differentiate which queue
queue LFB packets are coming from. LFB packets are coming from.
Figure 3. Input modeling concepts (examples). Figure 3. Input modeling concepts (examples).
The third method to model fan-in uses the concept of an input The third method to model fan-in uses the concept of an input group.
group. The concept is similar to the output group introduced in The concept is similar to the output group introduced in the
the previous section, and is depicted in Figure 4.c. An input previous section, and is depicted in Figure 4.c. An input group
group consists of a number of input instances, all sharing the consists of a number of input instances, all sharing the properties
properties (same frame and metadata expectations). The input (same frame and metadata expectations). The input instances are
instances are numbered from 0 to N-1. From the outside, these numbered from 0 to N-1. From the outside, these inputs appear as
inputs appear as normal inputs, i.e., any compatible upstream LFB normal inputs, i.e., any compatible upstream LFB can connect its
can connect its output to one of these inputs. When a packet is output to one of these inputs. When a packet is presented to the
presented to the LFB at a particular input instance, the index of LFB at a particular input instance, the index of the input where the
the input where the packet arrived is known to the LFB and this packet arrived is known to the LFB and this information may be used
information may be used in the internal processing. For example, in the internal processing. For example, the input index can be
the input index can be used as a table selector, or as an explicit used as a table selector, or as an explicit precedence selector to
precedence selector to resolve contention. As with output groups, resolve contention. As with output groups, the number of input
the number of input instances in an input group is not defined in instances in an input group is not defined in the LFB class.
the LFB class. However, the class definition may include However, the class definition may include restrictions on the range
restrictions on the range of possible values. In addition, if an of possible values. In addition, if an FE supports configurable
FE supports configurable topologies, it may impose further topologies, it may impose further limitations on the number of
limitations on the number of instances for a particular port instances for a particular port group(s) of a particular LFB class.
group(s) of a particular LFB class. Within these limitations, Within these limitations, different instances of the same class may
different instances of the same class may have a different number have a different number of input instances. The number of actual
of input instances. The number of actual input instances in the input instances in the group is an attribute of the LFB class, which
group is an attribute of the LFB class, which is read-only for is read-only for static topologies, and is read-write for
static topologies, and is read-write for configurable topologies. configurable topologies.
As an example for the input group, consider the Scheduler LFB As an example for the input group, consider the Scheduler LFB
depicted in Figure 3.c. Such an LFB receives packets from a depicted in Figure 3.c. Such an LFB receives packets from a number
number of Queue LFBs via a number of input instances, and uses the of Queue LFBs via a number of input instances, and uses the input
input index information to control contention resolution and index information to control contention resolution and scheduling.
scheduling.
In summary, the LFB class may define one input, multiple singleton In summary, the LFB class may define one input, multiple singleton
inputs, one or more input groups, or a combination thereof. Any inputs, one or more input groups, or a combination thereof. Any
input allows for implicit multiplexing of similar packet streams input allows for implicit multiplexing of similar packet streams via
via connecting multiple outputs to the same input. Explicit connecting multiple outputs to the same input. Explicit multiple
multiple singleton inputs are useful when either the contention singleton inputs are useful when either the contention handling must
handling must be handled explicitly, or when the LFB class must be handled explicitly, or when the LFB class must receive and
receive and process a known number of distinct types of packet process a known number of distinct types of packet streams. An
streams. An input group is suitable when contention handling must input group is suitable when contention handling must be modeled
be modeled explicitly, but the number of inputs are not inherent explicitly, but the number of inputs are not inherent from the class
from the class (and hence is not known when the class is defined), (and hence is not known when the class is defined), or when it is
or when it is critical for LFB operation to know exactly on which critical for LFB operation to know exactly on which input the packet
input the packet was received. was received.
3.2.3. Packet Type 3.2.3. Packet Type
When LFB classes are defined, the input and output packet formats When LFB classes are defined, the input and output packet formats
(e.g., IPv4, IPv6, Ethernet, etc.) must be specified. These are (e.g., IPv4, IPv6, Ethernet, etc.) MUST be specified. These are the
the types of packets a given LFB input is capable of receiving and types of packets a given LFB input is capable of receiving and
processing, or a given LFB output is capable of producing. This processing, or a given LFB output is capable of producing. This
requires distinct packet types be uniquely labeled with a symbolic requires distinct packet types be uniquely labeled with a symbolic
name and/or ID. name and/or ID.
Note that each LFB has a set of packet types that it operates on, Note that each LFB has a set of packet types that it operates on,
but does not care whether the underlying implementation is passing but does not care whether the underlying implementation is passing a
a greater portion of the packets. For example, an IPv4 LFB might greater portion of the packets. For example, an IPv4 LFB might only
only operate on IPv4 packets, but the underlying implementation operate on IPv4 packets, but the underlying implementation may or
may or may not be stripping the L2 header before handing it over - may not be stripping the L2 header before handing it over -- whether
- whether that is happening or not is opaque to the CE. that is happening or not is opaque to the CE.
3.2.4. Metadata 3.2.4. Metadata
Metadata is the per-packet state that is passed from one LFB to Metadata is the per-packet state that is passed from one LFB to
another. The metadata is passed with the packet to assist another. The metadata is passed with the packet to assist subsequent
subsequent LFBs to process that packet. The ForCES model captures LFBs to process that packet. The ForCES model captures how the per-
how the per-packet state information is propagated from one LFB to packet state information is propagated from one LFB to other LFBs.
other LFBs. Practically, such metadata propagation can happen Practically, such metadata propagation can happen within one FE, or
within one FE, or cross the FE boundary between two interconnected cross the FE boundary between two interconnected FEs. We believe
FEs. We believe that the same metadata model can be used for that the same metadata model can be used for either situation;
either situation; however, our focus here is for intra-FE however, our focus here is for intra-FE metadata.
metadata.
3.2.4.1. Metadata Vocabulary 3.2.4.1. Metadata Vocabulary
Metadata has historically been understood to mean "data about Metadata has historically been understood to mean "data about data".
data". While this definition is a start, it is inadequate to While this definition is a start, it is inadequate to describe the
describe the multiple forms of metadata, which may appear within a multiple forms of metadata, which may appear within a complex
complex network element. The discussion here categorizes forms of network element. The discussion here categorizes forms of metadata
metadata by two orthogonal axes. by two orthogonal axes.
The first axis is "internal" versus "external", which describes The first axis is "internal" versus "external", which describes
where the metadata exists in the network model or implementation. where the metadata exists in the network model or implementation.
For example, a particular vendor implementation of an IPv4 For example, a particular vendor implementation of an IPv4 forwarder
forwarder may make decisions inside of a chip that are not visible may make decisions inside of a chip that are not visible externally.
externally. Those decisions are metadata for the packet that is Those decisions are metadata for the packet that is "internal" to
"internal" to the chip. When a packet is forwarded out of the the chip. When a packet is forwarded out of the chip, it may be
chip, it may be marked with a traffic management header. That marked with a traffic management header. That header, which is
header, which is metadata for the packet, is visible outside of metadata for the packet, is visible outside of the chip, and is
the chip, and is therefore called "external" metadata. therefore called "external" metadata.
The second axis is "implicit" versus "expressed", which specifies The second axis is "implicit" versus "expressed", which specifies
whether or not the metadata has a visible physical representation. whether or not the metadata has a visible physical representation.
For example, the traffic management header described in the For example, the traffic management header described in the previous
previous paragraph may be represented as a series of bits in some paragraph may be represented as a series of bits in some format, and
format, and that header is associated with the packet. Those bits that header is associated with the packet. Those bits have physical
have physical representation, and are therefore "expressed" representation, and are therefore "expressed" metadata. If the
metadata. If the metadata does not have a physical metadata does not have a physical representation, it is called
representation, it is called "implicit" metadata. This situation "implicit" metadata. This situation occurs, for example, when a
occurs, for example, when a particular path through a network particular path through a network device is intended to be traversed
device is intended to be traversed only by particular kinds of only by particular kinds of packets, such as an IPv4 router. An
packets, such as an IPv4 router. An implementation may not mark implementation may not mark every packet along this path as being of
every packet along this path as being of type "IPv4", but the type "IPv4", but the intention of the designers is that every packet
intention of the designers is that every packet is of that type. is of that type. This understanding can be thought of as metadata
This understanding can be thought of as metadata about the packet, about the packet, which is implicitly attached to the packet through
which is implicitly attached to the packet through the intent of the intent of the designers.
the designers.
In the ForCES model, we do NOT discuss or represent metadata In the ForCES model, we do not discuss or represent metadata
"internal" to vendor implementations of LFBs. Our focus is solely "internal" to vendor implementations of LFBs. Our focus is solely
on metadata "external" to the LFBs, and therefore visible in the on metadata "external" to the LFBs, and therefore visible in the
ForCES model. The metadata discussed within this model may, or ForCES model. The metadata discussed within this model may, or may
may not, be visible outside of the particular FE implementing the not be visible outside of the particular FE implementing the LFB
LFB model. In this regard, the scope of the metadata within model. In this regard, the scope of the metadata within ForCES is
ForCES is very narrowly defined. very narrowly defined.
Note also that while we define metadata within this model, it is Note also that while we define metadata within this model, it is
only a model. There is no requirement that vendor implementations only a model. There is no requirement that vendor implementations
of ForCES use the exact metadata representations described in this of ForCES use the exact metadata representations described in this
document. The only implementation requirement is that vendors document. The only implementation requirement is that vendors
implement the ForCES protocol, not the model. implement the ForCES protocol, not the model.
3.2.4.2. Metadata lifecycle within the ForCES model 3.2.4.2. Metadata lifecycle within the ForCES model
Each metadata can be conveniently modeled as a <label, value> Each metadata can be conveniently modeled as a <label, value> pair,
pair, where the label identifies the type of information, (e.g., where the label identifies the type of information, (e.g., "color"),
"color"), and its value holds the actual information (e.g., and its value holds the actual information (e.g., "red"). The tag
"red"). The tag here is shown as a textual label, but it can be here is shown as a textual label, but it can be replaced or
replaced or associated with a unique numeric value (identifier). associated with a unique numeric value (identifier).
The metadata life-cycle is defined in this model using three types The metadata life-cycle is defined in this model using three types
of events: "write", "read" and "consume". The first "write" of events: "write", "read" and "consume". The first "write"
implicitly creates and initializes the value of the metadata, and implicitly creates and initializes the value of the metadata, and
hence starts the life-cycle. The explicit "consume" event hence starts the life-cycle. The explicit "consume" event
terminates the life-cycle. Within the life-cycle, that is, after terminates the life-cycle. Within the life-cycle, that is, after a
a "write" event, but before the next "consume" event, there can be "write" event, but before the next "consume" event, there can be an
an arbitrary number of "write" and "read" events. These "read" arbitrary number of "write" and "read" events. These "read" and
and "write" events can be mixed in an arbitrary order within the "write" events can be mixed in an arbitrary order within the life-
life-cycle. Outside of the life-cycle of the metadata, that is, cycle. Outside of the life-cycle of the metadata, that is, before
before the first "write" event, or between a "consume" event and the first "write" event, or between a "consume" event and the next
the next "write" event, the metadata should be regarded non- "write" event, the metadata should be regarded non-existent or non-
existent or non-initialized. Thus, reading a metadata outside of initialized. Thus, reading a metadata outside of its life-cycle is
its life-cycle is considered an error. considered an error.
To ensure inter-operability between LFBs, the LFB class To ensure inter-operability between LFBs, the LFB class
specification must define what metadata the LFB class "reads" or specification must define what metadata the LFB class "reads" or
"consumes" on its input(s) and what metadata it "produces" on its "consumes" on its input(s) and what metadata it "produces" on its
output(s). For maximum extensibility, this definition should output(s). For maximum extensibility, this definition should
neither specify which LFBs the metadata is expected to come from neither specify which LFBs the metadata is expected to come from for
for a consumer LFB, nor which LFBs are expected to consume a consumer LFB, nor which LFBs are expected to consume metadata for
metadata for a given producer LFB. a given producer LFB.
While it is important to define the metadata types passing between While it is important to define the metadata types passing between
LFBs, it is not appropriate to define the exact encoding mechanism LFBs, it is not appropriate to define the exact encoding mechanism
used by LFBs for that metadata. Different implementations are used by LFBs for that metadata. Different implementations are
allowed to use different encoding mechanisms for metadata. For allowed to use different encoding mechanisms for metadata. For
example, one implementation may store metadata in registers or example, one implementation may store metadata in registers or
shared memory, while another implementation may encode metadata shared memory, while another implementation may encode metadata in-
in-band as a preamble in the packets. band as a preamble in the packets. In order to allow the CE to
understand and control the meta-data related operations, the model
represents each metadata tag as a 32-bit integer. Each LFB
definition indicates in its metadata declarations the 32-bit value
associated with a given metadata tag. Ensuring consistency of usage
of tags is important, and outside the scope of the model.
At any link between two LFBs, the packet is marked with a finite At any link between two LFBs, the packet is marked with a finite set
set of active metadata, where active means the metadata is within of active metadata, where active means the metadata is within its
its life-cycle. There are two corollaries of this model: life-cycle. There are two corollaries of this model:
1. No un-initialized metadata exists in the model. 1. No un-initialized metadata exists in the model.
2. No more than one occurrence of each metadata tag can be 2. No more than one occurrence of each metadata tag can be
associated with a packet at any given time. associated with a packet at any given time.
3.2.4.3. LFB Operations on Metadata 3.2.4.3. LFB Operations on Metadata
When the packet is processed by an LFB (i.e., between the time it When the packet is processed by an LFB (i.e., between the time it is
is received and forwarded by the LFB), the LFB may perform read, received and forwarded by the LFB), the LFB may perform read, write
write and/or consume operations on any active metadata associated and/or consume operations on any active metadata associated with the
with the packet. If the LFB is considered to be a black box, one packet. If the LFB is considered to be a black box, one of the
of the following operations is performed on each active metadata. following operations is performed on each active metadata.
. IGNORE: ignores and forwards the metadata . IGNORE: ignores and forwards the metadata
. READ: reads and forwards the metadata . READ: reads and forwards the metadata
. READ/RE-WRITE: reads, over-writes and forwards the . READ/RE-WRITE: reads, over-writes and forwards the metadata
metadata
. WRITE: writes and forwards the metadata . WRITE: writes and forwards the metadata
(can also be used to create new metadata) (can also be used to create new metadata)
. READ-AND-CONSUME: reads and consumes the metadata . READ-AND-CONSUME: reads and consumes the metadata
. CONSUME consumes metadata without reading . CONSUME consumes metadata without reading
The last two operations terminate the life-cycle of the metadata, The last two operations terminate the life-cycle of the metadata,
meaning that the metadata is not forwarded with the packet when meaning that the metadata is not forwarded with the packet when the
the packet is sent to the next LFB. packet is sent to the next LFB.
In our model, a new metadata is generated by an LFB when the LFB In our model, a new metadata is generated by an LFB when the LFB
applies a WRITE operation to a metadata type that was not present applies a WRITE operation to a metadata type that was not present
when the packet was received by the LFB. Such implicit creation when the packet was received by the LFB. Such implicit creation may
may be unintentional by the LFB, that is, the LFB may apply the be unintentional by the LFB, that is, the LFB may apply the WRITE
WRITE operation without knowing or caring if the given metadata operation without knowing or caring if the given metadata existed or
existed or not. If it existed, the metadata gets over-written; if not. If it existed, the metadata gets over-written; if it did not
it did not exist, the metadata is created. exist, the metadata is created.
For LFBs that insert packets into the model, WRITE is the only For LFBs that insert packets into the model, WRITE is the only
meaningful metadata operation. meaningful metadata operation.
For LFBs that remove the packet from the model, they may either For LFBs that remove the packet from the model, they may either
READ-AND-CONSUME (read) or CONSUME (ignore) each active metadata READ-AND-CONSUME (read) or CONSUME (ignore) each active metadata
associated with the packet. associated with the packet.
3.2.4.4. Metadata Production and Consumption 3.2.4.4. Metadata Production and Consumption
For a given metadata on a given packet path, there must be at For a given metadata on a given packet path, there MUST be at least
least one producer LFB that creates that metadata and should be at one producer LFB that creates that metadata and SHOULD be at least
least one consumer LFB that needs that metadata. In this model, one consumer LFB that needs that metadata. In this model, the
the producer and consumer LFBs of a metadata are not required to producer and consumer LFBs of a metadata are not required to be
be adjacent. In addition, there may be multiple producers and adjacent. In addition, there may be multiple producers and
consumers for the same metadata. When a packet path involves consumers for the same metadata. When a packet path involves
multiple producers of the same metadata, then subsequent producers multiple producers of the same metadata, then subsequent producers
overwrite that metadata value. overwrite that metadata value.
The metadata that is produced by an LFB is specified by the LFB The metadata that is produced by an LFB is specified by the LFB
class definition on a per output port group basis. A producer may class definition on a per output port group basis. A producer may
always generate the metadata on the port group, or may generate it always generate the metadata on the port group, or may generate it
only under certain conditions. We call the former an only under certain conditions. We call the former an
"unconditional" metadata, whereas the latter is a "conditional" "unconditional" metadata, whereas the latter is a "conditional"
metadata. In the case of conditional metadata, it should be metadata. In the case of conditional metadata, it should be
possible to determine from the definition of the LFB when a possible to determine from the definition of the LFB when a
"conditional" metadata is produced. "conditional" metadata is produced.
The consumer behavior of an LFB, that is, the metadata that the LFB
The consumer behavior of an LFB, that is, the metadata that the needs for its operation, is defined in the LFB class definition on a
LFB needs for its operation, is defined in the LFB class per input port group basis. An input port group may "require" a
definition on a per input port group basis. An input port group given metadata, or may treat it as "optional" information. In the
may "require" a given metadata, or may treat it as "optional" latter case, the LFB class definition MUST explicitly define what
information. In the latter case, the LFB class definition must happens if an optional metadata is not provided. One approach is to
explicitly define what happens if an optional metadata is not specify a default value for each optional metadata, and assume that
provided. One approach is to specify a default value for each the default value is used if the metadata is not provided with the
optional metadata, and assume that the default value is used if packet.
the metadata is not provided with the packet.
When a consumer LFB requires a given metadata, it has dependencies When a consumer LFB requires a given metadata, it has dependencies
on its up-stream LFBs. That is, the consumer LFB can only on its up-stream LFBs. That is, the consumer LFB can only function
function if there is at least one producer of that metadata and no if there is at least one producer of that metadata and no
intermediate LFB consumes the metadata. intermediate LFB consumes the metadata.
The model should expose these inter-dependencies. Furthermore, it The model should expose these inter-dependencies. Furthermore, it
should be possible to take inter-dependencies into consideration should be possible to take inter-dependencies into consideration
when constructing LFB topologies, and also that the dependencies when constructing LFB topologies, and also that the dependencies can
can be verified when validating topologies. be verified when validating topologies.
For extensibility reasons, the LFB specification should define For extensibility reasons, the LFB specification SHOULD define what
what metadata the LFB requires without specifying which LFB(s) it metadata the LFB requires without specifying which LFB(s) it expects
expects a certain metadata to come from. Similarly, LFBs should a certain metadata to come from. Similarly, LFBs SHOULD specify
specify what metadata they produce without specifying which LFBs what metadata they produce without specifying which LFBs the
the metadata is meant for. metadata is meant for.
When specifying the metadata tags, some harmonization effort must When specifying the metadata tags, some harmonization effort must be
be made so that the producer LFB class uses the same tag as its made so that the producer LFB class uses the same tag as its
intended consumer(s), or vice versa. intended consumer(s), or vice versa.
3.2.4.5. Fixed, Variable and Configurable Tag 3.2.4.5. Fixed, Variable and Configurable Tag
When the produced metadata is defined for a given LFB class, most When the produced metadata is defined for a given LFB class, most
metadata will be specified with a fixed tag. For example, a Rate metadata will be specified with a fixed tag. For example, a Rate
Meter LFB will always produce the "Color" metadata. Meter LFB will always produce the "Color" metadata.
A small subset of LFBs need the capability to produce one or more A small subset of LFBs need the capability to produce one or more of
of their metadata with tags that are not fixed in the LFB class their metadata with tags that are not fixed in the LFB class
definition, but instead can be selected per LFB instance. An definition, but instead can be selected per LFB instance. An
example of such an LFB class is a Generic Classifier LFB. We call example of such an LFB class is a Generic Classifier LFB. We call
this capability "variable tag metadata production". If an LFB this capability "variable tag metadata production". If an LFB
produces metadata with a variable tag, the corresponding LFB produces metadata with a variable tag, the corresponding LFB
attribute, called the tag selector, specifies the tag for each attribute, called the tag selector, specifies the tag for each such
such metadata. This mechanism improves the versatility of certain metadata. This mechanism improves the versatility of certain multi-
multi-purpose LFB classes, since it allows the same LFB class to purpose LFB classes, since it allows the same LFB class to be used
be used in different topologies, producing the right metadata tags in different topologies, producing the right metadata tags according
according to the needs of the topology. to the needs of the topology. This selection of tags is variable in
that the produced output may have any number of different tags. The
meaning of the various tags is still defined by the metadata
declaration associated with the LFB class definition. This also
allows the CE to correctly set the tag values in the table to match
the declared meanings of the metadata tag values.
Depending on the capability of the FE, the tag selector can be Depending on the capability of the FE, the tag selector can be
either a read-only or a read-write attribute. If the selector is either a read-only or a read-write attribute. If the selector is
read-only, the tag cannot be modified by the CE. If the selector read-only, the tag cannot be modified by the CE. If the selector is
is read-write, the tag can be configured by the CE, hence we call read-write, the tag can be configured by the CE, hence we call this
this "configurable tag metadata production." Note that using this "configurable tag metadata production." Note that using this
definition, configurable tag metadata production is a subset of definition, configurable tag metadata production is a subset of
variable tag metadata production. variable tag metadata production.
Similar concepts can be introduced for the consumer LFBs to Similar concepts can be introduced for the consumer LFBs to satisfy
satisfy different metadata needs. Most LFB classes will specify different metadata needs. Most LFB classes will specify their
their metadata needs using fixed metadata tags. For example, a metadata needs using fixed metadata tags. For example, a Next Hop
Next Hop LFB may always require a "NextHopId" metadata; but the LFB may always require a "NextHopId" metadata; but the Redirector
Redirector LFB may need a "ClassID" metadata in one instance, and LFB may need a "ClassID" metadata in one instance, and a
a "ProtocolType" metadata in another instance as a basis for "ProtocolType" metadata in another instance as a basis for selecting
selecting the right output port. In this case, an LFB attribute the right output port. In this case, an LFB attribute is used to
is used to provide the required metadata tag at run-time. This provide the required metadata tag at run-time. This metadata tag
metadata tag selector attribute may be read-only or read-write, selector attribute may be read-only or read-write, depending on the
depending on the capabilities of the LFB instance and the FE. capabilities of the LFB instance and the FE.
3.2.4.6. Metadata Usage Categories 3.2.4.6. Metadata Usage Categories
Depending on the role and usage of a metadata, various amounts of Depending on the role and usage of a metadata, various amounts of
encoding information must be provided when the metadata is encoding information MUST be provided when the metadata is defined,
defined, where some cases offer less flexibility in the value where some cases offer less flexibility in the value selection than
selection than others. others.
There are three types of metadata related to metadata usage: There are three types of metadata related to metadata usage:
. Relational (or binding) metadata . Relational (or binding) metadata
. Enumerated metadata . Enumerated metadata
. Explicit/external value metadata . Explicit/external value metadata
The purpose of the relational metadata is to refer in one LFB The purpose of the relational metadata is to refer in one LFB
instance (producer LFB) to a "thing" in another downstream LFB instance (producer LFB) to a "thing" in another downstream LFB
instance (consumer LFB), where the "thing" is typically an entry instance (consumer LFB), where the "thing" is typically an entry in
in a table attribute of the consumer LFB. a table attribute of the consumer LFB.
For example, the Prefix Lookup LFB executes an LPM search using For example, the Prefix Lookup LFB executes an LPM search using its
its prefix table and resolves to a next-hop reference. This prefix table and resolves to a next-hop reference. This reference
reference needs to be passed as metadata by the Prefix Lookup LFB needs to be passed as metadata by the Prefix Lookup LFB (producer)
(producer) to the Next Hop LFB (consumer), and must refer to a to the Next Hop LFB (consumer), and must refer to a specific entry
specific entry in the next-hop table within the consumer. in the next-hop table within the consumer.
Expressing and propagating such a binding relationship is probably Expressing and propagating such a binding relationship is probably
the most common usage of metadata. One or more objects in the the most common usage of metadata. One or more objects in the
producer LFB are bound to a specific object in the consumer LFB. producer LFB are bound to a specific object in the consumer LFB.
Such a relationship is established by the CE explicitly by Such a relationship is established by the CE explicitly by properly
properly configuring the attributes in both LFBs. Available configuring the attributes in both LFBs. Available methods include
methods include the following: the following:
The binding may be expressed by tagging the involved objects in The binding may be expressed by tagging the involved objects in both
both LFBs with the same unique, but otherwise arbitrary, LFBs with the same unique, but otherwise arbitrary, identifier. The
identifier. The value of the tag is explicitly configured by the value of the tag is explicitly configured by the CE by writing the
CE by writing the value into both LFBs, and this value is also value into both LFBs, and this value is also carried by the metadata
carried by the metadata between the LFBs. between the LFBs.
Another way of setting up binding relations is to use a naturally Another way of setting up binding relations is to use a naturally
occurring unique identifier of the consumer's object as a occurring unique identifier of the consumer's object as a reference
reference and as a value of the metadata (e.g., the array index of and as a value of the metadata (e.g., the array index of a table
a table entry). In this case, the index is either read or entry). In this case, the index is either read or inferred by the
inferred by the CE by communicating with the consumer LFB. Once CE by communicating with the consumer LFB. Once the CE obtains the
the CE obtains the index, it needs to write it into the producer index, it needs to write it into the producer LFB to establish the
LFB to establish the binding. binding.
Important characteristics of the binding usage of metadata are: Important characteristics of the binding usage of metadata are:
. The value of the metadata shows up in the CE-FE communication . The value of the metadata shows up in the CE-FE communication
for BOTH the consumer and the producer. That is, the for both the consumer and the producer. That is, the metadata
metadata value must be carried over the ForCES protocol. value MUST be carried over the ForCES protocol. Using the
Using the tagging technique, the value is WRITTEN to both tagging technique, the value is written to both LFBs. Using
LFBs. Using the other technique, the value is WRITTEN to the other technique, the value is written to only the producer
only the producer LFB and may be READ from the consumer LFB. LFB and may be READ from the consumer LFB.
. The metadata value is irrelevant to the CE, the binding is . The metadata value is irrelevant to the CE, the binding is
simply expressed by using the SAME value at the consumer and simply expressed by using the same value at the consumer and
producer LFBs. producer LFBs.
. Hence the metadata definition is not required to include . Hence the metadata definition is not required to include value
value assignments. The only exception is when some special assignments. The only exception is when some special value(s)
value(s) of the metadata must be reserved to convey special of the metadata must be reserved to convey special events.
events. Even though these special cases must be defined with Even though these special cases must be defined with the
the metadata specification, their encoded values can be metadata specification, their encoded values can be selected
selected arbitrarily. For example, for the Prefix Lookup LFB arbitrarily. For example, for the Prefix Lookup LFB example, a
example, a special value may be reserved to signal the NO- special value may be reserved to signal the NO-MATCH case, and
MATCH case, and the value of zero may be assigned for this the value of zero may be assigned for this purpose.
purpose.
The second class of metadata is the enumerated type. An example The second class of metadata is the enumerated type. An example is
is the "Color" metadata that is produced by a Meter LFB. As the the "Color" metadata that is produced by a Meter LFB. As the name
name suggests, enumerated metadata has a relatively small number suggests, enumerated metadata has a relatively small number of
of possible values, each with a specific meaning. All possible possible values, each with a specific meaning. All possible cases
cases must be enumerated when defining this class of metadata. must be enumerated when defining this class of metadata. Although a
Although a value encoding must be included in the specification, value encoding must be included in the specification, the actual
the actual values can be selected arbitrarily (e.g., <Red=0, values can be selected arbitrarily (e.g., <Red=0, Yellow=1, Green=2>
Yellow=1, Green=2> and <Red=3, Yellow=2, Green 1> would be both and <Red=3, Yellow=2, Green 1> would be both valid encodings, what
valid encodings, what is important is that an encoding is is important is that an encoding is specified).
specified).
The value of the enumerated metadata may or may not be conveyed The value of the enumerated metadata may or may not be conveyed via
via the ForCES protocol between the CE and FE. the ForCES protocol between the CE and FE.
The third class of metadata is the explicit type. This refers to The third class of metadata is the explicit type. This refers to
cases where the metadata value is explicitly used by the consumer cases where the metadata value is explicitly used by the consumer
LFB to change some packet header fields. In other words, the LFB to change some packet header fields. In other words, the value
value has a direct and explicit impact on some field and will be has a direct and explicit impact on some field and will be visible
visible externally when the packet leaves the NE. Examples are: externally when the packet leaves the NE. Examples are: TTL
TTL increment given to a Header Modifier LFB, and DSCP value for a increment given to a Header Modifier LFB, and DSCP value for a
Remarker LFB. For explicit metadata, the value encoding must be Remarker LFB. For explicit metadata, the value encoding MUST be
explicitly provided in the metadata definition. The values cannot explicitly provided in the metadata definition. The values cannot
be selected arbitrarily and should conform to what is commonly be selected arbitrarily and should conform to what is commonly
expected. For example, a TTL increment metadata should be encoded expected. For example, a TTL increment metadata should be encoded
as zero for the no increment case, one for the single increment as zero for the no increment case, one for the single increment
case, etc. A DSCP metadata should use 0 to encode DSCP=0, 1 to case, etc. A DSCP metadata should use 0 to encode DSCP=0, 1 to
encode DSCP=1, etc. encode DSCP=1, etc.
3.2.5. LFB Events 3.2.5. LFB Events
During operation, various conditions may occur that can be During operation, various conditions may occur that can be detected
detected by LFBs. Examples range from link failure or restart, to by LFBs. Examples range from link failure or restart to timer
timer expiration in special purpose LFBs. The CE may wish to be expiration in special purpose LFBs. The CE may wish to be notified
notified of the occurrence of such events. The PL protocol of the occurrence of such events. The PL protocol provides for such
provides for such notifications. The LFB definition includes the notifications. The LFB definition includes the necessary
necessary declarations of events. The declarations include declarations of events. The declarations include identifiers
identifiers necessary for subscribing to events (so that the CE necessary for subscribing to events (so that the CE can indicate to
can indicate to the FE which events it wishes to receive) and to the FE which events it wishes to receive) and to indicate in event
indicate in event notification messages which event is being notification messages which event is being reported.
reported.
The declaration of an event defines a condition that an FE can
detect, and may report. From a conceptual point of view, event
processing is split into triggering (the detection of the condition)
and reporting (the generation of the notification of the event.) In
between these two conceptual points there is event filtering.
Properties associated with the event in the LFB instance can define
filtering conditions to suppress the reporting of that event. The
model thus describes event processing as if events always occur, and
filtering may suppress reporting. Implementations may function in
this manner, or may have more complex logic that eliminates some
event processing if the reporting would be suppressed. Any
implementation producing an effect equivalent to the model
description is valid.
3.2.6. LFB Element Properties 3.2.6. LFB Element Properties
LFBs are made up of elements, containing the information that the
CE needs to see and / or change about the functioning of the LFB. LFBs are made up of elements, containing the information that the CE
needs to see and / or change about the functioning of the LFB.
These elements, as described in detail elsewhere, may be basic These elements, as described in detail elsewhere, may be basic
values, complex structures, or tables (containing values, values, complex structures, or tables (containing values,
structures, or tables.) Some of these elements are optional. structures, or tables.) Some of these elements are optional. Some
Some elements may be readable or writeable at the discretion of elements may be readable or writeable at the discretion of the FE
the FE implementation. The CE needs to know these properties. implementation. The CE needs to know these properties.
Additionally, certain kinds of elements (arrays, aliases, and Additionally, certain kinds of elements (arrays, aliases, and events
events as of this writing) have additional property information as of this writing) have additional property information that the CE
that the CE may need to read or write. This model defines the may need to read or write. This model defines the structure of the
structure of the property information for all defined data types. property information for all defined data types.
The reports with events are designed to allow for the common, The reports with events are designed to allow for the common,
closely related information that the CE can be strongly expected closely related information that the CE can be strongly expected to
to need to react to the event. These reports are not intended to need to react to the event. It is not intended to carry information
carry information the CE already has, large volumes of the CE already has, nor large volumes of information, nor
information, nor information related in complex fashions. information related in complex fashions.
3.2.7. LFB Versioning 3.2.7. LFB Versioning
LFB class versioning is a method to enable incremental evolution LFB class versioning is a method to enable incremental evolution of
of LFB classes. In general, an FE is not allowed to contain an LFB LFB classes. In general, an FE is not allowed to contain an LFB
instance for more than one version of a particular class. instance for more than one version of a particular class.
Inheritance (discussed next in Section 3.2.6) has special rules. Inheritance (discussed next in Section 3.2.6) has special rules. If
If an FE datapath model containing an LFB instance of a particular an FE datapath model containing an LFB instance of a particular
class C also simultaneously contains an LFB instance of a class C' class C also simultaneously contains an LFB instance of a class C'
inherited from class C; C could have a different version than C'. inherited from class C; C could have a different version than C'.
LFB class versioning is supported by requiring a version string in LFB class versioning is supported by requiring a version string in
the class definition. CEs may support multiple versions of a the class definition. CEs may support multiple versions of a
particular LFB class to provide backward compatibility, but FEs particular LFB class to provide backward compatibility, but FEs MUST
are not allowed to support more than one version of a particular NOT support more than one version of a particular class.
class.
3.2.8. LFB Inheritance 3.2.8. LFB Inheritance
LFB class inheritance is supported in the FE model as a method to LFB class inheritance is supported in the FE model as a method to
define new LFB classes. This also allows FE vendors to add define new LFB classes. This also allows FE vendors to add vendor-
vendor-specific extensions to standardized LFBs. An LFB class specific extensions to standardized LFBs. An LFB class
specification MUST specify the base class and version number it specification MUST specify the base class and version number it
inherits from (the default is the base LFB class). Multiple- inherits from (the default is the base LFB class). Multiple-
inheritance is not allowed, however, to avoid unnecessary inheritance is not allowed, however, to avoid unnecessary
complexity. complexity.
Inheritance should be used only when there is significant reuse of Inheritance should be used only when there is significant reuse of
the base LFB class definition. A separate LFB class should be the base LFB class definition. A separate LFB class should be
defined if little or no reuse is possible between the derived and defined if little or no reuse is possible between the derived and
the base LFB class. the base LFB class.
An interesting issue related to class inheritance is backward An interesting issue related to class inheritance is backward
compatibility between a descendant and an ancestor class. compatibility between a descendant and an ancestor class. Consider
Consider the following hypothetical scenario where a standardized the following hypothetical scenario where a standardized LFB class
LFB class "L1" exists. Vendor A builds an FE that implements LFB "L1" exists. Vendor A builds an FE that implements LFB "L1" and
"L1" and vendor B builds a CE that can recognize and operate on vendor B builds a CE that can recognize and operate on LFB "L1".
LFB "L1". Suppose that a new LFB class, "L2", is defined based on Suppose that a new LFB class, "L2", is defined based on the existing
the existing "L1" class by extending its capabilities "L1" class by extending its capabilities incrementally. Let us
incrementally. Let us examine the FE backward compatibility issue examine the FE backward compatibility issue by considering what
by considering what would happen if vendor B upgrades its FE from would happen if vendor B upgrades its FE from "L1" to "L2" and
"L1" to "L2" and vendor C's CE is not changed. The old L1-based vendor C's CE is not changed. The old L1-based CE can interoperate
CE can interoperate with the new L2-based FE if the derived LFB with the new L2-based FE if the derived LFB class "L2" is indeed
class "L2" is indeed backward compatible with the base class "L1". backward compatible with the base class "L1".
The reverse scenario is a much less problematic case, i.e., when The reverse scenario is a much less problematic case, i.e., when CE
CE vendor B upgrades to the new LFB class "L2", but the FE is not vendor B upgrades to the new LFB class "L2", but the FE is not
upgraded. Note that as long as the CE is capable of working with upgraded. Note that as long as the CE is capable of working with
older LFB classes, this problem does not affect the model; hence older LFB classes, this problem does not affect the model; hence we
we will use the term "backward compatibility" to refer to the will use the term "backward compatibility" to refer to the first
first scenario concerning FE backward compatibility. scenario concerning FE backward compatibility.
Backward compatibility can be designed into the inheritance model Backward compatibility can be designed into the inheritance model by
by constraining LFB inheritance to require the derived class be a constraining LFB inheritance to require the derived class be a
functional superset of the base class (i.e. the derived class can functional superset of the base class (i.e. the derived class can
only add functions to the base class, but not remove functions). only add functions to the base class, but not remove functions).
Additionally, the following mechanisms are required to support FE Additionally, the following mechanisms are required to support FE
backward compatibility: backward compatibility:
1. When detecting an LFB instance of an LFB type that is
unknown to the CE, the CE MUST be able to query the base 1. When detecting an LFB instance of an LFB type that is unknown
class of such an LFB from the FE. to the CE, the CE MUST be able to query the base class of such
an LFB from the FE.
2. The LFB instance on the FE SHOULD support a backward 2. The LFB instance on the FE SHOULD support a backward
compatibility mode (meaning the LFB instance reverts itself compatibility mode (meaning the LFB instance reverts itself
back to the base class instance), and the CE SHOULD be able back to the base class instance), and the CE SHOULD be able to
to configure the LFB to run in such a mode. configure the LFB to run in such a mode.
3.3. FE Datapath Modeling 3.3. FE Datapath Modeling
Packets coming into the FE from ingress ports generally flow Packets coming into the FE from ingress ports generally flow through
through multiple LFBs before leaving out of the egress ports. How multiple LFBs before leaving out of the egress ports. How an FE
an FE treats a packet depends on many factors, such as type of the treats a packet depends on many factors, such as type of the packet
packet (e.g., IPv4, IPv6 or MPLS), actual header values, time of (e.g., IPv4, IPv6 or MPLS), actual header values, time of arrival,
arrival, etc. The result of LFB processing may have an impact on etc. The result of LFB processing may have an impact on how the
how the packet is to be treated in downstream LFBs. This packet is to be treated in downstream LFBs. This differentiation of
differentiation of packet treatment downstream can be packet treatment downstream can be conceptualized as having
conceptualized as having alternative datapaths in the FE. For alternative datapaths in the FE. For example, the result of a 6-
example, the result of a 6-tuple classification performed by a tuple classification performed by a classifier LFB could control
classifier LFB could control which rate meter is applied to the which rate meter is applied to the packet by a rate meter LFB in a
packet by a rate meter LFB in a later stage in the datapath. later stage in the datapath.
LFB topology is a directed graph representation of the logical LFB topology is a directed graph representation of the logical
datapaths within an FE, with the nodes representing the LFB datapaths within an FE, with the nodes representing the LFB
instances and the directed link depicting the packet flow instances and the directed link depicting the packet flow direction
direction from one LFB to the next. Section 3.3.1 discusses how from one LFB to the next. Section 3.3.1 discusses how the FE
the FE datapaths can be modeled as LFB topology; while Section datapaths can be modeled as LFB topology; while Section 3.3.2
3.3.2 focuses on issues related to LFB topology reconfiguration. focuses on issues related to LFB topology reconfiguration.
3.3.1. Alternative Approaches for Modeling FE Datapaths 3.3.1. Alternative Approaches for Modeling FE Datapaths
There are two basic ways to express the differentiation in packet There are two basic ways to express the differentiation in packet
treatment within an FE, one represents the datapath directly and treatment within an FE, one represents the datapath directly and
graphically (topological approach) and the other utilizes metadata graphically (topological approach) and the other utilizes metadata
(the encoded state approach). (the encoded state approach).
. Topological Approach . Topological Approach
Using this approach, differential packet treatment is expressed Using this approach, differential packet treatment is expressed by
by splitting the LFB topology into alternative paths. In other splitting the LFB topology into alternative paths. In other
words, if the result of an LFB must control how the packet is words, if the result of an LFB operation controls how the packet
further processed, then such an LFB will have separate output is further processed, then such an LFB will have separate output
ports, one for each alternative treatment, connected to ports, one for each alternative treatment, connected to separate
separate sub-graphs, each expressing the respective treatment sub-graphs, each expressing the respective treatment downstream.
downstream.
. Encoded State Approach . Encoded State Approach
An alternate way of expressing differential treatment is by An alternate way of expressing differential treatment is by using
using metadata. The result of the operation of an LFB can be metadata. The result of the operation of an LFB can be encoded in
encoded in a metadata, which is passed along with the packet to a metadata, which is passed along with the packet to downstream
downstream LFBs. A downstream LFB, in turn, can use the LFBs. A downstream LFB, in turn, can use the metadata and its
metadata and its value (e.g., as an index into some table) to value (e.g., as an index into some table) to determine how to
determine how to treat the packet. treat the packet.
Theoretically, either approach could substitute for the other, so Theoretically, either approach could substitute for the other, so
one could consider using a single pure approach to describe all one could consider using a single pure approach to describe all
datapaths in an FE. However, neither model by itself results in datapaths in an FE. However, neither model by itself results in the
the best representation for all practically relevant cases. For a best representation for all practically relevant cases. For a given
given FE with certain logical datapaths, applying the two FE with certain logical datapaths, applying the two different
different modeling approaches will result in very different modeling approaches will result in very different looking LFB
looking LFB topology graphs. A model using only the topological topology graphs. A model using only the topological approach may
approach may require a very large graph with many links or paths, require a very large graph with many links or paths, and nodes
and nodes (i.e., LFB instances) to express all alternative (i.e., LFB instances) to express all alternative datapaths. On the
datapaths. On the other hand, a model using only the encoded other hand, a model using only the encoded state model would be
state model would be restricted to a string of LFBs, which is not restricted to a string of LFBs, which is not an intuitive way to
an intuitive way to describe different datapaths (such as MPLS and describe different datapaths (such as MPLS and IPv4). Therefore, a
IPv4). Therefore, a mix of these two approaches will likely be mix of these two approaches will likely be used for a practical
used for a practical model. In fact, as we illustrate below, the model. In fact, as we illustrate below, the two approaches can be
two approaches can be mixed even within the same LFB. mixed even within the same LFB.
Using a simple example of a classifier with N classification Using a simple example of a classifier with N classification outputs
outputs followed by other LFBs, Figure 5(a) shows what the LFB followed by other LFBs, Figure 5(a) shows what the LFB topology
topology looks like when using the pure topological approach. looks like when using the pure topological approach. Each output
Each output from the classifier goes to one of the N LFBs where no from the classifier goes to one of the N LFBs where no metadata is
metadata is needed. The topological approach is simple, needed. The topological approach is simple, straightforward and
straightforward and graphically intuitive. However, if N is large graphically intuitive. However, if N is large and the N nodes
and the N nodes following the classifier (LFB#1, LFB#2, ..., following the classifier (LFB#1, LFB#2, ..., LFB#N) all belong to
LFB#N) all belong to the same LFB type (e.g., meter), but each has the same LFB type (e.g., meter), but each has its own independent
its own independent attributes, the encoded state approach gives a attributes, the encoded state approach gives a much simpler topology
much simpler topology representation, as shown in Figure 5(b). representation, as shown in Figure 5(b). The encoded state approach
The encoded state approach requires that a table of N rows of requires that a table of N rows of meter attributes is provided in
meter attributes is provided in the Meter node itself, with each the Meter node itself, with each row representing the attributes for
row representing the attributes for one meter instance. A one meter instance. A metadata M is also needed to pass along with
metadata M is also needed to pass along with the packet P from the the packet P from the classifier to the meter, so that the meter can
classifier to the meter, so that the meter can use M as a look-up use M as a look-up key (index) to find the corresponding row of the
key (index) to find the corresponding row of the attributes that attributes that should be used for any particular packet P.
should be used for any particular packet P.
What if those N nodes (LFB#1, LFB#2, ..., LFB#N) are not of the What if those N nodes (LFB#1, LFB#2, ..., LFB#N) are not of the same
same type? For example, if LFB#1 is a queue while the rest are all type? For example, if LFB#1 is a queue while the rest are all
meters, what is the best way to represent such datapaths? While meters, what is the best way to represent such datapaths? While it
it is still possible to use either the pure topological approach is still possible to use either the pure topological approach or the
or the pure encoded state approach, the natural combination of the pure encoded state approach, the natural combination of the two
two appears to be the best option. Figure 5(c) depicts two appears to be the best option. Figure 5(c) depicts two different
different functional datapaths using the topological approach functional datapaths using the topological approach while leaving
while leaving the N-1 meter instances distinguished by metadata the N-1 meter instances distinguished by metadata only, as shown in
only, as shown in Figure 5(c). Figure 5(c).
+----------+ +----------+
P | LFB#1 | P | LFB#1 |
+--------->|(Attrib-1)| +--------->|(Attrib-1)|
+-------------+ | +----------+ +-------------+ | +----------+
| 1|------+ P +----------+ | 1|------+ P +----------+
| 2|---------------->| LFB#2 | | 2|---------------->| LFB#2 |
| classifier 3| |(Attrib-2)| | classifier 3| |(Attrib-2)|
| ...|... +----------+ | ...|... +----------+
| N|------+ ... | N|------+ ...
+-------------+ | P +----------+ +-------------+ | P +----------+
skipping to change at page 33, line 16 skipping to change at page 31, line 27
+-------------+ (P, M) | queue | +-------------+ (P, M) | queue |
| 1|------------->| (Attrib-1) | | 1|------------->| (Attrib-1) |
| 2| +-------------+ | 2| +-------------+
| 3| (P, M) +-------------+ | 3| (P, M) +-------------+
| ...|------------->| Meter | | ...|------------->| Meter |
| N| | (Attrib-2) | | N| | (Attrib-2) |
+-------------+ | ... | +-------------+ | ... |
| (Attrib-N) | | (Attrib-N) |
+-------------+ +-------------+
5(c) Using a combination of the two, if LFB#1, LFB#2, ..., 5(c) Using a combination of the two, if LFB#1, LFB#2, ..., and
and LFB#N are of different types (e.g., queue and meter). LFB#N are of different types (e.g., queue and meter).
Figure 5. An example of how to model FE datapaths Figure 5. An example of how to model FE datapaths
From this example, we demonstrate that each approach has a From this example, we demonstrate that each approach has a distinct
distinct advantage depending on the situation. Using the encoded advantage depending on the situation. Using the encoded state
state approach, fewer connections are typically needed between a approach, fewer connections are typically needed between a fan-out
fan-out node and its next LFB instances of the same type because node and its next LFB instances of the same type because each packet
each packet carries metadata the following nodes can interpret and carries metadata the following nodes can interpret and hence invoke
hence invoke a different packet treatment. For those cases, a a different packet treatment. For those cases, a pure topological
pure topological approach forces one to build elaborate graphs approach forces one to build elaborate graphs with many more
with many more connections and often results in an unwieldy graph. connections and often results in an unwieldy graph. On the other
On the other hand, a topological approach is the most intuitive hand, a topological approach is the most intuitive for representing
for representing functionally different datapaths. functionally different datapaths.
For complex topologies, a combination of the two is the most For complex topologies, a combination of the two is the most
flexible. A general design guideline is provided to indicate flexible. A general design guideline is provided to indicate which
which approach is best used for a particular situation. The approach is best used for a particular situation. The topological
topological approach should primarily be used when the packet approach should primarily be used when the packet datapath forks to
datapath forks to distinct LFB classes (not just distinct distinct LFB classes (not just distinct parameterizations of the
parameterizations of the same LFB class), and when the fan-outs do same LFB class), and when the fan-outs do not require changes, such
not require changes, such as adding/removing LFB outputs, or as adding/removing LFB outputs, or require only very infrequent
require only very infrequent changes. Configuration information changes. Configuration information that needs to change frequently
that needs to change frequently should be expressed by using the should be expressed by using the internal attributes of one or more
internal attributes of one or more LFBs (and hence using the LFBs (and hence using the encoded state approach).
encoded state approach).
+---------------------------------------------+ +---------------------------------------------+
| | | |
+----------+ V +----------+ +------+ | +----------+ V +----------+ +------+ |
| | | | |if IP-in-IP| | | | | | | |if IP-in-IP| | |
---->| ingress |->+----->|classifier|---------->|Decap.|---->---+ ---->| ingress |->+----->|classifier|---------->|Decap.|---->---+
| ports | | |----+ | | | ports | | |----+ | |
+----------+ +----------+ |others+------+ +----------+ +----------+ |others+------+
| |
V V
(a) The LFB topology with a logical loop (a) The LFB topology with a logical loop
+-------+ +-----------+ +------+ +-----------+ +-------+ +-----------+ +------+ +-----------+
| | | |if IP-in-IP | | | | | | | |if IP-in-IP | | | |
--->|ingress|-->|classifier1|----------->|Decap.|-->+classifier2|- --->|ingress|-->|classifier1|----------->|Decap.|-->+classifier2|->
>
| ports | | |----+ | | | | | ports | | |----+ | | | |
+-------+ +-----------+ |others +------+ +-----------+ +-------+ +-----------+ |others +------+ +-----------+
| |
V V
(b) The LFB topology without the loop utilizing two The LFB topology without the loop utilizing two independent
independent classifier instances. classifier instances.
Figure 6. An LFB topology example. Figure 6. An LFB topology example.
It is important to point out that the LFB topology described here It is important to point out that the LFB topology described here is
is the logical topology, not the physical topology of how the FE the logical topology, not the physical topology of how the FE
hardware is actually laid out. Nevertheless, the actual hardware is actually laid out. Nevertheless, the actual
implementation may still influence how the functionality is mapped implementation may still influence how the functionality is mapped
to the LFB topology. Figure 6 shows one simple FE example. In to the LFB topology. Figure 6 shows one simple FE example. In this
this example, an IP-in-IP packet from an IPSec application like example, an IP-in-IP packet from an IPSec application like VPN may
VPN may go to the classifier first and have the classification go to the classifier first and have the classification done based on
done based on the outer IP header; upon being classified as an IP- the outer IP header; upon being classified as an IP-in-IP packet,
in-IP packet, the packet is then sent to a decapsulator to strip the packet is then sent to a decapsulator to strip off the outer IP
off the outer IP header, followed by a classifier again to perform header, followed by a classifier again to perform classification on
classification on the inner IP header. If the same classifier the inner IP header. If the same classifier hardware or software is
hardware or software is used for both outer and inner IP header used for both outer and inner IP header classification with the same
classification with the same set of filtering rules, a logical set of filtering rules, a logical loop is naturally present in the
loop is naturally present in the LFB topology, as shown in Figure LFB topology, as shown in Figure 6(a). However, if the
6(a). However, if the classification is implemented by two classification is implemented by two different pieces of hardware or
different pieces of hardware or software with different filters software with different filters (i.e., one set of filters for the
(i.e., one set of filters for the outer IP header and another set outer IP header and another set for the inner IP header), then it is
for the inner IP header), then it is more natural to model them as more natural to model them as two different instances of classifier
two different instances of classifier LFB, as shown in Figure LFB, as shown in Figure 6(b).
6(b).
To distinguish between multiple instances of the same LFB class, To distinguish between multiple instances of the same LFB class,
each LFB instance has its own LFB instance ID. One way to encode each LFB instance has its own LFB instance ID. One way to encode
the LFB instance ID is to encode it as x.y where x is the LFB the LFB instance ID is to encode it as x.y where x is the LFB class
class ID and y is the instance ID within each LFB class. ID and y is the instance ID within each LFB class.
3.3.2. Configuring the LFB Topology 3.3.2. Configuring the LFB Topology
While there is little doubt that an individual LFB must be While there is little doubt that an individual LFB must be
configurable, the configurability question is more complicated for configurable, the configurability question is more complicated for
LFB topology. Since the LFB topology is really the graphic LFB topology. Since the LFB topology is really the graphic
representation of the datapaths within an FE, configuring the LFB representation of the datapaths within an FE, configuring the LFB
topology means dynamically changing the datapaths, including topology means dynamically changing the datapaths, including
changing the LFBs along the datapaths on an FE (e.g., creating, changing the LFBs along the datapaths on an FE (e.g., creating,
instantiating or deleting LFBs) and setting up or deleting instantiating or deleting LFBs) and setting up or deleting
interconnections between outputs of upstream LFBs to inputs of interconnections between outputs of upstream LFBs to inputs of
downstream LFBs. downstream LFBs.
Why would the datapaths on an FE ever change dynamically? The Why would the datapaths on an FE ever change dynamically? The
datapaths on an FE are set up by the CE to provide certain data datapaths on an FE are set up by the CE to provide certain data
plane services (e.g., DiffServ, VPN, etc.) to the Network plane services (e.g., DiffServ, VPN, etc.) to the Network Element's
Element's (NE) customers. The purpose of reconfiguring the (NE) customers. The purpose of reconfiguring the datapaths is to
datapaths is to enable the CE to customize the services the NE is enable the CE to customize the services the NE is delivering at run
delivering at run time. The CE needs to change the datapaths when time. The CE needs to change the datapaths when the service
the service requirements change, such as adding a new customer or requirements change, such as adding a new customer or when an
when an existing customer changes their service. However, note existing customer changes their service. However, note that not all
that not all datapath changes result in changes in the LFB datapath changes result in changes in the LFB topology graph.
topology graph. Changes in the graph are dependent on the approach Changes in the graph are dependent on the approach used to map the
used to map the datapaths into LFB topology. As discussed in datapaths into LFB topology. As discussed in 3.3.1, the topological
3.3.1, the topological approach and encoded state approach can approach and encoded state approach can result in very different
result in very different looking LFB topologies for the same looking LFB topologies for the same datapaths. In general, an LFB
datapaths. In general, an LFB topology based on a pure topology based on a pure topological approach is likely to
topological approach is likely to experience more frequent experience more frequent topology reconfiguration than one based on
topology reconfiguration than one based on an encoded state an encoded state approach. However, even an LFB topology based
approach. However, even an LFB topology based entirely on an entirely on an encoded state approach may have to change the
encoded state approach may have to change the topology at times, topology at times, for example, to bypass some LFBs or insert new
for example, to bypass some LFBs or insert new LFBs. Since a mix LFBs. Since a mix of these two approaches is used to model the
of these two approaches is used to model the datapaths, LFB datapaths, LFB topology reconfiguration is considered an important
topology reconfiguration is considered an important aspect of the aspect of the FE model.
FE model.
We want to point out that allowing a configurable LFB topology in We want to point out that allowing a configurable LFB topology in
the FE model does not mandate that all FEs must have this the FE model does not mandate that all FEs are required to have this
capability. Even if an FE supports configurable LFB topology, the capability. Even if an FE supports configurable LFB topology, the
FE may impose limitations on what can actually be configured. FE may impose limitations on what can actually be configured.
Performance-optimized hardware implementations may have zero or Performance-optimized hardware implementations may have zero or very
very limited configurability, while FE implementations running on limited configurability, while FE implementations running on network
network processors may provide more flexibility and processors may provide more flexibility and configurability. It is
configurability. It is entirely up to the FE designers to decide entirely up to the FE designers to decide whether or not the FE
whether or not the FE actually implements reconfiguration and if actually implements reconfiguration and if so, how much. Whether a
so, how much. Whether a simple runtime switch is used to enable simple runtime switch is used to enable or disable (i.e., bypass)
or disable (i.e., bypass) certain LFBs, or more flexible software certain LFBs, or more flexible software reconfiguration is used, is
reconfiguration is used, is implementation detail internal to the implementation detail internal to the FE and outside of the scope of
FE and outside of the scope of FE model. In either case, the FE model. In either case, the CE(s) MUST be able to learn the FE's
CE(s) must be able to learn the FE's configuration capabilities. configuration capabilities. Therefore, the FE model MUST provide a
Therefore, the FE model must provide a mechanism for describing mechanism for describing the LFB topology configuration capabilities
the LFB topology configuration capabilities of an FE. These of an FE. These capabilities may include (see Section 5 for full
capabilities may include (see Section 5 for full details): details):
. Which LFB classes the FE can instantiate . Which LFB classes the FE can instantiate
. Maximum number of instances of the same LFB class that can be . Maximum number of instances of the same LFB class that can be
created created
. Any topological limitations, For example: . Any topological limitations, For example:
o The maximum number of instances of the same class or any o The maximum number of instances of the same class or any
class that can be created on any given branch of the class that can be created on any given branch of the graph
graph
o Ordering restrictions on LFBs (e.g., any instance of LFB o Ordering restrictions on LFBs (e.g., any instance of LFB
class A must be always downstream of any instance of LFB class A must be always downstream of any instance of LFB
class B). class B).
Note that even when the CE is allowed to configure LFB topology Note that even when the CE is allowed to configure LFB topology for
for the FE, the CE is not expected to be able to interpret an the FE, the CE is not expected to be able to interpret an arbitrary
arbitrary LFB topology and determine which specific service or LFB topology and determine which specific service or application
application (e.g. VPN, DiffServ, etc.) is supported by the FE. (e.g. VPN, DiffServ, etc.) is supported by the FE. However, once
However, once the CE understands the coarse capability of an FE, the CE understands the coarse capability of an FE, the CE MUST
it is the responsibility of the CE to configure the LFB topology configure the LFB topology to implement the network service the NE
to implement the network service the NE is supposed to provide. is supposed to provide. Thus, the mapping the CE has to understand
Thus, the mapping the CE has to understand is from the high level is from the high level NE service to a specific LFB topology, not
NE service to a specific LFB topology, not the other way around. the other way around. The CE is not expected to have the ultimate
The CE is not expected to have the ultimate intelligence to intelligence to translate any high level service policy into the
translate any high level service policy into the configuration configuration data for the FEs. However, it is conceivable that
data for the FEs. However, it is conceivable that within a given within a given network service domain, a certain amount of
network service domain, a certain amount of intelligence can be intelligence can be programmed into the CE to give the CE a general
programmed into the CE to give the CE a general understanding of understanding of the LFBs involved to allow the translation from a
the LFBs involved to allow the translation from a high level high level service policy to the low level FE configuration to be
service policy to the low level FE configuration to be done done automatically. Note that this is considered an implementation
automatically. Note that this is considered an implementation issue internal to the control plane and outside the scope of the FE
issue internal to the control plane and outside the scope of the model. Therefore, it is not discussed any further in this draft.
FE model. Therefore, it is not discussed any further in this
draft.
+----------+ +-----------+ +----------+ +-----------+
---->| Ingress |---->|classifier |--------------+ ---->| Ingress |---->|classifier |--------------+
| | |chip | | | | |chip | |
+----------+ +-----------+ | +----------+ +-----------+ |
v v
+-------------------------------------------+ +-------------------------------------------+
+--------+ | Network Processor | +--------+ | Network Processor |
<----| Egress | | +------+ +------+ +-------+ | <----| Egress | | +------+ +------+ +-------+ |
+--------+ | |Meter | |Marker| |Dropper| | +--------+ | |Meter | |Marker| |Dropper| |
skipping to change at page 38, line 43 skipping to change at page 36, line 43
Figure 7. An example of configuring LFB topology. Figure 7. An example of configuring LFB topology.
Figure 7 shows an example where a QoS-enabled router has several Figure 7 shows an example where a QoS-enabled router has several
line cards that have a few ingress ports and egress ports, a line cards that have a few ingress ports and egress ports, a
specialized classification chip, a network processor containing specialized classification chip, a network processor containing
codes for FE blocks like meter, marker, dropper, counter, queue, codes for FE blocks like meter, marker, dropper, counter, queue,
scheduler and Ipv4 forwarder. Some of the LFB topology is already scheduler and Ipv4 forwarder. Some of the LFB topology is already
fixed and has to remain static due to the physical layout of the fixed and has to remain static due to the physical layout of the
line cards. For example, all of the ingress ports might be hard- line cards. For example, all of the ingress ports might be hard-
wired into the classification chip so all packets must flow from wired into the classification chip so all packets flow from the
the ingress port into the classification engine. On the other ingress port into the classification engine. On the other hand, the
hand, the LFBs on the network processor and their execution order LFBs on the network processor and their execution order are
are programmable. However, certain capacity limits and linkage programmable. However, certain capacity limits and linkage
constraints could exist between these LFBs. Examples of the constraints could exist between these LFBs. Examples of the capacity
capacity limits might be: 8 meters; 16 queues in one FE; the limits might be: 8 meters; 16 queues in one FE; the scheduler can
scheduler can handle at most up to 16 queues; etc. The linkage handle at most up to 16 queues; etc. The linkage constraints might
constraints might dictate that the classification engine may be dictate that the classification engine may be followed by a meter,
followed by a meter, marker, dropper, counter, queue or IPv4 marker, dropper, counter, queue or IPv4 forwarder, but not a
forwarder, but not a scheduler; queues can only be followed by a scheduler; queues can only be followed by a scheduler; a scheduler
scheduler; a scheduler must be followed by the IPv4 forwarder; the must be followed by the IPv4 forwarder; the last LFB in the datapath
last LFB in the datapath before going into the egress ports must before going into the egress ports must be the IPv4 forwarder, etc.
be the IPv4 forwarder, etc.
Once the FE reports these capabilities and capacity limits to the Once the FE reports these capabilities and capacity limits to the
CE, it is now up to the CE to translate the QoS policy into a CE, it is now up to the CE to translate the QoS policy into a
desirable configuration for the FE. Figure 7(a) depicts the FE desirable configuration for the FE. Figure 7(a) depicts the FE
capability while 7(b) and 7(c) depict two different topologies capability while 7(b) and 7(c) depict two different topologies that
that the CE may request the FE to configure. Note that both the the CE may request the FE to configure. Note that both the ingress
ingress and egress are omitted in (b) and (c) to simplify the and egress are omitted in (b) and (c) to simplify the
representation. The topology in 7(c) is considerably more complex representation. The topology in 7(c) is considerably more complex
than 7(b) but both are feasible within the FE capabilities, and so than 7(b) but both are feasible within the FE capabilities, and so
the FE should accept either configuration request from the CE. the FE should accept either configuration request from the CE.
4. 4. Model and Schema for LFB Classes
Model and Schema for LFB Classes
The main goal of the FE model is to provide an abstract, generic, The main goal of the FE model is to provide an abstract, generic,
modular, implementation-independent representation of the FEs. modular, implementation-independent representation of the FEs. This
This is facilitated using the concept of LFBs, which are is facilitated using the concept of LFBs, which are instantiated
instantiated from LFB classes. LFB classes and associated from LFB classes. LFB classes and associated definitions will be
definitions will be provided in a collection of XML documents. The provided in a collection of XML documents. The collection of these
collection of these XML documents is called a LFB class library, XML documents is called a LFB class library, and each document is
and each document is called an LFB class library document (or called an LFB class library document (or library document, for
library document, for short). Each of the library documents will short). Each of the library documents will conform to the schema
conform to the schema presented in this section. The root element presented in this section. The root element of the library document
of the library document is the <LFBLibrary> element. is the <LFBLibrary> element.
It is not expected that library documents will be exchanged It is not expected that library documents will be exchanged between
between FEs and CEs "over-the-wire". But the model will serve as FEs and CEs "over-the-wire". But the model will serve as an
an important reference for the design and development of the CEs important reference for the design and development of the CEs
(software) and FEs (mostly the software part). It will also serve (software) and FEs (mostly the software part). It will also serve
as a design input when specifying the ForCES protocol elements for as a design input when specifying the ForCES protocol elements for
CE-FE communication. CE-FE communication.
4.1. Namespace 4.1. Namespace
The LFBLibrary element and all of its sub-elements are defined in The LFBLibrary element and all of its sub-elements are defined in
the following namespace: the following namespace:
http://ietf.org/forces/1.0/lfbmodel http://ietf.org/forces/1.0/lfbmodel
skipping to change at page 40, line 14 skipping to change at page 38, line 9
. <frameTypeDefs> for the frame declarations; . <frameTypeDefs> for the frame declarations;
. <dataTypeDefs> for defining common data types; . <dataTypeDefs> for defining common data types;
. <metadataDefs> for defining metadata, and . <metadataDefs> for defining metadata, and
. <LFBClassDefs> for defining LFB classes. . <LFBClassDefs> for defining LFB classes.
Each block is optional, that is, one library document may contain Each block is optional, that is, one library document may contain
only metadata definitions, another may contain only LFB class only metadata definitions, another may contain only LFB class
definitions, yet another may contain all of the above. definitions, yet another may contain all of the above.
In addition to the above main blocks, a library document can In addition to the above main blocks, a library document can import
import other library documents if it needs to refer to definitions other library documents if it needs to refer to definitions
contained in the included document. This concept is similar to contained in the included document. This concept is similar to the
the "#include" directive in C. Importing is expressed by the "#include" directive in C. Importing is expressed by the <load>
<load> elements, which must precede all the above elements in the elements, which must precede all the above elements in the document.
document. For unique referencing, each LFBLibrary instance For unique referencing, each LFBLibrary instance document has a
document has a unique label defined in the "provide" attribute of unique label defined in the "provide" attribute of the LFBLibrary
the LFBLibrary element. element.
The <LFBLibrary> element also includes an optional <description> The <LFBLibrary> element also includes an optional <description>
element, which can be used to provide textual description about element, which can be used to provide textual description about the
the library document. library document.
The following is a skeleton of a library document: The following is a skeleton of a library document:
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<LFBLibrary xmlns="http://ietf.org/forces/1.0/lfbmodel" <LFBLibrary xmlns="http://ietf.org/forces/1.0/lfbmodel"
provides="this_library"> provides="this_library">
<description> <description>
... ...
</description> </description>
skipping to change at page 41, line 10 skipping to change at page 39, line 4
</frameTypeDefs> </frameTypeDefs>
<!-- DATA TYPE DEFINITIONS (optional) --> <!-- DATA TYPE DEFINITIONS (optional) -->
<dataTypeDefs> <dataTypeDefs>
... ...
</dataTypeDefs> </dataTypeDefs>
<!-- METADATA DEFINITIONS (optional) --> <!-- METADATA DEFINITIONS (optional) -->
<metadataDefs> <metadataDefs>
... ...
</metadataDefs> </metadataDefs>
<!ùLFB CLASS DEFINITIONS (optional) --> <!LFB CLASS DEFINITIONS (optional) -->
<LFBCLassDefs> <LFBCLassDefs>
... ...
</LFBCLassDefs> </LFBCLassDefs>
</LFBLibrary> </LFBLibrary>
4.3. <load> Element 4.3. <load> Element
This element is used to refer to another LFB library document. This element is used to refer to another LFB library document.
Similar to the "#include" directive in C, this makes the objects Similar to the "#include" directive in C, this makes the objects
(metadata types, data types, etc.) defined in the referred library (metadata types, data types, etc.) defined in the referred library
document available for referencing in the current document. document available for referencing in the current document.
The load element must contain the label of the library document to The load element MUST contain the label of the library document to
be included and may contain a URL to specify where the library can be included and may contain a URL to specify where the library can
be retrieved. The load element can be repeated unlimited times. be retrieved. The load element can be repeated unlimited times.
Three examples for the <load> elements: Three examples for the <load> elements:
<load library="a_library"/> <load library="a_library"/>
<load library="another_library" location="another_lib.xml"/> <load library="another_library" location="another_lib.xml"/>
<load library="yetanother_library" <load library="yetanother_library"
location="http://www.petrimeat.com/forces/1.0/lfbmodel/lpm.xml"/> location="http://www.petrimeat.com/forces/1.0/lfbmodel/lpm.xml"/>
4.4. <frameDefs> Element for Frame Type Declarations 4.4. <frameDefs> Element for Frame Type Declarations
Frame names are used in the LFB definition to define the types of Frame names are used in the LFB definition to define the types of
frames the LFB expects at its input port(s) and emits at its frames the LFB expects at its input port(s) and emits at its output
output port(s). The <frameDefs> optional element in the library port(s). The <frameDefs> optional element in the library document
document contains one or more <frameDef> elements, each declaring contains one or more <frameDef> elements, each declaring one frame
one frame type. type.
Each frame definition contains a unique name (NMTOKEN) and a brief Each frame definition MUST contain a unique name (NMTOKEN) and a
synopsis. In addition, an optional detailed description may be brief synopsis. In addition, an optional detailed description may
provided. be provided.
Uniqueness of frame types must be ensured among frame types Uniqueness of frame types MUST be ensured among frame types defined
defined in the same library document and in all directly or in the same library document and in all directly or indirectly
indirectly included library documents. included library documents.
The following example defines two frame types: The following example defines two frame types:
<frameDefs> <frameDefs>
<frameDef> <frameDef>
<name>ipv4</name> <name>ipv4</name>
<synopsis>IPv4 packet</synopsis> <synopsis>IPv4 packet</synopsis>
<description> <description>
This frame type refers to an IPv4 packet. This frame type refers to an IPv4 packet.
</description> </description>
skipping to change at page 42, line 31 skipping to change at page 40, line 20
<synopsis>IPv6 packet</synopsis> <synopsis>IPv6 packet</synopsis>
<description> <description>
This frame type refers to an IPv6 packet. This frame type refers to an IPv6 packet.
</description> </description>
</frameDef> </frameDef>
... ...
</frameDefs> </frameDefs>
4.5. <dataTypeDefs> Element for Data Type Definitions 4.5. <dataTypeDefs> Element for Data Type Definitions
The (optional) <dataTypeDefs> element can be used to define The (optional) <dataTypeDefs> element can be used to define commonly
commonly used data types. It contains one or more <dataTypeDef> used data types. It contains one or more <dataTypeDef> elements,
elements, each defining a data type with a unique name. Such data each defining a data type with a unique name. Such data types can be
types can be used in several places in the library documents, used in several places in the library documents, including:
including:
. Defining other data types . Defining other data types
. Defining metadata
. Defining attributes of LFB classes . Defining attributes of LFB classes
This is similar to the concept of having a common header file for This is similar to the concept of having a common header file for
shared data types. shared data types.
Each <dataTypeDef> element contains a unique name (NMTOKEN), a Each <dataTypeDef> element MUST contain a unique name (NMTOKEN), a
brief synopsis, an optional longer description, and a type brief synopsis, an optional longer description, and a type
definition element. The name must be unique among all data types definition element. The name MUST be unique among all data types
defined in the same library document and in any directly or defined in the same library document and in any directly or
indirectly included library documents. For example: indirectly included library documents. For example:
<dataTypeDefs> <dataTypeDefs>
<dataTypeDef> <dataTypeDef>
<name>ieeemacaddr</name> <name>ieeemacaddr</name>
<synopsis>48-bit IEEE MAC address</synopsis> <synopsis>48-bit IEEE MAC address</synopsis>
... type definition ... ... type definition ...
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>ipv4addr</name> <name>ipv4addr</name>
<synopsis>IPv4 address</synopsis> <synopsis>IPv4 address</synopsis>
... type definition ... ... type definition ...
</dataTypeDef> </dataTypeDef>
... ...
</dataTypeDefs> </dataTypeDefs>
There are two kinds of data types: atomic and compound. Atomic data
There are two kinds of data types: atomic and compound. Atomic types are appropriate for single-value variables (e.g. integer,
data types are appropriate for single-value variables (e.g. ASCII string, byte array).
integer, ASCII string, byte array).
The following built-in atomic data types are provided, but The following built-in atomic data types are provided, but
additional atomic data types can be defined with the <typeRef> and additional atomic data types can be defined with the <typeRef> and
<atomic> elements: <atomic> elements:
<name> Meaning <name> Meaning
---- ------- ---- -------
char 8-bit signed integer char 8-bit signed integer
uchar 8-bit unsigned integer uchar 8-bit unsigned integer
int16 16-bit signed integer int16 16-bit signed integer
skipping to change at page 44, line 10 skipping to change at page 41, line 38
length limitation length limitation
byte[N] A byte array of N bytes byte[N] A byte array of N bytes
octetstring[N] A buffer of N octets, which may octetstring[N] A buffer of N octets, which may
contain fewer than N octets. Hence contain fewer than N octets. Hence
the encoded value will always have the encoded value will always have
a length. a length.
float16 16-bit floating point number float16 16-bit floating point number
float32 32-bit IEEE floating point number float32 32-bit IEEE floating point number
float64 64-bit IEEE floating point number float64 64-bit IEEE floating point number
These built-in data types can be readily used to define metadata These built-in data types can be readily used to define metadata or
or LFB attributes, but can also be used as building blocks when LFB attributes, but can also be used as building blocks when
defining new data types. The boolean data type is defined here defining new data types. The boolean data type is defined here
because it is so common, even though it can be built by sub- because it is so common, even though it can be built by sub-ranging
ranging the uchar data type. the uchar data type.
Compound data types can build on atomic data types and other Compound data types can build on atomic data types and other
compound data types. Compound data types can be defined in one of compound data types. Compound data types can be defined in one of
four ways. They may be defined as an array of elements of some four ways. They may be defined as an array of elements of some
compound or atomic data type. They may be a structure of named compound or atomic data type. They may be a structure of named
elements of compound or atomic data types (ala C structures). elements of compound or atomic data types (ala C structures). They
They may be a union of named elements of compound or atomic data may be a union of named elements of compound or atomic data types
types (ala C unions). They may also be defined as augmentations (ala C unions). They may also be defined as augmentations
(explained below in 4.5.6) of existing compound data types. (explained below in 4.5.6) of existing compound data types.
Given that the FORCES protocol will be getting and setting Given that the FORCES protocol will be getting and setting attribute
attribute values, all atomic data types used here must be able to values, all atomic data types used here must be able to be conveyed
be conveyed in the FORCES protocol. Further, the FORCES protocol in the FORCES protocol. Further, the FORCES protocol will need a
will need a mechanism to convey compound data types. However, the mechanism to convey compound data types. However, the details of
details of such representations are for the protocol document to such representations are for the protocol document to define, not
define, not the model document. the model document.
For the definition of the actual type in the <dataTypeDef> For the definition of the actual type in the <dataTypeDef> element,
element, the following elements are available: <typeRef>, the following elements are available: <typeRef>, <atomic>, <array>,
<atomic>, <array>, <struct>, and <union>. <struct>, and <union>.
The predefined type alias is somewhere between the atomic and The predefined type alias is somewhere between the atomic and
compound data types. It behaves like a structure, one element of compound data types. It behaves like a structure, one element of
which has special behavior. Given that the special behavior is which has special behavior. Given that the special behavior is tied
tied to the other parts of the structure, the compound result is to the other parts of the structure, the compound result is treated
treated as a predefined construct. as a predefined construct.
4.5.1. <typeRef> Element for Aliasing Existing Data Types 4.5.1. <typeRef> Element for Aliasing Existing Data Types
The <typeRef> element refers to an existing data type by its name. The <typeRef> element refers to an existing data type by its name.
The referred data type must be defined either in the same library The referred data type MUST be defined either in the same library
document, or in one of the included library documents. If the document, or in one of the included library documents. If the
referred data type is an atomic data type, the newly defined type referred data type is an atomic data type, the newly defined type
will also be regarded as atomic. If the referred data type is a will also be regarded as atomic. If the referred data type is a
compound type, the new type will also be compound. Some usage compound type, the new type will also be compound. Some usage
examples follow: examples follow:
<dataTypeDef> <dataTypeDef>
<name>short</name> <name>short</name>
<synopsis>Alias to int16</synopsis> <synopsis>Alias to int16</synopsis>
<typeRef>int16</typeRef> <typeRef>int16</typeRef>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>ieeemacaddr</name> <name>ieeemacaddr</name>
<synopsis>48-bit IEEE MAC address</synopsis> <synopsis>48-bit IEEE MAC address</synopsis>
<typeRef>byte[6]</typeRef> <typeRef>byte[6]</typeRef>
</dataTypeDef> </dataTypeDef>
4.5.2. <atomic> Element for Deriving New Atomic Types 4.5.2. <atomic> Element for Deriving New Atomic Types
The <atomic> element allows the definition of a new atomic type The <atomic> element allows the definition of a new atomic type from
from an existing atomic type, applying range restrictions and/or an existing atomic type, applying range restrictions and/or
providing special enumerated values. Note that the <atomic> providing special enumerated values. Note that the <atomic> element
element can only use atomic types as base types, and its result is can only use atomic types as base types, and its result MUST be
always another atomic type. another atomic type.
For example, the following snippet defines a new "dscp" data type: For example, the following snippet defines a new "dscp" data type:
<dataTypeDef> <dataTypeDef>
<name>dscp</name> <name>dscp</name>
<synopsis>Diffserv code point.</synopsis> <synopsis>Diffserv code point.</synopsis>
<atomic> <atomic>
<baseType>uchar</baseType> <baseType>uchar</baseType>
<rangeRestriction> <rangeRestriction>
<allowedRange min="0" max="63"/> <allowedRange min="0" max="63"/>
skipping to change at page 45, line 50 skipping to change at page 43, line 29
</specialValue> </specialValue>
... ...
</specialValues> </specialValues>
</atomic> </atomic>
</dataTypeDef> </dataTypeDef>
4.5.3. <array> Element to Define Arrays 4.5.3. <array> Element to Define Arrays
The <array> element can be used to create a new compound data type The <array> element can be used to create a new compound data type
as an array of a compound or an atomic data type. The type of the as an array of a compound or an atomic data type. The type of the
array entry can be specified either by referring to an existing array entry can be specified either by referring to an existing type
type (using the <typeRef> element) or defining an unnamed type (using the <typeRef> element) or defining an unnamed type inside the
inside the <array> element using any of the <atomic>, <array>, <array> element using any of the <atomic>, <array>, <struct>, or
<struct>, or <union> elements. <union> elements.
The array can be "fixed-size" or "variable-size", which is The array can be "fixed-size" or "variable-size", which is specified
specified by the "type" attribute of the <array> element. The by the "type" attribute of the <array> element. The default is
default is "variable-size". For variable size arrays, an optional "variable-size". For variable size arrays, an optional "max-length"
"max-length" attribute specifies the maximum allowed length. This attribute specifies the maximum allowed length. This attribute
attribute should be used to encode semantic limitations, not should be used to encode semantic limitations, not implementation
implementation limitations. The latter should be handled by limitations. The latter should be handled by capability attributes
capability attributes of LFB classes, and should never be included of LFB classes, and should never be included in data type
in data type definitions. If the "max-length" attribute is not definitions. If the "max-length" attribute is not provided, the
provided, the array is regarded as of unlimited-size. array is regarded as of unlimited-size.
For fixed-size arrays, a "length" attribute must be provided that For fixed-size arrays, a "length" attribute MUST be provided that
specifies the constant size of the array. specifies the constant size of the array.
The result of this construct is always a compound type, even if The result of this construct MUST always be a compound type, even if
the array has a fixed size of 1. the array has a fixed size of 1.
Arrays can only be subscripted by integers, and will be presumed Arrays MUST only be subscripted by integers, and will be presumed to
to start with index 0. start with index 0.
In addition to their subscripts, arrays may be declared to have In addition to their subscripts, arrays may be declared to have
content keys. Such a declaration has several effects: content keys. Such a declaration has several effects:
. Any declared key can be used in the ForCES protocol to select . Any declared key can be used in the ForCES protocol to select
an element for operations (for details, see the protocol). an element for operations (for details, see the protocol).
. In any instance of the array, each declared key must be . In any instance of the array, each declared key must be unique
unique within that instance. No two elements of an array may within that instance. No two elements of an array may have the
have the same values on all the fields which make up a key. same values on all the fields which make up a key.
Each key is declared with a keyID for use in the protocol, where Each key is declared with a keyID for use in the protocol, where the
the unique key is formed by combining one or more specified key unique key is formed by combining one or more specified key fields.
fields. To support the case where an array of an atomic type with To support the case where an array of an atomic type with unique
unique values can be referenced by those values, the key field values can be referenced by those values, the key field identifier
identifier may be "*" (i.e., the array entry is the key). If the may be "*" (i.e., the array entry is the key). If the value type of
value type of the array is a structure or an array, then the key the array is a structure or an array, then the key is one or more
is one or more fields, each identified by name. Since the field fields, each identified by name. Since the field may be an element
may be an element of the structure, the element of an element of a of the structure, the element of an element of a structure, or
structure, or further nested, the field name is actually a further nested, the field name is actually a concatenated sequence
concatenated sequence of part identifiers, separated by decimal of part identifiers, separated by decimal points ("."). The syntax
points ("."). The syntax for key field identification is given for key field identification is given following the array examples.
following the array examples.
The following example shows the definition of a fixed size array The following example shows the definition of a fixed size array
with a pre-defined data type as the array elements: with a pre-defined data type as the array elements:
<dataTypeDef> <dataTypeDef>
<name>dscp-mapping-table</name> <name>dscp-mapping-table</name>
<synopsis> <synopsis>
A table of 64 DSCP values, used to re-map code space. A table of 64 DSCP values, used to re-map code space.
</synopsis> </synopsis>
<array type="fixed-size" length="64"> <array type="fixed-size" length="64">
skipping to change at page 47, line 29 skipping to change at page 44, line 51
limit on its size: limit on its size:
<dataTypeDef> <dataTypeDef>
<name>mac-alias-table</name> <name>mac-alias-table</name>
<synopsis>A table with up to 8 IEEE MAC addresses</synopsis> <synopsis>A table with up to 8 IEEE MAC addresses</synopsis>
<array type="variable-size" max-length="8"> <array type="variable-size" max-length="8">
<typeRef>ieeemacaddr</typeRef> <typeRef>ieeemacaddr</typeRef>
</array> </array>
</dataTypeDef> </dataTypeDef>
The following example shows the definition of an array with a The following example shows the definition of an array with a local
local (unnamed) type definition: (unnamed) type definition:
<dataTypeDef> <dataTypeDef>
<name>classification-table</name> <name>classification-table</name>
<synopsis> <synopsis>
A table of classification rules and result opcodes. A table of classification rules and result opcodes.
</synopsis> </synopsis>
<array type="variable-size"> <array type="variable-size">
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>rule</name> <name>rule</name>
skipping to change at page 48, line 26 skipping to change at page 45, line 48
</synopsis> </synopsis>
<array type="variable-size"> <array type="variable-size">
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>address-prefix</name> <name>address-prefix</name>
<synopsis>the prefix being described</synopsis> <synopsis>the prefix being described</synopsis>
<typeRef>ipv4Prefix</typeRef> <typeRef>ipv4Prefix</typeRef>
</element> </element>
<element elementID="2"> <element elementID="2">
<name>source</name> <name>source</name>
<synopsis>where is this from</synopsis> <synopsis>
the protocol or process providing this information
</synopsis>
<typeRef>uint16</typeRef> <typeRef>uint16</typeRef>
</element> </element>
<element elementID="3"> <element elementID="3">
<name>prefInfo</name> <name>prefInfo</name>
<synopsis>the information we care about</synopsis> <synopsis>the information we care about</synopsis>
<typeRef>hypothetical-info-type</typeRef> <typeRef>hypothetical-info-type</typeRef>
</element> </element>
</struct> </struct>
<key keyID="1"> <key keyID="1">
<keyField> address-prefix.ipv4addr </keyField> <keyField> address-prefix.ipv4addr </keyField>
<keyField> address-prefix.prefixlen </keyField> <keyField> address-prefix.prefixlen </keyField>
<keyField> source </keyField> <keyField> source </keyField>
</key> </key>
</array> </array>
</dataTypeDef> </dataTypeDef>
Note that the keyField elements could also have been simply Note that the keyField elements could also have been simply address-
address-prefix and source, since all of the fields of address- prefix and source, since all of the fields of address-prefix are
prefix are being used. being used.
4.5.3.1 Key Field References 4.5.3.1 Key Field References
In order to use key declarations, one must refer to fields that
are potentially nested inside other fields in the array. If there
are nested arrays, one might even use an array element as a key
(but great care would be needed to ensure uniqueness.)
The key is the combination of the values of each field declared in In order to use key declarations, one must refer to fields that are
a keyField element. potentially nested inside other fields in the array. If there are
nested arrays, one might even use an array element as a key (but
great care would be needed to ensure uniqueness.)
Therefore, the value of a keyField element is defined as a The key is the combination of the values of each field declared in a
concatenated Sequence of field identifiers, separated by a "." keyField element.
(period) character. Whitespace is permitted and ignored.
Therefore, the value of a keyField element MUST be a concatenated
Sequence of field identifiers, separated by a "." (period)
character. Whitespace is permitted and ignored.
A valid string for a single field identifier within a keyField A valid string for a single field identifier within a keyField
depends upon the current context. Initially, in an array key depends upon the current context. Initially, in an array key
declaration, the context is the type of the array. Progressively, declaration, the context is the type of the array. Progressively,
the context is whatever type is selected by the field identifiers the context is whatever type is selected by the field identifiers
processed so far in the current key field declaration. processed so far in the current key field declaration.
When the current context is an array, (e.g., when declaring a key When the current context is an array, (e.g., when declaring a key
for an array whose content is an array) then the only valid value for an array whose content is an array) then the only valid value
for the field identifier is an explicit number. for the field identifier is an explicit number.
skipping to change at page 49, line 34 skipping to change at page 47, line 9
When the current context is a structure, the valid values for the When the current context is a structure, the valid values for the
field identifiers are the names of the elements of the structure. field identifiers are the names of the elements of the structure.
In the special case of declaring a key for an array containing an In the special case of declaring a key for an array containing an
atomic type, where that content is unique and is to be used as a atomic type, where that content is unique and is to be used as a
key, the value "*" can be used as the single key field identifier. key, the value "*" can be used as the single key field identifier.
4.5.4. <struct> Element to Define Structures 4.5.4. <struct> Element to Define Structures
A structure is comprised of a collection of data elements. Each A structure is comprised of a collection of data elements. Each
data element has a data type (either an atomic type or an existing data element has a data type (either an atomic type or an existing
compound type) and is assigned a name unique within the scope of compound type) and is assigned a name unique within the scope of the
the compound data type being defined. These serve the same compound data type being defined. These serve the same function as
function as "struct" in C, etc. "struct" in C, etc.
The actual type of the field can be defined by referring to an The actual type of the field can be defined by referring to an
existing type (using the <typeDef> element), or can be a locally existing type (using the <typeDef> element), or can be a locally
defined (unnamed) type created by any of the <atomic>, <array>, defined (unnamed) type created by any of the <atomic>, <array>,
<struct>, or <union> elements. <struct>, or <union> elements.
A structure definition is a series of element declarations. Each A structure definition is a series of element declarations. Each
element carries an elementID for use by the ForCES protocol. In element carries an elementID for use by the ForCES protocol. In
addition, the element contains the name, a synopsis, an optional addition, the element contains the name, a synopsis, an optional
description, an optional declaration that the element itself is description, an optional declaration that the element itself is
optional, and the typeRef declaration that specifies the element optional, and the typeRef declaration that specifies the element
type. type.
For a dataTypeDef of a struct, the structure definition may be For a dataTypeDef of a struct, the structure definition may be
inherited from, and augment, a previously defined structured type. inherited from, and augment, a previously defined structured type.
This is indicated by including the derivedFrom attribute on the This is indicated by including the derivedFrom attribute on the
struct declaration. struct declaration.
The result of this construct is always regarded a compound type, The result of this construct MUST be a compound type, even when the
even when the <struct> contains only one field. <struct> contains only one field.
An example: An example:
<dataTypeDef> <dataTypeDef>
<name>ipv4prefix</name> <name>ipv4prefix</name>
<synopsis> <synopsis>
IPv4 prefix defined by an address and a prefix length IPv4 prefix defined by an address and a prefix length
</synopsis> </synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
skipping to change at page 50, line 45 skipping to change at page 48, line 15
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
4.5.5. <union> Element to Define Union Types 4.5.5. <union> Element to Define Union Types
Similar to the union declaration in C, this construct allows the Similar to the union declaration in C, this construct allows the
definition of overlay types. Its format is identical to the definition of overlay types. Its format is identical to the
<struct> element. <struct> element.
The result of this construct is always regarded a compound type, The result of this construct MUST be a compound type, even when the
even when the union contains only one element. union contains only one element.
4.5.6 <alias> Element 4.5.6 <alias> Element
It is sometimes necessary to have an element in an LFB or It is sometimes necessary to have an element in an LFB or structure
structure refer to information in other LFBs. The <alias> refer to information in other LFBs. The <alias> declaration creates
declaration creates the constructs for this. The content of an the constructs for this. The content of an <alias> element MUST be a
<alias> element is a named type. It can be a base type of a named type. It can be a base type of a derived type. The actual
derived type. The actual value referenced by an alias is known as value referenced by an alias is known as its target. When a GET or
its target. When a GET or SET operation references the alias SET operation references the alias element, the value of the target
element, the value of the target is returned or replaced. Write is returned or replaced. Write access to an alias element is
access to an alias element is permitted if write access to both permitted if write access to both the alias and the target are
the alias and the target are permitted. permitted.
The target of an <alias> element is determined by its properties. The target of an <alias> element is determined by its properties.
Like all elements, the properties include the support / read / Like all elements, the properties MUST include the support / read /
write permission for the alias. In addition, several fields in write permission for the alias. In addition, there are several
the property elements define the target of the alias. These fields in the properties which define the target of the alias.
fields are the ID of the LFB class of the target, the ID of the These fields are the ID of the LFB class of the target, the ID of
LFB instance of the target, and a sequence of integers the LFB instance of the target, and a sequence of integers
representing the path within the target LFB instance to the target representing the path within the target LFB instance to the target
element. The type of the target element must match the declared element. The type of the target element must match the declared
type of the alias. Details of the alias property structure are type of the alias. Details of the alias property structure in in
contained in the section of this document on properties. the section of this document on properties.
Note that the read / write property of the alias refers to the Note that the read / write property of the alias refers to the
value. The CE can only determine if it can write the target value. The CE can only determine if it can write the target
selection properties of the alias by attempting such a write selection properties of the alias by attempting such a write
operation. (Property elements do not themselves have properties.) operation. (Property elements do not themselves have properties.)
4.5.6. Augmentations 4.5.6. Augmentations
Compound types can also be defined as augmentations of existing Compound types can also be defined as augmentations of existing
compound types. If the existing compound type is a structure, compound types. If the existing compound type is a structure,
skipping to change at page 51, line 47 skipping to change at page 49, line 16
One consequence of this is that augmentations are compatible with One consequence of this is that augmentations are compatible with
the compound type from which they are derived. As such, the compound type from which they are derived. As such,
augmentations are useful in defining attributes for LFB subclasses augmentations are useful in defining attributes for LFB subclasses
with backward compatibility. In addition to adding new attributes with backward compatibility. In addition to adding new attributes
to a class, the data type of an existing attribute may be replaced to a class, the data type of an existing attribute may be replaced
by an augmentation of that attribute, and still meet the by an augmentation of that attribute, and still meet the
compatibility rules for subclasses. compatibility rules for subclasses.
For example, consider a simple base LFB class A that has only one For example, consider a simple base LFB class A that has only one
attribute (attr1) of type X. One way to derive class A1 from A attribute (attr1) of type X. One way to derive class A1 from A can
can be by simply adding a second attribute (of any type). Another be by simply adding a second attribute (of any type). Another way
way to derive a class A2 from A can be by replacing the original to derive a class A2 from A can be by replacing the original
attribute (attr1) in A of type X with one of type Y, where Y is an attribute (attr1) in A of type X with one of type Y, where Y is an
augmentation of X. Both classes A1 and A2 are backward compatible augmentation of X. Both classes A1 and A2 are backward compatible
with class A. with class A.
The syntax for augmentations is to include a derivedFrom element The syntax for augmentations is to include a derivedFrom element in
in a structure definition, indicating what structure type is being a structure definition, indicating what structure type is being
augmented. Element names and element IDs within the augmentation augmented. Element names and element IDs within the augmentation
must not be the same as those in the structure type being must not be the same as those in the structure type being augmented.
augmented.
4.6. <metadataDefs> Element for Metadata Definitions 4.6. <metadataDefs> Element for Metadata Definitions
The (optional) <metadataDefs> element in the library document The (optional) <metadataDefs> element in the library document
contains one or more <metadataDef> elements. Each <metadataDef> contains one or more <metadataDef> elements. Each <metadataDef>
element defines a metadata. element defines a metadata.
Each <metadataDef> element contains a unique name (NMTOKEN). Each <metadataDef> element MUST contain a unique name (NMTOKEN).
Uniqueness is defined to be over all metadata defined in this Uniqueness is defined to be over all metadata defined in this
library document and in all directly or indirectly included library document and in all directly or indirectly included library
library documents. The <metadataDef> element also contains a brief documents. The <metadataDef> element MUST also contain a brief
synopsis, an optional detailed description, and a compulsory type synopsis, the mandatory tag value to be used for this metadata, an
definition information. Only atomic data types can be used as optional detailed description, and a mandatory type definition
value types for metadata. information. Only atomic data types can be used as value types for
metadata.
Two forms of type definitions are allowed. The first form uses the Two forms of type definitions are allowed. The first form uses the
<typeRef> element to refer to an existing atomic data type defined <typeRef> element to refer to an existing atomic data type defined
in the <dataTypeDefs> element of the same library document or in in the <dataTypeDefs> element of the same library document or in one
one of the included library documents. The usage of the <typeRef> of the included library documents. The usage of the <typeRef>
element is identical to how it is used in the <dataTypeDef> element is identical to how it is used in the <dataTypeDef>
elements, except here it can only refer to atomic types. elements, except here it can only refer to atomic types.
The latter restriction is not yet enforced by the XML schema.
[EDITOR: The latter restriction is not yet enforced by the XML
schema.]
The second form is an explicit type definition using the <atomic> The second form is an explicit type definition using the <atomic>
element. This element is used here in the same way as in the element. This element is used here in the same way as in the
<dataTypeDef> elements. <dataTypeDef> elements.
The following example shows both usages: The following example shows both usages:
<metadataDefs> <metadataDefs>
<metadataDef> <metadataDef>
<name>NEXTHOPID</name> <name>NEXTHOPID</name>
<synopsis>Refers to a Next Hop entry in NH LFB</synopsis> <synopsis>Refers to a Next Hop entry in NH LFB</synopsis>
<metadataID>17</metaDataID>
<typeRef>int32</typeRef> <typeRef>int32</typeRef>
</metadataDef> </metadataDef>
<metadataDef> <metadataDef>
<name>CLASSID</name> <name>CLASSID</name>
<synopsis> <synopsis>
Result of classification (0 means no match). Result of classification (0 means no match).
</synopsis> </synopsis>
<metadataID>21</metadataID>
<atomic> <atomic>
<baseType>int32</baseType> <baseType>int32</baseType>
<specialValues> <specialValues>
<specialValue value="0"> <specialValue value="0">
<name>NOMATCH</name> <name>NOMATCH</name>
<synopsis> <synopsis>
Classification didnÆt result in match. Classification didnt result in match.
</synopsis> </synopsis>
</specialValue> </specialValue>
</specialValues> </specialValues>
</atomic> </atomic>
</metadataDef> </metadataDef>
</metadataDefs> </metadataDefs>
4.7. <LFBClassDefs> Element for LFB Class Definitions 4.7. <LFBClassDefs> Element for LFB Class Definitions
The (optional) <LFBClassDefs> element can be used to define one or The (optional) <LFBClassDefs> element can be used to define one or
more LFB classes using <LFBClassDef> elements. Each <LFBClassDef> more LFB classes using <LFBClassDef> elements. Each <LFBClassDef>
element defines an LFB class and includes the following elements: element MUST define an LFB class and include the following elements:
. <name> provides the symbolic name of the LFB class. Example: . <name> provides the symbolic name of the LFB class. Example:
"ipv4lpm" "ipv4lpm"
. <synopsis> provides a short synopsis of the LFB class. . <synopsis> provides a short synopsis of the LFB class. Example:
Example: "IPv4 Longest Prefix Match Lookup LFB" "IPv4 Longest Prefix Match Lookup LFB"
. <version> is the version indicator . <version> is the version indicator
. <derivedFrom> is the inheritance indicator . <derivedFrom> is the inheritance indicator
. <inputPorts> lists the input ports and their specifications . <inputPorts> lists the input ports and their specifications
. <outputPorts> lists the output ports and their specifications . <outputPorts> lists the output ports and their specifications
. <attributes> defines the operational attributes of the LFB . <attributes> defines the operational attributes of the LFB
. <capabilities> defines the capability attributes of the LFB . <capabilities> defines the capability attributes of the LFB
. <description> contains the operational specification of the . <description> contains the operational specification of the LFB
LFB . The LFBClassID attribute of the LFBClassDef element defines the
. The LFBClassID attribute of the LFBClassDef element defines ID for this class. These must be globally unique.
the ID for this class. These must be globally unique. . <events> defines the events that can be generated by instances
. <events> defines the events that can be generated by of this LFB.
instances of this LFB.
[EDITOR: LFB class names should be unique not only among classes [EDITOR: LFB class names should be unique not only among classes
defined in this document and in all included documents, but also defined in this document and in all included documents, but also
unique across a large collection of libraries. Obviously some unique across a large collection of libraries. Obviously some global
global control is needed to ensure such uniqueness. This subject control is needed to ensure such uniqueness. This subject requires
requires further study. The uniqueness of the class IDs also further study. The uniqueness of the class IDs also requires further
requires further study.] study.]
Here is a skeleton of an example LFB class definition: Here is a skeleton of an example LFB class definition:
<LFBClassDefs> <LFBClassDefs>
<LFBClassDef LFBClassID="12345"> <LFBClassDef LFBClassID="12345">
<name>ipv4lpm</name> <name>ipv4lpm</name>
<synopsis>IPv4 Longest Prefix Match Lookup LFB</synopsis> <synopsis>IPv4 Longest Prefix Match Lookup LFB</synopsis>
<version>1.0</version> <version>1.0</version>
<derivedFrom>baseclass</derivedFrom> <derivedFrom>baseclass</derivedFrom>
skipping to change at page 54, line 38 skipping to change at page 52, line 4
<description> <description>
This LFB represents the IPv4 longest prefix match lookup This LFB represents the IPv4 longest prefix match lookup
operation. operation.
The modeled behavior is as follows: The modeled behavior is as follows:
Blah-blah-blah. Blah-blah-blah.
</description> </description>
</LFBClassDef> </LFBClassDef>
... ...
</LFBClassDefs> </LFBClassDefs>
The individual attributes and capabilities will have elementIDs for
The individual attributes and capabilities will have elementIDs use by the ForCES protocol. These parallel the elementIDs used in
for use by the ForCES protocol. These parallel the elementIDs structs, and are used the same way. Attribute and capability
used in structs, and are used the same way. Attribute and elementIDs must be unique within the LFB class definition.
capability elementIDs must be unique within the LFB class
definition.
Note that the <name>, <synopsis>, and <version> elements are Note that the <name>, <synopsis>, and <version> elements are
required, all other elements are optional in <LFBClassDef>. required, all other elements are optional in <LFBClassDef>. However,
However, when they are present, they must occur in the above when they are present, they must occur in the above order.
order.
4.7.1. <derivedFrom> Element to Express LFB Inheritance 4.7.1. <derivedFrom> Element to Express LFB Inheritance
The optional <derivedFrom> element can be used to indicate that
this class is a derivative of some other class. The content of The optional <derivedFrom> element can be used to indicate that this
this element must be the unique name (<name>) of another LFB class is a derivative of some other class. The content of this
class. The referred LFB class must be defined in the same library element MUST be the unique name (<name>) of another LFB class. The
document or in one of the included library documents. referred LFB class MUST be defined in the same library document or
in one of the included library documents.
[EDITOR: The <derivedFrom> element will likely need to specify the [EDITOR: The <derivedFrom> element will likely need to specify the
version of the ancestor, which is not included in the schema yet. version of the ancestor, which is not included in the schema yet.
The process and rules of class derivation are still being The process and rules of class derivation are still being studied.]
studied.]
It is assumed that the derived class is backwards compatible with It is assumed that the derived class is backwards compatible with
the base class. the base class.
4.7.2. <inputPorts> Element to Define LFB Inputs 4.7.2. <inputPorts> Element to Define LFB Inputs
The optional <inputPorts> element is used to define input ports. The optional <inputPorts> element is used to define input ports. An
An LFB class may have zero, one, or more inputs. If the LFB class LFB class may have zero, one, or more inputs. If the LFB class has
has no input ports, the <inputPorts> element must be omitted. The no input ports, the <inputPorts> element MUST be omitted. The
<inputPorts> element can contain one or more <inputPort> elements, <inputPorts> element can contain one or more <inputPort> elements,
one for each port or port-group. We assume that most LFBs will one for each port or port-group. We assume that most LFBs will have
have exactly one input. Multiple inputs with the same input type exactly one input. Multiple inputs with the same input type are
are modeled as one input group. Input groups are defined the same modeled as one input group. Input groups are defined the same way
way as input ports by the <inputPort> element, differentiated only as input ports by the <inputPort> element, differentiated only by an
by an optional "group" attribute. optional "group" attribute.
Multiple inputs with different input types should be avoided if Multiple inputs with different input types should be avoided if
possible (see discussion in Section 3.2.1). Some special LFBs possible (see discussion in Section 3.2.1). Some special LFBs will
will have no inputs at all. For example, a packet generator LFB have no inputs at all. For example, a packet generator LFB does not
does not need an input. need an input.
Single input ports and input port groups are both defined by the Single input ports and input port groups are both defined by the
<inputPort> element, they are differentiated by only an optional <inputPort> element; they are differentiated by only an optional
"group" attribute. "group" attribute.
The <inputPort> element contains the following elements: The <inputPort> element MUST contain the following elements:
. <name> provides the symbolic name of the input. Example: "in". . <name> provides the symbolic name of the input. Example: "in".
Note that this symbolic name must be unique only within the Note that this symbolic name must be unique only within the scope
scope of the LFB class. of the LFB class.
. <synopsis> contains a brief description of the input. Example: . <synopsis> contains a brief description of the input. Example:
"Normal packet input". "Normal packet input".
. <expectation> lists all allowed frame formats. Example: . <expectation> lists all allowed frame formats. Example: {"ipv4"
{"ipv4" and "ipv6"}. Note that this list should refer to names and "ipv6"}. Note that this list should refer to names specified
specified in the <frameDefs> element of the same library in the <frameDefs> element of the same library document or in any
document or in any included library documents. The included library documents. The <expectation> element can also
<expectation> element can also provide a list of required provide a list of required metadata. Example: {"classid",
metadata. Example: {"classid", "vifid"}. This list should "vifid"}. This list should refer to names of metadata defined in
refer to names of metadata defined in the <metadataDefs> the <metadataDefs> element in the same library document or in any
element in the same library document or in any included library included library documents. For each metadata, it must be
documents. For each metadata, it must be specified whether the specified whether the metadata is required or optional. For each
metadata is required or optional. For each optional metadata, optional metadata, a default value must be specified, which is
a default value must be specified, which is used by the LFB if used by the LFB if the metadata is not provided with a packet.
the metadata is not provided with a packet.
In addition, the optional "group" attribute of the <inputPort> In addition, the optional "group" attribute of the <inputPort>
element can specify if the port can behave as a port group, i.e., element can specify if the port can behave as a port group, i.e., it
it is allowed to be instantiated. This is indicated by a "yes" is allowed to be instantiated. This is indicated by a "yes" value
value (the default value is "no"). (the default value is "no").
An example <inputPorts> element, defining two input ports, the An example <inputPorts> element, defining two input ports, the
second one being an input port group: second one being an input port group:
<inputPorts> <inputPorts>
<inputPort> <inputPort>
<name>in</name> <name>in</name>
<synopsis>Normal input</synopsis> <synopsis>Normal input</synopsis>
<expectation> <expectation>
<frameExpected> <frameExpected>
skipping to change at page 56, line 41 skipping to change at page 53, line 51
<ref>vifid</ref> <ref>vifid</ref>
<ref dependency="optional" defaultValue="0">vrfid</ref> <ref dependency="optional" defaultValue="0">vrfid</ref>
</metadataExpected> </metadataExpected>
</expectation> </expectation>
</inputPort> </inputPort>
<inputPort group="yes"> <inputPort group="yes">
... another input port ... ... another input port ...
</inputPort> </inputPort>
</inputPorts> </inputPorts>
For each <inputPort>, the frame type expectations are defined by For each <inputPort>, the frame type expectations are defined by the
the <frameExpected> element using one or more <ref> elements (see <frameExpected> element using one or more <ref> elements (see
example above). When multiple frame types are listed, it means example above). When multiple frame types are listed, it means that
that "one of these" frame types are expected. A packet of any "one of these" frame types is expected. A packet of any other frame
other frame type is regarded as incompatible with this input port type is regarded as incompatible with this input port of the LFB
of the LFB class. The above example list two frames as expected class. The above example list two frames as expected frame types:
frame types: "ipv4" and "ipv6". "ipv4" and "ipv6".
Metadata expectations are specified by the <metadataExpected> Metadata expectations are specified by the <metadataExpected>
element. In its simplest form, this element can contain a list of element. In its simplest form, this element can contain a list of
<ref> elements, each referring to a metadata. When multiple <ref> elements, each referring to a metadata. When multiple
instances of metadata are listed by <ref> elements, it means that instances of metadata are listed by <ref> elements, it means that
"all of these" metadata must be received with each packet (except "all of these" metadata must be received with each packet (except
metadata that are marked as "optional" by the "dependency" metadata that are marked as "optional" by the "dependency" attribute
attribute of the corresponding <ref> element). For a metadata of the corresponding <ref> element). For a metadata that is
that is specified "optional", a default value must be provided specified "optional", a default value MUST be provided using the
using the "defaultValue" attribute. The above example lists three "defaultValue" attribute. The above example lists three metadata as
metadata as expected metadata, two of which are mandatory expected metadata, two of which are mandatory ("classid" and
("classid" and "vifid"), and one being optional ("vrfid"). "vifid"), and one being optional ("vrfid").
[EDITOR: How to express default values for byte[N] atomic types is [EDITOR: How to express default values for byte[N] atomic types is
yet to be defined.] yet to be defined.]
The schema also allows for more complex definitions of metadata The schema also allows for more complex definitions of metadata
expectations. For example, using the <one-of> element, a list of expectations. For example, using the <one-of> element, a list of
metadata can be specified to express that at least one of the metadata can be specified to express that at least one of the
specified metadata must be present with any packet. For example: specified metadata must be present with any packet. For example:
<metadataExpected> <metadataExpected>
<one-of> <one-of>
<ref>prefixmask</ref> <ref>prefixmask</ref>
<ref>prefixlen</ref> <ref>prefixlen</ref>
</one-of> </one-of>
</metadataExpected> </metadataExpected>
The above example specifies that either the "prefixmask" or the The above example specifies that either the "prefixmask" or the
"prefixlen" metadata must be provided with any packet. "prefixlen" metadata must be provided with any packet.
The two forms can also be combined, as it is shown in the The two forms can also be combined, as it is shown in the following
following example: example:
<metadataExpected> <metadataExpected>
<ref>classid</ref> <ref>classid</ref>
<ref>vifid</ref> <ref>vifid</ref>
<ref dependency="optional" defaultValue="0">vrfid</ref> <ref dependency="optional" defaultValue="0">vrfid</ref>
<one-of> <one-of>
<ref>prefixmask</ref> <ref>prefixmask</ref>
<ref>prefixlen</ref> <ref>prefixlen</ref>
</one-of> </one-of>
</metadataExpected> </metadataExpected>
skipping to change at page 57, line 44 skipping to change at page 55, line 4
<metadataExpected> <metadataExpected>
<ref>classid</ref> <ref>classid</ref>
<ref>vifid</ref> <ref>vifid</ref>
<ref dependency="optional" defaultValue="0">vrfid</ref> <ref dependency="optional" defaultValue="0">vrfid</ref>
<one-of> <one-of>
<ref>prefixmask</ref> <ref>prefixmask</ref>
<ref>prefixlen</ref> <ref>prefixlen</ref>
</one-of> </one-of>
</metadataExpected> </metadataExpected>
Although the schema is constructed to allow even more complex Although the schema is constructed to allow even more complex
definitions of metadata expectations, we do not discuss those definitions of metadata expectations, we do not discuss those here.
here.
4.7.3. <outputPorts> Element to Define LFB Outputs 4.7.3. <outputPorts> Element to Define LFB Outputs
The optional <outputPorts> element is used to define output
ports. An LFB class may have zero, one, or more outputs. If the The optional <outputPorts> element is used to define output ports.
LFB class has no output ports, the <outputPorts> element must be An LFB class may have zero, one, or more outputs. If the LFB class
omitted. The <outputPorts> element can contain one or more has no output ports, the <outputPorts> element MUST be omitted. The
<outputPort> elements, one for each port or port-group. If there <outputPorts> element can contain one or more <outputPort> elements,
are multiple outputs with the same output type, we model them as one for each port or port-group. If there are multiple outputs with
an output port group. Some special LFBs may have no outputs at the same output type, we model them as an output port group. Some
all (e.g., Dropper). special LFBs may have no outputs at all (e.g., Dropper).
Single output ports and output port groups are both defined by the Single output ports and output port groups are both defined by the
<outputPort> element; they are differentiated by only an optional <outputPort> element; they are differentiated by only an optional
"group" attribute. "group" attribute.
The <outputPort> element contains the following elements: The <outputPort> element MUST contain the following elements:
. <name> provides the symbolic name of the output. Example:
"out". Note that the symbolic name must be unique only within . <name> provides the symbolic name of the output. Example: "out".
the scope of the LFB class. Note that the symbolic name must be unique only within the scope
of the LFB class.
. <synopsis> contains a brief description of the output port. . <synopsis> contains a brief description of the output port.
Example: "Normal packet output". Example: "Normal packet output".
. <product> lists the allowed frame formats. Example: {"ipv4", . <product> lists the allowed frame formats. Example: {"ipv4",
"ipv6"}. Note that this list should refer to symbols specified "ipv6"}. Note that this list should refer to symbols specified in
in the <frameDefs> element in the same library document or in the <frameDefs> element in the same library document or in any
any included library documents. The <product> element may also included library documents. The <product> element may also
contain the list of emitted (generated) metadata. Example: contain the list of emitted (generated) metadata. Example:
{"classid", "color"}. This list should refer to names of {"classid", "color"}. This list should refer to names of metadata
metadata specified in the <metadataDefs> element in the same specified in the <metadataDefs> element in the same library
library document or in any included library documents. For document or in any included library documents. For each generated
each generated metadata, it should be specified whether the metadata, it should be specified whether the metadata is always
metadata is always generated or generated only in certain generated or generated only in certain conditions. This
conditions. This information is important when assessing information is important when assessing compatibility between
compatibility between LFBs. LFBs.
In addition, the optional "group" attribute of the <outputPort> In addition, the optional "group" attribute of the <outputPort>
element can specify if the port can behave as a port group, i.e., element can specify if the port can behave as a port group, i.e., it
it is allowed to be instantiated. This is indicated by a "yes" is allowed to be instantiated. This is indicated by a "yes" value
value (the default value is "no"). (the default value is "no").
The following example specifies two output ports, the second being The following example specifies two output ports, the second being
an output port group: an output port group:
<outputPorts> <outputPorts>
<outputPort> <outputPort>
<name>out</name> <name>out</name>
<synopsis>Normal output</synopsis> <synopsis>Normal output</synopsis>
<product> <product>
<frameProduced> <frameProduced>
skipping to change at page 59, line 30 skipping to change at page 56, line 33
<metadataProduced> <metadataProduced>
<ref availability="conditional">errorid</ref> <ref availability="conditional">errorid</ref>
</metadataProduced> </metadataProduced>
</product> </product>
</outputPort> </outputPort>
</outputPorts> </outputPorts>
The types of frames and metadata the port produces are defined The types of frames and metadata the port produces are defined
inside the <product> element in each <outputPort>. Within the inside the <product> element in each <outputPort>. Within the
<product> element, the list of frame types the port produces is <product> element, the list of frame types the port produces is
listed in the <frameProduced> element. When more than one frame listed in the <frameProduced> element. When more than one frame is
is listed, it means that "one of" these frames will be produced. listed, it means that "one of" these frames will be produced.
The list of metadata that is produced with each packet is listed The list of metadata that is produced with each packet is listed in
in the optional <metadataProduced> element of the <product>. In the optional <metadataProduced> element of the <product>. In its
its simplest form, this element can contain a list of <ref> simplest form, this element can contain a list of <ref> elements,
elements, each referring to a metadata type. The meaning of such each referring to a metadata type. The meaning of such a list is
a list is that "all of" these metadata are provided with each that "all of" these metadata are provided with each packet, except
packet, except those that are listed with the optional those that are listed with the optional "availability" attribute set
"availability" attribute set to "conditional". Similar to the to "conditional". Similar to the <metadataExpected> element of the
<metadataExpected> element of the <inputPort>, the <inputPort>, the <metadataProduced> element supports more complex
<metadataProduced> element supports more complex forms, which we forms, which we do not discuss here further.
do not discuss here further.
4.7.4. <attributes> Element to Define LFB Operational Attributes 4.7.4. <attributes> Element to Define LFB Operational Attributes
Operational parameters of the LFBs that must be visible to the CEs Operational parameters of the LFBs that must be visible to the CEs
are conceptualized in the model as the LFB attributes. These are conceptualized in the model as the LFB attributes. These
include, for example, flags, single parameter arguments, complex include, for example, flags, single parameter arguments, complex
arguments, and tables. Note that the attributes here refer to arguments, and tables. Note that the attributes here refer to only
only those operational parameters of the LFBs that must be visible those operational parameters of the LFBs that must be visible to the
to the CEs. Other variables that are internal to LFB CEs. Other variables that are internal to LFB implementation are
implementation are not regarded as LFB attributes and hence are not regarded as LFB attributes and hence are not covered.
not covered.
Some examples for LFB attributes are: Some examples for LFB attributes are:
. Configurable flags and switches selecting between operational . Configurable flags and switches selecting between operational
modes of the LFB modes of the LFB
. Number of inputs or outputs in a port group . Number of inputs or outputs in a port group
. Metadata CONSUME vs. PROPAGATE mode selectors . Metadata CONSUME vs.PROPAGATE mode selector
. Various configurable lookup tables, including interface . Various configurable lookup tables, including interface tables,
tables, prefix tables, classification tables, DSCP mapping prefix tables, classification tables, DSCP mapping tables, MAC
tables, MAC address tables, etc. address tables, etc.
. Packet and byte counters . Packet and byte counters
. Various event counters . Various event counters
. Number of current inputs or outputs for each input or output . Number of current inputs or outputs for each input or output
group group
. Metadata CONSUME/PROPAGATE mode selector
There may be various access permission restrictions on what the CE There may be various access permission restrictions on what the CE
can do with an LFB attribute. The following categories may be can do with an LFB attribute. The following categories may be
supported: supported:
. No-access attributes. This is useful when multiple access . No-access attributes. This is useful when multiple access
modes may be defined for a given attribute to allow some modes may be defined for a given attribute to allow some
flexibility for different implementations. flexibility for different implementations.
. Read-only attributes. . Read-only attributes.
. Read-write attributes. . Read-write attributes.
. Write-only attributes. This could be any configurable data . Write-only attributes. This could be any configurable data for
for which read capability is not provided to the CEs. (e.g., which read capability is not provided to the CEs. (e.g., the
the security key information) security key information)
. Read-reset attributes. The CE can read and reset this . Read-reset attributes. The CE can read and reset this
resource, but cannot set it to an arbitrary value. Example: resource, but cannot set it to an arbitrary value. Example:
Counters. Counters.
. Firing-only attributes. A write attempt to this resource . Firing-only attributes. A write attempt to this resource will
will trigger some specific actions in the LFB, but the actual trigger some specific actions in the LFB, but the actual value
value written is ignored. written is ignored.
The LFB class may define more than one possible access mode for a The LFB class may define more than one possible access mode for a
given attribute (for example, "write-only" and "read-write"), in given attribute (for example, "write-only" and "read-write"), in
which case it is left to the actual implementation to pick one of which case it is left to the actual implementation to pick one of
the modes. In such cases, a corresponding capability attribute the modes. In such cases, a corresponding capability attribute must
must inform the CE about the access mode the actual LFB instance inform the CE about the access mode the actual LFB instance supports
supports (see next subsection on capability attributes). (see next subsection on capability attributes).
The attributes of the LFB class are listed in the <attributes> The attributes of the LFB class are listed in the <attributes>
element. Each attribute is defined by an <attribute> element. An element. Each attribute is defined by an <attribute> element. An
<attribute> element contains the following elements: <attribute> element MUST contain the following elements:
. <name> defines the name of the attribute. This name must be . <name> defines the name of the attribute. This name must be
unique among the attributes of the LFB class. Example: unique among the attributes of the LFB class. Example:
"version". "version".
. <synopsis> should provide a brief description of the purpose . <synopsis> should provide a brief description of the purpose of
of the attribute. the attribute.
. <optional/> indicates that this attribute is optional. . <optional/> indicates that this attribute is optional.
. The data type of the attribute can be defined either via a . The data type of the attribute can be defined either via a
reference to a predefined data type or providing a local reference to a predefined data type or providing a local
definition of the type. The former is provided by using the definition of the type. The former is provided by using the
<typeRef> element, which must refer to the unique name of an <typeRef> element, which must refer to the unique name of an
existing data type defined in the <dataTypeDefs> element in existing data type defined in the <dataTypeDefs> element in the
the same library document or in any of the included library same library document or in any of the included library
documents. When the data type is defined locally (unnamed documents. When the data type is defined locally (unnamed
type), one of the following elements can be used: <atomic>, type), one of the following elements can be used: <atomic>,
<array>, <struct>, and <union>. Their usage is identical to <array>, <struct>, and <union>. Their usage is identical to how
how they are used inside <dataTypeDef> elements (see Section they are used inside <dataTypeDef> elements (see Section 4.5).
4.5). . The optional <defaultValue> element can specify a default value
. The optional <defaultValue> element can specify a default for the attribute, which is applied when the LFB is initialized
value for the attribute, which is applied when the LFB is or reset. [EDITOR: A convention to define default values for
initialized or reset. [EDITOR: A convention to define compound data types and byte[N] atomic types is yet to be
default values for compound data types and byte[N] atomic defined.]
types is yet to be defined.]
The attribute element also has a mandatory elementID attribute, The attribute element also MUST have an elementID attribute, which
which is a numeric value used by the ForCES protocol. is a numeric value used by the ForCES protocol.
In addition to the above elements, the <attribute> element In addition to the above elements, the <attribute> element includes
includes an optional "access" attribute, which can take any of the an optional "access" attribute, which can take any of the following
following values or even a list of these values: "read-only", values or even a list of these values: "read-only", "read-write",
"read-write", "write-only", "read-reset", and "trigger-only". The "write-only", "read-reset", and "trigger-only". The default access
default access mode is "read-write". mode is "read-write".
By reading the property information of an element the CE can Whether optional elements are supported, and whether elements
determine whether optional elements are supported and whether defined as read-write can actually be written can be determined for
elements defined as read-write can actually be written for a given a given LFB instance by the CE by reading the property information
LFB instance. of that element.
The following example defines two attributes for an LFB: The following example defines two attributes for an LFB:
<attributes> <attributes>
<attribute access="read-only" elementID=ö1ö> <attribute access="read-only" elementID=”1”>
<name>foo</name> <name>foo</name>
<synopsis>number of things</synopsis> <synopsis>number of things</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</attribute> </attribute>
<attribute access="read-write write-only" elementID=ö2ö> <attribute access="read-write write-only" elementID=”2”>
<name>bar</name> <name>bar</name>
<synopsis>number of this other thing</synopsis> <synopsis>number of this other thing</synopsis>
<atomic> <atomic>
<baseType>uint32</baseType> <baseType>uint32</baseType>
<rangeRestriction> <rangeRestriction>
<allowedRange min="10" max="2000"/> <allowedRange min="10" max="2000"/>
</rangeRestriction> </rangeRestriction>
</atomic> </atomic>
<defaultValue>10</defaultValue> <defaultValue>10</defaultValue>
</attribute> </attribute>
</attributes> </attributes>
The first attribute ("foo") is a read-only 32-bit unsigned The first attribute ("foo") is a read-only 32-bit unsigned integer,
integer, defined by referring to the built-in "uint32" atomic defined by referring to the built-in "uint32" atomic type. The
type. The second attribute ("bar") is also an integer, but uses second attribute ("bar") is also an integer, but uses the <atomic>
the <atomic> element to provide additional range restrictions. element to provide additional range restrictions. This attribute has
This attribute has two possible access modes, "read-write" or two possible access modes, "read-write" or "write-only". A default
"write-only". A default value of 10 is provided. value of 10 is provided.
Note that not all attributes are likely to exist at all times in a Note that not all attributes are likely to exist at all times in a
particular implementation. While the capabilities will frequently particular implementation. While the capabilities will frequently
indicate this non-existence, CEs may attempt to reference non- indicate this non-existence, CEs may attempt to reference non-
existent or non-permitted attributes anyway. The FORCES protocol existent or non-permitted attributes anyway. The FORCES protocol
mechanisms should include appropriate error indicators for this mechanisms should include appropriate error indicators for this
case. case.
The mechanism defined above for non-supported attributes can also The mechanism defined above for non-supported attributes can also
apply to attempts to reference non-existent array elements or to apply to attempts to reference non-existent array elements or to set
set read-only elements. read-only elements.
4.7.5. <capabilities> Element to Define LFB Capability Attributes 4.7.5. <capabilities> Element to Define LFB Capability Attributes
The LFB class specification will provide some flexibility for the The LFB class specification provides some flexibility for the FE
FE implementation regarding how the LFB class is implemented. For implementation regarding how the LFB class is implemented. For
example, the instance may have some limitations that are not example, the instance may have some limitations that are not
inherent from the class definition, but rather the result of some inherent from the class definition, but rather the result of some
implementation limitations. For example, an array attribute may implementation limitations. For example, an array attribute may be
be defined in the class definition as "unlimited" size, but the defined in the class definition as "unlimited" size, but the
physical implementation may impose a hard limit on the size of the physical implementation may impose a hard limit on the size of the
array. array.
Such capability related information is expressed by the capability Such capability related information is expressed by the capability
attributes of the LFB class. The capability attributes are always attributes of the LFB class. The capability attributes are always
read-only attributes, and they are listed in a separate read-only attributes, and they are listed in a separate
<capabilities> element in the <LFBClassDef>. The <capabilities> <capabilities> element in the <LFBClassDef>. The <capabilities>
element contains one or more <capability> elements, each defining element contains one or more <capability> elements, each defining
one capability attribute. The format of the <capability> element one capability attribute. The format of the <capability> element is
is almost the same as the <attribute> element, it differs in two almost the same as the <attribute> element, it differs in two
aspects: it lacks the access mode attribute (because it is always aspects: it lacks the access mode attribute (because it is always
read-only), and it lacks the <defaultValue> element (because read-only), and it lacks the <defaultValue> element (because default
default value is not applicable to read-only attributes). value is not applicable to read-only attributes).
Some examples of capability attributes follow:
Some examples of capability attributes:
. The version of the LFB class that this LFB instance complies . The version of the LFB class that this LFB instance complies
with; with;
. Supported optional features of the LFB class; . Supported optional features of the LFB class;
. Maximum number of configurable outputs for an output group; . Maximum number of configurable outputs for an output group;
. Metadata pass-through limitations of the LFB; . Metadata pass-through limitations of the LFB;
. Maximum size of configurable attribute tables; . Maximum size of configurable attribute tables;
. Additional range restriction on operational attributes; . Additional range restriction on operational attributes;
. Supported access modes of certain attributes (if the access . Supported access modes of certain attributes (if the access
mode of an operational attribute is specified as a list of mode of an operational attribute is specified as a list of two
two or mode modes). or mode modes).
The following example lists two capability attributes: The following example lists two capability attributes:
<capabilities> <capabilities>
<capability elementID="3"> <capability elementID="3">
<name>version</name> <name>version</name>
<synopsis> <synopsis>
LFB class version this instance is compliant with. LFB class version this instance is compliant with.
</synopsis> </synopsis>
<typeRef>version</typeRef> <typeRef>version</typeRef>
skipping to change at page 63, line 40 skipping to change at page 60, line 36
<capability elementID="4"> <capability elementID="4">
<name>limitBar</name> <name>limitBar</name>
<synopsis> <synopsis>
Maximum value of the "bar" attribute. Maximum value of the "bar" attribute.
</synopsis> </synopsis>
<typeRef>uint16</typeRef> <typeRef>uint16</typeRef>
</capability> </capability>
</capabilities> </capabilities>
4.7.6. <events> Element for LFB Notification Generation 4.7.6. <events> Element for LFB Notification Generation
The <events> element contains the information about the
occurrences for which instances of this LFB class can generate
notifications to the CE.
The <events> element includes a baseID attribute, so it is always The <events> element contains the information about the occurrences
<events baseID=önumberö>. The value of the baseID is the starting for which instances of this LFB class can generate notifications to
element for the path which identifies events. It must not be the the CE.
same as the elementID of any top level attribute or capability of
the LFB class. In a derived LFB (i.e. one with a <derivedFrom>
element) the baseID must not.
[Editors note: It may make sense to instead require the baseID The <events> definition needs a baseID attributevalue, which is
attribute and require it to have the same value as the parent normally <events baseID=”number”>. The value of the baseID is the
class events baseID. Both choices leave room for errors not starting element for the path which identifies events. It must not
covered by the XML Schema.] be the same as the elementID of any top level attribute or
capability of the LFB class. In derived LFBs (i.e. ones with a
<derivedFrom> element) where the parent LFB class has an events
declaration, the baseID must not be present. Instead, the value
from the parent class is used.
[editors note: There is an open issue with regard to how baseID is
used for an LFBclass and another class derived from it. Currently,
the derived class does not declare a baseID. It may make sense to
instead to require the baseID attribute and require that it have the
same value as the parent class events baseID. Both choices
(omission or inclusion of baseID in derived classes) leave room for
errors not covered by the XML Schema.]
The <events> element contains 0 or more <event> elements, each of The <events> element contains 0 or more <event> elements, each of
which declares a single event. The <event> element has an eventID which declares a single event. The <event> element has an eventID
attribute giving the unique ID of the event. The element will attribute giving the unique ID of the event. The element will
include: include:
. <eventTarget> element indicating which LFB field is tested to . <eventTarget> element indicating which LFB field is tested to
generate the event; generate the event;
. condition element indicating what condition on the field will . condition element indicating what condition on the field will
generate the event from a list of defined conditions; generate the event from a list of defined conditions;
. <eventReports> element indicating what values are to be . <eventReports> element indicating what values are to be
reported in the notification of the event. reported in the notification of the event.
4.7.6.1 <eventTarget> Element
The <eventTarget> element contains information identifying a field The <eventTarget> element contains information identifying a field
in the LFB. Specifically, the <target> element contains one or in the LFB. Specifically, the <target> element contains one or more
more <eventField> or <eventSubscript> elements. These elements <eventField> or <eventSubscript> elements. These elements represent
represent the textual equivalent of a path select a component of the textual equivalent of a path select component of the LFB. The
the LFB. The <eventField> element contains the name of an element <eventField> element contains the name of an element in the LFB or
of the LFB or struct. The first element in a <target> must be an struct. The first element in a <target> MUST be an <eventField>
<eventField> element and must name a field in the LFB. The element and MUST name a field in the LFB. The following element
following element must identify a valid field within the MUST identify a valid field within the containing context. If an
containing context. If an <eventField> identifies an array, and <eventField> identifies an array, and is not the last element in the
is not the last element in the target, then the next element MUST target, then the next element MUST be an <eventSubscript>.
be an <eventSubscript>. <eventSubscript> elements MUST occur only <eventSubscript> elements MUST occur only after <eventField> names
after <eventField> names that identifies an array. An that identifies an array. An <eventSubscript> may contain a numeric
<eventSubscript> may contain a numeric value to indicate that this value to indicate that this event applies to a specific element of
event applies to a specific element of the array. More commonly, the array. More commonly, the event is being defined across all
the event is being defined across all elements of the array. In elements of the array. In that case, <eventSubscript> will contain
that case, <eventSubscript> will contain a name. The name in an a name. The name in an <eventSubscript> element is not a field
<eventSubscript> element is not a field name. It is a variable name. It is a variable name for use in the <report> elements of
name for use in the <report> elements of this LFB definition. this LFB definition. This name MUST be distinct from any field name
This name MUST be distinct from any field name that can validly that can validly occur in the <eventReport> clause. Hence it SHOULD
occur in the <eventReport> clause. Hence it SHOULD be distinct be distinct from any field name used in the LFB or in structures
from any field name used in the LFB or in structures used within used within the LFB.
the LFB.
The <eventTarget> provides additional components for the path used The <eventTarget> provides additional components for the path used
to reference the event. The path will be the baseID for events, to reference the event. The path will be the baseID for events,
followed by the ID for the specific event, followed by a value for followed by the ID for the specific event, followed by a value for
each <eventSubscript> element in the <eventTarget>. This will each <eventSubscript> element in the <eventTarget>. This will
identify a specific occurrence of the event. So, for example, it identify a specific occurrence of the event. So, for example, it
will appear in the event notification LFB. It is also used for will appear in the event notification LFB. It is also used for the
the SET-PROPERTY operation to subscribe to a specific event. A SET-PROPERTY operation to subscribe to a specific event. A SET-
SET-PROPERTY of the subscription property (but not of any other PROPERTY of the subscription property (but not of any other
writeable properties) may sent be the CE with any prefix of the writeable properties) may be sent by the CE with any prefix of the
path of the event. So, for an event defined on a table, a SET- path of the event. So, for an event defined on a table, a SET-
PROPERTY with a path of the baseID and the eventID will subscribe PROPERTY with a path of the baseID and the eventID will subscribe
the CE to all occurrences of that event on any element of the the CE to all occurrences of that event on any element of the table.
table. This is particularly useful for the <eventCreated/> and This is particularly useful for the <eventCreated/> and
<eventDestroyed/> conditions. Events using those conditions will <eventDestroyed/> conditions. Events using those conditions will
generally be defined with a field / subscript sequence that generally be defined with a field / subscript sequence that
identifies an array, and that ends with an <eventSubscript> identifies an array and ends with an <eventSubscript> element.
element. Thus, the event notification will indicate which array Thus, the event notification will indicate which array entry has
entry has been created or destroyed. A typical subscribe however been created or destroyed. A typical subscriber will subscribe for
will subscribe for the array, not for a specific element, so it the array, as opposed to a specific element in an array, so it will
will use a shorter path. use a shorter path.
Thus, if there is an LFB with an event baseID of 7, and a specific
event with an event ID of 8, then one can subscribe to the event by
referencing the properties of the LFB element with path 7.8. If the
event target has no subscripts (for example, it is a simple
attribute of the LFB) then one can also reference the event
threshold and filtering properties via the properties on element
7.8. If the event target is defined as an element of an array, then
the target definition will include an <eventSubscript> element. In
that case, one can subscribe to the event for the entire array by
referencing the properties of 7.8. One can also subscribe to a
specific element, x, of the array by referencing the subscription
property of 7.8.x and also access the threshold and filtering
properties of 7.8.x. If the event is targeting an element of an
array within an array, then there will be two (or conceivably more)
<eventSubscript> elements in the target. If so, for the case of two
elements, one would reference the properties of 7.8.x.y to get to
the threshold and filtering properties of an individual event.
[Editors note: As currently defined, threshold and filtering can
only be applied to individual elements, not entire arrays. Should
this be changed to allow application to an array? If so, we would
add the complication of having it potentially set differently on the
element and the array as a whole.]
4.7.6.2 <events> Element Conditions
The condition element represents a condition that triggers a The condition element represents a condition that triggers a
notification. The list of conditions is: notification. The list of conditions is:
. <eventCreated/> the target must be an array, ending with a . <eventCreated/> the target must be an array, ending with a
subscript indication. The event is generated when an entry subscript indication. The event is generated when an entry in
in the array is created. This occurs even if the entry is the array is created. This occurs even if the entry is created
created by CE direction. by CE direction.
. <eventDeleted/> the target must be an array, ending with a . <eventDeleted/> the target must be an array, ending with a
subscript indication. The event is generated when an entry subscript indication. The event is generated when an entry in
in the array is destroyed. This occurs even if the entry is the array is destroyed. This occurs even if the entry is
destroyed by CE direction. destroyed by CE direction.
. <eventChanged/> the event is generated whenever the target . <eventChanged/> the event is generated whenever the target
element changes in any way, subject to hysteresis suppression element changes in any way. For binary attributes such as
for integer targets. The hysteresis suppression level is up/down, this reflects a change in state. It can also be used
part of the properties of the event. with numeric attributes, in which case any change in value
. <eventGreaterThan/> the event is generated whenever the results in a detected trigger.
target element becomes greater than the threshold, subject to . <eventGreaterThan/> the event is generated whenever the target
hysteresis suppression. The threshold and hysteresis element becomes greater than the threshold. The threshold is
suppression are part of the properties of the event. an event property.
. <eventLessThan/> the event is generated whenever the target . <eventLessThan/> the event is generated whenever the target
element becomes less than the threshold, subject to element becomes less than the threshold. The threshold is an
hysteresis suppression. The threshold and hysteresis event property.
suppression are part of the properties of the event.
Numeric conditions will have hysteresis. The level of the
hysteresis is defined by a property of the event. This allows the
FE to notify the CE of the hysteresis applied, and if it chooses
the FE can allow the CE to modify the hysteresis. This applies to
<eventChanged/> for a numeric field, and to <eventGreaterThan/>
and <eventLessThan/>. The content of a <variance> element is a
numeric value. The FE is required to track the value of the
element and make sure that the condition has become untrue by at
least the hysteresis from the event property. To be specific, if
the hysteresis is V, then
. For a <eventChanged/> condition, if the last notification was As described in the Event Properties section, event items have
for value X, then the <changed/> notification will not be properties associated with them. These properties include the
generated until the value reaches X +/- V. subscription information (indicating whether the CE wishes the FE to
. For a <eventGreaterThan/> condition with threshold T, once generate event reports for the event at all, thresholds for events
the event has been generated at least once it will not be related to level crossing, and filtering conditions that may reduce
generated again until the field first becomes less than or the set of event notifications generated by the FE. Details of the
equal to T û V, and then exceeds T. filtering conditions that can be applied are given in that section.
. For a <eventLessThan/> condition with threshold T, once the The filtering conditions allow the FE to suppress floods of events
event has been generated at least once it will not be that could result from oscillation around a condition value. For FEs
generated again until the field first becomes greater than or that do not wish to support filtering, the filter properties can
equal to T + V, and then becomes less than T. either be read only or not supported.
This allows the FE to suppress floods of events resulting from 4.7.6.3 <eventReports> Element
oscillation around a condition value. For FEs that do not support
flood suppression, the hysteresis property will be set to 0, and
the property will be read only.
The <eventReports> element of an <event> describes what The <eventReports> element of an <event> describes the information
information is to be delivered by the FE along with the to be delivered by the FE along with the notification of the
notification of the occurance of the event. The <reports> element occurrence of the event. The <reports> element contains one or more
contains one or more <eventReport> elements. Each <report> <eventReport> elements. Each <report> element identifies a piece of
element identifies a piece of data from the LFB which will be data from the LFB to be reported. The notification carries that
reported. The notification carries as a DATARAW the data as if data as if the collection of <eventReport> elements had been defined
the collection of <eventReport> elements has been defined in a in a structure. Each <eventReport> element thus MUST identify a
structure. Each <eventReport> element thus needs to identify a
field in the LFB. The syntax is exactly the same as used in the field in the LFB. The syntax is exactly the same as used in the
<eventTarget> element, using <eventField> and <eventSubscript> <eventTarget> element, using <eventField> and <eventSubscript>
elements. <eventSubcripts> may contain integers. If they contain elements. <eventSubcripts> may contain integers. If they contain
names, they must be names from <eventSubscript> elements of the names, they MUST be names from <eventSubscript> elements of the
<eventTarget>. The selection for the report will use the value <eventTarget>. The selection for the report will use the value for
for that subscript that identifies that specific element the subscript that identifies that specific element triggering the
triggering the event. This can be used to reference the structure event. This can be used to reference the structure / field causing
/ field causing the event, or to reference related information in the event, or to reference related information in parallel tables.
parallel tables. This event reporting structure is designed to This event reporting structure is designed to allow the LFB designer
allow the LFB designer to specify information that is likely not to specify information that is likely not known a priori by the CE
known a priori by the CE and is likely needed by the CE to process and is likely needed by the CE to process the event. While the
the event. While the structure allows for pointing at large structure allows for pointing at large blocks of information (full
blocks of information (full arrays or complex structures) this is arrays or complex structures) this is not recommended. Also, the
not recommended. Also, the variable reference / subscripting in variable reference / subscripting in reporting only captures a small
reporting only captures a small portion of the kinds of related portion of the kinds of related information. Chaining through index
information. Chaining through index fields stored in a table, for fields stored in a table, for example, is not supported. In
example, is not supported. In general, the <eventReports> general, the <eventReports> mechanism is an optimization for cases
mechanism is an optimization for cases that have been found to be that have been found to be common, saving the CE from having to
common. query for information it needs to understand the event. It does not
represent all possible information needs.
If any elements referenced by the eventReport are optional, then the
report MUST support optional elements. Any components which do not
exist are not reported.
4.7.7. <description> Element for LFB Operational Specification 4.7.7. <description> Element for LFB Operational Specification
The <description> element of the <LFBClass> provides unstructured The <description> element of the <LFBClass> provides unstructured
text (in XML sense) to verbally describe what the LFB does. text (in XML sense) to verbally describe what the LFB does.
4.8.Properties 4.8.Properties
Elements of LFBs have properties which are important to the CE. Elements of LFBs have properties which are important to the CE. The
The most important property is the existence / readability / most important property is the existence / readability /
writeability of the element. Depending up the type of the writeability of the element. Depending up the type of the element,
element, other information may be of importance. other information may be of importance.
The model provides the definition of the structure of property The model provides the definition of the structure of property
information. There is a base class of property information. For information. There is a base class of property information. For
the array, alias, and event elements there are subclasses of the array, alias, and event elements there are subclasses of
property information providing additional fields. This property information providing additional fields. This information
information is accessed by the CE (and updated where applicable) is accessed by the CE (and updated where applicable) via the PL
via the PL protocol. While some property information is protocol. While some property information is writeable, there is no
writeable, there is no mechanism currently provided for checking mechanism currently provided for checking the properties of a
the properties of a property element. Writeability can only be property element. Writeability can only be checked by attempting to
checked by attempting to modify the value. modify the value.
4.8.1 Basic Properties
The basic property definition, along with the scalar for The basic property definition, along with the scalar for
accessibility is below. Note that this access permission accessibility is below. Note that this access permission
information is generally read-only. information is generally read-only.
<dataTypeDef> <dataTypeDef>
<name>accessPermissionValues</name> <name>accessPermissionValues</name>
<synopsis> <synopsis>
The possible values of attribute access permission The possible values of attribute access permission
</synopsis> </synopsis>
skipping to change at page 68, line 15 skipping to change at page 65, line 25
</specialValue> </specialValue>
<specialValue value="3"> <specialValue value="3">
<name>Read-Write</name> <name>Read-Write</name>
<synopsis> <synopsis>
The attribute may be read or written The attribute may be read or written
</synopsis> </synopsis>
</specialValue> </specialValue>
</specialValues> </specialValues>
</atomic> </atomic>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>baseElementProperties</name> <name>baseElementProperties</name>
<synopsis>basic properties, accessibility</synopsis> <synopsis>basic properties, accessibility</synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>accessibility</name> <name>accessibility</name>
<synopsis> <synopsis>
does the element exist, and can it be read or written does the element exist, and
can it be read or written
</synopsis> </synopsis>
<typeRef>accessPermissionValues</typeRef> <typeRef>accessPermissionValues</typeRef>
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
4.8.2 Array Properties
The properties for an array add a number of important pieces of The properties for an array add a number of important pieces of
information. These properties are also read-only. information. These properties are also read-only.
<dataTypeDef> <dataTypeDef>
<name>arrayElementProperties</name> <name>arrayElementProperties</name>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<element elementID=ö2ö> <element elementID=”2”>
<name>entryCount</name> <name>entryCount</name>
<synopsis>the number of entries in the array</synopsis> <synopsis>the number of entries in the array</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID=ö3ö> <element elementID=”3”>
<name>highestUsedSubscript</name> <name>highestUsedSubscript</name>
<synopsis>the last used subscript in the array</synopsis> <synopsis>the last used subscript in the array</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID=ö4ö> <element elementID=”4”>
<name>firstUnusedSubscript</name> <name>firstUnusedSubscript</name>
<synopsis> <synopsis>
The subscript of the first unused array element The subscript of the first unused array element
</synopsis> </synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
4.8.3 Event Properties
The properties for an event add three (usually) writeable fields. The properties for an event add three (usually) writeable fields.
One is the subscription field. 0 means no notification is One is the subscription field. 0 means no notification is
generated. Any non-zero value (typically 1 is used) means that a generated. Any non-zero value (typically 1 is used) means that a
notification is generated. The hysteresis field is used to notification is generated. The hysteresis field is used to suppress
suppress generation of notifications for oscillations around a generation of notifications for oscillations around a condition
condition value, and is described in the text for events. The value, and is described in the text for events. The threshold field
threshold field is used for the <eventGreaterThan/> and is used for the <eventGreaterThan/> and <eventLessThan/> conditions.
<eventLessThan/> conditions. It indicates the value to compare It indicates the value to compare the event target against. Using
the event target against. Using the properties allows the CE to the properties allows the CE to set the level of interest. FEs
set the level of interest. FEs which do not supporting setting which do not supporting setting the threshold for events will make
the threshold for events will make this field read-only. this field read-only.
<dataTypeDef> <dataTypeDef>
<name>eventElementProperties</name> <name>eventElementProperties</name>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<element elementID=ö2ö> <element elementID=”2”>
<name>registration</name> <name>registration</name>
<synopsis>has the CE registered to be notified of this <synopsis>
event has the CE registered to be notified of this event
</synopsis> </synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID=ö3ö> <element elementID=”3”>
<name>hysteresis</name> <name>threshold</name>
<synopsis> comparison value for level crossing events
</synopsis>
</optional
<typeRef>uint32</typeRef>
</element>
<element elementID=”4”>
<name>eventHysteresis</name>
<synopsis>region to suppress event recurrence notices <synopsis>region to suppress event recurrence notices
</synopsis> </synopsis>
</optional>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID=ö4ö> <element elementID=”5”>
<name>threshold</name> <name>eventCount</name>
<synopsis> comparison value for level crossing events <synopsis> number of occurrences to suppress
</synopsis>
</optional>
<typeRef>uint32</typeRef>
</element>
<element elementID=”6”>
<name>eventHysteresis</name>
<synopsis> time interval in ms between notifications
</synopsis> </synopsis>
</optional>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
</struct> </struct>
<dataTypeDef> <dataTypeDef>
4.8.3.1 Common Event Filtering
The event properties have values for controlling several filter
conditions. Support of these conditions is optional, but all
conditions SHOULD be supported. Events which are reliably known not
to be subject to rapid occurrence or other concerns may not support
all filter conditions.
Currently, three different filter condition variables are defined.
These are eventCount, eventInterval, and eventHysteris. Setting the
condition variables to 0 (their default value) means that the
condition is not checked.
Conceptually, when an event is triggered, all configured conditions
are checked. If no filter conditions are triggered, or if any
trigger conditions are met, the event notification is generated. If
there are filter conditions, and no condition is met, then no event
notification is generated. Event filter conditions have reset
behavior when an event notification is generated. If any condition
is passed, and the notification is generated, the the notification
reset behavior is performed on all conditions, even those which had
not passed. This provides a clean definition of the interaction of
the various event conditions.
An example of the interaction of conditions is an event with an
eventCount property set to 5 and an eventInterval property set to
500 milliseconds. Suppose that a burst of occurrences of this event
is detected by the FE. The first occurrence will cause a
notification to be sent to the CE. Then, if four more occurrences
are detected rapidly (less than 0.5 seconds) they will not result in
notifications. If two more occurrences are detected, then the
second of those will result in a notification. Alternatively, if
more than 500 miliseconds has passed since the notification and an
occurrence is detected, that will result in a notification. In
either case, the count and time interval suppression is reset no
matter which condition actually caused the notification.
4.8.3.2 Event Hysteresis Filtering
Events with numeric conditions can have hysteresis filters applied
to them. The hystersis level is defined by a property of the event.
This allows the FE to notify the CE of the hysteresis applied, and
if it chooses, the FE can allow the CE to modify the hysteresis.
This applies to <eventChanged/> for a numeric field, and to
<eventGreaterThan/> and <eventLessThan/>. The content of a
<variance> element is a numeric value. When supporting hysteresis,
the FE MUST track the value of the element and make sure that the
condition has become untrue by at least the hysteresis from the
event property. To be specific, if the hysteresis is V, then
. For a <eventChanged/> condition, if the last notification was
for value X, then the <changed/> notification MUST NOT be
generated until the value reaches X +/- V.
. For a <eventGreaterThan/> condition with threshold T, once the
event has been generated at least once it MUST NOT be generated
again until the field first becomes less than or equal to T –
V, and then exceeds T.
. For a <eventLessThan/> condition with threshold T, once the
event has been generate at least once it MUST NOT be generated
again until the field first becomes greater than or equal to T
+ V, and then becomes less than T.
4.8.3.3 Event Count Filtering
Events may have a count filtering condition. This property, if set
to a non-zero value, indicates the number of occurrences of the event
that should be considered redundant and not result in a notification.
Thus, if this property is set to 1, and no other conditions apply,
then every other detected occurrence of the event will result in a
notification. This particular meaning is chosen so that the value 1
has a distinct meaning from the value 0.
A conceptual implementation (not required) for this might be an
internal suppression counter. Whenever an event is triggered, the
counter is checked. If the counter is 0, a notification is
generated. Whether a notification is generated or not, the counter
is incremented. If the counter exceeds the configured value, it is
reset to 0. In this conceptual implementation the reset behavior
when a notification is generated can be thought of as setting the
counter to 1.
[Editor’s note: a better description of the conceptual algorithm is
sought.]
4.8.3.4 Event Time Filtering
Events may have a time filtering condition. This property
represents the minimum time interval (in the absence of some other
filtering condition being passed) between generating notifications of
detected events. This condition MUST only be passed if the time
since the last notification of the event is longer than the
configured interval in milliseconds.
Conceptually, this can be thought of as a stored timestamp which is
compared with the detection time, or as a timer that is running that
resets a suppression flag. In either case, if a notification is
generated due to passing any condition then the time interval
detection MUST be restarted.
4.8.4 Alias Properties
The properties for an alias add three (usually) writeable fields. The properties for an alias add three (usually) writeable fields.
These combine to identify the target element the subject alias These combine to identify the target element the subject alias
refers to. refers to.
<dataTypeDef> <dataTypeDef>
<name>aliasElementProperties</name> <name>aliasElementProperties</name>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<element elementID=ö2ö> <element elementID=”2”>
<name>targetLFBClass</name> <name>targetLFBClass</name>
<synopsis>the class ID of the alias target</synopsis> <synopsis>the class ID of the alias target</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID=ö3ö> <element elementID=”3”>
<name>targetLFBInstance</name> <name>targetLFBInstance</name>
<synopsis>the instance ID of the alias target</synopsis> <synopsis>the instand ID of the alias target</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID=ö4ö> <element elementID=”4”>
<name>targetElementPath</name> <name>targetElementPath</name>
<synopsis> <synopsis>
The path to the element target, each 4 octets is read the path to the element target
as one path element, using the path construction in each 4 octets is read as one path element,
the PL protocol. using the path construction in the PL protocol.
</synopsis> </synopsis>
<typeRef>octetstring[128]</typeRef> <typeRef>octetstring[128]</typeRef>
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
4.9. XML Schema for LFB Class Library Documents 4.9. XML Schema for LFB Class Library Documents
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
skipping to change at page 71, line 16 skipping to change at page 70, line 47
maxOccurs="unbounded"/> maxOccurs="unbounded"/>
<xsd:element name="frameDefs" type="frameDefsType" <xsd:element name="frameDefs" type="frameDefsType"
minOccurs="0"/> minOccurs="0"/>
<xsd:element name="dataTypeDefs" type="dataTypeDefsType" <xsd:element name="dataTypeDefs" type="dataTypeDefsType"
minOccurs="0"/> minOccurs="0"/>
<xsd:element name="metadataDefs" type="metadataDefsType" <xsd:element name="metadataDefs" type="metadataDefsType"
minOccurs="0"/> minOccurs="0"/>
<xsd:element name="LFBClassDefs" type="LFBClassDefsType" <xsd:element name="LFBClassDefs" type="LFBClassDefsType"
minOccurs="0"/> minOccurs="0"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="provides" type="xsd:Name" <xsd:attribute name="provides" type="xsd:Name" use="required"/>
use="required"/>
</xsd:complexType> </xsd:complexType>
<!-- Uniqueness constraints --> <!-- Uniqueness constraints -->
<xsd:key name="frame"> <xsd:key name="frame">
<xsd:selector xpath="lfb:frameDefs/lfb:frameDef"/> <xsd:selector xpath="lfb:frameDefs/lfb:frameDef"/>
<xsd:field xpath="lfb:name"/> <xsd:field xpath="lfb:name"/>
</xsd:key> </xsd:key>
<xsd:key name="dataType"> <xsd:key name="dataType">
<xsd:selector xpath="lfb:dataTypeDefs/lfb:dataTypeDef"/> <xsd:selector xpath="lfb:dataTypeDefs/lfb:dataTypeDef"/>
<xsd:field xpath="lfb:name"/> <xsd:field xpath="lfb:name"/>
</xsd:key> </xsd:key>
skipping to change at page 71, line 39 skipping to change at page 71, line 20
<xsd:selector xpath="lfb:metadataDefs/lfb:metadataDef"/> <xsd:selector xpath="lfb:metadataDefs/lfb:metadataDef"/>
<xsd:field xpath="lfb:name"/> <xsd:field xpath="lfb:name"/>
</xsd:key> </xsd:key>
<xsd:key name="LFBClassDef"> <xsd:key name="LFBClassDef">
<xsd:selector xpath="lfb:LFBClassDefs/lfb:LFBClassDef"/> <xsd:selector xpath="lfb:LFBClassDefs/lfb:LFBClassDef"/>
<xsd:field xpath="lfb:name"/> <xsd:field xpath="lfb:name"/>
</xsd:key> </xsd:key>
</xsd:element> </xsd:element>
<xsd:complexType name="loadType"> <xsd:complexType name="loadType">
<xsd:attribute name="library" type="xsd:Name" use="required"/> <xsd:attribute name="library" type="xsd:Name" use="required"/>
<xsd:attribute name="location" type="xsd:anyURI" <xsd:attribute name="location" type="xsd:anyURI" use="optional"/>
use="optional"/>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="frameDefsType"> <xsd:complexType name="frameDefsType">
<xsd:sequence> <xsd:sequence>
<xsd:element name="frameDef" maxOccurs="unbounded"> <xsd:element name="frameDef" maxOccurs="unbounded">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/> <xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/> <xsd:element ref="synopsis"/>
<xsd:element ref="description" minOccurs="0"/> <xsd:element ref="description" minOccurs="0"/>
</xsd:sequence> </xsd:sequence>
skipping to change at page 72, line 35 skipping to change at page 72, line 13
string[N], string, byte[N], boolean, octetstring[N] string[N], string, byte[N], boolean, octetstring[N]
float16, float32, float64 float16, float32, float64
--> -->
<xsd:group name="typeDeclarationGroup"> <xsd:group name="typeDeclarationGroup">
<xsd:choice> <xsd:choice>
<xsd:element name="typeRef" type="typeRefNMTOKEN"/> <xsd:element name="typeRef" type="typeRefNMTOKEN"/>
<xsd:element name="atomic" type="atomicType"/> <xsd:element name="atomic" type="atomicType"/>
<xsd:element name="array" type="arrayType"/> <xsd:element name="array" type="arrayType"/>
<xsd:element name="struct" type="structType"/> <xsd:element name="struct" type="structType"/>
<xsd:element name="union" type="structType"/> <xsd:element name="union" type="structType"/>
<xsd:element name=öaliasö type="typeRefNMTOKEN"/> <xsd:element name="alias" type="typeRefNMTOKEN"/>
</xsd:choice> </xsd:choice>
</xsd:group> </xsd:group>
<xsd:simpleType name="typeRefNMTOKEN"> <xsd:simpleType name="typeRefNMTOKEN">
<xsd:restriction base="xsd:token"> <xsd:restriction base="xsd:token">
<xsd:pattern value="\c+"/> <xsd:pattern value="\c+"/>
<xsd:pattern value="string\[\d+\]"/> <xsd:pattern value="string\[\d+\]"/>
<xsd:pattern value="byte\[\d+\]"/> <xsd:pattern value="byte\[\d+\]"/>
<xsd:pattern value="octetstring\[\d+\]"/> <xsd:pattern value="octetstring\[\d+\]"/>
</xsd:restriction> </xsd:restriction>
</xsd:simpleType> </xsd:simpleType>
skipping to change at page 73, line 36 skipping to change at page 73, line 12
<xsd:element ref="synopsis"/> <xsd:element ref="synopsis"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="value" type="xsd:token"/> <xsd:attribute name="value" type="xsd:token"/>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="arrayType"> <xsd:complexType name="arrayType">
<xsd:sequence> <xsd:sequence>
<xsd:group ref="typeDeclarationGroup"/> <xsd:group ref="typeDeclarationGroup"/>
<xsd:element name="contentKey" minOccurs="0 <xsd:element name="contentKey" minOccurs="0"
maxOccurs="unbounded"> maxOccurs="unbounded">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="contentKeyField" <xsd:element name="contentKeyField" maxOccurs="unbounded"
maxOccurs="unbounded"
type="xsd:string"/> type="xsd:string"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="contentKeyID" use="required" <xsd:attribute name="contentKeyID" use="required"
type="xsd:integer"/> type="xsd:integer"/>
</xsd:complexType> </xsd:complexType>
<!--declare keys to have unique IDs -->
<xsd:key name="contentKeyID">
<xsd:selector xpath="lfb:contentKey"/>
<xsd:field xpath="@contentKeyID"/>
</xsd:key>
</xsd:element> </xsd:element>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="type" use="optional" <xsd:attribute name="type" use="optional"
default="variable-size"> default="variable-size">
<xsd:simpleType> <xsd:simpleType>
<xsd:restriction base="xsd:string"> <xsd:restriction base="xsd:string">
<xsd:enumeration value="fixed-size"/> <xsd:enumeration value="fixed-size"/>
<xsd:enumeration value="variable-size"/> <xsd:enumeration value="variable-size"/>
</xsd:restriction> </xsd:restriction>
</xsd:simpleType> </xsd:simpleType>
</xsd:attribute> </xsd:attribute>
<xsd:attribute name="length" type="xsd:integer" use="optional"/> <xsd:attribute name="length" type="xsd:integer" use="optional"/>
<xsd:attribute name="maxLength" type="xsd:integer" <xsd:attribute name="maxLength" type="xsd:integer"
use="optional"/> use="optional"/>
<!--declare keys to have unique IDs -->
<xsd:key name="contentKeyID">
<xsd:selector xpath="lfb:contentKey"/>
<xsd:field xpath="@contentKeyID"/>
</xsd:key>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="structType"> <xsd:complexType name="structType">
<xsd:sequence> <xsd:sequence>
<xsd:element name=öderivedFromö type=ötypeRefNMTOKENö <xsd:element name="derivedFrom" type="typeRefNMTOKEN"
minOccurs=ö0ö/> minOccurs="0"/>
<xsd:element name="element" maxOccurs="unbounded"> <xsd:element name="element" maxOccurs="unbounded">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/> <xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/> <xsd:element ref="synopsis"/>
<xsd:element name="optional" minOccurs="0"/> <xsd:element name="optional" minOccurs="0"/>
<xsd:group ref="typeDeclarationGroup"/> <xsd:group ref="typeDeclarationGroup"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="elementID" use="required" <xsd:attribute name="elementID" use="required"
type="xsd:integer"/> type="xsd:integer"/>
</xsd:complexType> </xsd:complexType>
</xsd:element> <!-- key declaration to make elementIDs unique in a struct
</xsd:sequence> -->
<!-- key declaration to make elementIDs unique in a struct -->
<xsd:key name="structElementID"> <xsd:key name="structElementID">
<xsd:selector xpath="lfb:element"/> <xsd:selector xpath="lfb:element"/>
<xsd:field xpath="@elementID"/> <xsd:field xpath="@elementID"/>
</xsd:key> </xsd:key>
</xsd:element>
</xsd:sequence>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="metadataDefsType"> <xsd:complexType name="metadataDefsType">
<xsd:sequence> <xsd:sequence>
<xsd:element name="metadataDef" maxOccurs="unbounded"> <xsd:element name="metadataDef" maxOccurs="unbounded">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/> <xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/> <xsd:element ref="synopsis"/>
<xsd:element name="metadataID" type="xsd:integer"/>
<xsd:element ref="description" minOccurs="0"/> <xsd:element ref="description" minOccurs="0"/>
<xsd:choice> <xsd:choice>
<xsd:element name="typeRef" type="typeRefNMTOKEN"/> <xsd:element name="typeRef" type="typeRefNMTOKEN"/>
<xsd:element name="atomic" type="atomicType"/> <xsd:element name="atomic" type="atomicType"/>
</xsd:choice> </xsd:choice>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
skipping to change at page 76, line 4 skipping to change at page 75, line 24
<xsd:key name="attributes"> <xsd:key name="attributes">
<xsd:selector xpath="lfb:attributes/lfb:attribute"/> <xsd:selector xpath="lfb:attributes/lfb:attribute"/>
<xsd:field xpath="lfb:name"/> <xsd:field xpath="lfb:name"/>
</xsd:key> </xsd:key>
<xsd:key name="capabilities"> <xsd:key name="capabilities">
<xsd:selector xpath="lfb:capabilities/lfb:capability"/> <xsd:selector xpath="lfb:capabilities/lfb:capability"/>
<xsd:field xpath="lfb:name"/> <xsd:field xpath="lfb:name"/>
</xsd:key> </xsd:key>
<!-- does the above ensure that attributes and capabilities <!-- does the above ensure that attributes and capabilities
have different names? have different names?
If so, the following is the elementID constraint --> If so, the following is the elementID constraint
-->
<xsd:key name="attributeIDs"> <xsd:key name="attributeIDs">
<xsd:selector xpath="lfb:attributes/lfb:attribute"/> <xsd:selector xpath="lfb:attributes/lfb:attribute"/>
<xsd:field xpath="@elementID"/> <xsd:field xpath="@elementID"/>
</xsd:key> </xsd:key>
<xsd:key name="capabilityIDs"> <xsd:key name="capabilityIDs">
<xsd:selector xpath="lfb:attributes/lfb:capability"/> <xsd:selector xpath="lfb:attributes/lfb:capability"/>
<xsd:field xpath="@elementID"/> <xsd:field xpath="@elementID"/>
</xsd:key> </xsd:key>
</xsd:element> </xsd:element>
</xsd:sequence> </xsd:sequence>
skipping to change at page 76, line 42 skipping to change at page 76, line 14
<xsd:element ref="description" minOccurs="0"/> <xsd:element ref="description" minOccurs="0"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="group" type="booleanType" use="optional" <xsd:attribute name="group" type="booleanType" use="optional"
default="no"/> default="no"/>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="portExpectationType"> <xsd:complexType name="portExpectationType">
<xsd:sequence> <xsd:sequence>
<xsd:element name="frameExpected" minOccurs="0"> <xsd:element name="frameExpected" minOccurs="0">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<!-- ref must refer to a name of a defined frame type -- <!-- ref must refer to a name of a defined frame type -->
>
<xsd:element name="ref" type="xsd:string" <xsd:element name="ref" type="xsd:string"
maxOccurs="unbounded"/> maxOccurs="unbounded"/>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
<xsd:element name="metadataExpected" minOccurs="0"> <xsd:element name="metadataExpected" minOccurs="0">
<xsd:complexType> <xsd:complexType>
<xsd:choice maxOccurs="unbounded"> <xsd:choice maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata --> <!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="metadataInputRefType"/> <xsd:element name="ref" type="metadataInputRefType"/>
skipping to change at page 78, line 20 skipping to change at page 77, line 36
<xsd:element ref="description" minOccurs="0"/> <xsd:element ref="description" minOccurs="0"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="group" type="booleanType" use="optional" <xsd:attribute name="group" type="booleanType" use="optional"
default="no"/> default="no"/>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="portProductType"> <xsd:complexType name="portProductType">
<xsd:sequence> <xsd:sequence>
<xsd:element name="frameProduced"> <xsd:element name="frameProduced">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<!-- ref must refer to a name of a defined frame type -- <!-- ref must refer to a name of a defined frame type
> -->
<xsd:element name="ref" type="xsd:NMTOKEN" <xsd:element name="ref" type="xsd:NMTOKEN"
maxOccurs="unbounded"/> maxOccurs="unbounded"/>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
<xsd:element name="metadataProduced" minOccurs="0"> <xsd:element name="metadataProduced" minOccurs="0">
<xsd:complexType> <xsd:complexType>
<xsd:choice maxOccurs="unbounded"> <xsd:choice maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata --> <!-- ref must refer to a name of a defined metadata
-->
<xsd:element name="ref" type="metadataOutputRefType"/> <xsd:element name="ref" type="metadataOutputRefType"/>
<xsd:element name="one-of" <xsd:element name="one-of"
type="metadataOutputChoiceType"/> type="metadataOutputChoiceType"/>
</xsd:choice> </xsd:choice>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="metadataOutputChoiceType"> <xsd:complexType name="metadataOutputChoiceType">
<xsd:choice minOccurs="2" maxOccurs="unbounded"> <xsd:choice minOccurs="2" maxOccurs="unbounded">
skipping to change at page 81, line 33 skipping to change at page 80, line 44
<xsd:element name="eventSubscript" type="xsd:string" <xsd:element name="eventSubscript" type="xsd:string"
substitutionGroup="eventPathPart"/> substitutionGroup="eventPathPart"/>
<xsd:complexType name="eventReportsType"> <xsd:complexType name="eventReportsType">
<xsd:sequence> <xsd:sequence>
<xsd:element name="eventReport" type="eventPathType" <xsd:element name="eventReport" type="eventPathType"
maxOccurs="unbounded"/> maxOccurs="unbounded"/>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
<xsd:simpleType name="booleanType"> <xsd:simpleType name="booleanType">
<xsd:restriction base="xsd:string"> <xsd:restriction base="xsd:string">
<xsd:enumeration value="yes"/> <xsd:enumeration value="0"/>
<xsd:enumeration value="no"/> <xsd:enumeration value="1"/>
</xsd:restriction> </xsd:restriction>
</xsd:simpleType> </xsd:simpleType>
</xsd:schema> </xsd:schema>
5. FE Attributes and Capabilities
5.
FE Attributes and Capabilities
A ForCES forwarding element handles traffic on behalf of a ForCES A ForCES forwarding element handles traffic on behalf of a ForCES
control element. While the standards will describe the protocol control element. While the standards will describe the protocol and
and mechanisms for this control, different implementations and mechanisms for this control, different implementations and different
different instances will have different capabilities. The CE instances will have different capabilities. The CE MUST be able to
needs to be able to determine what each instance it is responsible determine what each instance it is responsible for is actually
for is actually capable of doing. As stated previously, this is capable of doing. As stated previously, this is an approximation.
an approximation. The CE is expected to be prepared to cope with The CE is expected to be prepared to cope with errors in requests
errors in requests and variations in detail not captured by the and variations in detail not captured by the capabilities
capabilities information about an FE. information about an FE.
In addition to its capabilities, an FE will have attribute In addition to its capabilities, an FE will have attribute
information that can be used in understanding and controlling the information that can be used in understanding and controlling the
forwarding operations. Some of the attributes will be read only, forwarding operations. Some of the attributes will be read only,
while others will also be writeable. while others will also be writeable.
In order to make the FE attribute information easily accessible, In order to make the FE attribute information easily accessible, the
the information will be stored in an LFB. This LFB will have a information will be stored in an LFB. This LFB will have a class,
class, FEObject. The LFBClassID for this class is 1. Only one FEObject. The LFBClassID for this class is 1. Only one instance of
instance of this class will ever be present, and the instance ID this class will ever be present, and the instance ID of that
of that instance in the protocol is 1. Thus, by referencing the instance in the protocol is 1. Thus, by referencing the elements of
elements of class:1, instance:1 a CE can get all the information class:1, instance:1 a CE can get all the information about the FE.
about the FE. For model completeness, this LFB Class is described For model completeness, this LFB Class is described in this section.
in this section.
There will also be an FEProtocol LFB Class. LFBClassID 2 is There will also be an FEProtocol LFB Class. LFBClassID 2 is
reserved for that class. There will be only one instance of that reserved for that class. There will be only one instance of that
class as well. Details of that class are defined in the ForCES class as well. Details of that class are defined in the ForCES
protocol document. protocol document.
5.1. XML for FEObject Class definition 5.1. XML for FEObject Class definition
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<LFBLibrary xmlns="http://ietf.org/forces/1.0/lfbmodel" <LFBLibrary xmlns="http://ietf.org/forces/1.0/lfbmodel"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://ietf.org/forces/1.0/lfbmodel" xsi:schemaLocation="http://ietf.org/forces/1.0/lfbmodel.xsd"
provides="FEObject"> provides="FEObject">
<!—xmlns and schemaLocation need to be fixed -->
<dataTypeDefs> <dataTypeDefs>
<dataTypeDef> <dataTypeDef>
<name>LFBAdjacencyLimitType</name> <name>LFBAdjacencyLimitType</name>
<synopsis>Describing the Adjacent LFB</synopsis> <synopsis>Describing the Adjacent LFB</synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>NeighborLFB</name> <name>NeighborLFB</name>
<synopsis>ID for that LFB Class</synopsis> <synopsis>ID for that LFB Class</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID="2"> <element elementID="2">
<name>ViaPorts</name> <name>ViaPorts</name>
<synopsis> <synopsis>
the ports on which we can connect the ports on which we can connect
</synopsis> </synopsis>
<array type="variable-size"> <array type="variable-size">
<typeRef>String</typeRef> <typeRef>string</typeRef>
</array> </array>
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>PortGroupLimitType</name> <name>PortGroupLimitType</name>
<synopsis> <synopsis>
Limits on the number of ports in a given group Limits on the number of ports in a given group
</synopsis> </synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>PortGroupName</name> <name>PortGroupName</name>
<synopsis>Group Name</synopsis> <synopsis>Group Name</synopsis>
<typeRef>String</typeRef> <typeRef>string</typeRef>
</element> </element>
<element elementID="2"> <element elementID="2">
<name>MinPortCount</name> <name>MinPortCount</name>
<synopsis>Minimum Port Count</synopsis> <synopsis>Minimum Port Count</synopsis>
<optional/> <optional/>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID="3"> <element elementID="3">
<name>MaxPortCount</name> <name>MaxPortCount</name>
<synopsis>Max Port Count</synopsis> <synopsis>Max Port Count</synopsis>
skipping to change at page 84, line 6 skipping to change at page 83, line 14
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID="3"> <element elementID="3">
<name>LFBOccurrenceLimit</name> <name>LFBOccurrenceLimit</name>
<synopsis> <synopsis>
the upper limit of instances of LFBs of this class the upper limit of instances of LFBs of this class
</synopsis> </synopsis>
<optional/> <optional/>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<!-- For each port group, how many ports can exist --> <!-- For each port group, how many ports can exist
-->
<element elementID="4"> <element elementID="4">
<name>PortGroupLimits</name> <name>PortGroupLimits</name>
<synopsis>Table of Port Group Limits</synopsis> <synopsis>Table of Port Group Limits</synopsis>
<optional/> <optional/>
<array type="variable-size"> <array type="variable-size">
<typeRef>PortGroupLimitType</typeRef> <typeRef>PortGroupLimitType</typeRef>
</array> </array>
</element> </element>
<!-- for the named LFB Class, the LFB Classes it may follow --> <!-- for the named LFB Class, the LFB Classes it may follow -->
<element elementID="5"> <element elementID="5">
skipping to change at page 85, line 10 skipping to change at page 84, line 17
<name> AdminDisable </name> <name> AdminDisable </name>
<synopsis> <synopsis>
FE is administratively disabled FE is administratively disabled
</synopsis> </synopsis>
</specialValue> </specialValue>
<specialValue value="1"> <specialValue value="1">
<name>OperDisable</name> <name>OperDisable</name>
<synopsis>FE is operatively disabled</synopsis> <synopsis>FE is operatively disabled</synopsis>
</specialValue> </specialValue>
<specialValue value="2"> <specialValue value="2">
<name> Operenable </name> <name>OperEnable</name>
<synopsis>FE is operating</synopsis> <synopsis>FE is operating</synopsis>
</specialValue> </specialValue>
</specialValues> </specialValues>
</atomic> </atomic>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>FEConfiguredNeighborType</name> <name>FEConfiguredNeighborType</name>
<synopsis>Details of the FE's Neighbor</synopsis> <synopsis>Details of the FE's Neighbor</synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>NeighborID</name> <name>NeighborID</name>
<synopsis>Neighbors FEID</synopsis> <synopsis>Neighbors FEID</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID="2"> <element elementID="2">
<name>interfaceToNeighbor</name> <name>InterfaceToNeighbor</name>
<synopsis> <synopsis>
FE's interface that connects to this neighbor FE's interface that connects to this neighbor
</synopsis> </synopsis>
<optional/> <optional/>
<typeRef>String</typeRef> <typeRef>string</typeRef>
</element> </element>
<element elementID="3"> <element elementID="3">
<name>neighborNetworkAddress</name> <name>NeighborNetworkAddress</name>
<synopsis>The network layer address of the neighbor <synopsis>
The network layer address of the neighbor.
Presumably, the network type can be Presumably, the network type can be
determined from the interface information determined from the interface information.
</synopsis> </synopsis>
<typeRef>OctetSting[16]</typeRef> <typeRef>octetsting[16]</typeRef>
</element> </element>
<element elementID="4"> <element elementID="4">
<name>neighborMACAdddress</name> <name>NeighborMACAddress</name>
<synopsis>the media access control address of <synopsis>
the neighbor. Again, it is presumed The media access control address of the neighbor.
the type can be determined
from the interface information Again, it is presumed the type can be determined
from the interface information.
</synopsis> </synopsis>
<typeRef>octetstring[8]</typeRef> <typeRef>octetstring[8]</typeRef>
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>LFBSelectorType</name> <name>LFBSelectorType</name>
<synopsis> <synopsis>
Unique identification of a LFB class-instance Unique identification of an LFB class-instance
</synopsis> </synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>LFBClassID</name> <name>LFBClassID</name>
<synopsis>LFB Class Identifier</synopsis> <synopsis>LFB Class Identifier</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID="2"> <element elementID="2">
<name>LFBInstanceID</name> <name>LFBInstanceID</name>
<synopsis>LFB Instance ID</synopsis> <synopsis>LFB Instance ID</synopsis>
skipping to change at page 86, line 32 skipping to change at page 85, line 39
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>LFBLinkType</name> <name>LFBLinkType</name>
<synopsis> <synopsis>
Link between two LFB instances of topology Link between two LFB instances of topology
</synopsis> </synopsis>
<struct> <struct>
<element elementID="1"> <element elementID="1">
<name>FromLFBID</name> <name>FromLFBID</name>
<synopsis>LFB src</synopsis> <synopsis>LFB src</synopsis>
<typeRef>LFBSelector</typeRef> <typeRef>LFBSelectorType</typeRef>
</element> </element>
<element elementID="2"> <element elementID="2">
<name>FromPortGroup</name> <name>FromPortGroup</name>
<synopsis>src port group</synopsis> <synopsis>src port group</synopsis>
<typeRef>String</typeRef> <typeRef>string</typeRef>
</element> </element>
<element elementID="3"> <element elementID="3">
<name>FromPortIndex</name> <name>FromPortIndex</name>
<synopsis>src port index</synopsis> <synopsis>src port index</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
<element elementID="4"> <element elementID="4">
<name>ToLFBID</name> <name>ToLFBID</name>
<synopsis>dst LFBID</synopsis> <synopsis>dst LFBID</synopsis>
<typeRef>LFBSelector</typeRef> <typeRef>LFBSelectorType</typeRef>
</element> </element>
<element elementID="5"> <element elementID="5">
<name>ToPortGroup</name> <name>ToPortGroup</name>
<synopsis>dst port group</synopsis> <synopsis>dst port group</synopsis>
<typeRef>String</typeRef> <typeRef>string</typeRef>
</element> </element>
<element elementID="6"> <element elementID="6">
<name>ToPortIndex</name> <name>ToPortIndex</name>
<synopsis>dst port index</synopsis> <synopsis>dst port index</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</element> </element>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
</dataTypeDefs> </dataTypeDefs>
<LFBClassDefs> <LFBClassDefs>
<LFBClassDef LFBClassID="1"> <LFBClassDef LFBClassID="1">
<name>FEObject</name> <name>FEObject</name>
<synopsis>Core LFB: FE Object</synopsis> <synopsis>Core LFB: FE Object</synopsis>
<version>1.0<version/> <version>1.0</version>
<attributes> <attributes>
<attribute access="read-write" elementID="1"> <attribute access="read-write" elementID="1">
<name>LFBTopology</name> <name>LFBTopology</name>
<synopsis>the table of known Topologies</synopsis> <synopsis>the table of known Topologies</synopsis>
<array type="variable-size"> <array type="variable-size">
<typeRef>LFBLinkType</typeRef> <typeRef>LFBLinkType</typeRef>
</array> </array>
</attribute> </attribute>
<attribute access="read-write" elementID="2"> <attribute access="read-write" elementID="2">
<name>LFBSelectors</name> <name>LFBSelectors</name>
skipping to change at page 88, line 49 skipping to change at page 87, line 51
</array> </array>
</capability> </capability>
</capabilities> </capabilities>
</LFBClassDef> </LFBClassDef>
</LFBClassDefs> </LFBClassDefs>
</LFBLibrary> </LFBLibrary>
5.2. FE Capabilities 5.2. FE Capabilities
The FE Capability information is contained in the capabilities The FE Capability information is contained in the capabilities
element of the class definition. As described elsewhere, element of the class definition. As described elsewhere, capability
capability information is always considered to be read-only. information is always considered to be read-only.
The currently defined capabilities are ModifiableLFBTopology and The currently defined capabilities are ModifiableLFBTopology and
SupportedLFBs. Information as to which attributes of the FE LFB SupportedLFBs. Information as to which attributes of the FE LFB are
are supported is contained in the properties information for those supported is accessed by the properties information for those
elements. elements.
5.2.1. ModifiableLFBTopology 5.2.1. ModifiableLFBTopology
This element has a boolean value that indicates whether the LFB This element has a boolean value that indicates whether the LFB
topology of the FE may be changed by the CE. If the element is topology of the FE may be changed by the CE. If the element is
absent, the default value is assumed to be true, and the CE absent, the default value is assumed to be true, and the CE presumes
presumes the LFB topology may be changed. If the value is present the LFB topology may be changed. If the value is present and set to
and set to false, the LFB topology of the FE is fixed. If the false, the LFB topology of the FE is fixed. If the topology is
topology is fixed, the LFBs supported clause may be omitted, and fixed, the LFBs supported clause may be omitted, and the list of
the list of supported LFBs is inferred by the CE from the LFB supported LFBs is inferred by the CE from the LFB topology
topology information. If the list of supported LFBs is provided information. If the list of supported LFBs is provided when
when ModifiableLFBTopology is false, the CanOccurBefore and ModifiableLFBTopology is false, the CanOccurBefore and CanOccurAfter
CanOccurAfter information should be omitted. information should be omitted.
5.2.2. SupportedLFBs and SupportedLFBType 5.2.2. SupportedLFBs and SupportedLFBType
One capability that the FE should include is the list of supported One capability that the FE should include is the list of supported
LFB classes. The SupportedLFBs element, is an array that contains LFB classes. The SupportedLFBs element, is an array that contains
the information about each supported LFB Class. The array the information about each supported LFB Class. The array structure
structure type is defined as the SupportedLFBType dataTypeDef. type is defined as the SupportedLFBType dataTypeDef.
Each occurrence of the SupportedLFBs array element describes an Each occurrence of the SupportedLFBs array element describes an LFB
LFB class that the FE supports. In addition to indicating that class that the FE supports. In addition to indicating that the FE
the FE supports the class, FEs with modifiable LFB topology should supports the class, FEs with modifiable LFB topology should include
include information about how LFBs of the specified class may be information about how LFBs of the specified class may be connected
connected to other LFBs. This information should describe which to other LFBs. This information should describe which LFB classes
LFB classes the specified LFB class may succeed or precede in the the specified LFB class may succeed or precede in the LFB topology.
LFB topology. The FE should include information as to which port The FE should include information as to which port groups may be
groups may be connected to the given adjacent LFB class. If port connected to the given adjacent LFB class. If port group
group information is omitted, it is assumed that all port groups information is omitted, it is assumed that all port groups may be
may be used. used.
5.2.2.1. LFBName 5.2.2.1. LFBName
This element has as its value the name of the LFB being described. This element has as its value the name of the LFB being described.
5.2.2.2. LFBOccurrenceLimit 5.2.2.2. LFBOccurrenceLimit
This element, if present, indicates the largest number of This element, if present, indicates the largest number of instances
instances of this LFB class the FE can support. For FEs that do of this LFB class the FE can support. For FEs that do not have the
not have the capability to create or destroy LFB instances, this capability to create or destroy LFB instances, this can either be
can either be omitted or be the same as the number of LFB omitted or be the same as the number of LFB instances of this class
instances of this class contained in the LFB list attribute. contained in the LFB list attribute.
5.2.2.3. PortGroupLimits and PortGroupLimitType 5.2.2.3. PortGroupLimits and PortGroupLimitType
The PortGroupLimits element is an array of information about the The PortGroupLimits element is an array of information about the
port groups supported by the LFB class. The structure of the port port groups supported by the LFB class. The structure of the port
group limit information is defined by the PortGroupLimitType group limit information is defined by the PortGroupLimitType
dataTypeDef. dataTypeDef.
Each PortGroupLimits array element contains information describing Each PortGroupLimits array element contains information describing a
a single port group of the LFB class. Each array element contains single port group of the LFB class. Each array element contains the
the name of the port group in the PortGroupName element, the name of the port group in the PortGroupName element, the fewest
fewest number of ports that can exist in the group in the number of ports that can exist in the group in the MinPortCount
MinPortCount element, and the largest number of ports that can element, and the largest number of ports that can exist in the group
exist in the group in the MaxPortCount element. in the MaxPortCount element.
5.2.2.4.CanOccurAfters and LFBAdjacencyLimitType 5.2.2.4.CanOccurAfters and LFBAdjacencyLimitType
The CanOccurAfters element is an array that contains the list of The CanOccurAfters element is an array that contains the list of
LFBs the described class can occur after. The array elements are LFBs the described class can occur after. The array elements are
defined in the LFBAdjacencyLimitType dataTypeDef. defined in the LFBAdjacencyLimitType dataTypeDef.
The array elements describe a permissible positioning of the The array elements describe a permissible positioning of the
described LFB class, referred to here as the SupportedLFB. described LFB class, referred to here as the SupportedLFB.
Specifically, each array element names an LFB that can Specifically, each array element names an LFB that can topologically
topologically precede that LFB class. That is, the SupportedLFB precede that LFB class. That is, the SupportedLFB can have an input
can have an input port connected to an output port of an LFB that port connected to an output port of an LFB that appears in the
appears in the CanOccurAfters array. The LFB class that the CanOccurAfters array. The LFB class that the SupportedLFB can
SupportedLFB can follow is identified by the NeighborLFB element follow is identified by the NeighborLFB element of the
of the LFBAdjacencyLimitType array element. If this neighbor can LFBAdjacencyLimitType array element. If this neighbor can only be
only be connected to a specific set of input port groups, then the connected to a specific set of input port groups, then the viaPort
viaPort element is included. This element occurs once for each element is included. This element occurs once for each input port
input port group of the SupportedLFB that can be connected to an group of the SupportedLFB that can be connected to an output port of
output port of the NeighborLFB. the NeighborLFB.
[e.g., Within a SupportedLFBs element, each array element of the [e.g., Within a SupportedLFBs element, each array element of the
CanOccurAfters array must have a unique NeighborLFB, and within CanOccurAfters array must have a unique NeighborLFB, and within each
each array element each viaPort must represent a distinct and array element each viaPort must represent a distinct and valid input
valid input port group of the SupportedLFB. The LFB Class port group of the SupportedLFB. The LFB Class definition schema
definition schema does not yet support uniqueness declarations] does not yet support uniqueness declarations]
5.2.2.5. CanOccurBefores and LFBAdjacencyLimitType 5.2.2.5. CanOccurBefores and LFBAdjacencyLimitType
The CanOccurBefores array holds the information about which LFB The CanOccurBefores array holds the information about which LFB
classes can follow the described class. Structurally this element classes can follow the described class. Structurally this element
parallels CanOccurAfters, and uses the same type definition for parallels CanOccurAfters, and uses the same type definition for the
the array element. array element.
The array elements list those LFB classes that the SupportedLFB The array elements list those LFB classes that the SupportedLFB may
may precede in the topology. In this element, the precede in the topology. In this element, the
viaPort element of the array value represents the output port viaPort element of the array value represents the output port group
group of the SupportedLFB that may be connected to the of the SupportedLFB that may be connected to the NeighborLFB. As
NeighborLFB. As with CanOccurAfters, viaPort may occur multiple with CanOccurAfters, viaPort may occur multiple times if multiple
times if multiple output ports may legitimately connect to the output ports may legitimately connect to the given NeighborLFB
given NeighborLFB class. class.
[And a similar set of uniqueness constraints apply to the [And a similar set of uniqueness constraints apply to the
CanOccurBefore clauses, even though an LFB may occur both in CanOccurBefore clauses, even though an LFB may occur both in
CanOccurAfter and CanOccurBefore.] CanOccurAfter and CanOccurBefore.]
5.2.2.6. LFBClassCapabilities 5.2.2.6. LFBClassCapabilities
This element contains capability information about the subject LFB This element contains capability information about the subject LFB
class whose structure and semantics are defined by the LFB class class whose structure and semantics are defined by the LFB class
definition. definition.
[Note: Important Omissions] [Note: Important Omissions]
However, this element does not appear in the definition, because However, this element does not appear in the definition, because the
the author can not figure out how to write it. author can not figure out how to write it.
5.3. FEAttributes 5.3. FEAttributes
The attributes element is included if the class definition The attributes element is included if the class definition contains
contains the attributes of the FE that are not considered the attributes of the FE that are not considered "capabilities".
"capabilities". Some of these attributes are writeable, and some Some of these attributes are writeable, and some are read-only,
are read-only, which should be indicated by the capability which should be indicated by the capability information.
information.
[Editors note - At the moment, the set of attributes is woefully [Editors note - At the moment, the set of attributes is woefully
incomplete.] incomplete.]
5.3.1. FEStatus 5.3.1. FEStatus
This attribute carries the overall state of the FE. For now, it This attribute carries the overall state of the FE. For now, it is
is restricted to the strings AdminDisable, OperDisable and restricted to the strings AdminDisable, OperDisable and OperEnable.
OperEnable.
5.3.2. LFBSelectors and LFBSelectorType 5.3.2. LFBSelectors and LFBSelectorType
The LFBSelectors element is an array of information about the LFBs The LFBSelectors element is an array of information about the LFBs
currently accessible via ForCES in the FE. The structure of the currently accessible via ForCES in the FE. The structure of the LFB
LFB information is defined by the LFBSelectorType. information is defined by the LFBSelectorType.
Each entry in the array describes a single LFB instance in the FE. Each entry in the array describes a single LFB instance in the FE.
The array element contains the numeric class ID of the class of The array element contains the numeric class ID of the class of the
the LFB instance and the numeric instance ID for this instance. LFB instance and the numeric instance ID for this instance.
5.3.3. LFBTopology and LFBLinkType 5.3.3. LFBTopology and LFBLinkType
The optional LFBTopology element contains information about each The optional LFBTopology element contains information about each
inter-LFB link inside the FE, where each link is described in an inter-LFB link inside the FE, where each link is described in an
LFBLinkType element. The LFBLinkType element contains sufficient LFBLinkType element. The LFBLinkType element contains sufficient
information to identify precisely the end points of a link. The information to identify precisely the end points of a link. The
FromLFBID and ToLFBID fields specify the LFB instances at each end FromLFBID and ToLFBID fields specify the LFB instances at each end
of the link, and must reference LFBs in the LFB instance table. of the link, and must reference LFBs in the LFB instance table. The
The FromPortGroup and ToPortGroup must identify output and input FromPortGroup and ToPortGroup must identify output and input port
port groups defined in the LFB classes of the LFB instances groups defined in the LFB classes of the LFB instances identified by
identified by FromLFBID and ToLFBID. The FromPortIndex and FromLFBID and ToLFBID. The FromPortIndex and ToPortIndex fields
ToPortIndex fields select the elements from the port groups that select the elements from the port groups that this link connects.
this link connects. All links are uniquely identified by the All links are uniquely identified by the FromLFBID, FromPortGroup,
FromLFBID, FromPortGroup, and FromPortIndex fields. Multiple and FromPortIndex fields. Multiple links may have the same ToLFBID,
links may have the same ToLFBID, ToPortGroup, and ToPortIndex as ToPortGroup, and ToPortIndex as this model supports fan in of inter-
this model supports fan in of inter-LFB links but not fan out. LFB links but not fan out.
5.3.4. FENeighbors an FEConfiguredNeighborType 5.3.4. FENeighbors an FEConfiguredNeighborType
The FENeighbors element is an array of information about manually The FENeighbors element is an array of information about manually
configured adjacencies between this FE and other FEs. The content configured adjacencies between this FE and other FEs. The content
of the array is defined by the FEConfiguredNeighborType element. of the array is defined by the FEConfiguredNeighborType element.
This array is intended to capture information that may be This array is intended to capture information that may be configured
configured on the FE and is needed by the CE, where one array on the FE and is needed by the CE, where one array entry corresponds
entry corresponds to each configured neighbor. Note that this to each configured neighbor. Note that this array is not intended
array is not intended to represent the results of any discovery to represent the results of any discovery protocols, as those will
protocols, as those will have their own LFBs. have their own LFBs.
Similarly, the MAC address information in the table is intended to Similarly, the MAC address information in the table is intended to
be used in situations where neighbors are configured by MAC be used in situations where neighbors are configured by MAC address.
address. Resolution of network layer to MAC address information Resolution of network layer to MAC address information should be
should be captured in ARP LFBs and not duplicated in this table. captured in ARP LFBs and not duplicated in this table. Note that
Note that the same neighbor may be reached through multiple the same neighbor may be reached through multiple interfaces or at
interfaces or at multiple addresses. There is no uniqueness multiple addresses. There is no uniqueness requirement of any sort
requirement of any sort on occurrences of the FENeighbors element. on occurrences of the FENeighbors element.
Information about the intended forms of exchange with a given Information about the intended forms of exchange with a given
neighbor is not captured here, only the adjacency information is neighbor is not captured here, only the adjacency information is
included. included.
5.3.4.1.NeighborID 5.3.4.1.NeighborID
This is the ID in some space meaningful to the CE for the This is the ID in some space meaningful to the CE for the neighbor.
neighbor. If this table remains, we probably should add an FEID If this table remains, we probably should add an FEID from the same
from the same space as an attribute of the FE. space as an attribute of the FE.
5.3.4.2.NeighborInterface 5.3.4.2.NeighborInterface
This identifies the interface through which the neighbor is This identifies the interface through which the neighbor is reached.
reached.
[Editors note: As the port structures become better defined, the [Editors note: As the port structures become better defined, the
type for this should be filled in with the types necessary to type for this should be filled in with the types necessary to
reference the various possible neighbor interfaces, include reference the various possible neighbor interfaces, include physical
physical interfaces, logical tunnels, virtual circuits, etc.] interfaces, logical tunnels, virtual circuits, etc.]
5.3.4.3. NeighborNetworkAddress 5.3.4.3. NeighborNetworkAddress
Neighbor configuration is frequently done on the basis of a Neighbor configuration is frequently done on the basis of a network
network layer address. For neighbors configured in that fashion, layer address. For neighbors configured in that fashion, this is
this is where that address is stored. where that address is stored.
5.3.4.4.NeighborMacAddress 5.3.4.4.NeighborMacAddress
Neighbors are sometimes configured using MAC level addresses Neighbors are sometimes configured using MAC level addresses
(Ethernet MAC address, circuit identifiers, etc.) If such (Ethernet MAC address, circuit identifiers, etc.) If such addresses
addresses are used to configure the adjacency, then that are used to configure the adjacency, then that information is stored
information is stored here. Note that over some ports such as here. Note that over some ports such as physical point to point
physical point to point links or virtual circuits considered as links or virtual circuits considered as individual interfaces, there
individual interfaces, there is no need for either form of is no need for either form of address.
address.
6. 6. Satisfying the Requirements on FE Model
Satisfying the Requirements on FE Model
This section describes how the proposed FE model meets the This section describes how the proposed FE model meets the
requirements outlined in Section 5 of RFC 3654 [1]. The requirements outlined in Section 5 of RFC 3654 [1]. The
requirements can be separated into general requirements (Sections requirements can be separated into general requirements (Sections 5,
5, 5.1 - 5.4) and the specification of the minimal set of logical 5.1 - 5.4) and the specification of the minimal set of logical
functions that the FE model must support (Section 5.5). functions that the FE model must support (Section 5.5).
The general requirement on the FE model is that it be able to The general requirement on the FE model is that it be able to
express the logical packet processing capability of the FE, express the logical packet processing capability of the FE, through
through both a capability and a state model. In addition, the FE both a capability and a state model. In addition, the FE model is
model is expected to allow flexible implementations and be expected to allow flexible implementations and be extensible to
extensible to allow defining new logical functions. allow defining new logical functions.
A major component of the proposed FE model is the Logical A major component of the proposed FE model is the Logical Function
Function Block (LFB) model. Each distinct logical function in an Block (LFB) model. Each distinct logical function in an FE is
FE is modeled as an LFB. Operational parameters of the LFB that modeled as an LFB. Operational parameters of the LFB that must be
must be visible to the CE are conceptualized as LFB attributes. visible to the CE are conceptualized as LFB attributes. These
These attributes express the capability of the FE and support attributes express the capability of the FE and support flexible
flexible implementations by allowing an FE to specify which implementations by allowing an FE to specify which optional features
optional features are supported. The attributes also indicate are supported. The attributes also indicate whether they are
whether they are configurable by the CE for an LFB class. configurable by the CE for an LFB class. Configurable attributes
Configurable attributes provide the CE some flexibility in provide the CE some flexibility in specifying the behavior of an
specifying the behavior of an LFB. When multiple LFBs belonging LFB. When multiple LFBs belonging to the same LFB class are
to the same LFB class are instantiated on an FE, each of those instantiated on an FE, each of those LFBs could be configured with
LFBs could be configured with different attribute settings. By different attribute settings. By querying the settings of the
querying the settings of the attributes for an instantiated LFB, attributes for an instantiated LFB, the CE can determine the state
the CE can determine the state of that LFB. of that LFB.
Instantiated LFBs are interconnected in a directed graph that Instantiated LFBs are interconnected in a directed graph that
describes the ordering of the functions within an FE. This describes the ordering of the functions within an FE. This directed
directed graph is described by the topology model. The graph is described by the topology model. The combination of the
combination of the attributes of the instantiated LFBs and the attributes of the instantiated LFBs and the topology describe the
topology describe the packet processing functions available on packet processing functions available on the FE (current state).
the FE (current state).
Another key component of the FE model is the FE attributes. The Another key component of the FE model is the FE attributes. The FE
FE attributes are used mainly to describe the capabilities of the attributes are used mainly to describe the capabilities of the FE,
FE, but they also convey information about the FE state. but they also convey information about the FE state.
The FE model also includes a definition of the minimal set of LFBs The FE model also includes a definition of the minimal set of LFBs
that is required by Section 5.5 of RFC 3564[1]. The sections that that is required by Section 5.5 of RFC 3564[1]. The sections that
follow provide more detail on the specifics of each of those LFBs. follow provide more detail on the specifics of each of those LFBs.
Note that the details of the LFBs are contained in a separate LFB Note that the details of the LFBs are contained in a separate LFB
Class Library document. [EDITOR - need to add a reference to that Class Library document. [EDITOR - need to add a reference to that
document]. document].
6.1. Port Functions 6.1. Port Functions
The FE model can be used to define a Port LFB class and its The FE model can be used to define a Port LFB class and its
technology-specific subclasses to map the physical port of the technology-specific subclasses to map the physical port of the
device to the LFB model with both static and configurable device to the LFB model with both static and configurable
attributes. The static attributes model the type of port, link attributes. The static attributes model the type of port, link
speed, etc. The configurable attributes model the addressing, speed, etc. The configurable attributes model the addressing,
administrative status, etc. administrative status, etc.
6.2. Forwarding Functions 6.2. Forwarding Functions
Because forwarding function is one of the most common and
important functions in the forwarding plane, it requires special Because forwarding function is one of the most common and important
attention in modeling to allow design flexibility, implementation functions in the forwarding plane, it requires special attention in
efficiency, modeling accuracy and configuration simplicity. modeling to allow design flexibility, implementation efficiency,
Toward that end, it is recommended that the core forwarding modeling accuracy and configuration simplicity. Toward that end, it
function being modeled by the combination of two LFBs -- Longest is recommended that the core forwarding function being modeled by
Prefix Match (LPM) classifier LFB and Next Hop LFB. Special header the combination of two LFBs -- Longest Prefix Match (LPM) classifier
writer LFB is also needed to take care of TTL decrement and LFB and Next Hop LFB. Special header writer LFB is also needed to
checksum etc. take care of TTL decrement and checksum etc.
6.3. QoS Functions 6.3. QoS Functions
The LFB class library includes descriptions of the Meter, Queue , The LFB class library includes descriptions of the Meter, Queue ,
Scheduler, Counter and Dropper LFBs to support the QoS functions Scheduler, Counter and Dropper LFBs to support the QoS functions in
in the forwarding path. The FE model can also be used to define the forwarding path. The FE model can also be used to define other
other useful QoS functions as needed. These LFBs allow the CE to useful QoS functions as needed. These LFBs allow the CE to
manipulate the attributes to model IntServ or DiffServ functions. manipulate the attributes to model IntServ or DiffServ functions.
6.4. Generic Filtering Functions 6.4. Generic Filtering Functions
Various combinations of Classifier, Redirector, Meter and Dropper Various combinations of Classifier, Redirector, Meter and Dropper
LFBs can be used to model a complex set of filtering functions. LFBs can be used to model a complex set of filtering functions.
6.5. Vendor Specific Functions 6.5. Vendor Specific Functions
New LFB classes can be defined according to the LFB model as New LFB classes can be defined according to the LFB model as
described in Section 4 to support vendor specific functions. A described in Section 4 to support vendor specific functions. A new
new LFB class can also be derived from an existing LFB class LFB class can also be derived from an existing LFB class through
through inheritance. inheritance.
6.6.High-Touch Functions 6.6.High-Touch Functions
High-touch functions are those that take action on the contents or High-touch functions are those that take action on the contents or
headers of a packet based on content other than what is found in headers of a packet based on content other than what is found in the
the IP header. Examples of such functions include NAT, ALG, IP header. Examples of such functions include NAT, ALG, firewall,
firewall, tunneling and L7 content recognition. It is not tunneling and L7 content recognition. It is not practical to
practical to include all possible high-touch functions in the include all possible high-touch functions in the initial LFB library
initial LFB library due to the number and complexity. However, the due to the number and complexity. However, the flexibility of the
flexibility of the LFB model and the power of interconnection in LFB model and the power of interconnection in LFB topology should
LFB topology should make it possible to model any high-touch make it possible to model any high-touch functions.
functions.
6.7. Security Functions 6.7. Security Functions
Security functions are not included in the initial LFB class Security functions are not included in the initial LFB class
library. However, the FE model is flexible and powerful enough to library. However, the FE model is flexible and powerful enough to
model the types of encryption and/or decryption functions that an model the types of encryption and/or decryption functions that an FE
FE supports and the associated attributes for such functions. supports and the associated attributes for such functions.
The IP Security Policy (IPSP) Working Group in the IETF has The IP Security Policy (IPSP) Working Group in the IETF has started
started work in defining the IPSec Policy Information Base [8]. work in defining the IPSec Policy Information Base [8]. We will try
We will try to reuse as much of the work as possible. to reuse as much of the work as possible.
6.8. Off-loaded Functions 6.8. Off-loaded Functions
In addition to the packet processing functions typically found on In addition to the packet processing functions typically found on
the FEs, some logical functions may also be executed the FEs, some logical functions may also be executed asynchronously
asynchronously by some FEs, as directed by a finite-state machine by some FEs, as directed by a finite-state machine and triggered not
and triggered not only by packet events, but by timer events as only by packet events, but by timer events as well. Examples of
well. Examples of such functions include; finite-state machine such functions include; finite-state machine execution required by
execution required by TCP termination or OSPF Hello processing TCP termination or OSPF Hello processing off-loaded from the CE. By
off-loaded from the CE. By defining LFBs for such functions, the defining LFBs for such functions, the FE model is capable of
FE model is capable of expressing these asynchronous functions to expressing these asynchronous functions to allow the CE to take
allow the CE to take advantage of such off-loaded functions on the advantage of such off-loaded functions on the FEs.
FEs.
6.9. IPFLOW/PSAMP Functions 6.9. IPFLOW/PSAMP Functions
RFC 3917 [9] defines an architecture for IP traffic flow RFC 3917 [9] defines an architecture for IP traffic flow monitoring,
monitoring, measuring and exporting. The LFB model supports measuring and exporting. The LFB model supports statistics
statistics collection on the LFB by including statistical collection on the LFB by including statistical attributes (Section
attributes (Section 4.7.4) in the LFB class definitions; in 4.7.4) in the LFB class definitions; in addition, special statistics
addition, special statistics collection LFBs such as meter LFBs collection LFBs such as meter LFBs and counter LFBs can also be used
and counter LFBs can also be used to support accounting functions to support accounting functions in the FE.
in the FE.
[10] describes a framework to define a standard set of [10] describes a framework to define a standard set of capabilities
capabilities for network elements to sample subsets of packets by for network elements to sample subsets of packets by statistical and
statistical and other methods. Time event generation, filter LFB, other methods. Time event generation, filter LFB, and counter/meter
and counter/meter LFB are the elements needed to support packet LFB are the elements needed to support packet filtering and sampling
filtering and sampling functions -- these elements can all be functions -- these elements can all be supported in the FE model.
supported in the FE model.
7. 7. Using the FE model in the ForCES Protocol
Using the FE model in the ForCES Protocol
The actual model of the forwarding plane in a given NE is something
the CE must learn and control by communicating with the FEs (or by
other means). Most of this communication will happen in the post-
association phase using the ForCES protocol. The following types of
information must be exchanged between CEs and FEs via the ForCES
protocol: