draft-ietf-forces-model-16.txt   rfc5812.txt 
Working Group: ForCES J. Halpern Internet Engineering Task Force (IETF) J. Halpern
Internet-Draft Self Request for Comments: 5812 Self
Intended status: Standards Track J. Hadi Salim Category: Standards Track J. Hadi Salim
Expires: April 10, 2009 Znyx Networks ISSN: 2070-1721 Znyx Networks
October 7, 2008 March 2010
ForCES Forwarding Element Model
draft-ietf-forces-model-16.txt
Status of this Memo
By submitting this Internet-Draft, each author represents that any
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 she becomes
aware will be disclosed, in accordance with Section 6 of BCP 79.
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.
Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet-Drafts as reference
material or to cite them other than as "work in progress."
The list of current Internet-Drafts can be accessed at
http://www.ietf.org/ietf/1id-abstracts.txt.
The list of Internet-Draft Shadow Directories can be accessed at
http://www.ietf.org/shadow.html.
This Internet-Draft will expire on April 10, 2009.
Comments are solicited and should be addressed to the working group's Forwarding and Control Element Separation (ForCES)
mailing list at forces@peach.ease.lsoft.com and/or the author(s). Forwarding Element Model
Abstract Abstract
This document defines the forwarding element (FE) model used in the This document defines the forwarding element (FE) model used in the
Forwarding and Control Element Separation (ForCES) protocol [2]. The Forwarding and Control Element Separation (ForCES) protocol. 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 how present in an FE, what capabilities these functions support, and how
these functions are or can be interconnected. This FE model is these functions are or can be interconnected. This FE model is
intended to satisfy the model requirements specified in the ForCES intended to satisfy the model requirements specified in RFC 3654.
requirements document, RFC3654 [6].
Table of Contents
1. Definitions . . . . . . . . . . . . . . . . . . . . . . . . . 5
2. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1. Requirements on the FE model . . . . . . . . . . . . . . 7
2.2. The FE Model in Relation to FE Implementations . . . . . 8
2.3. The FE Model in Relation to the ForCES Protocol . . . . . 8
2.4. Modeling Language for the FE Model . . . . . . . . . . . 9
2.5. Document Structure . . . . . . . . . . . . . . . . . . . 10
3. ForCES Model Concepts . . . . . . . . . . . . . . . . . . . . 10
3.1. ForCES Capability Model and State Model . . . . . . . . . 11
3.1.1. FE Capability Model and State Model . . . . . . . . . 12
3.1.2. Relating LFB and FE Capability and State Model . . . 13
3.2. Logical Functional Block (LFB) Modeling . . . . . . . . . 14
3.2.1. LFB Outputs . . . . . . . . . . . . . . . . . . . . . 17
3.2.2. LFB Inputs . . . . . . . . . . . . . . . . . . . . . 20
3.2.3. Packet Type . . . . . . . . . . . . . . . . . . . . . 23
3.2.4. Metadata . . . . . . . . . . . . . . . . . . . . . . 24
3.2.5. LFB Events . . . . . . . . . . . . . . . . . . . . . 26
3.2.6. Component Properties . . . . . . . . . . . . . . . . 28
3.2.7. LFB Versioning . . . . . . . . . . . . . . . . . . . 28
3.2.8. LFB Inheritance . . . . . . . . . . . . . . . . . . . 29
3.3. ForCES Model Addressing . . . . . . . . . . . . . . . . . 30
3.3.1. Addressing LFB Components: Paths and Keys . . . . . . 31
3.4. FE Datapath Modeling . . . . . . . . . . . . . . . . . . 32
3.4.1. Alternative Approaches for Modeling FE Datapaths . . 32
3.4.2. Configuring the LFB Topology . . . . . . . . . . . . 36
4. Model and Schema for LFB Classes . . . . . . . . . . . . . . 40
4.1. Namespace . . . . . . . . . . . . . . . . . . . . . . . . 41
4.2. <LFBLibrary> Element . . . . . . . . . . . . . . . . . . 41
4.3. <load> Element . . . . . . . . . . . . . . . . . . . . . 43
4.4. <frameDefs> Element for Frame Type Declarations . . . . . 44
4.5. <dataTypeDefs> Element for Data Type Definitions . . . . 44
4.5.1. <typeRef> Element for Renaming Existing Data Types . 48
4.5.2. <atomic> Element for Deriving New Atomic Types . . . 48
4.5.3. <array> Element to Define Arrays . . . . . . . . . . 49
4.5.4. <struct> Element to Define Structures . . . . . . . . 53
4.5.5. <union> Element to Define Union Types . . . . . . . . 55
4.5.6. <alias> Element . . . . . . . . . . . . . . . . . . . 55
4.5.7. Augmentations . . . . . . . . . . . . . . . . . . . . 56
4.6. <metadataDefs> Element for Metadata Definitions . . . . . 57
4.7. <LFBClassDefs> Element for LFB Class Definitions . . . . 58
4.7.1. <derivedFrom> Element to Express LFB Inheritance . . 61
4.7.2. <inputPorts> Element to Define LFB Inputs . . . . . . 61
4.7.3. <outputPorts> Element to Define LFB Outputs . . . . . 64
4.7.4. <components> Element to Define LFB Operational
Components . . . . . . . . . . . . . . . . . . . . . 66
4.7.5. <capabilities> Element to Define LFB Capability
Components . . . . . . . . . . . . . . . . . . . . . 69
4.7.6. <events> Element for LFB Notification Generation . . 70
4.7.7. <description> Element for LFB Operational
Specification . . . . . . . . . . . . . . . . . . . . 77
4.8. Properties . . . . . . . . . . . . . . . . . . . . . . . 77
4.8.1. Basic Properties . . . . . . . . . . . . . . . . . . 78
4.8.2. Array Properties . . . . . . . . . . . . . . . . . . 80
4.8.3. String Properties . . . . . . . . . . . . . . . . . . 80
4.8.4. Octetstring Properties . . . . . . . . . . . . . . . 81
4.8.5. Event Properties . . . . . . . . . . . . . . . . . . 82
4.8.6. Alias Properties . . . . . . . . . . . . . . . . . . 85
4.9. XML Schema for LFB Class Library Documents . . . . . . . 86
5. FE Components and Capabilities . . . . . . . . . . . . . . . 97
5.1. XML for FEObject Class definition . . . . . . . . . . . . 98
5.2. FE Capabilities . . . . . . . . . . . . . . . . . . . . . 104
5.2.1. ModifiableLFBTopology . . . . . . . . . . . . . . . . 105
5.2.2. SupportedLFBs and SupportedLFBType . . . . . . . . . 105
5.3. FE Components . . . . . . . . . . . . . . . . . . . . . . 108
5.3.1. FEState . . . . . . . . . . . . . . . . . . . . . . . 108
5.3.2. LFBSelectors and LFBSelectorType . . . . . . . . . . 108
5.3.3. LFBTopology and LFBLinkType . . . . . . . . . . . . . 109
5.3.4. FENeighbors and FEConfiguredNeighborType . . . . . . 109
6. Satisfying the Requirements on FE Model . . . . . . . . . . . 110
7. Using the FE model in the ForCES Protocol . . . . . . . . . . 111
7.1. FE Topology Query . . . . . . . . . . . . . . . . . . . . 113
7.2. FE Capability Declarations . . . . . . . . . . . . . . . 114
7.3. LFB Topology and Topology Configurability Query . . . . . 114
7.4. LFB Capability Declarations . . . . . . . . . . . . . . . 114
7.5. State Query of LFB Components . . . . . . . . . . . . . . 116
7.6. LFB Component Manipulation . . . . . . . . . . . . . . . 116
7.7. LFB Topology Re-configuration . . . . . . . . . . . . . . 116
8. Example LFB Definition . . . . . . . . . . . . . . . . . . . 117
8.1. Data Handling . . . . . . . . . . . . . . . . . . . . . . 124
8.1.1. Setting up a DLCI . . . . . . . . . . . . . . . . . . 125
8.1.2. Error Handling . . . . . . . . . . . . . . . . . . . 125
8.2. LFB Components . . . . . . . . . . . . . . . . . . . . . 126
8.3. Capabilities . . . . . . . . . . . . . . . . . . . . . . 126
8.4. Events . . . . . . . . . . . . . . . . . . . . . . . . . 127
9. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 128
9.1. URN Namespace Registration . . . . . . . . . . . . . . . 128
9.2. LFB Class Names and LFB Class Identifiers . . . . . . . . 128
10. Authors Emeritus . . . . . . . . . . . . . . . . . . . . . . 129
11. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 130
12. Security Considerations . . . . . . . . . . . . . . . . . . . 130
13. References . . . . . . . . . . . . . . . . . . . . . . . . . 130
13.1. Normative References . . . . . . . . . . . . . . . . . . 130
13.2. Informative References . . . . . . . . . . . . . . . . . 131
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 131
Intellectual Property and Copyright Statements . . . . . . . . . 132
1. Definitions
The use of compliance terminology (MUST, SHOULD, MAY, MUST NOT) is
used in accordance with RFC2119 [1]. Such terminology is used in
describing the required behavior of ForCES forwarding elements or
control elements in supporting or manipulating information described
in this model.
Terminology associated with the ForCES requirements is defined in
RFC3654 [6] and is not copied here. The following list of
terminology relevant to the FE model is defined in this section.
FE Model -- The FE model is designed to model the logical processing
functions of an FE. The FE model proposed in this document includes
three components: the modeling of individual logical functional
blocks (LFB model), the logical interconnection between LFBs (LFB
topology) and the FE level attributes, including FE capabilities.
The FE model provides the basis to define the information elements
exchanged between the CE and the FE in the ForCES Protocol [2].
Datapath -- A conceptual path taken by packets within the forwarding
plane inside an FE. Note that more than one datapath can exist
within an FE.
LFB (Logical Functional Block) Class (or type) -- A template that
represents a fine-grained, logically separable aspect of FE
processing. Most LFBs relate to packet processing in the data path.
LFB classes are the basic building blocks of the FE model.
LFB Instance -- As a packet flows through an FE along a datapath, it
flows through one or multiple LFB instances, where each LFB is an
instance of a specific LFB class. Multiple instances of the same LFB
class can be present in an FE's datapath. Note that we often refer
to LFBs without distinguishing between an LFB class and LFB instance
when we believe the implied reference is obvious for the given
context.
LFB Model -- The LFB model describes the content and structures in an
LFB, plus the associated data definition. XML is used to provide a
formal definition of the necessary structures for the modeling. Four
types of information are defined in the LFB model. The core part of
the LFB model is the LFB class definitions; the other three types of
information define constructs associated with and used by the class
definition. These are reusable data types, supported frame (packet)
formats, and metadata.
Element -- Element is generally used in this document in accordance
with the XML usage of the term. It refers to an XML tagged part of
an XML document. For a precise definition, please see the full set
of XML specifications from the W3C. This term is included in this
list for completeness because the ForCES formal model uses XML.
Attribute -- Attribute is used in the ForCES formal modelling in
accordance with standard XML usage of the term. i.e, to provide
attribute information include in an XML tag.
LFB Metadata -- Metadata is used to communicate per-packet state from Status of This Memo
one LFB to another, but is not sent across the network. The FE model
defines how such metadata is identified, produced and consumed by the
LFBs, but not how the per-packet state is implemented within actual
hardware. Metadata is sent between the FE and the CE on redirect
packets.
ForCES Component -- a ForCES Component is a well-defined, uniquely This is an Internet Standards Track document.
identifiable and addressable ForCES model building block. A
component has a 32-bit ID, name, type and an optional synopsis
description. These are often referred to simply as components.
LFB Component -- A ForCES component that defines the Operational This document is a product of the Internet Engineering Task Force
parameters of the LFBs that must be visible to the CEs. (IETF). It represents the consensus of the IETF community. It has
received public review and has been approved for publication by the
Internet Engineering Steering Group (IESG). Further information on
Internet Standards is available in Section 2 of RFC 5741.
Structure Component -- A ForCES component that is part of a complex Information about the current status of this document, any errata,
data structure to be used in LFB data definitions. The individual and how to provide feedback on it may be obtained at
parts which make up a structured set of data are referred to as http://www.rfc-editor.org/info/rfc5812.
Structure Components. These can themselves be of any valid data
type, including tables and structures.
Property -- ForCES components have properties associated with them, Copyright Notice
such as readability. Other examples include lengths for variable
sized components. These properties are acessed by the CE for reading
(or, where appropriate, writing.) Details on the ForCES properties
are found in section 4.8.
LFB Topology -- A representation of the logical interconnection and Copyright (c) 2010 IETF Trust and the persons identified as the
the placement of LFB instances along the datapath within one FE. document authors. All rights reserved.
Sometimes this representation is called intra-FE topology, to be
distinguished from inter-FE topology. LFB topology is outside of the
LFB model, but is part of the FE model.
FE Topology -- A representation of how multiple FEs within a single This document is subject to BCP 78 and the IETF Trust's Legal
NE (Network Element) are interconnected. Sometimes this is called Provisions Relating to IETF Documents
inter-FE topology, to be distinguished from intra-FE topology (i.e., (http://trustee.ietf.org/license-info) in effect on the date of
LFB topology). An individual FE might not have the global knowledge publication of this document. Please review these documents
of the full FE topology, but the local view of its connectivity with carefully, as they describe your rights and restrictions with respect
other FEs is considered to be part of the FE model. The FE topology to this document. Code Components extracted from this document must
is discovered by the ForCES base protocol or by some other means. include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License.
Inter-FE Topology -- See FE Topology. Table of Contents
Intra-FE Topology -- See LFB Topology. 1. Introduction ....................................................5
1.1. Requirements on the FE Model ...............................5
1.2. The FE Model in Relation to FE Implementations .............6
1.3. The FE Model in Relation to the ForCES Protocol ............6
1.4. Modeling Language for the FE Model .........................7
1.5. Document Structure .........................................8
2. Definitions .....................................................8
3. ForCES Model Concepts ..........................................10
3.1. ForCES Capability Model and State Model ...................12
3.1.1. FE Capability Model and State Model ................12
3.1.2. Relating LFB and FE Capability and State Model .....14
3.2. Logical Functional Block (LFB) Modeling ...................14
3.2.1. LFB Outputs ........................................18
3.2.2. LFB Inputs .........................................21
3.2.3. Packet Type ........................................24
3.2.4. Metadata ...........................................24
3.2.5. LFB Events .........................................27
3.2.6. Component Properties ...............................28
3.2.7. LFB Versioning .....................................29
3.2.8. LFB Inheritance ....................................29
3.3. ForCES Model Addressing ...................................30
3.3.1. Addressing LFB Components: Paths and Keys ..........32
3.4. FE Data Path Modeling .....................................32
3.4.1. Alternative Approaches for Modeling FE Data Paths ..33
3.4.2. Configuring the LFB Topology .......................37
4. Model and Schema for LFB Classes ...............................41
4.1. Namespace .................................................42
4.2. <LFBLibrary> Element ......................................42
4.3. <load> Element ............................................44
4.4. <frameDefs> Element for Frame Type Declarations ...........45
4.5. <dataTypeDefs> Element for Data Type Definitions ..........45
4.5.1. <typeRef> Element for Renaming Existing
Data Types .........................................49
4.5.2. <atomic> Element for Deriving New Atomic Types .....49
4.5.3. <array> Element to Define Arrays ...................50
4.5.4. <struct> Element to Define Structures ..............54
4.5.5. <union> Element to Define Union Types ..............56
4.5.6. <alias> Element ....................................56
4.5.7. Augmentations ......................................57
4.6. <metadataDefs> Element for Metadata Definitions ...........58
4.7. <LFBClassDefs> Element for LFB Class Definitions ..........59
4.7.1. <derivedFrom> Element to Express LFB Inheritance ...62
4.7.2. <inputPorts> Element to Define LFB Inputs ..........62
4.7.3. <outputPorts> Element to Define LFB Outputs ........65
4.7.4. <components> Element to Define LFB
Operational Components .............................67
LFB class library -- A set of LFB classes that has been identified as 4.7.5. <capabilities> Element to Define LFB
the most common functions found in most FEs and hence should be Capability Components ..............................70
defined first by the ForCES Working Group. 4.7.6. <events> Element for LFB Notification Generation ...71
4.7.7. <description> Element for LFB Operational
Specification ......................................79
4.8. Properties ................................................79
4.8.1. Basic Properties ...................................79
4.8.2. Array Properties ...................................81
4.8.3. String Properties ..................................81
4.8.4. Octetstring Properties .............................82
4.8.5. Event Properties ...................................83
4.8.6. Alias Properties ...................................87
4.9. XML Schema for LFB Class Library Documents ................88
5. FE Components and Capabilities .................................99
5.1. XML for FEObject Class Definition .........................99
5.2. FE Capabilities ..........................................106
5.2.1. ModifiableLFBTopology .............................106
5.2.2. SupportedLFBs and SupportedLFBType ................106
5.3. FE Components ............................................110
5.3.1. FEState ...........................................110
5.3.2. LFBSelectors and LFBSelectorType ..................110
5.3.3. LFBTopology and LFBLinkType .......................110
5.3.4. FENeighbors and FEConfiguredNeighborType ..........111
6. Satisfying the Requirements on the FE Model ...................111
7. Using the FE Model in the ForCES Protocol .....................112
7.1. FE Topology Query ........................................115
7.2. FE Capability Declarations ...............................116
7.3. LFB Topology and Topology Configurability Query ..........116
7.4. LFB Capability Declarations ..............................116
7.5. State Query of LFB Components ............................118
7.6. LFB Component Manipulation ...............................118
7.7. LFB Topology Reconfiguration .............................118
8. Example LFB Definition ........................................119
8.1. Data Handling ............................................126
8.1.1. Setting Up a DLCI .................................127
8.1.2. Error Handling ....................................127
8.2. LFB Components ...........................................128
8.3. Capabilities .............................................128
8.4. Events ...................................................129
9. IANA Considerations ...........................................130
9.1. URN Namespace Registration ...............................130
9.2. LFB Class Names and LFB Class Identifiers ................130
10. Authors Emeritus .............................................132
11. Acknowledgments ..............................................132
12. Security Considerations ......................................132
13. References ...................................................132
13.1. Normative References ....................................132
13.2. Informative References ..................................133
2. Introduction 1. Introduction
RFC3746 [7] specifies a framework by which control elements (CEs) can RFC 3746 [RFC3746] specifies a framework by which control elements
configure and manage one or more separate forwarding elements (FEs) (CEs) can configure and manage one or more separate forwarding
within a networking element (NE) using the ForCES protocol. The elements (FEs) within a network element (NE) using the ForCES
ForCES architecture allows Forwarding Elements of varying protocol. The ForCES architecture allows forwarding elements of
functionality to participate in a ForCES network element. The varying functionality to participate in a ForCES network element.
implication of this varying functionality is that CEs can make only The implication of this varying functionality is that CEs can make
minimal assumptions about the functionality provided by FEs in an NE. only minimal assumptions about the functionality provided by FEs in
Before CEs can configure and control the forwarding behavior of FEs, an NE. Before CEs can configure and control the forwarding behavior
CEs need to query and discover the capabilities and states of their of FEs, CEs need to query and discover the capabilities and states of
FEs. RFC3654 [6] mandates that the capabilities, states and their FEs. RFC 3654 [RFC3654] mandates that the capabilities, states
configuration information be expressed in the form of an FE model. and configuration information be expressed in the form of an FE
model.
RFC3444 [10] observed that information models (IMs) and data models RFC 3444 [RFC3444] observed that information models (IMs) and data
(DMs) are different because they serve different purposes. "The main models (DMs) are different because they serve different purposes.
purpose of an IM is to model managed objects at a conceptual level, "The main purpose of an IM is to model managed objects at a
independent of any specific implementations or protocols used". conceptual level, independent of any specific implementations or
"DMs, conversely, are defined at a lower level of abstraction and protocols used". "DMs, conversely, are defined at a lower level of
include many details. They are intended for implementors and include abstraction and include many details. They are intended for
protocol-specific constructs." Sometimes it is difficult to draw a implementors and include protocol-specific constructs". Sometimes it
clear line between the two. The FE model described in this document is difficult to draw a clear line between the two. The FE model
is primarily an information model, but also includes some aspects of described in this document is primarily an information model, but
a data model, such as explicit definitions of the LFB class schema also includes some aspects of a data model, such as explicit
and FE schema. It is expected that this FE model will be used as the definitions of the LFB (Logical Functional Block) class schema and FE
basis to define the payload for information exchange between the CE schema. It is expected that this FE model will be used as the basis
and FE in the ForCES protocol. to define the payload for information exchange between the CE and FE
in the ForCES protocol.
2.1. Requirements on the FE model 1.1. Requirements on the FE Model
RFC3654 [6]defines requirements that must be satisfied by a ForCES FE RFC 3654 [RFC3654] defines requirements that must be satisfied by a
model. To summarize, an FE model must define: ForCES FE model. To summarize, an FE model must define:
o Logically separable and distinct packet forwarding operations in o Logically separable and distinct packet forwarding operations in
an FE datapath (logical functional blocks or LFBs); an FE data path (Logical Functional Blocks or LFBs);
o The possible topological relationships (and hence the sequence of o The possible topological relationships (and hence the sequence of
packet forwarding operations) between the various LFBs; packet forwarding operations) between the various LFBs;
o The possible operational capabilities (e.g., capacity limits, o The possible operational capabilities (e.g., capacity limits,
constraints, optional features, granularity of configuration) of constraints, optional features, granularity of configuration) of
each type of LFB; each type of LFB;
o The possible configurable parameters (e.g., components) of each o The possible configurable parameters (e.g., components) of each
type of LFB; type of LFB; and
o Metadata that may be exchanged between LFBs. o Metadata that may be exchanged between LFBs.
2.2. The FE Model in Relation to FE Implementations 1.2. The FE Model in Relation to FE Implementations
The FE model proposed here is based on an abstraction using distinct The FE model proposed here is based on an abstraction using 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 is designed, and any defined LFB along with metadata. The FE model is designed, and any defined LFB
classes should be designed, such that different implementations of classes should be designed, such that different implementations of
the forwarding datapath can be logically mapped onto the model with the forwarding data path can be logically mapped onto the model with
the functionality and sequence of operations correctly captured. the functionality and sequence of operations correctly captured.
However, the model is not intended to directly address how a However, the model is not intended to directly address how a
particular implementation maps to an LFB topology. It is left to the particular implementation maps to an LFB topology. It is left to the
forwarding plane vendors to define how the FE functionality is forwarding plane vendors to define how the FE functionality is
represented using the FE model. Our goal is to design the FE model represented using the FE model. Our goal is to design the FE model
such that it is flexible enough to accommodate most common such that it is flexible enough to accommodate most common
implementations. implementations.
The LFB topology model for a particular datapath implementation must The LFB topology model for a particular data path implementation must
correctly capture the sequence of operations on the packet. Metadata correctly capture the sequence of operations on the packet. Metadata
generation by certain LFBs MUST always precede any use of that generation by certain LFBs MUST always precede any use of that
metadata by subsequent LFBs in the topology graph; this is required metadata by subsequent LFBs in the topology graph; this is required
for logically consistent operation. Further, modification of packet for logically consistent operation. Further, modification of packet
fields that are subsequently used as inputs for further processing fields that are subsequently used as inputs for further processing
MUST occur in the order specified in the model for that particular MUST occur in the order specified in the model for that particular
implementation to ensure correctness. implementation to ensure correctness.
2.3. The FE Model in Relation to the ForCES Protocol 1.3. The FE Model in Relation to the ForCES Protocol
The ForCES base Protocol [2] is used by the CEs and FEs to maintain The ForCES base protocol [RFC5810] is used by the CEs and FEs to
the communication channel between the CEs and FEs. The ForCES maintain the communication channel between the CEs and FEs. The
protocol may be used to query and discover the intra-FE topology. ForCES protocol may be used to query and discover the intra-FE
The details of a particular datapath implementation inside an FE, topology. The details of a particular data path implementation
including the LFB topology, along with the operational capabilities inside an FE, including the LFB topology, along with the operational
and attributes of each individual LFB, are conveyed to the CE within capabilities and attributes of each individual LFB, are conveyed to
information elements in the ForCES protocol. The model of an LFB the CE within information elements in the ForCES protocol. The model
class should define all of the information that needs to be exchanged of an LFB class should define all of the information that needs to be
between an FE and a CE for the proper configuration and management of exchanged between an FE and a CE for the proper configuration and
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 components for The FE model document defines a set of classes and components 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 the These class definitions themselves will generally not appear in the
ForCES protocol. Rather, ForCES protocol operations will reference ForCES protocol. Rather, ForCES protocol operations will reference
classes defined in this model, including relevant components and the classes defined in this model, including relevant components 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 1.4. Modeling Language for the FE Model
Even though not absolutely required, it is beneficial to use a formal Even though not absolutely required, it is beneficial to use a formal
data modeling language to represent the conceptual FE model described data modeling language to represent the conceptual FE model described
in this document. Use of a formal language can help to enforce in this document. Use of a formal language can help to enforce
consistency and logical compatibility among LFBs. A full 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 eventual The formal definition of the LFB classes may facilitate the eventual
automation of some of the code generation process and the functional automation of some of the code generation process and the functional
validation of arbitrary LFB topologies. These class definitions form validation of arbitrary LFB topologies. These class definitions form
the LFB Library. Documents which describe LFB Classes are therefore the LFB library. Documents that describe LFB classes are therefore
referred to as LFB Library documents. referred to as LFB library documents.
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 and selecting the specification language, whereas encoding, decoding, and
transmission performance was not a selection factor. The encoding transmission performance were not a selection factor. The encoding
method for over the wire transport is not dependent on the method for over-the-wire transport is not dependent on 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 is chosen as the specification language in this document, because XML is chosen as the specification language in this document, because
XML has the advantage of being both human and machine readable with XML has the advantage of being both human and machine readable with
widely available tools support. This document uses an XML Schema to widely available tools support. This document uses an XML schema to
define the structure of the LFB Library documents, as defined in [11] define the structure of the LFB library documents, as defined in
and [4] and [5]. While these LFB Class definitions are not sent in [RFC3470] and [Schema1] and [Schema2]. While these LFB class
the ForCES protocol, these definitions comply with the definitions are not sent in the ForCES protocol, these definitions
recommendations in RFC3470 [11] on the use of XML in IETF protocols. comply with the recommendations in RFC 3470 [RFC3470] on the use of
XML in IETF protocols.
By useing XML Schema to define the structure for the LFB Library By using an XML schema to define the structure for the LFB library
documents, we have a very clear set of syntactic restrictions to go documents, we have a very clear set of syntactic restrictions to go
with the desired semantic descriptions and restrictions covered in with the desired semantic descriptions and restrictions covered in
this document. As a corrolary to that, if it is determined that a this document. As a corollary to that, if it is determined that a
change in the syntax is needed then a new schema will be required. change in the syntax is needed, then a new schema will be required.
This would be identified by a different URN to identify the namespace This would be identified by a different URN to identify the namespace
for such a new schema. for such a new schema.
2.5. Document Structure 1.5. Document Structure
Section 3 provides a conceptual overview of the FE model, laying the Section 3 provides a conceptual overview of the FE model, laying the
foundation for the more detailed discussion and specifications in the foundation for the more detailed discussion and specifications in the
sections that follow. Section 4 and Section 5 constitute the core of sections that follow. Section 4 and Section 5 constitute the core of
the FE model, detailing the two major aspects of the FE model: a the FE model, detailing the two major aspects of the FE model: a
general LFB model and a definition of the FE Object LFB, with its general LFB model and a definition of the FE Object LFB, with its
components, including FE capabilities and LFB topology information. components, including FE capabilities and LFB topology information.
Section 6 directly addresses the model requirements imposed by the Section 6 directly addresses the model requirements imposed by the
ForCES requirements defined in RFC3654 [6] while Section 7 explains ForCES requirements defined in RFC 3654 [RFC3654], while Section 7
how the FE model should be used in the ForCES protocol. explains how the FE model should be used in the ForCES protocol.
2. Definitions
The use of compliance terminology (MUST, SHOULD, MAY, MUST NOT) is
used in accordance with RFC 2119 [RFC2119]. Such terminology is used
in describing the required behavior of ForCES forwarding elements or
control elements in supporting or manipulating information described
in this model.
Terminology associated with the ForCES requirements is defined in RFC
3654 [RFC3654] and is not copied here. The following list of
terminology relevant to the FE model is defined in this section.
FE Model: The FE model is designed to model the logical processing
functions of an FE. The FE model proposed in this document
includes three components; the LFB modeling of individual Logical
Functional Block (LFB model), the logical interconnection between
LFBs (LFB topology), and the FE-level attributes, including FE
capabilities. The FE model provides the basis to define the
information elements exchanged between the CE and the FE in the
ForCES protocol [RFC5810].
Data Path: A conceptual path taken by packets within the forwarding
plane inside an FE. Note that more than one data path can exist
within an FE.
LFB (Logical Functional Block) Class (or type): A template that
represents a fine-grained, logically separable aspect of FE
processing. Most LFBs relate to packet processing in the data
path. LFB classes are the basic building blocks of the FE model.
LFB Instance: As a packet flows through an FE along a data path, it
flows through one or multiple LFB instances, where each LFB is an
instance of a specific LFB class. Multiple instances of the same
LFB class can be present in an FE's data path. Note that we often
refer to LFBs without distinguishing between an LFB class and LFB
instance when we believe the implied reference is obvious for the
given context.
LFB Model: The LFB model describes the content and structures in an
LFB, plus the associated data definition. XML is used to provide
a formal definition of the necessary structures for the modeling.
Four types of information are defined in the LFB model. The core
part of the LFB model is the LFB class definitions; the other
three types of information define constructs associated with and
used by the class definition. These are reusable data types,
supported frame (packet) formats, and metadata.
Element: Element is generally used in this document in accordance
with the XML usage of the term. It refers to an XML tagged part
of an XML document. For a precise definition, please see the full
set of XML specifications from the W3C. This term is included in
this list for completeness because the ForCES formal model uses
XML.
Attribute: Attribute is used in the ForCES formal modeling in
accordance with standard XML usage of the term, i.e., to provide
attribute information included in an XML tag.
LFB Metadata: Metadata is used to communicate per-packet state from
one LFB to another, but is not sent across the network. The FE
model defines how such metadata is identified, produced, and
consumed by the LFBs, but not how the per-packet state is
implemented within actual hardware. Metadata is sent between the
FE and the CE on redirect packets.
ForCES Component: A ForCES Component is a well-defined, uniquely
identifiable and addressable ForCES model building block. A
component has a 32-bit ID, name, type, and an optional synopsis
description. These are often referred to simply as components.
LFB Component: An LFB component is a ForCES component that defines
the Operational parameters of the LFBs that must be visible to the
CEs.
Structure Component: A ForCES component that is part of a complex
data structure to be used in LFB data definitions. The individual
parts that make up a structured set of data are referred to as
structure components. These can themselves be of any valid data
type, including tables and structures.
Property: ForCES components have properties associated with them,
such as readability. Other examples include lengths for variable-
sized components. These properties are accessed by the CE for
reading (or, where appropriate, writing.) Details on the ForCES
properties are found in Section 4.8.
LFB Topology: LFB topology is a representation of the logical
interconnection and the placement of LFB instances along the data
path within one FE. Sometimes this representation is called
intra-FE topology, to be distinguished from inter-FE topology.
LFB topology is outside of the LFB model, but is part of the FE
model.
FE Topology: FE topology is a representation of how multiple FEs
within a single network element (NE) are interconnected.
Sometimes this is called inter-FE topology, to be distinguished
from intra-FE topology (i.e., LFB topology). An individual FE
might not have the global knowledge of the full FE topology, but
the local view of its connectivity with other FEs is considered to
be part of the FE model. The FE topology is discovered by the
ForCES base protocol or by some other means.
Inter-FE Topology: See FE Topology.
Intra-FE Topology: See LFB Topology.
LFB Class Library: The LFB class library is a set of LFB classes
that has been identified as the most common functions found in
most FEs and hence should be defined first by the ForCES Working
Group.
3. ForCES Model Concepts 3. ForCES Model Concepts
Some of the important ForCES concepts used throughout this document Some of the important ForCES concepts used throughout this document
are introduced in this section. These include the capability and are introduced in this section. These include the capability and
state abstraction, the FE and LFB model construction, and the unique state abstraction, the FE and LFB model construction, and the unique
addressing of the different model structures. Details of these addressing of the different model structures. Details of these
aspects are described in Section 4 and Section 5. The intent of this aspects are described in Section 4 and Section 5. The intent of this
section is to discuss these concepts at the high level and lay the section is to discuss these concepts at the high level and lay the
foundation for the detailed description in the following sections. foundation for the detailed description in the following sections.
skipping to change at page 10, line 45 skipping to change at page 11, line 15
o The state model describes the current state of the FE/LFB, that o The state model describes the current state of the FE/LFB, that
is, the instantaneous values or operational behavior of the FE/ is, the instantaneous values or operational behavior of the FE/
LFB. LFB.
Section 3.1 explains the difference between a capability model and a Section 3.1 explains the difference between a capability model and a
state model, and describes how the two can be combined in the FE state model, and describes how the two can be combined in the FE
model. model.
The ForCES model construction laid out in this document allows an FE The ForCES model construction laid out in this document allows an FE
to provide information about its structure for operation. This can to provide information about its structure for operation. This can
be thought of as FE level information and information about the be thought of as FE-level information and information about the
individual instances of LFBs provided by the FE. individual instances of LFBs provided by the FE.
o The ForCES model includes the constructions for defining the class o The ForCES model includes the constructions for defining the class
of logical function blocks (LFBS) that an FE may support. These of Logical Functional Blocks (LFBs) that an FE may support. These
classes are defined in this and other documents. The definition classes are defined in this and other documents. The definition
of such a class provides the information content for monitoring of such a class provides the information content for monitoring
and controlling instances of the LFB class for ForCES purposes. and controlling instances of the LFB class for ForCES purposes.
Each LFB model class formally defines the operational LFB Each LFB model class formally defines the operational LFB
components, LFB capabilities, and LFB events. Essentially, components, LFB capabilities, and LFB events. Essentially,
Section 3.2 introduces the concept of LFBs as the basic functional Section 3.2 introduces the concept of LFBs as the basic functional
building blocks in the ForCES model. building blocks in the ForCES model.
o The FE model also provides the construction necessary to monitor o The FE model also provides the construction necessary to monitor
and control the FE as a whole for ForCES purposes. For and control the FE as a whole for ForCES purposes. For
consistency of operation and simplicity, this information is consistency of operation and simplicity, this information is
represented as an LFB, the FE Object LFB class and a singular LFB represented as an LFB, the FE Object LFB class and a singular LFB
instance of that class, defined using the LFB model. The FE instance of that class, defined using the LFB model. The FE
Object class defines the components to provide information at the Object class defines the components to provide information at the
FE level, particularly the capabilities of the FE at a coarse FE level, particularly the capabilities of the FE at a coarse
level, i.e., not all possible capabilities nor all details about level, i.e., not all possible capabilities or all details about
the capabilities of the FE. Part of the FE level information is the capabilities of the FE. Part of the FE-level information is
the LFB topology, which expresses the logical inter-connection the LFB topology, which expresses the logical inter-connection
between the LFB instances along the datapath(s) within the FE. between the LFB instances along the data path(s) within the FE.
Section 3.3 discusses the LFB topology. The FE Object also Section 3.3 discusses the LFB topology. The FE Object also
includes information about what LFB classes the FE can support. includes information about what LFB classes the FE can support.
The ForCES model allows for unique identification of the different The ForCES model allows for unique identification of the different
constructs it defines. This includes identification of the LFB constructs it defines. This includes identification of the LFB
classes, and of LFB instances within those classes, as well as classes, and of LFB instances within those classes, as well as
identification of components within those instances. identification of components within those instances.
The ForCES Protocol [2] encapsulates target address(es) to eventually The ForCES protocol [RFC5810] encapsulates target address(es) to
get to a fine-grained entity being referenced by the CE. The eventually get to a fine-grained entity being referenced by the CE.
addressing hierarchy is broken into the following: The addressing hierarchy is broken into the following:
o An FE is uniquely identified by a 32 bit FEID. o An FE is uniquely identified by a 32-bit FEID.
o Each Class of LFB is uniquely identified by a 32 bit LFB ClassID. o Each class of LFB is uniquely identified by a 32-bit LFB ClassID.
The LFB ClassIDs are global within the Network Element and may be The LFB ClassIDs are global within the network element and may be
issued by IANA. issued by IANA.
o Within an FE, there can be multiple instances of each LFB class. o Within an FE, there can be multiple instances of each LFB class.
Each LFB Class instance is identified by a 32 bit identifier which Each LFB class instance is identified by a 32-bit identifier that
is unique within a particular LFB class on that FE. is unique within a particular LFB class on that FE.
o All the components within an LFB instance are further defined o All the components within an LFB instance are further defined
using 32 bit identifiers. using 32-bit identifiers.
Refer to Section 3.3 for more details on addressing. Refer to Section 3.3 for more details on addressing.
3.1. ForCES Capability Model and State Model 3.1. ForCES Capability Model and State Model
Capability and state modelling applies to both the FE and LFB Capability and state modeling applies to both the FE and LFB
abstraction. abstraction.
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 |
| |<-----------------------------------------| | | |<-----------------------------------------| |
| | | | | | | |
| | FE configuration: what it should be. | | | | FE configuration: what it should be. | |
| |----------------------------------------->| | | |----------------------------------------->| |
+-------+ +-------+ +-------+ +-------+
Figure 1: Illustration of FE capabilities, state and configuration Figure 1: Illustration of FE capabilities, state, and configuration
exchange in the context of CE-FE communication via ForCES. exchange in the context of CE-FE communication via ForCES.
3.1.1. FE Capability Model and State Model 3.1.1. FE Capability Model and State Model
Conceptually, the FE capability model tells the CE which states are Conceptually, the FE capability model tells the CE which states 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. FE.
skipping to change at page 12, line 44 skipping to change at page 13, line 18
level. For example, an FE might be defined as follows: level. For example, an FE might be defined as follows:
o the FE can handle IPv4 and IPv6 forwarding; o the FE can handle IPv4 and IPv6 forwarding;
o the FE can perform classification based on the following fields: o the FE can perform classification based on the following fields:
source IP address, destination IP address, source port number, source IP address, destination IP address, source port number,
destination port number, etc.; destination port number, etc.;
o the FE can perform metering; o the FE can perform metering;
o the FE can handle up to N queues (capacity); o the FE can handle up to N queues (capacity); and
o the FE can add and remove encapsulating headers of types including o the FE can add and remove encapsulating headers of types including
IPsec, GRE, L2TP. IPsec, GRE, L2TP.
While one could try to build an object model to fully represent the While one could try to build an object model to fully represent the
FE capabilities, other efforts found this approach to be a FE capabilities, other efforts found this approach to be a
significant undertaking. The main difficulty arises in describing significant undertaking. The main difficulty arises in describing
detailed limits, such as the maximum number of classifiers, queues, detailed limits, such as the maximum number of classifiers, queues,
buffer pools, and meters that the FE can provide. We believe that a buffer pools, and meters that the FE can provide. We believe that a
good balance between simplicity and flexibility can be achieved for good balance between simplicity and flexibility can be achieved for
the FE model by combining coarse level capability reporting with an the FE model by combining coarse-level-capability reporting with an
error reporting mechanism. That is, if the CE attempts to instruct error reporting mechanism. That is, if the CE attempts to instruct
the FE to set up some specific behavior it cannot support, the FE the FE to set up some specific behavior it cannot support, the FE
will return an error indicating the problem. Examples of similar will return an error indicating the problem. Examples of similar
approaches include DiffServ PIB RFC3317 [8] and Framework PIB RFC3318 approaches include Diffserv PIB RFC 3317 [RFC3317] and framework PIB
[9]. RFC 3318 [RFC3318].
3.1.1.2. FE State Model 3.1.1.2. FE State 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 might be described to its For example, using an FE state model, an FE might be described to its
corresponding CE as the following: corresponding CE as the following:
o on a given port, the packets are classified using a given o on a given port, the packets are classified using a given
classification filter; classification filter;
o the given classifier results in packets being metered in a certain o the given classifier results in packets being metered in a certain
way and then marked in a certain way; way and then marked in a certain way;
o the packets coming from specific markers are delivered into a o the packets coming from specific markers are delivered into a
shared queue for handling, while other packets are delivered to a shared queue for handling, while other packets are delivered to a
different queue; different queue; and
o a specific scheduler with specific behavior and parameters will o a specific scheduler with specific behavior and parameters will
service these collected queues. service these collected queues.
3.1.1.3. LFB Capability and State Model 3.1.1.3. LFB Capability and State Model
Both LFB Capability and State information are defined formally using Both LFB capability and state information are defined formally using
the LFB modelling XML schema. the LFB modeling XML schema.
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 provides for powerful semantics. For example, when LFB model and provides for powerful semantics. For example, when
certain features of an LFB class are optional, the CE needs to be certain features of an LFB class are optional, the CE needs to be
able to determine whether those optional features are supported by a able to determine whether those optional features are supported by a
given LFB instance. The schema for the definition of LFB classes given LFB instance. The schema for the definition of LFB classes
provides a means for identifying such components. provides a means for identifying such components.
State information is defined formally using LFB component constructs. State information is defined formally using LFB component constructs.
3.1.2. Relating LFB and FE Capability and State Model 3.1.2. Relating LFB and FE Capability and State Model
Capability information at the FE level describes the LFB classes that Capability information at the FE level describes the LFB classes that
the FE can instantiate, the number of instances of each that can be the FE can instantiate, the number of instances of each that can be
created, the topological (linkage) limitations between these LFB created, the topological (linkage) limitations between these LFB
instances, etc. Section 5 defines the FE level components including instances, etc. Section 5 defines the FE-level components including
capability information. Since all information is represented as capability information. Since all information is represented as
LFBs, this is provided by a single instance of the FE Object LFB LFBs, this is provided by a single instance of the FE Object LFB
Class. By using a single instance with a known LFB Class and a known class. By using a single instance with a known LFB class and a known
instance identification, the ForCES protocol can allow a CE to access instance identification, the ForCES protocol can allow a CE to access
this information whenever it needs to, including while the CE is this information whenever it needs to, including while the CE is
establishing the control of the FE. establishing the control of the FE.
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 at two levels. The first level is the information can be represented at two levels. The first level is the
logically separable and distinct packet processing functions, called logically separable and distinct packet processing functions, called
LFBs. The second level of information describes how these individual LFBs. The second level of information describes how these individual
LFBs are ordered and placed along the datapath to deliver a complete LFBs are ordered and placed along the data path to deliver a complete
forwarding plane service. The interconnection and ordering of the forwarding plane service. The interconnection and ordering of the
LFBs is called LFB Topology. Section 3.2 discusses high level LFBs is called LFB topology. Section 3.2 discusses high-level
concepts around LFBs, whereas Section 3.3 discusses LFB topology concepts around LFBs, whereas Section 3.3 discusses LFB topology
issues. This topology information is represented as components of issues. This topology information is represented as components of
the FE Object LFB instance, to allow the CE to fetch and manipulate the FE Object LFB instance, to allow the CE to fetch and manipulate
this. this.
3.2. Logical Functional Block (LFB) Modeling 3.2. Logical Functional Block (LFB) Modeling
Each LFB performs a well-defined action or computation on the packets Each LFB performs a well-defined action or computation on the packets
passing through it. Upon completion of its prescribed function, passing through it. Upon completion of its prescribed function,
either the packets are modified in certain ways (e.g., decapsulator, either the packets are modified in certain ways (e.g., decapsulator,
marker), or some results are generated and stored, often in the form marker), or some results are generated and stored, often in the form
of metadata (e.g., classifier). Each LFB typically performs a single of metadata (e.g., classifier). Each LFB typically performs a single
action. Classifiers, shapers and meters are all examples of such action. Classifiers, shapers, and meters are all examples of such
LFBs. Modeling LFBs at such a fine granularity allows us to use a LFBs. Modeling LFBs at such a fine granularity allows us to use a
small number of LFBs to express the higher-order FE functions (such small number of LFBs to express the higher-order FE functions (such
as an IPv4 forwarder) precisely, which in turn can describe more as an IPv4 forwarder) precisely, which in turn can describe more
complex networking functions and vendor implementations of software complex networking functions and vendor implementations of software
and hardware. These fine grained LFBs will be defined in detail in and hardware. These fine-grained LFBs will be defined in detail in
one or more documents to be published separately, using the material one or more documents to be published separately, using the material
in this model. in this model.
It is also the case that LFBs may exist in order to provide a set of It is also the case that LFBs may exist in order to provide a set of
components for control of FE operation by the CE (i.e., a locus of components for control of FE operation by the CE (i.e., a locus of
control), without tying that control to specific packets or specific control), without tying that control to specific packets or specific
parts of the data path. An example of such an LFB is the FE Object parts of the data path. An example of such an LFB is the FE Object,
which provides the CE with information about the FE as a whole, and which provides the CE with information about the FE as a whole, and
allows the FE to control some aspects of the FE, such as the datapath allows the FE to control some aspects of the FE, such as the data
itself. Such LFBs will not have the packet oriented properties path itself. Such LFBs will not have the packet-oriented properties
described in this section. described in this section.
In general, multiple LFBs are contained in one FE, as shown in In general, multiple LFBs are contained in one FE, as shown in
Figure 2, and all the LFBs share the same ForCES protocol (Fp) Figure 2, and all the LFBs share the same ForCES protocol (Fp)
termination point that implements the ForCES protocol logic and termination point that implements the ForCES protocol logic and
maintains the communication channel to and from the CE. maintains the communication channel to and from the CE.
+-----------+ +-----------+
| CE | | CE |
+-----------+ +-----------+
skipping to change at page 15, line 32 skipping to change at page 16, line 31
| +---:----------+ +---:----------| | | +---:----------+ +---:----------| |
| | :LFB1 | | : LFB2 | | | | :LFB1 | | : LFB2 | |
| =====>| v |============>| v |======>...| | =====>| v |============>| v |======>...|
| Inputs| +----------+ |Outputs | +----------+ | | | Inputs| +----------+ |Outputs | +----------+ | |
| (P,M) | |Components| |(P',M') | |Components| |(P",M") | | (P,M) | |Components| |(P',M') | |Components| |(P",M") |
| | +----------+ | | +----------+ | | | | +----------+ | | +----------+ | |
| +--------------+ +--------------+ | | +--------------+ +--------------+ |
| | | |
+--------------------------------------------------------------+ +--------------------------------------------------------------+
Figure 2: Generic LFB Diagram Figure 2: Generic LFB diagram.
An LFB, as shown in Figure 2, may have inputs, outputs and components An LFB, as shown in Figure 2, may have inputs, outputs, and
that can be queried and manipulated by the CE via an Fp reference components that can be queried and manipulated by the CE via an Fp
point (defined in RFC3746 [7]) and the ForCES protocol termination reference point (defined in RFC 3746 [RFC3746]) and the ForCES
point. The horizontal axis is in the forwarding plane for connecting protocol termination point. The horizontal axis is in the forwarding
the inputs and outputs of LFBs within the same FE. P (with marks to plane for connecting the inputs and outputs of LFBs within the same
indicate modification) indicates a data packet, while M (with marks FE. P (with marks to indicate modification) indicates a data packet,
to indicate modification) indicates the metadata associated with a while M (with marks to indicate modification) indicates the metadata
packet. The vertical axis between the CE and the FE denotes the Fp associated with a packet. The vertical axis between the CE and the
reference point where bidirectional communication between the CE and FE denotes the Fp reference point where bidirectional communication
FE occurs: the CE to FE communication is for configuration, control, between the CE and FE occurs: the CE-to-FE communication is for
and packet injection, while FE to CE communication is used for packet configuration, control, and packet injection, while the FE-to-CE
redirection to the control plane, reporting of monitoring and communication is used for packet redirection to the control plane,
accounting information, reporting of errors, etc. Note that the reporting of monitoring and accounting information, reporting of
interaction between the CE and the LFB is only abstract and indirect. errors, etc. Note that the interaction between the CE and the LFB is
The result of such an interaction is for the CE to manipulate the only abstract and indirect. The result of such an interaction is for
components of the LFB instances. the CE to manipulate the components of the LFB instances.
An LFB can have one or more inputs. Each input takes a pair of a An LFB can have one or more inputs. Each input takes a pair of a
packet and its associated metadata. Depending upon the LFB input packet and its associated metadata. Depending upon the LFB input
port definition, the packet or the metadata may be allowed to be port definition, the packet or the metadata may be allowed to be
empty (or equivalently to not be provided.) When input arrives at an empty (or equivalently to not be provided). When input arrives at an
LFB, either the packet or its associated metadata must be non-empty LFB, either the packet or its associated metadata must be non-empty
or there is effectively no input. (LFB operation generally may be or there is effectively no input. (LFB operation generally may be
triggered by input arrival, by timers, or by other system state. It triggered by input arrival, by timers, or by other system state. It
is only in the case where the goal is to have input drive operation is only in the case where the goal is to have input drive operation
that the input must be non-empty.) that the input must be non-empty.)
The LFB processes the input, and produces one or more outputs, each The LFB processes the input, and produces one or more outputs, each
of which is a pair of a packet and its associated metadata. Again, of which is a pair of a packet and its associated metadata. Again,
depending upon the LFB output port definition, either the packet or depending upon the LFB output port definition, either the packet or
the metadata may be allowed to be empty (or equivalently to be the metadata may be allowed to be empty (or equivalently to be
absent.) Metadata attached to packets on output may be metadata that absent). Metadata attached to packets on output may be metadata that
was received, or may be information about the packet processing that was received, or may be information about the packet processing that
may be used by later LFBs in the FEs packet processing. may be used by later LFBs in the FEs packet processing.
A namespace is used to associate a unique name and ID with each LFB A namespace is used to associate a unique name and ID with each LFB
class. The namespace MUST be extensible so that a new LFB class can class. The namespace MUST be extensible so that a new LFB class can
be added later to accommodate future innovation in the forwarding be added later to accommodate future innovation in the forwarding
plane. plane.
LFB operation is specified in the model to allow the CE to understand LFB operation is specified in the model to allow the CE to understand
the behavior of the forwarding datapath. For instance, the CE needs the behavior of the forwarding data path. For instance, the CE needs
to understand at what point in the datapath the IPv4 header TTL is to understand at what point in the data path the IPv4 header TTL is
decremented by the FE. That is, the CE needs to know if a control decremented by the FE. That is, the CE needs to know if a control
packet could be delivered to it either before or after this point in packet could be delivered to it either before or after this point in
the datapath. In addition, the CE needs to understand where and what the data path. In addition, the CE needs to understand where and
type of header modifications (e.g., tunnel header append or strip) what type of header modifications (e.g., tunnel header append or
are performed by the FEs. Further, the CE works to verify that the strip) are performed by the FEs. Further, the CE works to verify
various LFBs along a datapath within an FE are compatible to link that the various LFBs along a data path within an FE are compatible
together. Connecting incompatible LFB instances will produce a non- to link together. Connecting incompatible LFB instances will produce
working data path. So the model is designed to provide sufficient a non-working data path. So the model is designed to provide
information for the CE to make this determination. sufficient information for the CE to make this determination.
Selecting the right granularity for describing the functions of the Selecting the right granularity for describing the functions of the
LFBs is an important aspect of this model. There is value to vendors LFBs is an important aspect of this model. There is value to vendors
if the operation of LFB classes can be expressed in sufficient detail if the operation of LFB classes can be expressed in sufficient detail
so that physical devices implementing different LFB functions can be so that physical devices implementing different LFB functions can be
integrated easily into an FE design. However, the model, and the integrated easily into an FE design. However, the model, and the
associated library of LFBs, must not be so detailed and so specific associated library of LFBs, must not be so detailed and so specific
as to significantly constrain implementations. Therefore, a semi- as to significantly constrain implementations. Therefore, a semi-
formal specification is needed; that is, a text description of the formal specification is needed; that is, a text description of the
LFB operation (human readable), but sufficiently specific and LFB operation (human readable), but sufficiently specific and
unambiguous to allow conformance testing and efficient design, so unambiguous to allow conformance testing and efficient design, so
that interoperability between different CEs and FEs can be achieved. that interoperability between different CEs and FEs can be achieved.
The LFB class model specifies information such as: The LFB class model specifies the following, among other information:
o number of inputs and outputs (and whether they are configurable) o number of inputs and outputs (and whether they are configurable)
o metadata read/consumed from inputs; o metadata read/consumed from inputs
o metadata produced at the outputs; o metadata produced at the outputs
o packet type(s) accepted at the inputs and emitted at the outputs; o packet types accepted at the inputs and emitted at the outputs
o packet content modifications (including encapsulation or o packet content modifications (including encapsulation or
decapsulation); decapsulation)
o packet routing criteria (when multiple outputs on an LFB are o packet routing criteria (when multiple outputs on an LFB are
present); present)
o packet timing modifications; o packet timing modifications
o packet flow ordering modifications; o packet flow ordering modifications
o LFB capability information components; o LFB capability information components
o events that can be detected by the LFB, with notification to the o events that can be detected by the LFB, with notification to the
CE; CE
o LFB operational components;
o etc. o LFB operational components
Section 4 of this document provides a detailed discussion of the LFB Section 4 of this document provides a detailed discussion of the LFB
model with a formal specification of LFB class schema. The rest of model with a formal specification of LFB class schema. The rest of
Section 3.2 only intends to provide a conceptual overview of some Section 3.2 only intends to provide a conceptual overview of some
important issues in LFB modeling, without covering all the specific important issues in LFB modeling, without covering all the 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
skipping to change at page 18, line 29 skipping to change at page 19, line 29
| ... +... | 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 are To accommodate a non-trivial LFB topology, multiple LFB outputs are
needed so that an LFB class can fork the datapath. Two mechanisms needed so that an LFB class can fork the data path. Two mechanisms
are provided for forking: multiple singleton outputs and output are provided for forking: multiple singleton outputs 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 predetermined number of semantically different outputs. That
That is, the LFB class definition MUST include the number of outputs, is, the LFB class definition MUST include the number of outputs,
implying the number of outputs is known when the LFB class is implying the number of outputs is known when the LFB class is
defined. Additional singleton outputs cannot be created at LFB defined. Additional singleton outputs cannot be created at LFB
instantiation time, nor can they be created on the fly after the LFB instantiation time, nor can they be created on the fly after the LFB
is instantiated. is instantiated.
For example, an IPv4 LPM (Longest-Prefix-Matching) LFB may have one For example, an IPv4 LPM (Longest-Prefix-Matching) LFB may have one
output (OUT) to send those packets for which the LPM look-up was output (OUT) to send those packets for which the LPM look-up was
successful, passing a META_ROUTEID as metadata; and have another successful, passing a META_ROUTEID as metadata; and have another
output (EXCEPTIONOUT) for sending exception packets when the LPM output (EXCEPTIONOUT) for sending exception packets when the LPM
look-up failed. This example is depicted in Figure 3.b. Packets look-up failed. This example is depicted in Figure 3.b. Packets
emitted by these two outputs not only require different downstream emitted by these two outputs not only require different downstream
treatment, but they are a result of two different conditions in the treatment, but they are a result of two different conditions in the
LFB and each output carries different metadata. This concept assumes LFB and each output carries different metadata. This concept assumes
the number of distinct outputs is known when the LFB class is that the number of distinct outputs is known when the LFB class is
defined. For each singleton output, the LFB class definition defines defined. For each singleton output, the LFB class definition defines
the types of frames (packets) and metadata the output emits. the types of frames (packets) and metadata the output emits.
An output group, on the other hand, is used to model the case where a An output group, on the other hand, is used to model the case where a
flow of similar packets with an identical set of permitted metadata flow of similar packets with an identical set of permitted metadata
needs to be split into multiple paths. In this case, the number of needs to be split into multiple paths. In this case, the number of
such paths is not known when the LFB class is defined because it is such paths is not known when the LFB class is defined because it is
not an inherent property of the LFB class. An output group consists not an inherent property of the LFB class. An output group consists
of a number of outputs, called the output instances of the group, of a number of outputs, called the output instances of the group,
where all output instances share the same frame (packet) and metadata where all output instances share the same frame (packet) and metadata
emission definitions (see Figure 3.c). Each output instance can emission definitions (see Figure 3.c). Each output instance can
connect to a different downstream LFB, just as if they were separate connect to a different downstream LFB, just as if they were separate
singleton outputs, but the number of output instances can differ singleton outputs, but the number of output instances can differ
between LFB instances of the same LFB class. The class definition between LFB instances of the same LFB class. The class definition
may include a lower and/or an upper limit on the number of outputs. may include a lower and/or an upper limit on the number of outputs.
In addition, for configurable FEs, the FE capability information may In addition, for configurable FEs, the FE capability information may
define further limits on the number of instances in specific output define further limits on the number of instances in specific output
groups for certain LFBs. The actual number of output instances in a groups for certain LFBs. The actual number of output instances in a
group is an component of the LFB instance, which is read-only for group is a component of the LFB instance, which is read-only for
static topologies, and read-write for dynamic topologies. The output static topologies, and read-write for dynamic topologies. The output
instances in a group are numbered sequentially, from 0 to N-1, and instances in a group are numbered sequentially, from 0 to N-1, and
are addressable from within the LFB. To use Output Port groups, the are addressable from within the LFB. To use Output Port groups, the
LFB has to have a built-in mechanism to select one specific output LFB has to have a built-in mechanism to select one specific output
instance for each packet. This mechanism is described in the textual instance for each packet. This mechanism is described in the textual
definition of the class and is typically configurable via some definition of the class and is typically configurable via some
attributes of the LFB. attributes of the LFB.
For example, consider a redirector LFB, whose sole purpose is to For example, consider a redirector 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 fairly metadata associated with each arriving packet. Such an LFB is fairly
versatile and can be used in many different places in a topology. versatile and can be used in many different places in a topology.
For example, given LFBs which record the type of packet in a For example, given LFBs that record the type of packet in a FRAMETYPE
FRAMETYPE metadatum, or a packet rate class in a COLOR metadatum, one metadatum, or a packet rate class in a COLOR metadatum, one may uses
may uses these metadata for branching. A redirector can be used to these metadata for branching. A redirector can be used to divide the
divide the data path into an IPv4 and an IPv6 path based on a data path into an IPv4 and an IPv6 path based on a FRAMETYPE
FRAMETYPE metadatum (N=2), or to fork into rate specific paths after metadatum (N=2), or to fork into rate-specific paths after metering
metering using the COLOR metadatum (red, yellow, green; N=3), etc. using the COLOR metadatum (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 the 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 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 metadatum value to output instance. table that maps a metadatum value to output instance.
Note that other LFBs may also use the output group concept to build Note that other LFBs may also use the output group concept to build
in similar adaptive forking capability. For example, a classifier in similar adaptive forking capability. For example, a classifier
LFB with one input and N outputs can be defined easily by using the LFB with one input and N outputs can be defined easily by using the
output group concept. Alternatively, a classifier LFB with one output group concept. Alternatively, a classifier LFB with one
singleton output in combination with an explicit N-output re- singleton output in combination with an explicit N-output re-director
director LFB models the same processing behavior. The decision of LFB models the same processing behavior. The decision of whether to
whether to use the output group model for a certain LFB class is left use the output group model for a certain LFB class is left to the LFB
to the LFB class designers. class designers.
The model allows the output group to be combined with other singleton The model allows the output group to be combined with other singleton
output(s) in the same class, as demonstrated in Figure 3.d. The LFB output(s) in the same class, as demonstrated in Figure 3.d. The LFB
here has two types of outputs, OUT, for normal packet output, and here has two types of outputs, OUT, for normal packet output, and
EXCEPTIONOUT for packets that triggered some exception. The normal EXCEPTIONOUT, for packets that triggered some exception. The normal
OUT has multiple instances, thus, it is an output group. OUT has multiple instances; thus, it is an output group.
In summary, the LFB class may define one output, multiple singleton In summary, the LFB class may define one output, multiple singleton
outputs, one or more output groups, or a combination thereof. outputs, one or more output groups, or a combination thereof.
Multiple singleton outputs should be used when the LFB must provide Multiple singleton outputs should be used when the LFB must provide
for forking the datapath and at least one of the following conditions for forking the data path and at least one of the following
hold: conditions hold:
o the number of downstream directions is inherent from the o the number of downstream directions is inherent from the
definition of the class and hence fixed; definition of the class and hence fixed
o the frame type and set of permitted metadata emitted on any of the o the frame type and set of permitted metadata emitted on any of the
outputs are different from what is emitted on the other outputs outputs are different from what is emitted on the other outputs
(i.e., they cannot share their frametype and permitted metadata (i.e., they cannot share their frametype and permitted metadata
definitions). definitions)
An output group is appropriate when the LFB must provide for forking An output group is appropriate when the LFB must provide for forking
the datapath and at least one of the following conditions hold: the data path and at least one of the following conditions hold:
o the number of downstream directions is not known when the LFB o the number of downstream directions is not known when the LFB
class is defined; class is defined
o the frame type and set of metadata emitted on these outputs are o the frame type and set of metadata emitted on these outputs are
sufficiently similar or, ideally, identical, such they can share sufficiently similar or, ideally, identical, such they can 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 on which the LFB can An LFB input is a conceptual port on an LFB on which the LFB can
receive information from other LFBs. The information is typically a receive information from other LFBs. The information is typically a
pair of a packet and its associated metadata. Either the packet, or pair of a packet and its associated metadata. Either the packet or
the metadata, may for some LFBs and some situations be empty. They the metadata may for some LFBs and some situations be empty. They
can not both be empty, as then there is no input. cannot both be empty, as then there is no input.
For LFB instances that receive packets from more than one other LFB For LFB instances that receive packets from more than one other LFB
instance (fan-in) there are three ways to model fan-in, all supported instance (fan-in), there are three ways to model fan-in, all
by the LFB model and can all be combined in the same LFB: supported by the LFB model and can all be combined in the same LFB:
o Implicit multiplexing via a single input o Implicit multiplexing via a single input
o Explicit multiplexing via multiple singleton inputs o Explicit multiplexing via multiple singleton inputs
o Explicit multiplexing via a group of inputs (input group) o Explicit multiplexing via a group of inputs (input group)
The simplest form of multiplexing uses a singleton input The simplest form of multiplexing uses a singleton input
(Figure 4.a). Most LFBs will have only one singleton input. (Figure 4.a). Most LFBs will have only one singleton input.
Multiplexing into a single input is possible because the model allows Multiplexing into a single input is possible because the model allows
more than one LFB output to connect to the same LFB input. This more than one LFB output to connect to the same LFB input. This
property applies to any LFB input without any special provisions in property applies to any LFB input without any special provisions in
the LFB class. Multiplexing into a single input is applicable when the LFB class. Multiplexing into a single input is applicable when
skipping to change at page 21, line 29 skipping to change at page 22, line 26
this model does not address how potential contention is handled when this model does not address how potential contention is handled when
multiple packets arrive simultaneously. If contention handling needs multiple packets arrive simultaneously. If contention handling needs
to be explicitly modeled, one of the other two modeling solutions to be explicitly modeled, one of the other two modeling solutions
must be used. must be used.
The second method to model fan-in uses individually defined singleton The second method to model fan-in uses individually defined singleton
inputs (Figure 4.b). This model is meant for situations where the inputs (Figure 4.b). This model is meant for situations where the
LFB needs to handle distinct types of packet streams, requiring LFB needs to handle distinct types of packet streams, requiring
input-specific handling inside the LFB, and where the number of such input-specific handling inside the LFB, and where the number of such
distinct cases is known when the LFB class is defined. For example, distinct cases is known when the LFB class is defined. For example,
an LFB which can perform both Layer 2 decapsulation (to Layer 3) and an LFB that can perform both Layer 2 decapsulation (to Layer 3) and
Layer 3 encapsulation (to Layer 2) may have two inputs, one for Layer 3 encapsulation (to Layer 2) may have two inputs, one for
receiving Layer 2 frames for decapsulation, and one for receiving receiving Layer 2 frames for decapsulation, and one for receiving
Layer 3 frames for encapsulation. This LFB type expects different Layer 3 frames for encapsulation. This LFB type expects different
frames (L2 vs. L3) at its inputs, each with different sets of frames (L2 versus L3) at its inputs, each with different sets of
metadata, and would thus apply different processing on frames metadata, and would thus apply different processing on frames
arriving at these inputs. This model is capable of explicitly arriving at these inputs. This model is capable of explicitly
addressing packet contention by defining how the LFB class handles addressing packet contention by defining how the LFB class handles
the contending packets. the contending packets.
+--------------+ +------------------------+ +--------------+ +------------------------+
| LFB X +---+ | | | LFB X +---+ | |
+--------------+ | | | +--------------+ | | |
| | | | | |
+--------------+ v | | +--------------+ v | |
skipping to change at page 23, line 40 skipping to change at page 24, line 19
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 4.c. Such an LFB receives packets from a number depicted in Figure 4.c. Such an LFB receives packets from a number
of Queue LFBs via a number of input instances, and uses the input of Queue LFBs via a number of input instances, and uses the input
index information to control contention resolution and scheduling. index information to control contention resolution and 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 via input allows for implicit multiplexing of similar packet streams via
connecting multiple outputs to the same input. Explicit multiple connecting multiple outputs to the same input. Explicit multiple
singleton inputs are useful when either the contention handling must singleton inputs are useful when either the contention handling must
be handled explicitly, or when the LFB class must receive and process be handled explicitly or when the LFB class must receive and process
a known number of distinct types of packet streams. An input group a known number of distinct types of packet streams. An input group
is suitable when contention handling must be modeled explicitly, but is suitable when contention handling must be modeled explicitly, but
the number of inputs is not inherent from the class (and hence is not the number of inputs is not inherent from the class (and hence is not
known when the class is defined), or when it is critical for LFB known when the class is defined), or when it is critical for LFB
operation to know exactly on which input the packet was received. operation to know exactly on which input the packet 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 the (e.g., IPv4, IPv6, Ethernet) MUST be specified. These are the types
types of packets that a given LFB input is capable of receiving and of packets that a given LFB input is capable of receiving and
processing, or that a given LFB output is capable of producing. This processing, or that a given LFB output is capable of producing. This
model requires that distinct packet types be uniquely labeled with a model requires that distinct packet types be uniquely labeled with a
symbolic name and/or ID. symbolic name and/or ID.
Note that each LFB has a set of packet types that it operates on, but Note that each LFB has a set of packet types that it operates on, but
does not care whether the underlying implementation is passing a does not care whether the underlying implementation is passing a
greater portion of the packets. For example, an IPv4 LFB might only greater portion of the packets. For example, an IPv4 LFB might only
operate on IPv4 packets, but the underlying implementation may or may operate on IPv4 packets, but the underlying implementation may or may
not be stripping the L2 header before handing it over. Whether such not be stripping the L2 header before handing it over. Whether or
processing is happening or not is opaque to the CE. not such processing is happening is opaque to the CE.
3.2.4. Metadata 3.2.4. Metadata
Metadata is state that is passed from one LFB to another alongside a Metadata is state that is passed from one LFB to another alongside a
packet. The metadata passed with the packet assists subsequent LFBs packet. The metadata passed with the packet assists subsequent LFBs
to process that packet. to process that packet.
The ForCES model defines metadata as precise atomic definitions in The ForCES model defines metadata as precise atomic definitions in
the form of label, value pairs. the form of label, value pairs.
The ForCES model provides to the authors of LFB classes a way to The ForCES model provides to the authors of LFB classes a way to
formally define how to achieve metadata creation, modification, formally define how to achieve metadata creation, modification,
reading, as well as consumption (deletion). reading, as well as consumption (deletion).
Inter-FE metadata, i.e, metadata crossing FEs, while it is likely to Inter-FE metadata, i.e., metadata crossing FEs, while it is likely to
be semantically similar to this metadata, is out of scope for this be semantically similar to this metadata, is out of scope for this
document. document.
Section 4 has informal details on metadata. Section 4 has informal details on metadata.
3.2.4.1. Metadata Lifecycle Within the ForCES Model 3.2.4.1. Metadata Lifecycle within the ForCES Model
Each metadatum is modeled as a <label, value> pair, where the label Each metadatum is modeled as a <label, value> pair, where the label
identifies the type of information, (e.g., "color"), and its value identifies the type of information (e.g., "color"), and its value
holds the actual information (e.g., "red"). The label here is shown holds the actual information (e.g., "red"). The label here is shown
as a textual label, but for protocol processing it is associated with as a textual label, but for protocol processing it is associated with
a unique numeric value (identifier). a unique numeric value (identifier).
To ensure inter-operability between LFBs, the LFB class specification To ensure inter-operability between LFBs, the LFB class specification
must define what metadata the LFB class "reads" or "consumes" on its must define what metadata the LFB class "reads" or "consumes" on its
input(s) and what metadata it "produces" on its output(s). For input(s) and what metadata it "produces" on its output(s). For
maximum extensibility, this definition should neither specify which maximum extensibility, this definition should specify neither which
LFBs the metadata is expected to come from for a consumer LFB, nor LFBs the metadata is expected to come from for a consumer LFB nor
which LFBs are expected to consume metadata for a given producer LFB. which LFBs are expected to consume metadata for a given producer LFB.
3.2.4.2. Metadata Production and Consumption 3.2.4.2. Metadata Production and Consumption
For a given metadatum on a given packet path, there MUST be at least For a given metadatum on a given packet path, there MUST be at least
one producer LFB that creates that metadatum and SHOULD be at least one producer LFB that creates that metadatum and SHOULD be at least
one consumer LFB that needs that metadatum. one consumer LFB that needs that metadatum.
In the ForCES model, the producer and consumer LFBs of a metadatum In the ForCES model, the producer and consumer LFBs of a metadatum
are not required to be adjacent. In addition, there may be multiple are not required to be adjacent. In addition, there may be multiple
producers and consumers for the same metadatum. When a packet path producers and consumers for the same metadatum. When a packet path
involves multiple producers of the same metadatum, then subsequent involves multiple producers of the same metadatum, then subsequent
producers overwrite that metadatum value. producers overwrite that metadatum value.
The metadata that is produced by an LFB is specified by the LFB class 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 always definition on a per-output-port-group basis. A producer may always
generate the metadata on the port group, or may generate it only generate the metadata on the port group, or may generate it only
under certain conditions. We call the former "unconditional" under certain conditions. We call the former "unconditional"
metadata, whereas the latter is a "conditional" metadata. For metadata, whereas the latter is "conditional" metadata. For example,
example, deep packet inspection LFB might produce several pieces of deep packet inspection LFB might produce several pieces of metadata
metadata about the packet. The first metadatum might be the IP about the packet. The first metadatum might be the IP protocol (TCP,
protocol (TCP, UDP, SCTP, ...) being carried, and two additional UDP, SCTP, ...) being carried, and two additional metadata items
metadata items might be the source and destination port number. might be the source and destination port number. These additional
These additional metadata items are conditional on the value of the metadata items are conditional on the value of the first metadatum
first metadatum (IP carried protocol) as they are only produced for (IP carried protocol) as they are only produced for protocols that
protocols which use port numbers. In the case of conditional use port numbers. In the case of conditional metadata, it should be
metadata, it should be possible to determine from the definition of possible to determine from the definition of the LFB when
the LFB when "conditional" metadata is produced. The consumer "conditional" metadata is produced. The consumer behavior of an LFB,
behavior of an LFB, that is, the metadata that the LFB needs for its that is, the metadata that the LFB needs for its operation, is
operation, is defined in the LFB class definition on a per-input- defined in the LFB class definition on a per-input-port-group basis.
port-group basis. An input port group may "require" a given An input port group may "require" a given metadatum, or may treat it
metadatum, or may treat it as "optional" information. In the latter as "optional" information. In the latter case, the LFB class
case, the LFB class definition MUST explicitly define what happens if definition MUST explicitly define what happens if any optional
any optional metadata is not provided. One approach is to specify a metadata is not provided. One approach is to specify a default value
default value for each optional metadatum, and assume that the for each optional metadatum, and assume that the default value is
default value is used for any metadata which is not provided with the used for any metadata that is not provided with the packet.
packet.
When specifying the metadata tags, some harmonization effort must be When specifying the metadata tags, some harmonization effort must be
made so that the producer LFB class uses the same tag as its intended made so that the producer LFB class uses the same tag as its intended
consumer(s). consumer(s).
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 is When the packet is processed by an LFB (i.e., between the time it is
received and forwarded by the LFB), the LFB may perform read, write, received and forwarded by the LFB), the LFB may perform read, write,
and/or consume operations on any active metadata associated with the and/or consume operations on any active metadata associated with the
packet. If the LFB is considered to be a black box, one of the packet. If the LFB is considered to be a black box, one of the
following operations is performed on each active metadatum. following operations is performed on each active metadatum.
* IGNORE: ignores and forwards the metadatum * IGNORE: ignores and forwards the metadatum
* READ: reads and forwards the metadatum * READ: reads and forwards the metadatum
* READ/RE-WRITE: reads, over-writes and forwards the metadatum
* READ/RE-WRITE: reads, over-writes, and forwards the metadatum
* WRITE: writes and forwards the metadatum (can also be used to * WRITE: writes and forwards the metadatum (can also be used to
create new metadata) create new metadata)
* READ-AND-CONSUME: reads and consumes the metadatum * READ-AND-CONSUME: reads and consumes the metadatum
* CONSUME consumes metadatum without reading * CONSUME: consumes metadatum without reading
The last two operations terminate the life-cycle of the metadatum, The last two operations terminate the life-cycle of the metadatum,
meaning that the metadatum is not forwarded with the packet when the meaning that the metadatum is not forwarded with the packet when the
packet is sent to the next LFB. packet is sent to the next LFB.
In the ForCES model, a new metadatum is generated by an LFB when the In the ForCES model, a new metadatum is generated by an LFB when the
LFB applies a WRITE operation to a metadatum type that was not LFB applies a WRITE operation to a metadatum type that was not
present when the packet was received by the LFB. Such implicit present when the packet was received by the LFB. Such implicit
creation may be unintentional by the LFB, that is, the LFB may apply creation may be unintentional by the LFB; that is, the LFB may apply
the WRITE operation without knowing or caring if the given metadatum the WRITE operation without knowing or caring whether or not the
existed or not. If it existed, the metadatum gets over-written; if given metadatum existed. If it existed, the metadatum gets over-
it did not exist, the metadatum is created. written; if it did not exist, the metadatum 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 READ- For LFBs that remove the packet from the model, they may either READ-
AND-CONSUME (read) or CONSUME (ignore) each active metadatum AND-CONSUME (read) or CONSUME (ignore) each active metadatum
associated with the packet. associated with the packet.
3.2.5. LFB Events 3.2.5. LFB Events
During operation, various conditions may occur that can be detected During operation, various conditions may occur that can be detected
by LFBs. Examples range from link failure or restart to timer by LFBs. Examples range from link failure or restart to timer
expiration in special purpose LFBs. The CE may wish to be notified expiration in special purpose LFBs. The CE may wish to be notified
of the occurrence of such events. The description of how such of the occurrence of such events. The description of how such
messages are sent, and their format, is part of the Forwarding and messages are sent, and their format, is part of the Forwarding and
Control Element Separation (ForCES) protocol [2] document. Control Element Separation (ForCES) protocol [RFC5810] document.
Indicating how such conditions are understood is part of the job of Indicating how such conditions are understood is part of the job of
this model. this model.
Events are declared in the LFB class definition. The LFB event Events are declared in the LFB class definition. The LFB event
declaration constitutes: declaration constitutes:
o a unique 32 bit identifier. o a unique 32-bit identifier.
o An LFB component which is used to trigger the event. This entity o An LFB component that is used to trigger the event. This entity
is known as the event target. is known as the event target.
o A condition that will happen to the event target that will result o A condition that will happen to the event target that will result
in a generation of an event to the CE. Examples of a condition in a generation of an event to the CE. Examples of a condition
include something getting created, deleted, config change, etc. include something getting created or deleted, a config change,
etc.
o What should be reported to the CE by the FE if the declared o What should be reported to the CE by the FE if the declared
condition is met. condition is met.
The declaration of an event within an LFB class essentially defines The declaration of an event within an LFB class essentially defines
what part of the LFB component(s) need to be monitored for events, what part of the LFB component(s) need to be monitored for events,
what condition on the LFB monitored LFB component an FE should detect what condition on the LFB monitored LFB component an FE should detect
to trigger such an event, and what to report to the CE when the event to trigger such an event, and what to report to the CE when the event
is triggered. is triggered.
While events may be declared by the LFB class definition, runtime While events may be declared by the LFB class definition, runtime
activity is controlled using built-in event properties using LFB activity is controlled using built-in event properties using LFB
component Properties (discussed in Section 3.2.6). A CE subscribes component properties (discussed in Section 3.2.6). A CE subscribes
to the events on an LFB class instance by setting an event property to the events on an LFB class instance by setting an event property
for subscription. Each event has a subscription property which is by for subscription. Each event has a subscription property that is by
default off. A CE wishing to receive a specific event needs to turn default off. A CE wishing to receive a specific event needs to turn
on the subscription property at runtime. on the subscription property at runtime.
Event properties also provide semantics for runtime event filtering. Event properties also provide semantics for runtime event filtering.
A CE may set an event property to further suppress events to which it A CE may set an event property to further suppress events to which it
has already subscribed. The LFB model defines such filters to has already subscribed. The LFB model defines such filters to
include threshold values, hysteresis, time intervals, number of include threshold values, hysteresis, time intervals, number of
events, etc. events, etc.
The contents of reports with events are designed to allow for the The contents of reports with events are designed to allow for the
common, closely related information that the CE can be strongly common, closely related information that the CE can be strongly
expected to need to react to the event. It is not intended to carry expected to need to react to the event. It is not intended to carry
information that the CE already has, nor large volumes of information that the CE already has, large volumes of information, or
information, nor information related in complex fashions. information related in complex fashions.
From a conceptual point of view, at runtime, event processing is From a conceptual point of view, at runtime, event processing is
split into: split into:
1. detection of something happening to the (declared during LFB 1. Detection of something happening to the (declared during LFB
class definition) event target. Processing the next step happens class definition) event target. Processing the next step happens
if the CE subscribed (at runtime) to the event. if the CE subscribed (at runtime) to the event.
2. checking of the (declared during LFB class definition) condition 2. Checking of the (declared during LFB class definition) condition
on the LFB event target. If the condition is met, proceed with on the LFB event target. If the condition is met, proceed with
the next step. the next step.
3. checking (runtime set) event filters if they exist to see if the 3. Checking (runtime set) event filters if they exist to see if the
event should be reported or suppressed. If the event is to be event should be reported or suppressed. If the event is to be
reported proceed to the next step. reported, proceed to the next step.
4. Submitting of the declared report to the CE. 4. Submitting of the declared report to the CE.
Section 4.7.6 discusses events in more details. Section 4.7.6 discusses events in more details.
3.2.6. Component Properties 3.2.6. Component Properties
LFBs and structures are made up of Components, containing the LFBs and structures are made up of components, containing the
information that the CE needs to see and/or change about the information that the CE needs to see and/or change about the
functioning of the LFB. These Components, as described in detail in functioning of the LFB. These components, as described in detail in
Section 4.7, may be basic values, complex structures (containing Section 4.7, may be basic values, complex structures (containing
multiple Components themselves, each of which can be values, multiple components themselves, each of which can be values,
structures, or tables), or tables (which contain values, structures structures, or tables), or tables (which contain values, structures,
or tables). Components may be defined such that their appearence in or tables). Components may be defined such that their appearance in
LFB instances is optional. Components may be readable or writable at LFB instances is optional. Components may be readable or writable at
the discretion of the FE implementation. The CE needs to know these the discretion of the FE implementation. The CE needs to know these
properties. Additionally, certain kinds of Components (arrays / properties. Additionally, certain kinds of components (arrays /
tables, aliases, and events) have additional property information tables, aliases, and events) have additional property information
that the CE may need to read or write. This model defines the that the CE may need to read or write. This model defines the
structure of the property information for all defined data types. structure of the property information for all defined data types.
Section 4.8 describes properties in more details. Section 4.8 describes properties in more details.
3.2.7. LFB Versioning 3.2.7. LFB Versioning
LFB class versioning is a method to enable incremental evolution of LFB class versioning is a method to enable incremental evolution 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.8) has special rules. If Inheritance (discussed next in Section 3.2.8) has special rules. If
an FE datapath model containing an LFB instance of a particular class an FE data path model containing an LFB instance of a particular
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 MUST particular LFB class to provide backward compatibility, but FEs MUST
NOT support more than one version of a particular class. NOT support more than one version of a particular class.
Versioning is not restricted to making backwards compatible changes. Versioning is not restricted to making backward-compatible changes.
It is specifically expected to be used to make changes that cannot be It is specifically expected to be used to make changes that cannot be
represented by inheritance. Often this will be to correct errors, represented by inheritance. Often this will be to correct errors,
and hence may not be backwards compatible. It may also be used to and hence may not be backward compatible. It may also be used to
remove components which are not considered useful (particularly if remove components that are not considered useful (particularly if
they were previously mandatory, and hence were an implementation they were previously mandatory, and hence were an implementation
impediment.) impediment).
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 vendor- define new LFB classes. This also allows FE vendors to add vendor-
specific extensions to standardized LFBs. An LFB class specification specific extensions to standardized LFBs. An LFB class specification
MUST specify the base class and version number it inherits from (the MUST specify the base class and version number it inherits from (the
default is the base LFB class). Multiple inheritance is not allowed, default is the base LFB class). Multiple inheritance is not allowed,
however, to avoid unnecessary complexity. however, to avoid unnecessary 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 the defined if little or no reuse is possible between the derived and the
base LFB class. 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. Consider compatibility between a descendant and an ancestor class. Consider
the following hypothetical scenario where a standardized LFB class the following hypothetical scenario where a standardized LFB class
"L1" exists. Vendor A builds an FE that implements LFB "L1" and "L1" exists. Vendor A builds an FE that implements LFB "L1", and
vendor B builds a CE that can recognize and operate on LFB "L1". vendor B builds a CE that can recognize and operate on LFB "L1".
Suppose that a new LFB class, "L2", is defined based on the existing Suppose that a new LFB class, "L2", is defined based on the existing
"L1" class by extending its capabilities incrementally. Let us "L1" class by extending its capabilities incrementally. Let us
examine the FE backward compatibility issue by considering what would examine the FE backward-compatibility issue by considering what would
happen if vendor B upgrades its FE from "L1" to "L2" and vendor C's happen if vendor B upgrades its FE from "L1" to "L2" and vendor C's
CE is not changed. The old L1-based CE can interoperate with the new CE is not changed. The old L1-based CE can interoperate with the new
L2-based FE if the derived LFB class "L2" is indeed backward L2-based FE if the derived LFB class "L2" is indeed backward
compatible with the base class "L1". compatible with the base class "L1".
The reverse scenario is a much less problematic case, i.e., when CE The reverse scenario is a much less problematic case, i.e., when 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 we older LFB classes, this problem does not affect the model; hence we
will use the term "backward compatibility" to refer to the first will use the term "backward compatibility" to refer to the first
scenario concerning FE backward compatibility. scenario concerning FE backward compatibility.
Backward compatibility can be designed into the inheritance model by Backward compatibility can be designed into the inheritance model by
constraining LFB inheritance to require the derived class be a constraining LFB inheritance to require that 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 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 class of such an the CE, the CE MUST be able to query the base class of such an
LFB from the FE. 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 back compatibility mode (meaning the LFB instance reverts itself back
to the base class instance), and the CE SHOULD be able to to the base class instance), and the CE SHOULD be able to
configure the LFB to run in such a mode. configure the LFB to run in such a mode.
3.3. ForCES Model Addressing 3.3. ForCES Model Addressing
Figure 5 demonstrates the abstraction of the different ForCES model Figure 5 demonstrates the abstraction of the different ForCES model
entities. The ForCES protocol provides the mechanism to uniquely entities. The ForCES protocol provides the mechanism to uniquely
identify any of the LFB Class instance components. identify any of the LFB class instance components.
FE Address = FE01 FE Address = FE01
+--------------------------------------------------------------+ +--------------------------------------------------------------+
| | | |
| +--------------+ +--------------+ | | +--------------+ +--------------+ |
| | LFB ClassID 1| |LFB ClassID 91| | | | LFB ClassID 1| |LFB ClassID 91| |
| | InstanceID 3 |============>|InstanceID 3 |======>... | | | InstanceID 3 |============>|InstanceID 3 |======>... |
| | +----------+ | | +----------+ | | | | +----------+ | | +----------+ | |
| | |Components| | | |Components| | | | | |Components| | | |Components| | |
| | +----------+ | | +----------+ | | | | +----------+ | | +----------+ | |
| +--------------+ +--------------+ | | +--------------+ +--------------+ |
| | | |
+--------------------------------------------------------------+ +--------------------------------------------------------------+
Figure 5: FE Entity Hierarchy Figure 5: FE entity hierarchy.
At the top of the addressing hierachy is the FE identifier. In the At the top of the addressing hierarchy is the FE identifier. In the
example above, the 32-bit FE identifier is illustrated with the example above, the 32-bit FE identifier is illustrated with the
mnemonic FE01. The next 32-bit entity selector is the LFB ClassID. mnemonic FE01. The next 32-bit entity selector is the LFB ClassID.
In the illustration above, two LFB classes with identifiers 1 and 91 In the illustration above, two LFB classes with identifiers 1 and 91
are demonstrated. The example above further illustrates one instance are demonstrated. The example above further illustrates one instance
of each of the two classes. The scope of the 32-bit LFB class of each of the two classes. The scope of the 32-bit LFB class
instance identifier is valid only within the LFB class. To emphasize instance identifier is valid only within the LFB class. To emphasize
that point, each of class 1 and 91 has an instance of 3. that point, each of class 1 and 91 has an instance of 3.
Using the described addressing scheme, a message could be sent to Using the described addressing scheme, a message could be sent to
address FE01, LFB ClassID 1, LFB InstanceID 3, utilizing the ForCES address FE01, LFB ClassID 1, LFB InstanceID 3, utilizing the ForCES
skipping to change at page 31, line 29 skipping to change at page 31, line 45
| +----------------------+ | | +----------------------+ |
| | LFB ComponentID 89 | | | | LFB ComponentID 89 | |
| | +-----------------+ | | | | +-----------------+ | |
| | | | | | | | | | | |
| | +-----------------+ | | | | +-----------------+ | |
| +----------------------+ | | +----------------------+ |
| | | |
| | | |
+-------------------------------------+ +-------------------------------------+
Figure 6: LFB Hierarchy Figure 6: LFB hierarchy.
Figure 6 zooms into the components carried by LFB Class ID 1, LFB Figure 6 zooms into the components carried by LFB Class ID 1, LFB
InstanceID 3 from Figure 5. InstanceID 3 from Figure 5.
The example shows three components with 32-bit component identifiers The example shows three components with 32-bit component identifiers
1, 31, and 51. LFB ComponentID 51 is a complex structure 1, 31, and 51. LFB ComponentID 51 is a complex structure
encapsulating within it an entity with LFB ComponentID 89. LFB encapsulating within it an entity with LFB ComponentID 89. LFB
ComponentID 89 could be a complex structure itself but is restricted ComponentID 89 could be a complex structure itself, but is restricted
in the example for the sake of clarity. in the example for the sake of clarity.
3.3.1. Addressing LFB Components: Paths and Keys 3.3.1. Addressing LFB Components: Paths and Keys
As mentioned above, LFB components could be complex structures, such As mentioned above, LFB components could be complex structures, such
as a table, or even more complex structures such as a table whose as a table, or even more complex structures such as a table whose
cells are further tables, etc. The ForCES model XML schema cells are further tables, etc. The ForCES model XML schema
(Section 4) allows for uniquely identifying anything with such (Section 4) allows for uniquely identifying anything with such
complexity, utilizing the concept of dot-annotated static paths and complexity, utilizing the concept of dot-annotated static paths and
content addressing of paths as derived from keys. As an example, if content addressing of paths as derived from keys. As an example, if
the LFB Component 51 were a structure, then the path to LFB LFB ComponentID 51 were a structure, then the path to LFB ComponentID
ComponentID 89 above will be 51.89. 89 above will be 51.89.
LFB ComponentID 51 might represent a table (an array). In that case, LFB ComponentID 51 might represent a table (an array). In that case,
to select the LFB Component with ID 89 from within the 7th entry of to select the LFB component with ID 89 from within the 7th entry of
the table, one would use the path 51.7.89. In addition to supporting the table, one would use the path 51.7.89. In addition to supporting
explicit table element selection by including an index in the dotted explicit table element selection by including an index in the dotted
path, the model supports identifying table elements by their path, the model supports identifying table elements by their
contents. This is referred to as using keys, or key indexing. So, contents. This is referred to as using keys, or key indexing. So,
as a further example, if ComponentID 51 was a table which was key as a further example, if ComponentID 51 was a table that was key
index-able, then a key describing content could also be passed by the index-able, then a key describing content could also be passed by the
CE, along with path 51 to select the table, and followed by the path CE, along with path 51 to select the table, and followed by the path
89 to select the table structure element, which upon computation by 89 to select the table structure element, which upon computation by
the FE would resolve to the LFB ComponentID 89 within the specified the FE would resolve to the LFB ComponentID 89 within the specified
table entry. table entry.
3.4. FE Datapath Modeling 3.4. FE Data Path Modeling
Packets coming into the FE from ingress ports generally flow through Packets coming into the FE from ingress ports generally flow through
one or more LFBs before leaving out of the egress ports. How an FE one or more LFBs before leaving out of the egress ports. How an FE
treats a packet depends on many factors, such as type of the packet treats a packet depends on many factors, such as type of the packet
(e.g., IPv4, IPv6, or MPLS), header values, time of arrival, etc. (e.g., IPv4, IPv6, or MPLS), header values, time of arrival, etc.
The result of LFB processing may have an impact on how the packet is The result of LFB processing may have an impact on how the packet is
to be treated in downstream LFBs. This differentiation of packet to be treated in downstream LFBs. This differentiation of packet
treatment downstream can be conceptualized as having alternative treatment downstream can be conceptualized as having alternative data
datapaths in the FE. For example, the result of a 6-tuple paths in the FE. For example, the result of a 6-tuple classification
classification performed by a classifier LFB could control which rate performed by a classifier LFB could control which rate meter is
meter is applied to the packet by a rate meter LFB in a later stage applied to the packet by a rate meter LFB in a later stage in the
in the datapath. data path.
LFB topology is a directed graph representation of the logical LFB topology is a directed graph representation of the logical data
datapaths within an FE, with the nodes representing the LFB instances paths within an FE, with the nodes representing the LFB instances and
and the directed link depicting the packet flow direction from one the directed link depicting the packet flow direction from one LFB to
LFB to the next. Section 3.4.1 discusses how the FE datapaths can be the next. Section 3.4.1 discusses how the FE data paths can be
modeled as LFB topology; while Section 3.4.2 focuses on issues modeled as LFB topology, while Section 3.4.2 focuses on issues
related to LFB topology reconfiguration. related to LFB topology reconfiguration.
3.4.1. Alternative Approaches for Modeling FE Datapaths 3.4.1. Alternative Approaches for Modeling FE Data Paths
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 data path 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).
o Topological Approach o Topological Approach
Using this approach, differential packet treatment is expressed by Using this approach, differential packet treatment is expressed by
splitting the LFB topology into alternative paths. In other words, splitting the LFB topology into alternative paths. In other words,
if the result of an LFB operation controls how the packet is further if the result of an LFB operation controls how the packet is further
processed, then such an LFB will have separate output ports, one for processed, then such an LFB will have separate output ports, one for
each alternative treatment, connected to separate sub-graphs, each each alternative treatment, connected to separate sub-graphs, each
skipping to change at page 33, line 14 skipping to change at page 33, line 33
o Encoded State Approach o Encoded State Approach
An alternate way of expressing differential treatment is by using An alternate way of expressing differential treatment is by using
metadata. The result of the operation of an LFB can be encoded in a metadata. The result of the operation of an LFB can be encoded in a
metadatum, which is passed along with the packet to downstream LFBs. metadatum, which is passed along with the packet to downstream LFBs.
A downstream LFB, in turn, can use the metadata and its value (e.g., A downstream LFB, in turn, can use the metadata and its value (e.g.,
as an index into some table) to determine how to treat the packet. as an index into some table) to determine how to treat the packet.
Theoretically, either approach could substitute for the other, so one Theoretically, either approach could substitute for the other, so one
could consider using a single pure approach to describe all datapaths could consider using a single pure approach to describe all data
in an FE. However, neither model by itself results in the best paths in an FE. However, neither model by itself results in the best
representation for all practically relevant cases. For a given FE representation for all practically relevant cases. For a given FE
with certain logical datapaths, applying the two different modeling with certain logical data paths, applying the two different modeling
approaches will result in very different looking LFB topology graphs. approaches will result in very different looking LFB topology graphs.
A model using only the topological approach may require a very large A model using only the topological approach may require a very large
graph with many links or paths, and nodes (i.e., LFB instances) to graph with many links or paths, and nodes (i.e., LFB instances) to
express all alternative datapaths. On the other hand, a model using express all alternative data paths. On the other hand, a model using
only the encoded state model would be restricted to a string of LFBs, only the encoded state model would be restricted to a string of LFBs,
which is not an intuitive way to describe different datapaths (such which is not an intuitive way to describe different data paths (such
as MPLS and IPv4). Therefore, a mix of these two approaches will as MPLS and IPv4). Therefore, a mix of these two approaches will
likely be used for a practical model. In fact, as we illustrate likely be used for a practical model. In fact, as we illustrate
below, the two approaches can be mixed even within the same LFB. below, the two approaches can be mixed even within the same LFB.
Using a simple example of a classifier with N classification outputs Using a simple example of a classifier with N classification outputs
followed by other LFBs, Figure 7.a shows what the LFB topology looks followed by other LFBs, Figure 7.a shows what the LFB topology looks
like when using the pure topological approach. Each output from the like when using the pure topological approach. Each output from the
classifier goes to one of the N LFBs where no metadata is needed. classifier goes to one of the N LFBs where no metadata is needed.
The topological approach is simple, straightforward and graphically The topological approach is simple, straightforward, and graphically
intuitive. However, if N is large and the N nodes following the intuitive. However, if N is large and the N nodes following the
classifier (LFB#1, LFB#2, ..., LFB#N) all belong to the same LFB type classifier (LFB#1, LFB#2, ..., LFB#N) all belong to the same LFB type
(e.g., meter), but each has its own independent components, the (e.g., meter), but each has its own independent components, the
encoded state approach gives a much simpler topology representation, encoded state approach gives a much simpler topology representation,
as shown in Figure 7.b. The encoded state approach requires that a as shown in Figure 7.b. The encoded state approach requires that a
table of N rows of meter components is provided in the Meter node table of N rows of meter components be provided in the Meter node
itself, with each row representing the attributes for one meter itself, with each row representing the attributes for one meter
instance. A metadatum M is also needed to pass along with the packet instance. A metadatum M is also needed to pass along with the packet
P from the classifier to the meter, so that the meter can use M as a P from the classifier to the meter, so that the meter can use M as a
look-up key (index) to find the corresponding row of the attributes look-up key (index) to find the corresponding row of the attributes
that should be used for any particular packet P. that should be used for any particular packet P.
What if those N nodes (LFB#1, LFB#2, ..., LFB#N) are not of the same What if those N nodes (LFB#1, LFB#2, ..., LFB#N) are not of the 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 it meters, what is the best way to represent such data paths? While it
is still possible to use either the pure topological approach or the is still possible to use either the pure topological approach or the
pure encoded state approach, the natural combination of the two pure encoded state approach, the natural combination of the two
appears to be the best option. Figure 7.c depicts two different appears to be the best option. Figure 7.c depicts two different
functional datapaths using the topological approach while leaving the functional data paths using the topological approach while leaving
N-1 meter instances distinguished by metadata only, as shown in the N-1 meter instances distinguished by metadata only, as shown in
Figure 7.c. Figure 7.c.
+----------+ +----------+
P | LFB#1 | P | LFB#1 |
+--------->|(Compon-1)| +--------->|(Compon-1)|
+-------------+ | +----------+ +-------------+ | +----------+
| 1|------+ P +----------+ | 1|------+ P +----------+
| 2|---------------->| LFB#2 | | 2|---------------->| LFB#2 |
| classifier 3| |(Compon-2)| | classifier 3| |(Compon-2)|
| ...|... +----------+ | ...|... +----------+
skipping to change at page 34, line 48 skipping to change at page 35, line 30
| 3| (P, M) +-------------+ | 3| (P, M) +-------------+
| ...|------------->| Meter | | ...|------------->| Meter |
| N| | (Compon-2) | | N| | (Compon-2) |
+-------------+ | ... | +-------------+ | ... |
| (Compon-N) | | (Compon-N) |
+-------------+ +-------------+
(c) Using a combination of the two, if LFB#1, LFB#2, ..., and (c) Using a combination of the two, if LFB#1, LFB#2, ..., and
LFB#N are of different types (e.g., queue and meter). LFB#N are of different types (e.g., queue and meter).
Figure 7: An example of how to model FE datapaths Figure 7: An example of how to model FE data paths.
From this example, we demonstrate that each approach has a distinct From this example, we demonstrate that each approach has a distinct
advantage depending on the situation. Using the encoded state advantage depending on the situation. Using the encoded state
approach, fewer connections are typically needed between a fan-out approach, fewer connections are typically needed between a fan-out
node and its next LFB instances of the same type because each packet node and its next LFB instances of the same type because each packet
carries metadata the following nodes can interpret and hence invoke a carries metadata the following nodes can interpret and hence invoke a
different packet treatment. For those cases, a pure topological different packet treatment. For those cases, a pure topological
approach forces one to build elaborate graphs with many more approach forces one to build elaborate graphs with many more
connections and often results in an unwieldy graph. On the other connections and often results in an unwieldy graph. On the other
hand, a topological approach is the most intuitive for representing hand, a topological approach is the most intuitive for representing
functionally different datapaths. functionally different data paths.
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 which flexible. A general design guideline is provided to indicate which
approach is best used for a particular situation. The topological approach is best used for a particular situation. The topological
approach should primarily be used when the packet datapath forks to approach should primarily be used when the packet data path forks to
distinct LFB classes (not just distinct parameterizations of the same distinct LFB classes (not just distinct parameterizations of the same
LFB class), and when the fan-outs do not require changes, such as LFB class), and when the fan-outs do not require changes, such as
adding/removing LFB outputs, or require only very infrequent changes. adding/removing LFB outputs, or require only very infrequent changes.
Configuration information that needs to change frequently should be Configuration information that needs to change frequently should be
expressed by using the internal attributes of one or more LFBs (and expressed by using the internal attributes of one or more LFBs (and
hence using the encoded state approach). hence using the encoded state approach).
+---------------------------------------------+ +---------------------------------------------+
| | | |
+----------+ V +----------+ +------+ | +----------+ V +----------+ +------+ |
| | | | |if IP-in-IP| | | | | | | |if IP-in-IP| | |
---->| ingress |->+----->|classifier|---------->|Decap.|---->---+ ---->| ingress |->+----->|classifier|---------->|Decap.|---->---+
| ports | | |---+ | | | ports | | |---+ | |
skipping to change at page 35, line 43 skipping to change at page 36, line 27
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 independent (b) The LFB topology without the loop utilizing two independent
classifier instances. classifier instances.
Figure 8: An LFB topology example. Figure 8: An LFB topology example.
It is important to point out that the LFB topology described here is It is important to point out that the LFB topology described here 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 to implementation may still influence how the functionality is mapped to
the LFB topology. Figure 8 shows one simple FE example. In this the LFB topology. Figure 8 shows one simple FE example. In this
example, an IP-in-IP packet from an IPSec application like VPN may go example, an IP-in-IP packet from an IPsec application like VPN may go
to the classifier first and have the classification done based on the to the classifier first and have the classification done based on the
outer IP header; upon being classified as an IP-in-IP packet, the outer IP header. Upon being classified as an IP-in-IP packet, the
packet is then sent to a decapsulator to strip off the outer IP packet is then sent to a decapsulator to strip off the outer IP
header, followed by a classifier again to perform classification on header, followed by a classifier again to perform classification on
the inner IP header. If the same classifier hardware or software is the inner IP header. If the same classifier hardware or software is
used for both outer and inner IP header classification with the same used for both outer and inner IP header classification with the same
set of filtering rules, a logical loop is naturally present in the set of filtering rules, a logical loop is naturally present in the
LFB topology, as shown in Figure 8.a. However, if the classification LFB topology, as shown in Figure 8.a. However, if the classification
is implemented by two different pieces of hardware or software with is implemented by two different pieces of hardware or software with
different filters (i.e., one set of filters for the outer IP header different filters (i.e., one set of filters for the outer IP header
and another set for the inner IP header), then it is more natural to and another set for the inner IP header), then it is more natural to
model them as two different instances of classifier LFB, as shown in model them as two different instances of classifier LFB, as shown in
Figure 8.b. Figure 8.b.
3.4.2. Configuring the LFB Topology 3.4.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 data paths within an FE, configuring the LFB
topology means dynamically changing the datapaths, including changing topology means dynamically changing the data paths, including
the LFBs along the datapaths on an FE (e.g., creating/instantiating, changing the LFBs along the data paths on an FE (e.g., creating/
updating or deleting LFBs) and setting up or deleting instantiating, updating, 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 data paths on an FE ever change dynamically? The data
datapaths on an FE are set up by the CE to provide certain data plane paths on an FE are set up by the CE to provide certain data plane
services (e.g., DiffServ, VPN, etc.) to the Network Element's (NE) services (e.g., Diffserv, VPN) to the network element's (NE)
customers. The purpose of reconfiguring the datapaths is to enable customers. The purpose of reconfiguring the data paths is to enable
the CE to customize the services the NE is delivering at run time. the CE to customize the services the NE is delivering at run time.
The CE needs to change the datapaths when the service requirements The CE needs to change the data paths when the service requirements
change, such as adding a new customer or when an existing customer change, such as adding a new customer or when an existing customer
changes their service. However, note that not all datapath changes changes their service. However, note that not all data path changes
result in changes in the LFB topology graph. Changes in the graph result in changes in the LFB topology graph. Changes in the graph
are dependent on the approach used to map the datapaths into LFB are dependent on the approach used to map the data paths into LFB
topology. As discussed in Section 3.4.1, the topological approach topology. As discussed in Section 3.4.1, the topological approach
and encoded state approach can result in very different looking LFB and encoded state approach can result in very different looking LFB
topologies for the same datapaths. In general, an LFB topology based topologies for the same data paths. In general, an LFB topology
on a pure topological approach is likely to experience more frequent based on a pure topological approach is likely to experience more
topology reconfiguration than one based on an encoded state approach. frequent topology reconfiguration than one based on an encoded state
However, even an LFB topology based entirely on an encoded state approach. However, even an LFB topology based entirely on an encoded
approach may have to change the topology at times, for example, to state approach may have to change the topology at times, for example,
bypass some LFBs or insert new LFBs. Since a mix of these two to bypass some LFBs or insert new LFBs. Since a mix of these two
approaches is used to model the datapaths, LFB topology approaches is used to model the data paths, LFB topology
reconfiguration is considered an important aspect of the FE model. reconfiguration is considered an important aspect of the FE model.
We want to point out that allowing a configurable LFB topology in the We want to point out that allowing a configurable LFB topology in the
FE model does not mandate that all FEs are required to have this FE model does not mandate that all FEs are required to have this
capability. Even if an FE supports configurable LFB topology, the FE capability. Even if an FE supports configurable LFB topology, the FE
may impose limitations on what can actually be configured. may impose limitations on what can actually be configured.
Performance-optimized hardware implementations may have zero or very Performance-optimized hardware implementations may have zero or very
limited configurability, while FE implementations running on network limited configurability, while FE implementations running on network
processors may provide more flexibility and configurability. It is processors may provide more flexibility and configurability. It is
entirely up to the FE designers to decide whether or not the FE entirely up to the FE designers to decide whether or not the FE
actually implements reconfiguration and if so, how much. Whether a actually implements reconfiguration and if so, how much. Whether a
simple runtime switch is used to enable or disable (i.e., bypass) simple runtime switch is used to enable or disable (i.e., bypass)
certain LFBs, or more flexible software reconfiguration is used, is certain LFBs, or more flexible software reconfiguration is used, is
an implementation detail internal to the FE and outside of the scope an implementation detail internal to the FE and outside the scope of
of FE model. In either case, the CE(s) MUST be able to learn the the FE model. In either case, the CE(s) MUST be able to learn the
FE's configuration capabilities. Therefore, the FE model MUST FE's configuration capabilities. Therefore, the FE model MUST
provide a mechanism for describing the LFB topology configuration provide a mechanism for describing the LFB topology configuration
capabilities of an FE. These capabilities may include (see Section 5 capabilities of an FE. These capabilities may include (see Section 5
for full details): for full details):
o Which LFB classes the FE can instantiate o Which LFB classes the FE can instantiate
o The maximum number of instances of the same LFB class that can be o The maximum number of instances of the same LFB class that can be
created created
o Any topological limitations, for example: o Any topological limitations, for example:
* The maximum number of instances of the same class or any class * The maximum number of instances of the same class or any class
that can be created on any given branch of the graph that can be created on any given branch of the graph
* Ordering restrictions on LFBs (e.g., any instance of LFB class * Ordering restrictions on LFBs (e.g., any instance of LFB class
A must be always downstream of any instance of LFB class B). A must be always downstream of any instance of LFB class B)
The CE needs some programming help in order to cope with the range of The CE needs some programming help in order to cope with the range of
complexity. In other words, even when the CE is allowed to configure complexity. In other words, even when the CE is allowed to configure
LFB topology for the FE, the CE is not expected to be able to LFB topology for the FE, the CE is not expected to be able to
interpret an arbitrary LFB topology and determine which specific interpret an arbitrary LFB topology and determine which specific
service or application (e.g. VPN, DiffServ, etc.) is supported by service or application (e.g., VPN, Diffserv) is supported by the FE.
the FE. However, once the CE understands the coarse capability of an However, once the CE understands the coarse capability of an FE, the
FE, the CE MUST configure the LFB topology to implement the network CE MUST configure the LFB topology to implement the network service
service the NE is supposed to provide. Thus, the mapping the CE has the NE is supposed to provide. Thus, the mapping the CE has to
to understand is from the high level NE service to a specific LFB understand is from the high-level NE service to a specific LFB
topology, not the other way around. The CE is not expected to have topology, not the other way around. The CE is not expected to have
the ultimate intelligence to translate any high level service policy the ultimate intelligence to translate any high-level service policy
into the configuration data for the FEs. However, it is conceivable into the configuration data for the FEs. However, it is conceivable
that within a given network service domain, a certain amount of that within a given network service domain, a certain amount of
intelligence can be programmed into the CE to give the CE a general intelligence can be programmed into the CE to give the CE a general
understanding of the LFBs involved to allow the translation from a understanding of the LFBs involved to allow the translation from a
high level service policy to the low level FE configuration to be high-level service policy to the low-level FE configuration to be
done automatically. Note that this is considered an implementation done 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 FE
model. Therefore, it is not discussed any further in this draft. model. Therefore, it is not discussed any further in this document.
+----------+ +-----------+ +----------+ +-----------+
---->| Ingress |---->|classifier |--------------+ ---->| Ingress |---->|classifier |--------------+
| | |chip | | | | |chip | |
+----------+ +-----------+ | +----------+ +-----------+ |
v v
+-------------------------------------------+ +-------------------------------------------+
+--------+ | Network Processor | +--------+ | Network Processor |
<----| Egress | | +------+ +------+ +-------+ | <----| Egress | | +------+ +------+ +-------+ |
+--------+ | |Meter | |Marker| |Dropper| | +--------+ | |Meter | |Marker| |Dropper| |
^ | +------+ +------+ +-------+ | ^ | +------+ +------+ +-------+ |
| | | | | |
+----------+-------+ | +----------+-------+ |
| | | | | |
| +---------+ +---------+ +------+ +---------+ | | +---------+ +---------+ +------+ +---------+ |
| |Forwarder|<------|Scheduler|<--|Queue | |Counter | | | |Forwarder|<------|Scheduler|<--|Queue | |Counter | |
| +---------+ +---------+ +------+ +---------+ | | +---------+ +---------+ +------+ +---------+ |
+--------------------------------------------------------------+ +--------------------------------------------------------------+
Figure 9: The Capability of an FE as reported to the CE Figure 9: The capability of an FE as reported to the CE.
Figure 9 shows an example where a QoS-enabled router has several line Figure 9 shows an example where a QoS-enabled (quality-of-service)
cards that have a few ingress ports and egress ports, a specialized router has several line cards that have a few ingress ports and
classification chip, and a network processor containing codes for FE egress ports, a specialized classification chip, and a network
blocks like meter, marker, dropper, counter, queue, scheduler, and processor containing codes for FE blocks like meter, marker, dropper,
IPv4 forwarder. Some of the LFB topology is already fixed and has to counter, queue, scheduler, and IPv4 forwarder. Some of the LFB
remain static due to the physical layout of the line cards. For topology is already fixed and has to remain static due to the
example, all of the ingress ports might be hardwired into the physical layout of the line cards. For example, all of the ingress
classification chip so all packets flow from the ingress port into ports might be hardwired into the classification chip so all packets
the classification engine. On the other hand, the LFBs on the flow from the ingress port into the classification engine. On the
network processor and their execution order are programmable. other hand, the LFBs on the network processor and their execution
However, certain capacity limits and linkage constraints could exist order are programmable. However, certain capacity limits and linkage
between these LFBs. Examples of the capacity limits might be: constraints could exist between these LFBs. Examples of the capacity
limits might be:
o 8 meters o 8 meters
o 16 queues in one FE o 16 queues in one FE
o the scheduler can handle at most up to 16 queues o the scheduler can handle at most up to 16 queues
o The linkage constraints might dictate that: o The linkage constraints might dictate that:
* the classification engine may be followed by: * the classification engine may be followed by:
+ a meter + a meter
+ marker + marker
+ dropper + dropper
+ counter + counter
+ queue or IPv4 forwarder, but not a scheduler + queue or IPv4 forwarder, but not a scheduler
* queues can only be followed by a scheduler * queues can only be followed by a scheduler
* a scheduler must be followed by the IPv4 forwarder * a scheduler must be followed by the IPv4 forwarder
skipping to change at page 39, line 22 skipping to change at page 40, line 14
+ dropper + dropper
+ counter + counter
+ queue or IPv4 forwarder, but not a scheduler + queue or IPv4 forwarder, but not a scheduler
* queues can only be followed by a scheduler * queues can only be followed by a scheduler
* a scheduler must be followed by the IPv4 forwarder * a scheduler must be followed by the IPv4 forwarder
* the last LFB in the datapath before going into the egress ports * the last LFB in the data path before going into the egress
must be the IPv4 forwarder ports must be the IPv4 forwarder
+-----+ +-------+ +---+ +-----+ +-------+ +---+
| A|--->|Queue1 |--------------------->| | | A|--->|Queue1 |--------------------->| |
------>| | +-------+ | | +---+ ------>| | +-------+ | | +---+
| | | | | | | | | | | |
| | +-------+ +-------+ | | | | | | +-------+ +-------+ | | | |
| B|--->|Meter1 |----->|Queue2 |------>| |->| | | B|--->|Meter1 |----->|Queue2 |------>| |->| |
| | | | +-------+ | | | | | | | | +-------+ | | | |
| | | |--+ | | | | | | | |--+ | | | |
+-----+ +-------+ | +-------+ | | +---+ +-----+ +-------+ | +-------+ | | +---+
classifier +-->|Dropper| | | IPv4 classifier +-->|Dropper| | | IPv4
+-------+ +---+ Fwd. +-------+ +---+ Fwd.
Scheduler Scheduler
Figure 10: An LFB topology as configured by the CE and accepted by Figure 10: An LFB topology as configured
the FE by the CE and accepted by the FE.
Once the FE reports these capabilities and capacity limits to the CE, 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 desirable it is now up to the CE to translate the QoS policy into a desirable
configuration for the FE. Figure 9 depicts the FE capability while configuration for the FE. Figure 9 depicts the FE capability, while
Figure 10 and Figure 11 depict two different topologies that the CE Figure 10 and Figure 11 depict two different topologies that the CE
may request the FE to configure. Note that Figure 11 is not fully may request the FE to configure. Note that Figure 11 is not fully
drawn, as inter-LFB links are included to suggest potential drawn, as inter-LFB links are included to suggest potential
complexity, without drawing in the endpoints of all such links. complexity, without drawing in the endpoints of all such links.
Queue1 Queue1
+---+ +--+ +---+ +--+
| A|------------------->| |--+ | A|------------------->| |--+
+->| | | | | +->| | | | |
| | B|--+ +--+ +--+ +--+ | | | B|--+ +--+ +--+ +--+ |
| +---+ | | | | | | | +---+ | | | | | |
| Meter1 +->| |-->| | | | Meter1 +->| |-->| | |
| | | | | | | | | | | |
| +--+ +--+ | Ipv4 | +--+ +--+ | IPv4
| Counter1 Dropper1 Queue2| +--+ Fwd. | Counter1 Dropper1 Queue2| +--+ Fwd.
+---+ | +--+ +--->|A | +-+ +---+ | +--+ +--->|A | +-+
| A|---+ | |------>|B | | | | A|---+ | |------>|B | | |
------>| B|------------------------------>| | +-->|C |->| |-> ------>| B|------------------------------>| | +-->|C |->| |->
| C|---+ +--+ | +>|D | | | | C|---+ +--+ | +>|D | | |
| D|-+ | | | +--+ +-+ | D|-+ | | | +--+ +-+
+---+ | | +---+ Queue3 | |Scheduler +---+ | | +---+ Queue3 | |Scheduler
Classifier1 | | | A|------------> +--+ | | Classifier1 | | | A|------------> +--+ | |
| +->| | | |-+ | | +->| | | |-+ |
| | B|--+ +--+ +-------->| | | | | B|--+ +--+ +-------->| | |
| +---+ | | | | +--+ | | +---+ | | | | +--+ |
| Meter2 +->| |-+ | | Meter2 +->| |-+ |
| | | | | | | |
| +--+ Queue4 | | +--+ Queue4 |
| Marker1 +--+ | | Marker1 +--+ |
+---------------------------->| |---+ +---------------------------->| |---+
| | | |
+--+ +--+
Figure 11: Another LFB topology as configured by the CE and accepted Figure 11: Another LFB topology as configured
by the FE by the CE and accepted by the FE.
Note that both the ingress and egress are omitted in Figure 10 and Note that both the ingress and egress are omitted in Figure 10 and
Figure 11 to simplify the representation. The topology in Figure 11 Figure 11 to simplify the representation. The topology in Figure 11
is considerably more complex than Figure 10 but both are feasible is considerably more complex than Figure 10, but both are feasible
within the FE capabilities, and so the FE should accept either within the FE capabilities, and so the FE should accept either
configuration request from the CE. configuration request from the CE.
4. Model and Schema for LFB Classes 4. 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. This modular, implementation-independent representation of the FEs. This
is facilitated using the concept of LFBs, which are instantiated from is facilitated using the concept of LFBs, which are instantiated from
LFB classes. LFB classes and associated definitions will be provided LFB classes. LFB classes and associated definitions will be provided
in a collection of XML documents. The collection of these XML in a collection of XML documents. The collection of these XML
documents is called a LFB class library, and each document is called documents is called an LFB class library, and each document is called
an LFB class library document (or library document, for short). Each an LFB class library document (or library document, for short). Each
of the library documents MUST conform to the schema presented in this of the library documents MUST conform to the schema presented in this
section. The schema here, and the rules for confoming to the schema section. The schema here and the rules for conforming to the schema
are those defined by the W3C in the definitions of XML schema in XML are those defined by the W3C in the definitions of XML schema in XML
Schema [4] and XML Schema DataTypes [5]. The root element of the schema [Schema1] and XML schema DataTypes [Schema2]. The root
library document is the <LFBLibrary> element. element of the library document is the <LFBLibrary> element.
It is not expected that library documents will be exchanged between It is not expected that library documents will be exchanged between
FEs and CEs "over-the-wire". But the model will serve as an FEs and CEs "over-the-wire". But the model will serve as 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 as (software) and FEs (mostly the software part). It will also serve as
a design input when specifying the ForCES protocol elements for CE-FE a design input when specifying the ForCES protocol elements for CE-FE
communication. communication.
The following sections describe the portions of an LFBLibrary XML The following sections describe the portions of an LFBLibrary XML
Document. The descriptions primarily provide the necessary semantic document. The descriptions primarily provide the necessary semantic
information to understand the meaning and uses of the XML elements. information to understand the meaning and uses of the XML elements.
The XML Schema below provides the final definition on what elements The XML schema below provides the final definition on what elements
are permitted, and their base syntax. Unfortunately, due to the are permitted, and their base syntax. Unfortunately, due to the
limitations of english and XML, there are constraints described in limitations of English and XML, there are constraints described in
the semantic sections which are not fully captured in the XML Schema, the semantic sections that are not fully captured in the XML schema,
so both sets of information need to be used to build a compliant so both sets of information need to be used to build a compliant
library document. library document.
4.1. Namespace 4.1. Namespace
A namespace is needed to uniquely identify the LFB type in the LFB A namespace is needed to uniquely identify the LFB type in the LFB
class library. The reference to the namespace definition is class library. The reference to the namespace definition is
contained in Section 9, IANA Considerations. contained in Section 9, IANA Considerations.
4.2. <LFBLibrary> Element 4.2. <LFBLibrary> Element
The <LFBLibrary> element serves as a root element of all library The <LFBLibrary> element serves as a root element of all library
documents. A library document contains a sequence of top level documents. A library document contains a sequence of top-level
elements. The following is a list of all the elements which can elements. The following is a list of all the elements that can occur
occur directly in the <LFBLibrary> element. If they occur, they must directly in the <LFBLibrary> element. If they occur, they must occur
occur in the order listed. in the order listed.
o <description> providing a text description of the purpose of the o <description> providing a text description of the purpose of the
library document. library document,
o <load> for loading information from other library documents.
o <frameDefs> for the frame declarations; o <load> for loading information from other library documents,
o <dataTypeDefs> for defining common data types; o <frameDefs> for the frame declarations,
o <dataTypeDefs> for defining common data types,
o <metadataDefs> for defining metadata, and o <metadataDefs> for defining metadata, and
o <LFBClassDefs> for defining LFB classes. o <LFBClassDefs> for defining LFB classes.
Each element is optional. One library document may contain only Each element is optional. One library document may contain only
metadata definitions, another may contain only LFB class definitions, metadata definitions, another may contain only LFB class definitions,
yet another may contain all of the above. and yet another may contain all of the above.
A library document can import other library documents if it needs to A library document can import other library documents if it needs to
refer to definitions contained in the included document. This refer to definitions contained in the included document. This
concept is similar to the "#include" directive in C. Importing is concept is similar to the "#include" directive in the C programming
expressed by the use of <load> elements, which must precede all the language. Importing is expressed by the use of <load> elements,
above elements in the document. For unique referencing, each which must precede all the above elements in the document. For
LFBLibrary instance document has a unique label defined in the unique referencing, each LFBLibrary instance document has a unique
"provide" attribute of the LFBLibrary element. Note that what this label defined in the "provide" attribute of the LFBLibrary element.
performs is a ForCES inclusion, not an XML inclusion. The semantic Note that what this performs is a ForCES inclusion, not an XML
content of the library referenced by the <load> element is included, inclusion. The semantic content of the library referenced by the
not the xml content. Also, in terms of the conceptual processing of <load> element is included, not the xml content. Also, in terms of
<load> elements, the total set of documents loaded are considered to the conceptual processing of <load> elements, the total set of
form a single document for processing. A given document is included documents loaded is considered to form a single document for
in this set only once, even if it is referenced by <load> elements processing. A given document is included in this set only once, even
several times, even from several different files. As the processing if it is referenced by <load> elements several times, even from
of LFBLibrary information is not order dependent, the order for several different files. As the processing of LFBLibrary information
processing loaded elements is up to the implementor, as long as the is not order dependent, the order for processing loaded elements is
total effect is as if all of the information from all the files were up to the implementor, as long as the total effect is as if all of
available for referencing when needed. Note that such computer the information from all the files were available for referencing
processing of ForCES model library documents may be helpful for when needed. Note that such computer processing of ForCES model
various implementations, but is not required to define the libraries, library documents may be helpful for various implementations, but is
or for the actual operation of the protocol itself. not required to define the libraries, or for the actual operation of
the protocol itself.
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="urn:ietf:params:xml:ns:forces:lfbmodel:1.0" <LFBLibrary xmlns="urn:ietf:params:xml:ns:forces:lfbmodel:1.0"
provides="this_library"> provides="this_library">
<description> <description>
</description> </description>
<!-- Loading external libraries (optional) --> <!-- Loading external libraries (optional) -->
<load library="another_library"/> <load library="another_library"/>
... ...
<!-- FRAME TYPE DEFINITIONS (optional) --> <!-- FRAME TYPE DEFINITIONS (optional) -->
<frameDefs> <frameDefs>
... ...
</frameDefs> </frameDefs>
<!-- 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 be 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. Three retrieved. The load element can be repeated unlimited times. Below
examples for the <load> elements: are 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.example.com/forces/1.0/lfbmodel/lpm.xml"/> location="http://www.example.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 output frames the LFB expects at its input port(s) and emits at its output
skipping to change at page 45, line 17 skipping to change at page 46, line 17
o Defining components of LFB classes o Defining components 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 MUST contain a unique name (NMTOKEN), a Each <dataTypeDef> element MUST contain a unique name (NMTOKEN), a
brief synopsis, and a type definition element. The name MUST be brief synopsis, and a type definition element. The name MUST be
unique among all data types defined in the same library document and unique among all data types defined in the same library document and
in any directly or indirectly included library documents. The in any directly or indirectly included library documents. The
<dataTypeDef> element MAY also include an optional longer <dataTypeDef> element MAY also include an optional longer
description, For example: description, 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 data
types are appropriate for single-value variables (e.g. integer, types are appropriate for single-value variables (e.g., integer,
string, byte array). string, byte array).
The following built-in atomic data types are provided, but additional The following built-in atomic data types are provided, but additional
atomic data types can be defined with the <typeRef> and <atomic> atomic data types can be defined with the <typeRef> and <atomic>
elements: 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
uint16 16-bit unsigned integer uint16 16-bit unsigned integer
int32 32-bit signed integer int32 32-bit signed integer
uint32 32-bit unsigned integer uint32 32-bit unsigned integer
int64 64-bit signed integer int64 64-bit signed integer
uint64 64-bit unsigned integer uint64 64-bit unsigned integer
boolean A true / false value where boolean A true / false value where
0 = false, 1 = true 0 = false, 1 = true
string[N] A UTF-8 string represented in at most string[N] A UTF-8 string represented in at most
N Octets. N octets
string A UTF-8 string without a configured string A UTF-8 string without a configured
storage length limit. storage length limit
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
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 or These built-in data types can be readily used to define metadata or
LFB attributes, but can also be used as building blocks when defining LFB attributes, but can also be used as building blocks when defining
new data types. The boolean data type is defined here because it is new data types. The boolean data type is defined here because it is
so common, even though it can be built by sub-ranging the uchar data so common, even though it can be built by sub-ranging the uchar data
type, as defined under atomic types (Section 4.5.2). type, as defined under atomic types (Section 4.5.2).
Compound data types can build on atomic data types and other compound Compound data types can build on atomic data types and other compound
data types. Compound data types can be defined in one of four ways. data types. Compound data types can be defined in one of four ways.
They may be defined as an array of components of some compound or They may be defined as an array of components of some compound or
atomic data type. They may be a structure of named components of atomic data type. They may be a structure of named components of
compound or atomic data types (c.f. C structures). They may be a compound or atomic data types (cf. C structures). They may be a
union of named components of compound or atomic data types (c.f. C union of named components of compound or atomic data types (cf. C
unions). They may also be defined as augmentations (explained in unions). They may also be defined as augmentations (explained in
Section 4.5.7) of existing compound data types. Section 4.5.7) of existing compound data types.
Given that the ForCES protocol will be getting and setting component Given that the ForCES protocol will be getting and setting component
values, all atomic data types used here must be able to be conveyed values, all atomic data types used here must be able to be conveyed
in the ForCES protocol. Further, the ForCES protocol will need a in the ForCES protocol. Further, the ForCES protocol will need a
mechanism to convey compound data types. However, the details of mechanism to convey compound data types. However, the details of
such representations are for the ForCES Protocol [2] document to such representations are for the ForCES protocol [RFC5810] document
define, not the model document. Strings and octetstrings must be to define, not the model document. Strings and octetstrings must be
conveyed by the protocol with their length, as they are not conveyed by the protocol with their length, as they are not
delimited, the value does not itself include the length, and these delimited, the value does not itself include the length, and these
items are variable length. items are variable length.
With regard to strings, this model defines a small set of With regard to strings, this model defines a small set of
restrictions and definitions on how they are structured. String and restrictions and definitions on how they are structured. String and
octetstring length limits can be specified in the LFB Class octetstring length limits can be specified in the LFB class
definitions. The component properties for string and octetstring definitions. The component properties for string and octetstring
components also contain actual lengths and length limits. This components also contain actual lengths and length limits. This
duplication of limits is to allow for implementations with smaller duplication of limits is to allow for implementations with smaller
limits than the maximum limits specified in the LFB Class definition. limits than the maximum limits specified in the LFB class definition.
In all cases, these lengths are specified in octets, not in In all cases, these lengths are specified in octets, not in
characters. In terms of protocol operation, as long as the specified characters. In terms of protocol operation, as long as the specified
length is within the FE's supported capabilities, the FE stores the length is within the FE's supported capabilities, the FE stores the
contents of a string exactly as provided by the CE, and returns those contents of a string exactly as provided by the CE, and returns those
contents when requested. No canonicalization, transformations, or contents when requested. No canonicalization, transformations, or
equivalences are performed by the FE. Components of type string (or equivalences are performed by the FE. Components of type string (or
string[n]) MAY be used to hold identifiers for correlation with string[n]) MAY be used to hold identifiers for correlation with
components in other LFBs. In such cases, an exact octet for octet components in other LFBs. In such cases, an exact octet for octet
match is used. No equivalences are used by the FE or CE in match is used. No equivalences are used by the FE or CE in
performing that matching. The ForCES Protocol [2] does not perform performing that matching. The ForCES protocol [RFC5810] does not
or require validation of the content of UTF-8 strings. However, perform or require validation of the content of UTF-8 strings.
UTF-8 strings SHOULD be encoded in the shortest form to avoid However, UTF-8 strings SHOULD be encoded in the shortest form to
potential security issues described in [12]. Any entity displaying avoid potential security issues described in [UNICODE]. Any entity
such strings is expected to perform its own validation (for example displaying such strings is expected to perform its own validation
for correct multi-byte characters, and for ensuring that the string (for example, for correct multi-byte characters, and for ensuring
does not end in the middle of a multi-byte sequence.) Specific LFB that the string does not end in the middle of a multi-byte sequence).
class definitions MAY restrict the valid contents of a string as Specific LFB class definitions MAY restrict the valid contents of a
suited to the particular usage (for example, a component that holds a string as suited to the particular usage (for example, a component
DNS name would be restricted to hold only octets valid in such a that holds a DNS name would be restricted to hold only octets valid
name.) FEs should validate the contents of SET requests for such in such a name). FEs should validate the contents of SET requests
restricted components at the time the set is performed, just as range for such restricted components at the time the set is performed, just
checks for range limited components are performed. The ForCES as range checks for range-limited components are performed. The
protocol behavior defines the normative processing for requests using ForCES protocol behavior defines the normative processing for
that protocol. requests using that protocol.
For the definition of the actual type in the <dataTypeDef> element, For the definition of the actual type in the <dataTypeDef> element,
the following elements are available: <typeRef>, <atomic>, <array>, the following elements are available: <typeRef>, <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. Alias is used to allow a component inside an compound data types. Alias is used to allow a component inside an
LFB to be an indirect reference to another component inside the same LFB to be an indirect reference to another component inside the same
or a different LFB class or instance. The alias component behaves or a different LFB class or instance. The alias component behaves
like a structure, one component of which has special behavior. Given like a structure, one component of which has special behavior. Given
that the special behavior is tied to the other parts of the that the special behavior is tied to the other parts of the
structure, the compound result is treated as a predefined construct. structure, the compound result is treated as a predefined construct.
4.5.1. <typeRef> Element for Renaming Existing Data Types 4.5.1. <typeRef> Element for Renaming 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>
skipping to change at page 49, line 9 skipping to change at page 50, line 9
</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 as The <array> element can be used to create a new compound data type as
an array of a compound or an atomic data type. Depending upon an array of a compound or an atomic data type. Depending upon
context, this document, and others, refer to such arrays as tables or context, this document and others refer to such arrays as tables or
arrays interchangeably, without semantic or syntactic implication. arrays interchangeably, without semantic or syntactic implication.
The type of the array entry can be specified either by referring to The type of the array entry can be specified either by referring to
an existing type (using the <typeRef> element) or defining an unnamed an existing type (using the <typeRef> element) or defining an unnamed
type inside the <array> element using any of the <atomic>, <array>, type inside the <array> element using any of the <atomic>, <array>,
<struct>, or <union> elements. <struct>, or <union> elements.
The array can be "fixed-size" or "variable-size", which is specified The array can be "fixed-size" or "variable-size", which is specified
by the "type" attribute of the <array> element. The default is by the "type" attribute of the <array> element. The default is
"variable-size". For variable size arrays, an optional "maxlength" "variable-size". For variable-size arrays, an optional "maxlength"
attribute specifies the maximum allowed length. This attribute attribute specifies the maximum allowed length. This attribute
should be used to encode semantic limitations, not implementation should be used to encode semantic limitations, not implementation
limitations. The latter (support for implementation constraints) limitations. The latter (support for implementation constraints)
should be handled by capability components of LFB classes, and should should be handled by capability components of LFB classes, and should
never be included as the maxlength in a data type array which is never be included as the maxlength in a data type array that is
regarded as being of unlimited size. regarded as being 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 The result of this construct is always a compound type, even if the
array has a fixed size of 1. array has a fixed size of 1.
Arrays MUST only be subscripted by integers, and will be presumed to Arrays MUST only be subscripted by integers, and will be presumed 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:
o Any declared key can be used in the ForCES protocol to select a o Any declared key can be used in the ForCES protocol to select a
component for operations (for details, see the ForCES Protocol component for operations (for details, see the ForCES protocol
[2]). [RFC5810]).
o In any instance of the array, each declared key MUST be unique o In any instance of the array, each declared key MUST be unique
within that instance. That is, no two components of an array may within that instance. That is, no two components of an array may
have the same values on all the fields which make up a key. have the same values on all the fields that make up a key.
Each key is declared with a keyID for use in the ForCES Protocol [2],
where the unique key is formed by combining one or more specified key
fields. To support the case where an array of an atomic type with
unique values can be referenced by those values, the key field
identifier MAY be "*" (i.e., the array entry is the key). If the
value type of the array is a structure or an array, then the key is
one or more components of the value type, each identified by name.
Since the field MAY be a component of the contained structure, a Each key is declared with a keyID for use in the ForCES protocol
component of a component of a structure, or further nested, the field [RFC5810], where the unique key is formed by combining one or more
name is actually a concatenated sequence of component identifiers, specified key fields. To support the case where an array of an
separated by decimal points ("."). The syntax for key field atomic type with unique values can be referenced by those values, the
identification is given following the array examples. key field identifier MAY be "*" (i.e., the array entry is the key).
If the value type of the array is a structure or an array, then the
key is one or more components of the value type, each identified by
name. Since the field MAY be a component of the contained structure,
a component of a component of a structure, or further nested, the
field name is actually a concatenated sequence of component
identifiers, separated by decimal points ("."). The syntax for key
field identification is given following the array examples.
The following example shows the definition of a fixed size array with The following example shows the definition of a fixed-size array with
a pre-defined data type as the array content type: a predefined data type as the array content type:
<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">
<typeRef>dscp</typeRef> <typeRef>dscp</typeRef>
</array> </array>
</dataTypeDef> </dataTypeDef>
The following example defines a variable size array with an upper The following example defines a variable-size array with an upper
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" maxlength="8"> <array type="variable-size" maxlength="8">
<typeRef>ieeemacaddr</typeRef> <typeRef>ieeemacaddr</typeRef>
</array> </array>
</dataTypeDef> </dataTypeDef>
skipping to change at page 52, line 5 skipping to change at page 52, line 32
<synopsis>The result code</synopsis> <synopsis>The result code</synopsis>
<typeRef>opcode</typeRef> <typeRef>opcode</typeRef>
</component> </component>
</struct> </struct>
</array> </array>
</dataTypeDef> </dataTypeDef>
In the above example, each entry of the array is a <struct> of two In the above example, each entry of the array is a <struct> of two
components ("rule" and "opcode"). components ("rule" and "opcode").
The following example shows a table of IP Prefix information that can The following example shows a table of IP prefix information that can
be accessed by a multi-field content key on the IP Address, prefix be accessed by a multi-field content key on the IP address, prefix
length, and information source. This means that in any instance of length, and information source. This means that in any instance of
this table, no two entries can have the same IP address, prefix this table, no two entries can have the same IP address, prefix
length, and information source. length, and information source.
<dataTypeDef> <dataTypeDef>
<name>ipPrefixInfo_table</name> <name>ipPrefixInfo_table</name>
<synopsis> <synopsis>
A table of information about known prefixes A table of information about known prefixes
</synopsis> </synopsis>
<array type="variable-size"> <array type="variable-size">
skipping to change at page 53, line 4 skipping to change at page 54, line 10
Note that the keyField elements could also have been simply address- Note that the keyField elements could also have been simply address-
prefix and source, since all of the fields of address-prefix are prefix and source, since all of the fields of address-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 components that In order to use key declarations, one must refer to components that
are potentially nested inside other components in the array. If are potentially nested inside other components in the array. If
there are nested arrays, one might even use an array element as a key there are nested arrays, one might even use an array element as a key
(but great care would be needed to ensure uniqueness.) (but great care would be needed to ensure uniqueness).
The key is the combination of the values of each field declared in a The key is the combination of the values of each field declared in a
keyField element. keyField element.
Therefore, the value of a keyField element MUST be a concatenated Therefore, the value of a keyField element MUST be a concatenated
Sequence of field identifiers, separated by a "." (period) character. sequence of field identifiers, separated by a "." (period) character.
Whitespace is permitted and ignored. 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 for 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 the an array whose content is an array), then the only valid value for
field identifier is an explicit number. the field identifier is an explicit number.
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 components of the structure. field identifiers are the names of the components 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 key, atomic type, where that content is unique and is to be used as a key,
the value "*" MUST be used as the single key field identifier. the value "*" MUST be used as the single key field identifier.
In reference array or structure elements, it is possible to construct In reference array or structure elements, it is possible to construct
keyFields that do not exist. keyField references SHOULD never keyFields that do not exist. keyField references SHOULD never
reference optional structure components. For references to array reference optional structure components. For references to array
elements, care must be taken to ensure that the necessary array elements, care must be taken to ensure that the necessary array
elements exist when creating or modifying the overall array element. elements exist when creating or modifying the overall array element.
Failure to do so will result in FEs returning errors on the creation Failure to do so will result in FEs returning errors on the creation
attempt. attempt.
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 components. Each A structure is composed of a collection of data components. Each
data components has a data type (either an atomic type or an existing data component has a data type (either an atomic type or an existing
compound type) and is assigned a name unique within the scope of the compound type) and is assigned a name unique within the scope of the
compound data type being defined. These serve the same function as compound data type being defined. These serve the same function as
"struct" in C, etc. These components are defined using <component> "struct" in C, etc. These components are defined using <component>
elements. A <struct> element MAY contain an optional derivation elements. A <struct> element MAY contain an optional derivation
indication, a <derivedFrom> element. The structure definition MUST indication, a <derivedFrom> element. The structure definition MUST
contain a sequence of one or more <component> elements. contain a sequence of one or more <component> elements.
The actual type of the component can be defined by referring to an The actual type of the component can be defined by referring to an
existing type (using the <typeRef> element), or can be a locally existing type (using the <typeRef> 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.
The <component> element MUST include a componentID attribute. This The <component> element MUST include a componentID attribute. This
provides the numeric ID for this component, for use by the protocol. provides the numeric ID for this component, for use by the protocol.
The <component> MUST contain a component name and a synopsis. It MAY The <component> MUST contain a component name and a synopsis. It MAY
contain a <description> element giving a textual description of the contain a <description> element giving a textual description of the
component. The definition MAY also include a <optional> element, component. The definition MAY also include an <optional> element,
which indicates that the component being defined is optional. The which indicates that the component being defined is optional. The
definition MUST contain elements to define the data type of the definition MUST contain elements to define the data type of the
component, as described above. component, as described above.
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 optional derivedFrom attribute in This is indicated by including the optional derivedFrom attribute in
the struct declaration before the definition of the augmenting or the struct declaration before the definition of the augmenting or
replacing components. The augmentation (Section 4.5.7) section replacing components. Section 4.5.7 describes how this is done in
describes how this is done in more detail. more detail.
The componentID attribute for different components in a structure (or The componentID attribute for different components in a structure (or
in an LFB) MUST be distinct. They do not need to be in order, nor do in an LFB) MUST be distinct. They do not need to be in order, nor do
they need to be sequential. For clarity of human readability, and they need to be sequential. For clarity of human readability, and
ease of maintanence, it is usual to define at least sequential sets ease of maintenance, it is usual to define at least sequential sets
of values. But this is for human ease, not a model or protocol of values. But this is for human ease, not a model or protocol
requirement. requirement.
The result of this construct is always a compound type, even when the The result of this construct is always a compound type, even when the
<struct> contains only one field. <struct> contains only one field.
An example: An example is the following:
<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>
<component componentID="1"> <component componentID="1">
<name>address</name> <name>address</name>
<synopsis>Address part</synopsis> <synopsis>Address part</synopsis>
skipping to change at page 56, line 7 skipping to change at page 57, line 7
refer to information (a component) in other LFBs. This can, for refer to information (a component) in other LFBs. This can, for
example, allow an ARP LFB to share the IP->MAC Address table with the example, allow an ARP LFB to share the IP->MAC Address table with the
local transmission LFB, without duplicating information. Similarly, local transmission LFB, without duplicating information. Similarly,
it could allow a traffic measurement LFB to share information with a it could allow a traffic measurement LFB to share information with a
traffic enforcement LFB. The <alias> declaration creates the traffic enforcement LFB. The <alias> declaration creates the
constructs for this. This construct tells the CE and FE that any constructs for this. This construct tells the CE and FE that any
manipulation of the defined data is actually manipulation of data manipulation of the defined data is actually manipulation of data
defined to exist in some specified part of some other LFB instance. defined to exist in some specified part of some other LFB instance.
The content of an <alias> element MUST be a named type. Whatever The content of an <alias> element MUST be a named type. Whatever
component the alias references (which is determined by the alias component the alias references (which is determined by the alias
component properties, as described below) that component must be of component properties, as described below), that component must be of
the same type as that declared for the alias. Thus, when the CE or the same type as that declared for the alias. Thus, when the CE or
FE dereferences the alias component, the type of the information FE dereferences the alias component, the type of the information
returned is known. The type can be a base type or a derived type. returned is known. The type can be a base type or a derived type.
The actual value referenced by an alias is known as its target. When The actual value referenced by an alias is known as its target. When
a GET or SET operation references the alias element, the value of the a GET or SET operation references the alias element, the value of the
target is returned or replaced. Write access to an alias element is target is returned or replaced. Write access to an alias element is
permitted if write access to both the alias and the target are permitted if write access to both the alias and the target is
permitted. permitted.
The target of a component declared by an <alias> element is The target of a component declared by an <alias> element is
determined by the information in the component's properties. Like determined by the information in the component's properties. Like
all components, the properties include the support / read / write all components, the properties include the support / read / write
permission for the alias. In addition, there are several fields permission for the alias. In addition, there are several fields
(components) in the alias properties which define the target of the (components) in the alias properties that define the target of the
alias. These components are the ID of the LFB class of the target, alias. These components are the ID of the LFB class of the target,
the ID of the LFB instance of the target, and a sequence of integers the ID of 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
component. The type of the target element must match the declared component. 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 are
described in Section 4.8 of this document on properties. described in Section 4.8 of this document, on properties.
Note that the read / write property of the alias refers to the value. Note that the read / write property of the alias refers to the value.
The CE can only determine if it can write the target selection The CE can only determine if it can write the target selection
properties of the alias by attempting such a write operation. properties of the alias by attempting such a write operation.
(Property components do not themselves have properties.) (Property components do not themselves have properties.)
4.5.7. Augmentations 4.5.7. 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,
augmentation MAY add new elements to the type. The type of an augmentation MAY add new elements to the type. The type of an
existing component MAY be replaced in the definition of an augmenting existing component MAY be replaced in the definition of an augmenting
structure, but MAY only be replaced with an augmentation derived from structure, but MAY only be replaced with an augmentation derived from
the current type of the existing component. An existing component the current type of the existing component. An existing component
cannot be deleted. If the existing compound type is an array, cannot be deleted. If the existing compound type is an array,
augmentation means augmentation of the array element type. augmentation means augmentation of the array element type.
Augmentation MUST NOT be applied to unions. Augmentation MUST NOT be applied to unions.
One consequence of this is that augmentations are backwards One consequence of this is that augmentations are backward compatible
compatible with the compound type from which they are derived. As with the compound type from which they are derived. As such,
such, augmentations are useful in defining components for LFB augmentations are useful in defining components for LFB subclasses
subclasses with backward compatibility. In addition to adding new with backward compatibility. In addition to adding new components to
components to a class, the data type of an existing component MAY be a class, the data type of an existing component MAY be replaced by an
replaced by an augmentation of that component, and still meet the augmentation of that component, and still meet the compatibility
compatibility rules for subclasses. This compatibility constraint is rules for subclasses. This compatibility constraint is why
why augmentations can not be applied to unions. augmentations cannot be applied to unions.
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
component (comp1) of type X. One way to derive class A1 from A can be component (comp1) of type X. One way to derive class A1 from A can
by simply adding a second component (of any type). Another way to be by simply adding a second component (of any type). Another way to
derive a class A2 from A can be by replacing the original component derive a class A2 from A can be by replacing the original component
(comp1) in A of type X with one of type Y, where Y is an augmentation (comp1) 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 with class A. of X. Both classes A1 and A2 are backward compatible with class A.
The syntax for augmentations is to include a <derivedFrom> element in The syntax for augmentations is to include a <derivedFrom> element in
a structure definition, indicating what structure type is being a structure definition, indicating what structure type is being
augmented. Component names and component IDs for new components augmented. Component names and component IDs for new components
within the augmentation MUST NOT be the same as those in the within the augmentation MUST NOT be the same as those in the
structure type being augmented. For those components where the data structure type being augmented. For those components where the data
type of an existing component is being replaced with a suitable type of an existing component is being replaced with a suitable
augmenting data type, the existing Component name and component ID augmenting data type, the existing component name and component ID
MUST be used in the augmentation. Other than the constraint on MUST be used in the augmentation. Other than the constraint on
existing elements, there is no requirement that the new component IDs existing elements, there is no requirement that the new component IDs
be sequential with, greater than, or in any other specific be sequential with, greater than, or in any other specific
relationship to the existing component IDs except different. It is relationship to the existing component IDs except different. It is
expected that using values sequential within an augmentation, and expected that using values sequential within an augmentation, and
distinct from the previously used values, will be a common method to distinct from the previously used values, will be a common method to
enhance human readability. enhance human readability.
4.6. <metadataDefs> Element for Metadata Definitions 4.6. <metadataDefs> Element for Metadata Definitions
skipping to change at page 58, line 45 skipping to change at page 59, line 45
</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 MUST define an LFB class and include the following elements: element MUST define an LFB class and include the following elements:
o <name> provides the symbolic name of the LFB class. Example: o <name> provides the symbolic name of the LFB class. Example:
"ipv4lpm" "ipv4lpm".
o <synopsis> provides a short synopsis of the LFB class. Example: o <synopsis> provides a short synopsis of the LFB class. Example:
"IPv4 Longest Prefix Match Lookup LFB" "IPv4 Longest Prefix Match Lookup LFB".
o <version> is the version indicator o <version> is the version indicator.
o <derivedFrom> is the inheritance indicator
o <inputPorts> lists the input ports and their specifications o <derivedFrom> is the inheritance indicator.
o <outputPorts> lists the output ports and their specifications o <inputPorts> lists the input ports and their specifications.
o <components> defines the operational components of the LFB o <outputPorts> lists the output ports and their specifications.
o <capabilities> defines the capability components of the LFB o <components> defines the operational components of the LFB.
o <description> contains the operational specification of the LFB o <capabilities> defines the capability components of the LFB.
o <description> contains the operational specification of the LFB.
o The LFBClassID attribute of the LFBClassDef element defines the ID o The LFBClassID attribute of the LFBClassDef element defines the ID
for this class. These must be globally unique. for this class. These must be globally unique.
o <events> defines the events that can be generated by instances of o <events> defines the events that can be generated by instances of
this LFB. this LFB.
LFB Class Names must be unique, in order to enable other documents to LFB class names must be unique, in order to enable other documents to
reference the classes by name, and to enable human readers to reference the classes by name, and to enable human readers to
understand references to class names. While a complex naming understand references to class names. While a complex naming
structure could be created, simplicity is preferred. As given in the structure could be created, simplicity is preferred. As given in the
IANA considerations section of this document, the IANA will maintain IANA Considerations section of this document, the IANA maintains a
a registry of LFB Class names and Class identifiers, along with a registry of LFB class names and class identifiers, along with a
reference to the document defining the class. reference to the document defining the class.
Below is a skeleton of an example LFB class definition. Note that in Below is a skeleton of an example LFB class definition. Note that in
order to keep from complicating the XML Schema, the order of elements order to keep from complicating the XML schema, the order of elements
in the class definition is fixed. Elements, if they appear, must in the class definition is fixed. Elements, if they appear, must
appear in the order shown. appear in the order shown.
<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 60, line 49 skipping to change at page 61, line 49
</LFBClassDef> </LFBClassDef>
... ...
</LFBClassDefs> </LFBClassDefs>
The individual components and capabilities will have componentIDs for The individual components and capabilities will have componentIDs for
use by the ForCES protocol. These parallel the componentIDs used in use by the ForCES protocol. These parallel the componentIDs used in
structs, and are used the same way. Component and capability structs, and are used the same way. Component and capability
componentIDs must be unique within the LFB class definition. componentIDs 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>. However, required; all other elements are optional in <LFBClassDef>. However,
when they are present, they must occur in the above order. when they are present, they must occur in the above order.
The componentID attribute for different items in an LFB class The componentID attribute for different items in an LFB class
definition (or components in a struct) MUST be distinct. They do not definition (or components in a struct) MUST be distinct. They do not
need to be in order, nor do they need to be sequential. For clarity need to be in order, nor do they need to be sequential. For clarity
of human readability, and ease of maintanence, it is usual to define of human readability, and ease of maintenance, it is usual to define
at least sequential sets of values. But this is for human ease, not at least sequential sets of values. But this is for human ease, not
a model or protocol requirement. a model or protocol requirement.
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 The optional <derivedFrom> element can be used to indicate that this
class is a derivative of some other class. The content of this class is a derivative of some other class. The content of this
element MUST be the unique name (<name>) of another LFB class. The element MUST be the unique name (<name>) of another LFB class. The
referred LFB class MUST be defined in the same library document or in referred LFB class MUST be defined in the same library document or in
one of the included library documents. In the absence of a one of the included library documents. In the absence of a
<derivedFrom> the class is conceptually derived from the common, <derivedFrom>, the class is conceptually derived from the common,
empty, base class. empty, base class.
It is assumed that a derived class is backwards compatible with its It is assumed that a derived class is backward compatible with its
base class. A derived class MAY add compoents to a parent class, but base class. A derived class MAY add components to a parent class,
can not delete components. This also applies to input and output but cannot delete components. This also applies to input and output
ports, events, and to capabilities. ports, events, and capabilities.
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. An The optional <inputPorts> element is used to define input ports. An
LFB class MAY have zero, one, or more inputs. If the LFB class has LFB class MAY have zero, one, or more inputs. If the LFB class 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 have one for each port or port group. We assume that most LFBs will have
exactly one input. Multiple inputs with the same input type are exactly one input. Multiple inputs with the same input type are
modeled as one input group. Input groups are defined the same way as modeled as one input group. Input groups are defined the same way as
input ports by the <inputPort> element, differentiated only by an input ports by the <inputPort> element, differentiated only 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 4.7.3). Some special LFBs will possible (see discussion in Section 4.7.3). Some special LFBs will
have no inputs at all. For example, a packet generator LFB does not have no inputs at all. For example, a packet generator LFB 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 only by an optional
"group" attribute. "group" attribute.
The <inputPort> element MUST contain the following elements: The <inputPort> element MUST contain the following elements:
o <name> provides the symbolic name of the input. Example: "in". o <name> provides the symbolic name of the input. Example: "in".
Note that this symbolic name must be unique only within the scope Note that this symbolic name must be unique only within the scope
of the LFB class. of the LFB class.
o <synopsis> contains a brief description of the input. Example: o <synopsis> contains a brief description of the input. Example:
"Normal packet input". "Normal packet input".
skipping to change at page 62, line 26 skipping to change at page 63, line 26
specified whether the metadatum is required or optional. For each specified whether the metadatum is required or optional. For each
optional metadatum, a default value must be specified, which is optional metadatum, a default value must be specified, which is
used by the LFB if the metadatum is not provided with a packet. used by the LFB if the metadatum 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., it element can specify if the port can behave as a port group, i.e., it
is allowed to be instantiated. This is indicated by a "true" value is allowed to be instantiated. This is indicated by a "true" value
(the default value is "false"). (the default value is "false").
An example <inputPorts> element, defining two input ports, the second An example <inputPorts> element, defining two input ports, the second
one being an input port group: one being an input port group is the following:
<inputPorts> <inputPorts>
<inputPort> <inputPort>
<name>in</name> <name>in</name>
<synopsis>Normal input</synopsis> <synopsis>Normal input</synopsis>
<expectation> <expectation>
<frameExpected> <frameExpected>
<ref>ipv4</ref> <ref>ipv4</ref>
<ref>ipv6</ref> <ref>ipv6</ref>
</frameExpected> </frameExpected>
skipping to change at page 63, line 5 skipping to change at page 64, line 5
<inputPort group="true"> <inputPort group="true">
... another input port ... ... another input port ...
</inputPort> </inputPort>
</inputPorts> </inputPorts>
For each <inputPort>, the frame type expectations are defined by the For each <inputPort>, the frame type expectations are defined by the
<frameExpected> element using one or more <ref> elements (see example <frameExpected> element using one or more <ref> elements (see example
above). When multiple frame types are listed, it means that "one of above). When multiple frame types are listed, it means that "one of
these" frame types is expected. A packet of any other frame type is these" frame types is expected. A packet of any other frame type is
regarded as incompatible with this input port of the LFB class. The regarded as incompatible with this input port of the LFB class. The
above example list two frames as expected frame types: "ipv4" and above example lists two frames as expected frame types: "ipv4" and
"ipv6". "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 metadatum. When multiple <ref> elements, each referring to a metadatum. 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" attribute metadata that are marked as "optional" by the "dependency" attribute
of the corresponding <ref> element). For a metadatum that is of the corresponding <ref> element). For a metadatum that is
specified "optional", a default value MUST be provided using the specified "optional", a default value MUST be provided using the
"defaultValue" attribute. The above example lists three metadata as "defaultValue" attribute. The above example lists three metadata as
expected metadata, two of which are mandatory ("classid" and expected metadata, two of which are mandatory ("classid" and
"vifid"), and one being optional ("vrfid"). "vifid"), and one being optional ("vrfid").
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. An example is
the following:
<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 following The two forms can also be combined, as shown in the 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>
skipping to change at page 64, line 11 skipping to change at page 65, line 11
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 here. definitions of metadata expectations, we do not discuss those 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. The optional <outputPorts> element is used to define output ports.
An LFB class MAY have zero, one, or more outputs. If the LFB class An LFB class MAY have zero, one, or more outputs. If the LFB class
has no output ports, the <outputPorts> element MUST be omitted. The has no output ports, the <outputPorts> element MUST be omitted. The
<outputPorts> element MUST contain one or more <outputPort> elements, <outputPorts> element MUST contain one or more <outputPort> elements,
one for each port or port-group. If there are multiple outputs with one for each port or port group. If there are multiple outputs with
the same output type, we model them as an output port group. Some the same output type, we model them as an output port group. Some
special LFBs have no outputs at all (e.g., Dropper). special LFBs 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 only by an optional
"group" attribute. "group" attribute.
The <outputPort> element MUST contain the following elements: The <outputPort> element MUST contain the following elements:
o <name> provides the symbolic name of the output. Example: "out". o <name> provides the symbolic name of the output. Example: "out".
Note that the symbolic name must be unique only within the scope Note that the symbolic name must be unique only within the scope
of the LFB class. of the LFB class.
o <synopsis> contains a brief description of the output port. o <synopsis> contains a brief description of the output port.
Example: "Normal packet output". Example: "Normal packet output".
skipping to change at page 66, line 5 skipping to change at page 67, line 5
The list of metadata that is produced with each packet is listed in The list of metadata that is produced with each packet is listed in
the optional <metadataProduced> element of the <product>. In its the optional <metadataProduced> element of the <product>. In its
simplest form, this element can contain a list of <ref> elements, simplest form, this element can contain a list of <ref> elements,
each referring to a metadatum type. The meaning of such a list is each referring to a metadatum type. The meaning of such a list is
that "all of" these metadata are provided with each packet, except that "all of" these metadata are provided with each packet, except
those that are listed with the optional "availability" attribute set those that are listed with the optional "availability" attribute set
to "conditional". Similar to the <metadataExpected> element of the to "conditional". Similar to the <metadataExpected> element of the
<inputPort>, the <metadataProduced> element supports more complex <inputPort>, the <metadataProduced> element supports more complex
forms, which we do not discuss here further. forms, which we do not discuss here further.
4.7.4. <components> Element to Define LFB Operational Components 4.7.4. <components> Element to Define LFB Operational Components
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 components. These are conceptualized in the model as the LFB components. These
include, for example, flags, single parameter arguments, complex include, for example, flags, single parameter arguments, complex
arguments, and tables. Note that the components here refer to only arguments, and tables. Note that the components here refer to only
those operational parameters of the LFBs that must be visible to the those operational parameters of the LFBs that must be visible to the
CEs. Other variables that are internal to LFB implementation are not CEs. Other variables that are internal to LFB implementation are not
regarded as LFB components and hence are not covered. regarded as LFB components and hence are not covered.
Some examples for LFB components are: Some examples for LFB components are:
skipping to change at page 66, line 37 skipping to change at page 67, line 37
o Various event counters o Various event counters
o Number of current inputs or outputs for each input or output group o Number of current inputs or outputs for each input or output group
The ForCES model supports the definition of access permission The ForCES model supports the definition of access permission
restrictions on what the CE can do with an LFB component. The restrictions on what the CE can do with an LFB component. The
following categories are supported by the model: following categories are supported by the model:
o No-access components. This is useful for completeness, and to o No-access components. This is useful for completeness, and to
allow for defining objects which are used by other things, but not allow for defining objects that are used by other things, but not
directly referencable by the CE. It is also useful for an FE directly referencable by the CE. It is also useful for an FE that
which is reporting that certain defined, and typically accessible, is reporting that certain defined, and typically accessible,
Components are not supported for CE access by a reporting FE. components are not supported for CE access by a reporting FE.
o Read-only components. o Read-only components.
o Read-write components. o Read-write components.
o Write-only components. This could be any configurable data for o Write-only components. This could be any configurable data for
which read capability is not provided to the CEs. (e.g., the which read capability is not provided to the CEs (e.g., the
security key information) security key information).
o Read-reset components. The CE can read and reset this resource, o Read-reset components. The CE can read and reset this resource,
but cannot set it to an arbitrary value. Example: Counters. but cannot set it to an arbitrary value. Example: Counters.
o Firing-only components. A write attempt to this resource will o Firing-only components. A write attempt to this resource will
trigger some specific actions in the LFB, but the actual value trigger some specific actions in the LFB, but the actual value
written is ignored. written is ignored.
The LFB class MUST define only one possible access mode for a given The LFB class MUST define only one possible access mode for a given
component. component.
skipping to change at page 67, line 28 skipping to change at page 68, line 28
name must be unique among the components of the LFB class. name must be unique among the components of the LFB class.
Example: "version". Example: "version".
o <synopsis> is also mandatory, and provides a brief description of o <synopsis> is also mandatory, and provides a brief description of
the purpose of the component. the purpose of the component.
o <optional/> is an optional element, and if present indicates that o <optional/> is an optional element, and if present indicates that
this component is optional. this component is optional.
o The data type of the component can be defined either via a o The data type of the component can be defined either via a
reference to a predefined data type or providing a local reference to a predefined data type or by 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 the existing data type defined in the <dataTypeDefs> element in the
same library document or in any of the included library documents. same library document or in any of the included library documents.
When the data type is defined locally (unnamed type), one of the When the data type is defined locally (unnamed type), one of the
following elements can be used: <atomic>, <array>, <struct>, and following elements can be used: <atomic>, <array>, <struct>, or
<union>. Their usage is identical to how they are used inside <union>. Their usage is identical to how they are used inside
<dataTypeDef> elements (see Section 4.5). Some form of data type <dataTypeDef> elements (see Section 4.5). Some form of data type
definition MUST be included in the component definition. definition MUST be included in the component definition.
o The <defaultValue> element is optional, and if present is used to o The <defaultValue> element is optional, and if present is used to
specify a default value for a component. If a default value is specify a default value for a component. If a default value is
specified, the FE must ensure that the component has that value specified, the FE must ensure that the component has that value
when the LFB is initialized or reset. If a default value is not when the LFB is initialized or reset. If a default value is not
specified for a component, the CE MUST make no assumptions as to specified for a component, the CE MUST make no assumptions as to
what the value of the component will be upon initalization. The what the value of the component will be upon initialization. The
CE must either read the value, or set the value, if it needs to CE must either read the value or set the value, if it needs to
know what it is. know what it is.
o The <description> element MAY also appear. If included, it o The <description> element MAY also appear. If included, it
provides a longer description of the meaning or usage of the provides a longer description of the meaning or usage of the
particular component being defined. particular component being defined.
The <component> element also MUST have an componentID attribute, The <component> element also MUST have a componentID 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 <component> element includes In addition to the above elements, the <component> element includes
an optional "access" attribute, which can take any of the following an optional "access" attribute, which can take any of the following
values: "read-only", "read-write", "write-only", "read-reset", and values: "read-only", "read-write", "write-only", "read-reset", and
"trigger-only". The default access mode is "read-write". "trigger-only". The default access mode is "read-write".
Whether optional components are supported, and whether components Whether optional components are supported, and whether components
defined as read-write can actually be written can be determined for a defined as read-write can actually be written, can be determined for
given LFB instance by the CE by reading the property information of a given LFB instance by the CE by reading the property information of
that component. An access control setting of "trigger-only" means that component. An access control setting of "trigger-only" means
that this component is included only for use in event detection. that this component is included only for use in event detection.
The following example defines two components for an LFB: The following example defines two components for an LFB:
<components> <components>
<component access="read-only" componentID="1"> <component access="read-only" componentID="1">
<name>foo</name> <name>foo</name>
<synopsis>number of things</synopsis> <synopsis>number of things</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
skipping to change at page 68, line 43 skipping to change at page 69, line 45
</atomic> </atomic>
<defaultValue>10</defaultValue> <defaultValue>10</defaultValue>
</component> </component>
</components> </components>
The first component ("foo") is a read-only 32-bit unsigned integer, The first component ("foo") is a read-only 32-bit unsigned integer,
defined by referring to the built-in "uint32" atomic type. The defined by referring to the built-in "uint32" atomic type. The
second component ("bar") is also an integer, but uses the <atomic> second component ("bar") is also an integer, but uses the <atomic>
element to provide additional range restrictions. This component has element to provide additional range restrictions. This component has
access mode of read-write allowing it to be both read and written. A access mode of read-write allowing it to be both read and written. A
default value of 10 is provided for bar. although the access for bar default value of 10 is provided for bar. Although the access for bar
is read-write, some implementations MAY offer only more restrictive is read-write, some implementations MAY offer only more restrictive
access, and this would be reported in the component properties. access, and this would be reported in the component properties.
Note that not all components are likely to exist at all times in a Note that not all components 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 components anyway. The ForCES protocol existent or non-permitted components anyway. The ForCES protocol
mechanisms should include appropriate error indicators for this case. mechanisms should include appropriate error indicators for this case.
The mechanism defined above for non-supported components can also The mechanism defined above for non-supported components can also
skipping to change at page 69, line 19 skipping to change at page 70, line 25
4.7.5. <capabilities> Element to Define LFB Capability Components 4.7.5. <capabilities> Element to Define LFB Capability Components
The LFB class specification provides some flexibility for the FE The LFB class specification provides some flexibility for the 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 inherent example, the instance may have some limitations that are not inherent
from the class definition, but rather the result of some from the class definition, but rather the result of some
implementation limitations. Some of these limitations are captured implementation limitations. Some of these limitations are captured
by the property information of the LFB components. The model allows by the property information of the LFB components. The model allows
for the notion of additional capability information. for the notion of additional capability information.
Such capability related information is expressed by the capability Such capability-related information is expressed by the capability
components of the LFB class. The capability components are always components of the LFB class. The capability components 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 one element contains one or more <capability> elements, each defining one
capability component. The format of the <capability> element is capability component. The format of the <capability> element is
almost the same as the <component> element, it differs in two almost the same as the <component> 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 default read-only), and it lacks the <defaultValue> element (because default
value is not applicable to read-only attributes). value is not applicable to read-only attributes).
Some examples of capability components follow: Some examples of capability components follow:
o The version of the LFB class that this LFB instance complies with; o The version of the LFB class with which this LFB instance complies
o Supported optional features of the LFB class;
o Maximum number of configurable outputs for an output group; o Supported optional features of the LFB class
o Metadata pass-through limitations of the LFB; o Maximum number of configurable outputs for an output group
o Additional range restriction on operational components; o Metadata pass-through limitations of the LFB
o Additional range restriction on operational components
The following example lists two capability attributes: The following example lists two capability attributes:
<capabilities> <capabilities>
<capability componentID="3"> <capability componentID="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>
</capability> </capability>
skipping to change at page 70, line 26 skipping to change at page 71, line 27
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 The <events> element contains the information about the occurrences
for which instances of this LFB class can generate notifications to for which instances of this LFB class can generate notifications to
the CE. High level view on the declaration and operation of LFB the CE. High-level view on the declaration and operation of LFB
events is described in Section 3.2.5. events is described in Section 3.2.5.
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 (per LFB class) ID of the event. The attribute giving the unique (per LFB class) ID of the event. The
element will include: element will include:
o <eventTarget> element indicating which LFB field (component) is o <eventTarget> element indicating which LFB field (component) is
tested to generate the event; tested to generate the event.
o <condition> element indicating what condition on the field will o <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.
o <eventReports> element indicating what values are to be reported o <eventReports> element indicating what values are to be reported
in the notification of the event. in the notification of the event.
The example below demonstrates the different constructs. The example below demonstrates the different constructs.
The <events> element has a baseID attribute value, which is normally The <events> element has a baseID attribute value, which is normally
<events baseID="number">. The value of the baseID is the starting <events baseID="number">. The value of the baseID is the starting
componentID for the path which identifies events. It must not be the componentID for the path that identifies events. It must not be the
same as the componentID of any top level components (including same as the componentID of any top-level components (including
capabilities) of the LFB class. In derived LFBs (i.e. ones with a capabilities) of the LFB class. In derived LFBs (i.e., ones with a
<derivedFrom> element) where the parent LFB class has an events <derivedFrom> element) where the parent LFB class has an events
declaration, the baseID must not be present in the derived LFB declaration, the baseID must not be present in the derived LFB
<events> element. Instead, the baseID value from the parent LFB <events> element. Instead, the baseID value from the parent LFB
class is used. In the example shown the baseID is 7. class is used. In the example shown, the baseID is 7.
<events baseID="7"> <events baseID="7">
<event eventID="7"> <event eventID="7">
<name>Foochanged</name> <name>Foochanged</name>
<synopsis> <synopsis>
An example event for a scalar An example event for a scalar
</synopsis> </synopsis>
<eventTarget> <eventTarget>
<eventField>foo</eventField> <eventField>foo</eventField>
</eventTarget> </eventTarget>
skipping to change at page 73, line 4 skipping to change at page 74, line 20
<eventField>gah</eventField> <eventField>gah</eventField>
<eventSubscript>10</eventSubscript> <eventSubscript>10</eventSubscript>
<eventField>field1</eventField> <eventField>field1</eventField>
</eventTarget> </eventTarget>
<eventChanged/> <eventChanged/>
<eventReports> <eventReports>
<eventReport> <eventReport>
<eventField>gah</eventField> <eventField>gah</eventField>
<eventSubscript>10</eventSubscript> <eventSubscript>10</eventSubscript>
</eventReport> </eventReport>
</eventReports> </eventReports>
</event> </event>
</events> </events>
4.7.6.1. <eventTarget> Element 4.7.6.1. <eventTarget> Element
The <eventTarget> element contains information identifying a field in The <eventTarget> element contains information identifying a field in
the LFB that is to be monitored for events. the LFB that is to be monitored for events.
The <eventTarget> element contains one or more <eventField> each of The <eventTarget> element contains one or more <eventField>s each of
which MAY be followed by one or more <eventSubscript> elements. Each which MAY be followed by one or more <eventSubscript> elements. Each
of these two elements represent the textual equivalent of a path of these two elements represents the textual equivalent of a path
select component of the LFB. select component of the LFB.
The <eventField> element contains the name of a component in the LFB The <eventField> element contains the name of a component in the LFB
or a component nested in an array or structure within the LFB. The or a component nested in an array or structure within the LFB. The
name used in <eventField> MUST identify a valid component within the name used in <eventField> MUST identify a valid component within the
containing LFB context. The first element in a <eventTarget> MUST be containing LFB context. The first element in an <eventTarget> MUST
an <eventField> element. In the example shown, four LFB components be an <eventField> element. In the example shown, four LFB
foo, goo, bar and gah are used as <eventField>s. components foo, goo, bar, and gah are used as <eventField>s.
In the simple case, an <eventField> identifies an atomic component. In the simple case, an <eventField> identifies an atomic component.
This is the case illustrated in the event named Foochanged. This is the case illustrated in the event named Foochanged.
<eventField> is also used to address complex components such as <eventField> is also used to address complex components such as
arrays or structures. arrays or structures.
The first defined event, Foochanged, demonstrates how a scalar LFB The first defined event, Foochanged, demonstrates how a scalar LFB
component, foo, could be monitored to trigger an event. component, foo, could be monitored to trigger an event.
The second event, Goof1changed, demonstrates how a member of the The second event, Goof1changed, demonstrates how a member of the
complex structure goo could be monitored to trigger an event. complex structure goo could be monitored to trigger an event.
The events named NewbarEntry, Gah11changed and Gah10field1 The events named NewbarEntry, Gah11changed, and Gah10field1
represent monitoring of arrays bar and gah in differing details. represent monitoring of arrays bar and gah in differing details.
If an <eventField> identifies a complex component then a further If an <eventField> identifies a complex component, then a further
<eventField> MAY be used to refine the path to the target element. <eventField> MAY be used to refine the path to the target element.
Defined event Goof1changed demonstrates how a second <eventField> is Defined event Goof1changed demonstrates how a second <eventField> is
used to point to member f1 of the structure goo. used to point to member f1 of the structure goo.
If an <eventField> identifies an array then the following rules If an <eventField> identifies an array, then the following rules
apply: apply:
o <eventSubscript> elements MUST be present as the next XML element o <eventSubscript> elements MUST be present as the next XML element
after an <eventField> which identifies an array component. after an <eventField> that identifies an array component.
<eventSubscript> MUST NOT occur other than after an array <eventSubscript> MUST NOT occur other than after an array
reference, as it is only meaningful in that context. reference, as it is only meaningful in that context.
o An <eventSubscript> contains either: o An <eventSubscript> contains either:
* A numeric value to indicate that the event applies to a * A numeric value to indicate that the event applies to a
specific entry (by index) of the array. As an example, event specific entry (by index) of the array. As an example, event
Gah11changed shows how table gah's index 11 is being targeted Gah11changed shows how table gah's index 11 is being targeted
for monitoring. for monitoring.
Or
* It is expected that the more common usage is to have the event * It is expected that the more common usage is to have the event
being defined across all elements of the array (i.e a wildcard being defined across all elements of the array (i.e., a
for all indices). In that case, the value of the wildcard for all indices). In that case, the value of the
<eventSubscript> MUST be a name rather than a numeric value. <eventSubscript> MUST be a name rather than a numeric value.
That same name can then be used as the value of That same name can then be used as the value of
<eventSubscript> in <eventReport> elements as described below. <eventSubscript> in <eventReport> elements as described below.
An example of a wild card table index is shown in event An example of a wild card table index is shown in event
NewBarentry where the <eventSubscript> value is named NewBarentry where the <eventSubscript> value is named
_barIndex_ _barIndex_
o An <eventField> MAY follow an <eventSubscript> to further refine o An <eventField> MAY follow an <eventSubscript> to further refine
the path to the target element (Note: this is in the same spirit the path to the target element. (Note: this is in the same spirit
as the case where <eventField> is used to further refine as the case where <eventField> is used to further refine
<eventField> in the earlier example of a complex structure example <eventField> in the earlier example of a complex structure example
of Goof1changed). The example event Gah10field1 illustrates how of Goof1changed.) The example event Gah10field1 illustrates how
the column field1 of table gah is monitored for changes. the column field1 of table gah is monitored for changes.
It should be emphasized that the name in an <eventSubscript> element It should be emphasized that the name in an <eventSubscript> element
in defined event NewbarEntry is not a component name. It is a in defined event NewbarEntry is not a component name. It is a
variable name for use in the <eventReport> elements (described in variable name for use in the <eventReport> elements (described in
Section 4.7.6.3) of the given LFB definition. This name MUST be Section 4.7.6.3) of the given LFB definition. This name MUST be
distinct from any component name that can validly occur in the distinct from any component name that can validly occur in the
<eventReport> clause. <eventReport> clause.
4.7.6.2. <eventCondition> Element 4.7.6.2. <eventCondition> Element
The event condition element represents a condition that triggers a The event condition element represents a condition that triggers a
notification. The list of conditions is: notification. The list of conditions is:
o <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 in the subscript indication. The event is generated when
array is created. This occurs even if the entry is created by CE an entry in the array is created. This occurs even
direction. The event example NewbarEntry demonstrates the if the entry is created by CE direction. The event
<eventCreated/> condition. example NewbarEntry demonstrates the
<eventCreated/> condition.
o <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 in the subscript indication. The event is generated when
array is destroyed. This occurs even if the entry is destroyed by an entry in the array is destroyed. This occurs
CE direction. even if the entry is destroyed by CE direction.
o <eventChanged/> the event is generated whenever the target <eventChanged/>: The event is generated whenever the target
component changes in any way. For binary components such as up/ component changes in any way. For binary
down, this reflects a change in state. It can also be used with components such as up/down, this reflects a change
numeric attributes, in which case any change in value results in a in state. It can also be used with numeric
detected trigger. Event examples Foochanged, Gah11changed, and attributes, in which case any change in value
Gah10field1 illustrate the <eventChanged/> condition. results in a detected trigger. Event examples
Foochanged, Gah11changed, and Gah10field1
illustrate the <eventChanged/> condition.
o <eventGreaterThan/> the event is generated whenever the target <eventGreaterThan/>: The event is generated whenever the target
component becomes greater than the threshold. The threshold is an component becomes greater than the threshold.
event property. The threshold is an event property.
o <eventLessThan/> the event is generated whenever the target <eventLessThan/>: The event is generated whenever the target
component becomes less than the threshold. The threshold is an component becomes less than the threshold. The
event property. threshold is an event property.
4.7.6.3. <eventReports> Element 4.7.6.3. <eventReports> Element
The <eventReports> element of an <event> declare the information to The <eventReports> element of an <event> declares the information to
be delivered by the FE along with the notification of the occurrence be delivered by the FE along with the notification of the occurrence
of the event. of the event.
The <eventReports> element contains one or more <eventReport> The <eventReports> element contains one or more <eventReport>
elements. Each <eventReport> element identifies a piece of data from elements. Each <eventReport> element identifies a piece of data from
the LFB class to be reported. The notification carries that data as the LFB class to be reported. The notification carries that data as
if the collection of <eventReport> elements had been defined in a if the collection of <eventReport> elements had been defined in a
structure. The syntax is exactly the same as used in the structure. The syntax is exactly the same as used in the
<eventTarget> element, using <eventField> and <eventSubscript> <eventTarget> element, using <eventField> and <eventSubscript>
elements and so the same rules apply. Each <eventReport> element elements, and so the same rules apply. Each <eventReport> element
thus MUST identify a component in the LFB class. <eventSubcript> MAY thus MUST identify a component in the LFB class. <eventSubcript> MAY
contain integers. If they contain names, they MUST be names from contain integers. If they contain names, they MUST be names from
<eventSubscript> elements of the <eventTarget> in the event. The <eventSubscript> elements of the <eventTarget> in the event. The
selection for the report will use the value for the subscript that selection for the report will use the value for the subscript that
identifies that specific element triggering the event. This can be identifies that specific element triggering the event. This can be
used to reference the component causing the event, or to reference used to reference the component causing the event, or to reference
related information in parallel tables. related information in parallel tables.
In the example shown, in the case of the event Foochanged, the report In the example shown, in the case of the event Foochanged, the report
will carry the value of foo; in the case of the defined event will carry the value of foo. In the case of the defined event
NewbarEntry acting on LFB component bar, which is an array, there are NewbarEntry acting on LFB component bar, which is an array, there are
two items that are reported as indicated by the two <eventReport> two items that are reported as indicated by the two <eventReport>
declarations: declarations:
o The first <eventReport> details what new entry was added in the o The first <eventReport> details what new entry was added in the
table bar. Recall that _barIndex_ is declared as the event's table bar. Recall that _barIndex_ is declared as the event's
<eventTarget> <eventSubcript> and that by virtue of using a name <eventTarget> <eventSubcript> and that by virtue of using a name
instead of a numeric value, the <eventSubcript> is implied to be a instead of a numeric value, the <eventSubcript> is implied to be a
wildcard and will carry whatever index of the new entry. wildcard and will carry whatever index of the new entry.
o The second <eventReport> includes the value of LFB component foo o The second <eventReport> includes the value of LFB component foo
at the time the new entry was created in bar. Reporting foo in at the time the new entry was created in bar. Reporting foo in
this case is provided to demonstrate the flexibility of event this case is provided to demonstrate the flexibility of event
reporting. reporting.
This event reporting structure is designed to allow the LFB designer This event reporting structure is designed to allow the LFB designer
to specify information that is likely not known a priori by the CE to specify information that is likely not known a priori by the CE
and is likely needed by the CE to process the event. While the and is likely needed by the CE to process the event. While the
structure allows for pointing at large blocks of information (full structure allows for pointing at large blocks of information (full
arrays or complex structures) this is not recommended. Also, the arrays or complex structures), this is not recommended. Also, the
variable reference/subscripting in reporting only captures a small variable reference/subscripting in reporting only captures a small
portion of the kinds of related information. Chaining through index portion of the kinds of related information. Chaining through index
fields stored in a table, for example, is not supported. In general, fields stored in a table, for example, is not supported. In general,
the <eventReports> mechanism is an optimization for cases that have the <eventReports> mechanism is an optimization for cases that have
been found to be common, saving the CE from having to query for been found to be common, saving the CE from having to query for
information it needs to understand the event. It does not represent information it needs to understand the event. It does not represent
all possible information needs. all possible information needs.
If any components referenced by the eventReport are optional, then If any components referenced by the eventReport are optional, then
the report MUST use a protocol format that supports optional elements the report MUST use a protocol format that supports optional elements
and allows for the non-existence of such elements. Any components and allows for the non-existence of such elements. Any components
which do not exist are not reported. that do not exist are not reported.
4.7.6.4. Runtime control of events 4.7.6.4. Runtime Control of Events
The high level view of the declaration and operation of LFB events is The high-level view of the declaration and operation of LFB events is
described in Section 3.2.5. described in Section 3.2.5.
The <eventTarget> provides additional components used in the path to The <eventTarget> provides additional components used in the path to
reference the event. The path constitutes the baseID for events, reference the event. The path constitutes 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 if it exists in the <eventTarget>. each <eventSubscript> element if it exists in the <eventTarget>.
The event path will uniquely identify a specific occurrence of the The event path will uniquely identify a specific occurrence of the
event in the event notification to the CE. In the example provided event in the event notification to the CE. In the example provided
above, at the end of Section 4.7.6, a notification with path of 7.7 above, at the end of Section 4.7.6, a notification with path of 7.7
uniquely identifies the event to be that caused by the change of foo; uniquely identifies the event to be that caused by the change of foo;
an event with path 7.9.100 uniquely identifies the event to be that an event with path 7.9.100 uniquely identifies the event to be that
caused by a creation of table bar entry with index/subscript 100. caused by a creation of table bar entry with index/subscript 100.
As described in the Section 4.8.5, event elements have properties As described in Section 4.8.5, event elements have properties
associated with them. These properties include the subscription associated with them. These properties include the subscription
information indicating whether the CE wishes the FE to generate event information indicating whether the CE wishes the FE to generate event
reports for the event at all, thresholds for events related to level reports for the event at all, thresholds for events related to level
crossing, and filtering conditions that may reduce the set of event crossing, and filtering conditions that may reduce the set of event
notifications generated by the FE. Details of the filtering notifications generated by the FE. Details of the filtering
conditions that can be applied are given in that section. The conditions that can be applied are given in that section. The
filtering conditions allow the FE to suppress floods of events that filtering conditions allow the FE to suppress floods of events that
could result from oscillation around a condition value. For FEs that could result from oscillation around a condition value. For FEs that
do not wish to support filtering, the filter properties can either be do not wish to support filtering, the filter properties can be either
read only or not supported. read-only or not supported.
In addition to identifying the event sources, the CE also uses the In addition to identifying the event sources, the CE also uses the
event path to activate runtime control of the event via the event event path to activate runtime control of the event via the event
properties (defined in Section 4.8.5) utilizing SET-PROP as defined properties (defined in Section 4.8.5) utilizing SET-PROP as defined
in ForCES Protocol [2] operation. in the ForCES protocol [RFC5810] operation.
To activate event generation on the FE, a SET-PROP message To activate event generation on the FE, a SET-PROP message
referencing the event and registration property of the event is referencing the event and registration property of the event is
issued to the FE by the CE with any prefix of the path of the event. issued to the FE by the CE with any prefix of the path of the event.
So, for an event defined on the example table bar, a SET-PROP with a So, for an event defined on the example table bar, a SET-PROP with a
path of 7.9 will subscribe the CE to all occurrences of that event on path of 7.9 will subscribe the CE to all occurrences of that event on
any entry of the table. This is particularly useful for the any entry of the table. This is particularly useful for the
<eventCreated/> and <eventDestroyed/> conditions on tables. Events <eventCreated/> and <eventDestroyed/> conditions on tables. Events
using those conditions will generally be defined with a field/ using those conditions will generally be defined with a field/
subscript sequence that identifies an array and ends with an subscript sequence that identifies an array and ends with an
skipping to change at page 77, line 43 skipping to change at page 79, line 17
specification does not allow for defining a threshold or filtering specification does not allow for defining a threshold or filtering
condition on an event for all elements of an array. condition on an event for all elements of an array.
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 explain what the LFB does to a human user. text (in XML sense) to explain what the LFB does to a human user.
4.8. Properties 4.8. Properties
Components of LFBs have properties which are important to the CE. Components of LFBs have properties that are important to the CE. The
The most important property is the existence / readability / most important property is the existence / readability / writeability
writeability of the element. Depending on the type of the component, of the element. Depending on the type of the component, other
other information may be of importance. 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 the information. There is a base class of property information. For the
array, alias, and event components there are subclasses of property array, alias, and event components, there are subclasses of property
information providing additional fields. This information is information providing additional fields. This information is
accessed by the CE (and updated where applicable) via the ForCES accessed by the CE (and updated where applicable) via the ForCES
protocol. While some property information is writeable, there is no protocol. While some property information is writeable, there is no
mechanism currently provided for checking the properties of a mechanism currently provided for checking the properties of a
property element. Writeability can only be checked by attempting to property element. Writeability can only be checked by attempting to
modify the value. modify the value.
4.8.1. Basic Properties 4.8.1. Basic Properties
The basic property definition, along with the scalar dataTypeDef for The basic property definition, along with the scalar dataTypeDef for
accessibility is below. Note that this access permission information accessibility, is below. Note that this access permission
is generally read-only. information is generally read-only.
<dataTypeDef> <dataTypeDef>
<name>accessPermissionValues</name> <name>accessPermissionValues</name>
<synopsis> <synopsis>
The possible values of component access permission The possible values of component access permission
</synopsis> </synopsis>
<atomic> <atomic>
<baseType>uchar</baseType> <baseType>uchar</baseType>
<specialValues> <specialValues>
<specialValue value="0"> <specialValue value="0">
skipping to change at page 80, line 40 skipping to change at page 81, line 40
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</component> </component>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
4.8.3. String Properties 4.8.3. String Properties
The properties of a string specify the actual octet length and the The properties of a string specify the actual octet length and the
maximum octet length for the element. The maximum length is included maximum octet length for the element. The maximum length is included
because an FE implementation MAY limit a string to be shorter than because an FE implementation MAY limit a string to be shorter than
the limit in the LFB Class definition. the limit in the LFB class definition.
<dataTypeDef> <dataTypeDef>
<name>stringElementProperties</name> <name>stringElementProperties</name>
<synopsis>string Element Properties definition </synopsis> <synopsis>string Element Properties definition </synopsis>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<component componentID="2"> <component componentID="2">
<name>stringLength</name> <name>stringLength</name>
<synopsis>the number of octets in the string</synopsis> <synopsis>the number of octets in the string</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
skipping to change at page 81, line 29 skipping to change at page 82, line 29
</synopsis> </synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</component> </component>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
4.8.4. Octetstring Properties 4.8.4. Octetstring Properties
The properties of an octetstring specify the actual length and the The properties of an octetstring specify the actual length and the
maximum length, since the FE implementation MAY limit an octetstring maximum length, since the FE implementation MAY limit an octetstring
to be shorter than the LFB Class definition. to be shorter than the LFB class definition.
<dataTypeDef> <dataTypeDef>
<name>octetstringElementProperties</name> <name>octetstringElementProperties</name>
<synopsis>octetstring Element Properties definition <synopsis>octetstring Element Properties definition
</synopsis> </synopsis>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<component componentID="2"> <component componentID="2">
<name>octetstringLength</name> <name>octetstringLength</name>
<synopsis> <synopsis>
skipping to change at page 82, line 15 skipping to change at page 83, line 15
4.8.5. Event Properties 4.8.5. 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 generated. One is the subscription field. 0 means no notification is generated.
Any non-zero value (typically 1 is used) means that a notification is Any non-zero value (typically 1 is used) means that a notification is
generated. The hysteresis field is used to suppress generation of generated. The hysteresis field is used to suppress generation of
notifications for oscillations around a condition value, and is notifications for oscillations around a condition value, and is
described below (Section 4.8.5.2). The threshold field is used for described below (Section 4.8.5.2). The threshold field is used for
the <eventGreaterThan/> and <eventLessThan/> conditions. It the <eventGreaterThan/> and <eventLessThan/> conditions. It
indicates the value to compare the event target against. Using the indicates the value to compare the event target against. Using the
properties allows the CE to set the level of interest. FEs which do properties allows the CE to set the level of interest. FEs that do
not support setting the threshold for events will make this field not support setting the threshold for events will make this field
read-only. read-only.
<dataTypeDef> <dataTypeDef>
<name>eventElementProperties</name> <name>eventElementProperties</name>
<synopsis>event Element Properties definition</synopsis> <synopsis>event Element Properties definition</synopsis>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<component componentID="2"> <component componentID="2">
<name>registration</name> <name>registration</name>
skipping to change at page 83, line 46 skipping to change at page 84, line 46
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</component> </component>
<component componentID="6"> <component componentID="6">
<name>eventInterval</name> <name>eventInterval</name>
<synopsis> time interval in ms between notifications <synopsis> time interval in ms between notifications
</synopsis> </synopsis>
<optional/> <optional/>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</component> </component>
</struct> </struct>
<dataTypeDef> </dataTypeDef>
4.8.5.1. Common Event Filtering 4.8.5.1. Common Event Filtering
The event properties have values for controlling several filter The event properties have values for controlling several filter
conditions. Support of these conditions is optional, but all conditions. Support of these conditions is optional, but all
conditions SHOULD be supported. Events which are reliably known not conditions SHOULD be supported. Events that are reliably known not
to be subject to rapid occurrence or other concerns MAY not support to be subject to rapid occurrence or other concerns MAY not support
all filter conditions. all filter conditions.
Currently, three different filter condition variables are defined. Currently, three different filter condition variables are defined.
These are eventCount, eventInterval, and eventHysteresis. Setting These are eventCount, eventInterval, and eventHysteresis. Setting
the condition variables to 0 (their default value) means that the the condition variables to 0 (their default value) means that the
condition is not checked. condition is not checked.
Conceptually, when an event is triggered, all configured conditions Conceptually, when an event is triggered, all configured conditions
are checked. If no filter conditions are triggered, or if any are checked. If no filter conditions are triggered, or if any
trigger conditions are met, the event notification is generated. If trigger conditions are met, the event notification is generated. If
there are filter conditions, and no condition is met, then no event there are filter conditions, and no condition is met, then no event
notification is generated. Event filter conditions have reset notification is generated. Event filter conditions have reset
behavior when an event notification is generated. If any condition behavior when an event notification is generated. If any condition
is passed, and the notification is generated, the notification reset is passed, and the notification is generated, the notification reset
behavior is performed on all conditions, even those which had not behavior is performed on all conditions, even those that had not
passed. This provides a clean definition of the interaction of the passed. This provides a clean definition of the interaction of the
various event conditions. various event conditions.
An example of the interaction of conditions is an event with an An example of the interaction of conditions is an event with an
eventCount property set to 5 and an eventInterval property set to 500 eventCount property set to 5 and an eventInterval property set to 500
milliseconds. Suppose that a burst of occurrences of this event is milliseconds. Suppose that a burst of occurrences of this event is
detected by the FE. The first occurrence will cause a notification detected by the FE. The first occurrence will cause a notification
to be sent to the CE. Then, if four more occurrences are detected to be sent to the CE. Then, if four more occurrences are detected
rapidly (less than 0.5 seconds) they will not result in rapidly (less than 0.5 seconds) they will not result in
notifications. If two more occurrences are detected, then the second notifications. If two more occurrences are detected, then the second
skipping to change at page 84, line 47 skipping to change at page 86, line 7
Events with numeric conditions can have hysteresis filters applied to Events with numeric conditions can have hysteresis filters applied to
them. The hysteresis level is defined by a property of the event. them. The hysteresis level is defined by a property of the event.
This allows the FE to notify the CE of the hysteresis applied, and if 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 it chooses, the FE can allow the CE to modify the hysteresis. This
applies to <eventChanged/> for a numeric field, and to applies to <eventChanged/> for a numeric field, and to
<eventGreaterThan/> and <eventLessThan/>. The content of a <eventGreaterThan/> and <eventLessThan/>. The content of a
<variance> element is a numeric value. When supporting hysteresis, <variance> element is a numeric value. When supporting hysteresis,
the FE MUST track the value of the element and make sure that the 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 condition has become untrue by at least the hysteresis from the event
property. To be specific, if the hysteresis is V, then property. To be specific, if the hysteresis is V, then:
o For a <eventChanged/> condition, if the last notification was for o For an <eventChanged/> condition, if the last notification was for
value X, then the <changed/> notification MUST NOT be generated value X, then the <changed/> notification MUST NOT be generated
until the value reaches X +/- V. until the value reaches X +/- V.
o For a <eventGreaterThan/> condition with threshold T, once the o For an <eventGreaterThan/> condition with threshold T, once the
event has been generated at least once it MUST NOT be generated 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, again until the field first becomes less than or equal to T - V,
and then exceeds T. and then exceeds T.
o For a <eventLessThan/> condition with threshold T, once the event o For an <eventLessThan/> condition with threshold T, once the event
has been generate at least once it MUST NOT be generated again 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 until the field first becomes greater than or equal to T + V, and
then becomes less than T. then becomes less than T.
4.8.5.3. Event Count Filtering 4.8.5.3. Event Count Filtering
Events MAY have a count filtering condition. This property, if set Events MAY have a count filtering condition. This property, if set
to a non-zero value, indicates the number of occurrences of the event to a non-zero value, indicates the number of occurrences of the event
that should be considered redundant and not result in a notification. that should be considered redundant and not result in a notification.
Thus, if this property is set to 1, and no other conditions apply, 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 then every other detected occurrence of the event will result in a
notification. This particular meaning is chosen so that the value 1 notification. This particular meaning is chosen so that the value 1
has a distinct meaning from the value 0. has a distinct meaning from the value 0.
A conceptual implementation (not required) for this might be an A conceptual implementation (not required) for this might be an
internal suppression counter. Whenever an event is triggered, the internal suppression counter. Whenever an event is triggered, the
counter is checked. If the counter is 0, a notification is counter is checked. If the counter is 0, a notification is
generated. Whether a notification is generated or not, the counter generated. Whether or not a notification is generated, the counter
is incremented. If the counter exceeds the configured value, it is is incremented. If the counter exceeds the configured value, it is
set to 0. set to 0.
4.8.5.4. Event Time Filtering 4.8.5.4. Event Time Filtering
Events MAY have a time filtering condition. This property represents Events MAY have a time filtering condition. This property represents
the minimum time interval (in the absence of some other filtering the minimum time interval (in the absence of some other filtering
condition being passed) between generating notifications of detected condition being passed) between generating notifications of detected
events. This condition MUST only be passed if the time since the events. This condition MUST only be passed if the time since the
last notification of the event is longer than the configured interval last notification of the event is longer than the configured interval
in milliseconds. in milliseconds.
Conceptually, this can be thought of as a stored timestamp which is Conceptually, this can be thought of as a stored timestamp that is
compared with the detection time, or as a timer that is running that compared with the detection time, or as a timer that is running that
resets a suppression flag. In either case, if a notification is resets a suppression flag. In either case, if a notification is
generated due to passing any condition then the time interval generated due to passing any condition then the time interval
detection MUST be restarted. detection MUST be restarted.
4.8.6. Alias Properties 4.8.6. 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 component the subject alias These combine to identify the target component to which the subject
refers to. alias refers.
<dataTypeDef> <dataTypeDef>
<name>aliasElementProperties</name> <name>aliasElementProperties</name>
<synopsis>alias Element Properties defintion</synopsis> <synopsis>alias Element Properties definition</synopsis>
<struct> <struct>
<derivedFrom>baseElementProperties</derivedFrom> <derivedFrom>baseElementProperties</derivedFrom>
<component componentID="2"> <component componentID="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>
</component> </component>
<component componentID="3"> <component componentID="3">
<name>targetLFBInstance</name> <name>targetLFBInstance</name>
<synopsis>the instance ID of the alias target</synopsis> <synopsis>the instance ID of the alias target</synopsis>
skipping to change at page 88, line 25 skipping to change at page 89, line 44
<xsd:group ref="typeDeclarationGroup"/> <xsd:group ref="typeDeclarationGroup"/>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> </xsd:complexType>
<!-- <!--
Predefined (built-in) atomic data-types are: Predefined (built-in) atomic data-types are:
char, uchar, int16, uint16, int32, uint32, int64, uint64, char, uchar, int16, uint16, int32, uint32, int64, uint64,
string[N], string, byte[N], boolean, octetstring[N], string[N], string, byte[N], boolean, octetstring[N],
float16, float32, float64 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>
skipping to change at page 94, line 4 skipping to change at page 95, line 26
</xsd:complexType> </xsd:complexType>
<xsd:complexType name="outputPortType"> <xsd:complexType name="outputPortType">
<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="product" type="portProductType"/> <xsd:element name="product" type="portProductType"/>
<xsd:element ref="description" minOccurs="0"/> <xsd:element ref="description" minOccurs="0"/>
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="group" type="xsd:boolean" use="optional" <xsd:attribute name="group" type="xsd:boolean" use="optional"
default="0"/> default="0"/>
</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"/>
skipping to change at page 97, line 41 skipping to change at page 99, line 19
mechanisms for this control, different implementations and different mechanisms for this control, different implementations and different
instances will have different capabilities. The CE MUST be able to instances will have different capabilities. The CE MUST be able to
determine what each instance it is responsible for is actually determine what each instance it is responsible for is actually
capable of doing. As stated previously, this is an approximation. capable of doing. As stated previously, this is an approximation.
The CE is expected to be prepared to cope with errors in requests and The CE is expected to be prepared to cope with errors in requests and
variations in detail not captured by the capabilities information variations in detail not captured by the capabilities information
about an FE. about an FE.
In addition to its capabilities, an FE will have information that can In addition to its capabilities, an FE will have information that can
be used in understanding and controlling the forwarding operations. be used in understanding and controlling the forwarding operations.
Some of this information will be read only, while others parts may Some of this information will be read-only, while others parts may
also be writeable. also be writeable.
In order to make the FE information easily accessible, the In order to make the FE information easily accessible, the
information is represented in an LFB. This LFB has a class, information is represented in an LFB. This LFB has a class,
FEObject. The LFBClassID for this class is 1. Only one instance of FEObject. The LFBClassID for this class is 1. Only one instance of
this class will ever be present in an FE, and the instance ID of that this class will ever be present in an FE, and the instance ID of that
instance in the protocol is 1. Thus, by referencing the components instance in the protocol is 1. Thus, by referencing the components
of class:1, instance:1 a CE can get the general information about the of class:1, instance:1 a CE can get the general information about the
FE. The FEObject LFB Class is described in this section. FE. The FEObject LFB class is described in this section.
There will also be an FEProtocol LFB Class. LFBClassID 2 is reserved There will also be an FEProtocol LFB class. LFBClassID 2 is reserved
for that class. There will be only one instance of that class as for that class. There will be only one instance of that class as
well. Details of that class are defined in the ForCES Protocol [2] well. Details of that class are defined in the ForCES protocol
document. [RFC5810] 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="urn:ietf:params:xml:ns:forces:lfbmodel:1.0" <LFBLibrary xmlns="urn:ietf:params:xml:ns:forces:lfbmodel:1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
provides="FEObject"> provides="FEObject">
<dataTypeDefs> <dataTypeDefs>
<dataTypeDef> <dataTypeDef>
<name>LFBAdjacencyLimitType</name> <name>LFBAdjacencyLimitType</name>
<synopsis>Describing the Adjacent LFB</synopsis> <synopsis>Describing the Adjacent LFB</synopsis>
<struct> <struct>
<component componentID="1"> <component componentID="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>
</component> </component>
<component componentID="2"> <component componentID="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>
skipping to change at page 99, line 21 skipping to change at page 100, line 45
</component> </component>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>SupportedLFBType</name> <name>SupportedLFBType</name>
<synopsis>table entry for supported LFB</synopsis> <synopsis>table entry for supported LFB</synopsis>
<struct> <struct>
<component componentID="1"> <component componentID="1">
<name>LFBName</name> <name>LFBName</name>
<synopsis> <synopsis>
The name of a supported LFB Class The name of a supported LFB class
</synopsis> </synopsis>
<typeRef>string</typeRef> <typeRef>string</typeRef>
</component> </component>
<component componentID="2"> <component componentID="2">
<name>LFBClassID</name> <name>LFBClassID</name>
<synopsis>the id of a supported LFB Class</synopsis> <synopsis>the id of a supported LFB class</synopsis>
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</component> </component>
<component componentID="3"> <component componentID="3">
<name>LFBVersion</name> <name>LFBVersion</name>
<synopsis> <synopsis>
The version of the LFB Class used The version of the LFB class used
by this FE. by this FE.
</synopsis> </synopsis>
<typeRef>string</typeRef> <typeRef>string</typeRef>
</component> </component>
<component componentID="4"> <component componentID="4">
<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/>
skipping to change at page 100, line 7 skipping to change at page 101, line 32
<!-- For each port group, how many ports can exist <!-- For each port group, how many ports can exist
--> -->
<component componentID="5"> <component componentID="5">
<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>
</component> </component>
<!-- for the named LFB Class, the LFB Classes it may follow --> <!-- for the named LFB Class, the LFB Classes it may follow -->
<component componentID="6"> <component componentID="6">
<name>CanOccurAfters</name> <name>CanOccurAfters</name>
<synopsis> <synopsis>
List of LFB Classes that this LFB class can follow List of LFB classes that this LFB class can follow
</synopsis> </synopsis>
<optional/> <optional/>
<array type="variable-size"> <array type="variable-size">
<typeRef>LFBAdjacencyLimitType</typeRef> <typeRef>LFBAdjacencyLimitType</typeRef>
</array> </array>
</component> </component>
<!-- for the named LFB Class, the LFB Classes that may follow it <!-- for the named LFB Class, the LFB Classes that may follow it
--> -->
<component componentID="7"> <component componentID="7">
<name>CanOccurBefores</name> <name>CanOccurBefores</name>
<synopsis> <synopsis>
List of LFB Classes that can follow this LFB class List of LFB classes that can follow this LFB class
</synopsis> </synopsis>
<optional/> <optional/>
<array type="variable-size"> <array type="variable-size">
<typeRef>LFBAdjacencyLimitType</typeRef> <typeRef>LFBAdjacencyLimitType</typeRef>
</array> </array>
</component> </component>
<component componentID="8"> <component componentID="8">
<name>UseableParentLFBClasses</name> <name>UseableParentLFBClasses</name>
<synopsis> <synopsis>
List of LFB Classes from which this class has List of LFB classes from which this class has
inherited, and which the FE is willing to allow inherited, and which the FE is willing to allow
for references to instances of this class. for references to instances of this class.
</synopsis> </synopsis>
<optional/> <optional/>
<array type="variable-size"> <array type="variable-size">
<typeRef>uint32</typeRef> <typeRef>uint32</typeRef>
</array> </array>
</component> </component>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
skipping to change at page 101, line 41 skipping to change at page 103, line 19
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>
</component> </component>
<component componentID="3"> <component componentID="3">
<name>NeighborInterface</name> <name>NeighborInterface</name>
<synopsis> <synopsis>
The name of the interface on the neighbor to The name of the interface on the neighbor to
which this FE is adjacent. This is required which this FE is adjacent. This is required
In case two FEs are adjacent on more than in case two FEs are adjacent on more than
one interface. one interface.
</synopsis> </synopsis>
<optional/> <optional/>
<typeRef>string</typeRef> <typeRef>string</typeRef>
</component> </component>
</struct> </struct>
</dataTypeDef> </dataTypeDef>
<dataTypeDef> <dataTypeDef>
<name>LFBSelectorType</name> <name>LFBSelectorType</name>
<synopsis> <synopsis>
skipping to change at page 104, line 44 skipping to change at page 106, line 21
<typeRef>SupportedLFBType</typeRef> <typeRef>SupportedLFBType</typeRef>
</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, capability element of the class definition. As described elsewhere, 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 components of the FEObject SupportedLFBs. Information as to which components of the FEObject
LFB are supported is accessed by the properties information for those LFB are supported is accessed by the properties information for those
components. components.
5.2.1. ModifiableLFBTopology 5.2.1. ModifiableLFBTopology
This component has a boolean value that indicates whether the LFB This component has a boolean value that indicates whether the LFB
topology of the FE may be changed by the CE. If the component is topology of the FE may be changed by the CE. If the component is
absent, the default value is assumed to be true, and the CE presumes absent, the default value is assumed to be true, and the CE presumes
the LFB topology may be changed. If the value is present and set to that the LFB topology may be changed. If the value is present and
false, the LFB topology of the FE is fixed. If the topology is set to false, the LFB topology of the FE is fixed. If the topology
fixed, the SupportedLFBs element may be omitted, and the list of is fixed, the SupportedLFBs element may be omitted, and the list of
supported LFBs is inferred by the CE from the LFB topology supported LFBs is inferred by the CE from the LFB topology
information. If the list of supported LFBs is provided when information. If the list of supported LFBs is provided when
ModifiableLFBTopology is false, the CanOccurBefore and CanOccurAfter ModifiableLFBTopology is false, the CanOccurBefore and 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 component, is an array that contains LFB classes. The SupportedLFBs component, is an array that contains
the information about each supported LFB Class. The array structure the information about each supported LFB class. The array structure
type is defined as the SupportedLFBType dataTypeDef. type is defined as the SupportedLFBType dataTypeDef.
Each entry in the SupportedLFBs array describes an LFB class that the Each entry in the SupportedLFBs array describes an LFB class that the
FE supports. In addition to indicating that the FE supports the FE supports. In addition to indicating that the FE supports the
class, FEs with modifiable LFB topology SHOULD include information class, FEs with modifiable LFB topology SHOULD include information
about how LFBs of the specified class may be connected to other LFBs. about how LFBs of the specified class may be connected to other LFBs.
This information SHOULD describe which LFB classes the specified LFB This information SHOULD describe which LFB classes the specified LFB
class may succeed or precede in the LFB topology. The FE SHOULD class may succeed or precede in the LFB topology. The FE SHOULD
include information as to which port groups may be connected to the include information as to which port groups may be connected to the
given adjacent LFB class. If port group information is omitted, it given adjacent LFB class. If port group information is omitted, it
is assumed that all port groups may be used. This capability is assumed that all port groups may be used. This capability
information on the acceptable ordering and connection of LFBs MAY be information on the acceptable ordering and connection of LFBs MAY be
omitted if the implementor concludes that the actual constraints are omitted if the implementor concludes that the actual constraints are
such that the information would be misleading for the CE. such that the information would be misleading for the CE.
5.2.2.1. LFBName 5.2.2.1. LFBName
This component has as its value the name of the LFB Class being This component has as its value the name of the LFB class being
described. described.
5.2.2.2. LFBClassID 5.2.2.2. LFBClassID
The numeric ID of the LFB Class being described. While conceptually LFBClassID is the numeric ID of the LFB class being described. While
redundant with the LFB Name, both are included for clarity and to conceptually redundant with the LFB name, both are included for
allow consistency checking. clarity and to allow consistency checking.
5.2.2.3. LFBVersion 5.2.2.3. LFBVersion
The version string specifying the LFB Class version supported by this LFBVersion is the version string specifying the LFB class version
FE. As described above in versioning, an FE can support only a supported by this FE. As described above in versioning, an FE can
single version of a given LFB Class. support only a single version of a given LFB class.
5.2.2.4. LFBOccurrenceLimit 5.2.2.4. LFBOccurrenceLimit
This component, if present, indicates the largest number of instances This component, if present, indicates the largest number of instances
of this LFB class the FE can support. For FEs that do not have the of this LFB class the FE can support. For FEs that do not have the
capability to create or destroy LFB instances, this can either be capability to create or destroy LFB instances, this can either be
omitted or be the same as the number of LFB instances of this class omitted or be the same as the number of LFB instances of this class
contained in the LFB list attribute. contained in the LFB list attribute.
5.2.2.5. PortGroupLimits and PortGroupLimitType 5.2.2.5. PortGroupLimits and PortGroupLimitType
skipping to change at page 106, line 47 skipping to change at page 108, line 24
class. That is, the SupportedLFB can have an input port connected to class. That is, the SupportedLFB can have an input port connected to
an output port of an LFB that appears in the CanOccurAfters array. an output port of an LFB that appears in the CanOccurAfters array.
The LFB class that the SupportedLFB can follow is identified by the The LFB class that the SupportedLFB can follow is identified by the
NeighborLFB component (of the LFBAdjacencyLimitType dataTypeDef) of NeighborLFB component (of the LFBAdjacencyLimitType dataTypeDef) of
the CanOccurAfters array entry. If this neighbor can only be the CanOccurAfters array entry. If this neighbor can only be
connected to a specific set of input port groups, then the viaPort connected to a specific set of input port groups, then the viaPort
component is included. This component is an array, with one entry component is included. This component is an array, with one entry
for each input port group of the SupportedLFB that can be connected for each input port group of the SupportedLFB that can be connected
to an output port of the NeighborLFB. to an output port of the NeighborLFB.
[e.g., Within a SupportedLFBs entry, each array entry of the (For example, within a SupportedLFBs entry, each array entry of the
CanOccurAfters array must have a unique NeighborLFB, and within each CanOccurAfters array must have a unique NeighborLFB, and within each
such array entry each viaPort must represent a distinct and valid such array entry each viaPort must represent a distinct and valid
input port group of the SupportedLFB. The LFB Class definition input port group of the SupportedLFB. The LFB class definition
schema does not include these uniqueness constraints.] schema does not include these uniqueness constraints.)
5.2.2.7. CanOccurBefores and LFBAdjacencyLimitType 5.2.2.7. 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 the parallels CanOccurAfters, and uses the same type definition for the
array entries. array entries.
The array entries list those LFB classes that the SupportedLFB may The array entries list those LFB classes that the SupportedLFB may
precede in the topology. In this component, the entries in the precede in the topology. In this component, the entries in the
viaPort component of the array value represent the output port groups viaPort component of the array value represent the output port groups
of the SupportedLFB that may be connected to the NeighborLFB. As of the SupportedLFB that may be connected to the NeighborLFB. As
with CanOccurAfters, viaPort may have multiple entries if multiple with CanOccurAfters, viaPort may have multiple entries if multiple
output ports may legitimately connect to the given NeighborLFB class. output ports may legitimately connect to the given NeighborLFB class.
[And a similar set of uniqueness constraints apply to the (And a similar set of uniqueness constraints applies 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.8. UseableParentLFBClasses 5.2.2.8. UseableParentLFBClasses
The UseableParentLFBClasses array, if present, is used to hold a list The UseableParentLFBClasses array, if present, is used to hold a list
of parent LFB class IDs. All the entries in the list must be IDs of of parent LFB class IDs. All the entries in the list must be IDs of
classes from which the SupportedLFB Class being described has classes from which the SupportedLFB class being described has
inherited (either directly, or through an intermediate parent.) (If inherited (either directly or through an intermediate parent.) (If
an FE includes improper values in this list, improper manipulations an FE includes improper values in this list, improper manipulations
by the CE are likely, and operational failures are likely.) In by the CE are likely, and operational failures are likely.) In
addition, the FE, by including a given class in the last, is addition, the FE, by including a given class in the last, is
indicating to the CE that a given parent class may be used to indicating to the CE that a given parent class may be used to
manipulate an instance of this supported LFB class. manipulate an instance of this supported LFB class.
By allowing such substitution, the FE allows for the case where an By allowing such substitution, the FE allows for the case where an
instantiated LFB may be of a class not known to the CE, but could instantiated LFB may be of a class not known to the CE, but could
still be manipulated. While it is hoped that such situations are still be manipulated. While it is hoped that such situations are
rare, it is desirable for this to be supported. This can occur if an rare, it is desirable for this to be supported. This can occur if an
FE locally defines certain LFB instances, or if an earlier CE had FE locally defines certain LFB instances, or if an earlier CE had
configured some LFB instances. It can also occur if the FE would configured some LFB instances. It can also occur if the FE would
prefer to instantiate a more recent, more specific and suitable, LFB prefer to instantiate a more recent, more specific and suitable LFB
class rather than a common parent. class rather than a common parent.
In order to permit this, the FE MUST be more restrained in assigning In order to permit this, the FE MUST be more restrained in assigning
LFB Instance IDs. Normally, instance IDs are qualified by the LFB LFB instance IDs. Normally, instance IDs are qualified by the LFB
class. However, if two LFB classes share a parent, and if that class. However, if two LFB classes share a parent, and if that
parent is listed in the UseableParentLFBClasses for both specific LFB parent is listed in the UseableParentLFBClasses for both specific LFB
classes, then all the instances of both (or any, if multiple classes classes, then all the instances of both (or any, if multiple classes
are listing the common parent) MUST use distinct instances. This are listing the common parent) MUST use distinct instances. This
permits the FE to determine which LFB Instance is intended by CE permits the FE to determine which LFB instance is intended by CE
manipulation operations even when a parent class is used. manipulation operations even when a parent class is used.
5.2.2.9. LFBClassCapabilities 5.2.2.9. LFBClassCapabilities
While it would be desirable to include class capability level While it would be desirable to include class-capability-level
information, this is not included in the model. While such information, this is not included in the model. While such
information belongs in the FE Object in the supported class table, information belongs in the FE Object in the supported class table,
the contents of that information would be class specific. The the contents of that information would be class specific. The
currently expected encoding structures for transferring information currently expected encoding structures for transferring information
between the CE and FE are such that allowing completely unspecified between the CE and FE are such that allowing completely unspecified
information would be likely to induce parse errors. We could specify information would be likely to induce parse errors. We could specify
that the information is encoded in an octetstring, but then we would that the information be encoded in an octetstring, but then we would
have to define the internal format of that octet string. have to define the internal format of that octet string.
As there also are not currently any defined LFB Class level As there also are not currently any defined LFB class-level
Capabilities that the FE needs to report, this information is not capabilities that the FE needs to report, this information is not
present now, but may be added in a future version of the FE Object. present now, but may be added in a future version of the FE object.
(This is an example of a case where versioning, rather than (This is an example of a case where versioning, rather than
inheritance, would be needed, since the FE Object must have class ID inheritance, would be needed, since the FE object must have class ID
1 and instance ID 1 so that the protocol behavior can start by 1 and instance ID 1 so that the protocol behavior can start by
finding this object.) finding this object.)
5.3. FE Components 5.3. FE Components
The <components> element is included if the class definition contains The <components> element is included if the class definition contains
the definition of the components of the FE Object that are not the definition of the components of the FE object that are not
considered "capabilities". Some of these components are writeable, considered "capabilities". Some of these components are writeable
and some are read-only, which is determinable by examining the and some are read-only, which is determinable by examining the
property information of the components. property information of the components.
5.3.1. FEState 5.3.1. FEState
This component carries the overall state of the FE. The possible This component carries the overall state of the FE. The possible
values are the strings AdminDisable, OperDisable and OperEnable. The values are the strings AdminDisable, OperDisable, and OperEnable.
starting state is OperDisable, and the transition to OperEnable is The starting state is OperDisable, and the transition to OperEnable
controlled by the FE. The CE controls the transition from OperEnable is controlled by the FE. The CE controls the transition from
to/from AdminDisable. For details refer to the ForCES Protocol OperEnable to/from AdminDisable. For details, refer to the ForCES
document [2]. protocol document [RFC5810].
5.3.2. LFBSelectors and LFBSelectorType 5.3.2. LFBSelectors and LFBSelectorType
The LFBSelectors component is an array of information about the LFBs The LFBSelectors component is an array of information about the LFBs
currently accessible via ForCES in the FE. The structure of the LFB currently accessible via ForCES in the FE. The structure of the LFB
information is defined by the LFBSelectorType dataTypeDef. information is defined by the LFBSelectorType dataTypeDef.
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 entry contains the numeric class ID of the class of the LFB The array entry contains the numeric class ID of the class of the LFB
instance and the numeric instance ID for this instance. instance and the numeric instance ID for this instance.
skipping to change at page 109, line 20 skipping to change at page 110, line 47
sufficient information to identify precisely the end points of a sufficient information to identify precisely the end points of a
link. The FromLFBID and ToLFBID components specify the LFB instances link. The FromLFBID and ToLFBID components specify the LFB instances
at each end of the link, and MUST reference LFBs in the LFB instance at each end of the link, and MUST reference LFBs in the LFB instance
table. The FromPortGroup and ToPortGroup MUST identify output and table. The FromPortGroup and ToPortGroup MUST identify output and
input port groups defined in the LFB classes of the LFB instances input port groups defined in the LFB classes of the LFB instances
identified by FromLFBID and ToLFBID. The FromPortIndex and identified by FromLFBID and ToLFBID. The FromPortIndex and
ToPortIndex components select the entries from the port groups that ToPortIndex components select the entries from the port groups that
this link connects. All links are uniquely identified by the this link connects. All links are uniquely identified by the
FromLFBID, FromPortGroup, and FromPortIndex fields. Multiple links FromLFBID, FromPortGroup, and FromPortIndex fields. Multiple links
may have the same ToLFBID, ToPortGroup, and ToPortIndex as this model may have the same ToLFBID, ToPortGroup, and ToPortIndex as this model
supports fan-in of inter- LFB links but not fan-out. supports fan-in of inter-LFB links but not fan-out.
5.3.4. FENeighbors and FEConfiguredNeighborType 5.3.4. FENeighbors and FEConfiguredNeighborType
The FENeighbors component is an array of information about manually The FENeighbors component is an array of information about manually
configured adjacencies between this FE and other FEs. The content of configured adjacencies between this FE and other FEs. The content of
the array is defined by the FEConfiguredNeighborType dataTypeDef. the array is defined by the FEConfiguredNeighborType dataTypeDef.
This array is intended to capture information that may be configured This array is intended to capture information that may be configured
on the FE and is needed by the CE, where one array entry corresponds on the FE and is needed by the CE, where one array entry corresponds
to each configured neighbor. Note that this array is not intended to to each configured neighbor. Note that this array is not intended to
represent the results of any discovery protocols, as those will have represent the results of any discovery protocols, as those will have
their own LFBs. This component is optional. their own LFBs. This component is optional.
While there may be many ways to configure neighbors, the FE-ID is the While there may be many ways to configure neighbors, the FE-ID is the
best way for the CE to correlate entities. And the interface best way for the CE to correlate entities. And the interface
identifier (name string) is the best correlator. The CE will be able identifier (name string) is the best correlator. The CE will be able
to determine the IP address and media level information about the to determine the IP address and media-level information about the
neighbor from the neighbor directly. Omitting that information from neighbor from the neighbor directly. Omitting that information from
this table avoids the risk of incorrect double configuration. this table avoids the risk of incorrect double configuration.
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 neighbor. This is the ID in some space meaningful to the CE for the neighbor.
5.3.4.2. InterfaceToNeighbor 5.3.4.2. InterfaceToNeighbor
This identifies the interface through which the neighbor is reached. This identifies the interface through which the neighbor is reached.
5.3.4.3. NeighborInterface 5.3.4.3. NeighborInterface
This identifies the interface on the neighbor through which the This identifies the interface on the neighbor through which the
neighbor is reached. The interface identification is needed when neighbor is reached. The interface identification is needed when
either only one side of the adjacency has configuration information, either only one side of the adjacency has configuration information
or the two FEs are adjacent on more than one interface. or the two FEs are adjacent on more than one interface.
6. Satisfying the Requirements on FE Model 6. Satisfying the Requirements on the 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 RFC3654 [6]. The requirements requirements outlined in Section 5 of RFC 3654 [RFC3654]. The
can be separated into general requirements (Section 5, 5.1 - 5.4) and requirements can be separated into general requirements (Section 5,
the specification of the minimal set of logical functions that the FE 5.1 - 5.4) and the specification of the minimal set of logical
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 express The general requirement on the FE model is that it be able to express
the logical packet processing capability of the FE, through both a the logical packet processing capability of the FE, through both a
capability and a state model. In addition, the FE model is expected capability and a state model. In addition, the FE model is expected
to allow flexible implementations and be extensible to allow defining to allow flexible implementations and be extensible to allow defining
new logical functions. new logical functions.
A major component of the proposed FE model is the Logical Function A major component of the proposed FE model is the Logical Functional
Block (LFB) model. Each distinct logical function in an FE is Block (LFB) model. Each distinct logical function in an FE is
modeled as an LFB. Operational parameters of the LFB that must be modeled as an LFB. Operational parameters of the LFB that must be
visible to the CE are conceptualized as LFB components. These visible to the CE are conceptualized as LFB components. These
components express the capability of the FE and support flexible components express the capability of the FE and support flexible
implementations by allowing an FE to specify which optional features implementations by allowing an FE to specify which optional features
are supported. The components also indicate whether they are are supported. The components also indicate whether they are
configurable by the CE for an LFB class. Configurable components configurable by the CE for an LFB class. Configurable components
provide the CE some flexibility in specifying the behavior of an LFB. provide the CE some flexibility in specifying the behavior of an LFB.
When multiple LFBs belonging to the same LFB class are instantiated When multiple LFBs belonging to the same LFB class are instantiated
on an FE, each of those LFBs could be configured with different on an FE, each of those LFBs could be configured with different
skipping to change at page 111, line 7 skipping to change at page 112, line 40
Another key component of the FE model is the FE components. The FE Another key component of the FE model is the FE components. The FE
components are used mainly to describe the capabilities of the FE, components are used mainly to describe the capabilities of the FE,
but they also convey information about the FE state. but they also convey information about the FE state.
The FE model includes only the definition of the FE Object LFB The FE model includes only the definition of the FE Object LFB
itself. Meeting the full set of working group requirements requires itself. Meeting the full set of working group requirements requires
other LFBs. The class definitions for those LFBs will be provided in other LFBs. The class definitions for those LFBs will be provided in
other documents. other documents.
7. Using the FE model in the ForCES Protocol 7. Using the FE Model in the ForCES Protocol
The actual model of the forwarding plane in a given NE is something 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 the CE must learn and control by communicating with the FEs (or by
other means). Most of this communication will happen in the post- other means). Most of this communication will happen in the post-
association phase using the ForCES protocol. The following types of association phase using the ForCES protocol. The following types of
information must be exchanged between CEs and FEs via the ForCES information must be exchanged between CEs and FEs via the ForCES
Protocol [2]: protocol [RFC5810]:
1. FE topology query;
2. FE capability declaration; 1. FE topology query,
3. LFB topology (per FE) and configuration capabilities query; 2. FE capability declaration,
3. LFB topology (per FE) and configuration capabilities query,
4. LFB capability declaration; 4. LFB capability declaration,
5. State query of LFB components; 5. State query of LFB components,
6. Manipulation of LFB components; 6. Manipulation of LFB components, and
7. LFB topology reconfiguration. 7. LFB topology reconfiguration.
Items 1) through 5) are query exchanges, where the main flow of Items 1 through 5 are query exchanges, where the main flow of
information is from the FEs to the CEs. Items 1) through 4) are information is from the FEs to the CEs. Items 1 through 4 are
typically queried by the CE(s) in the beginning of the post- typically queried by the CE(s) in the beginning of the post-
association (PA) phase, though they may be repeatedly queried at any association (PA) phase, though they may be repeatedly queried at any
time in the PA phase. Item 5) (state query) will be used at the time in the PA phase. Item 5 (state query) will be used at the
beginning of the PA phase, and often frequently during the PA phase beginning of the PA phase, and often frequently during the PA phase
(especially for the query of statistical counters). (especially for the query of statistical counters).
Items 6) and 7) are "command" types of exchanges, where the main flow Items 6 and 7 are "command" types of exchanges, where the main flow
of information is from the CEs to the FEs. Messages in Item 6) (the of information is from the CEs to the FEs. Messages in Item 6 (the
LFB re-configuration commands) are expected to be used frequently. LFB re-configuration commands) are expected to be used frequently.
Item 7) (LFB topology re-configuration) is needed only if dynamic LFB Item 7 (LFB topology re-configuration) is needed only if dynamic LFB
topologies are supported by the FEs and it is expected to be used topologies are supported by the FEs and it is expected to be used
infrequently. infrequently.
The inter-FE topology (item 1 above) can be determined by the CE in The inter-FE topology (Item 1 above) can be determined by the CE in
many ways. Neither this document nor the ForCES Protocol [2] many ways. Neither this document nor the ForCES protocol [RFC5810]
document mandates a specific mechanism. The LFB Class definition document mandates a specific mechanism. The LFB class definition
does include the capability for an FE to be configured with, and to does include the capability for an FE to be configured with, and to
provide to the CE in response to a query, the identity of its provide to the CE in response to a query, the identity of its
neighbors. There may also be defined specific LFB classes and neighbors. There may also be defined specific LFB classes and
protocols for neighbor discovery. Routing protocols may be used by protocols for neighbor discovery. Routing protocols may be used by
the CE for adjacency determination. The CE may be configured with the CE for adjacency determination. The CE may be configured with
the relevant information. the relevant information.
The relationship between the FE model and the seven post-association The relationship between the FE model and the seven post-association
messages are visualized in Figure 12: messages is visualized in Figure 12:
+--------+ +--------+
..........-->| CE | ..........-->| CE |
/----\ . +--------+ /----\ . +--------+
\____/ FE Model . ^ | \____/ FE Model . ^ |
| |................ (1),2 | | 6, 7 | |................ (1),2 | | 6, 7
| | (off-line) . 3, 4, 5 | | | | (off-line) . 3, 4, 5 | |
\____/ . | v \____/ . | v
. +--------+ . +--------+
e.g. RFCs ..........-->| FE | e.g., RFCs ..........-->| FE |
+--------+ +--------+
Figure 12: Relationship between the FE model and the ForCES protocol Figure 12: Relationship between the FE model and the ForCES protocol
messages, where (1) is part of the ForCES base protocol, and the messages, where (1) is part of the ForCES base protocol, and the
rest are defined by the FE model. rest are defined by the FE model.
The actual encoding of these messages is defined by the ForCES The actual encoding of these messages is defined by the ForCES
Protocol [2] document and is beyond the scope of the FE model. Their protocol [RFC5810] document and is beyond the scope of the FE model.
discussion is nevertheless important here for the following reasons: Their discussion is nevertheless important here for the following
reasons:
o These PA model components have considerable impact on the FE o These PA model components have considerable impact on the FE
model. For example, some of the above information can be model. For example, some of the above information can be
represented as components of the LFBs, in which case such represented as components of the LFBs, in which case such
components must be defined in the LFB classes. components must be defined in the LFB classes.
o The understanding of the type of information that must be o The understanding of the type of information that must be
exchanged between the FEs and CEs can help to select the exchanged between the FEs and CEs can help to select the
appropriate protocol format and the actual encoding method (such appropriate protocol format and the actual encoding method (such
as XML, TLVs). as XML, TLVs).
o Understanding the frequency of these types of messages should o Understanding the frequency of these types of messages should
influence the selection of the protocol format (efficiency influence the selection of the protocol format (efficiency
considerations). considerations).
The remaining sub-sections of this section address each of the seven The remaining sub-sections of this section address each of the seven
message types. message types.
7.1. FE Topology Query 7.1. FE Topology Query
An FE may contain zero, one or more external ingress ports. An FE may contain zero, one, or more external ingress ports.
Similarly, an FE may contain zero, one or more external egress ports. Similarly, an FE may contain zero, one, or more external egress
In other words, not every FE has to contain any external ingress or ports. In other words, not every FE has to contain any external
egress interfaces. For example, Figure 13 shows two cascading FEs. ingress or egress interfaces. For example, Figure 13 shows two
FE #1 contains one external ingress interface but no external egress cascading FEs. FE #1 contains one external ingress interface but no
interface, while FE #2 contains one external egress interface but no external egress interface, while FE #2 contains one external egress
ingress interface. It is possible to connect these two FEs together interface but no ingress interface. It is possible to connect these
via their internal interfaces to achieve the complete ingress-to- two FEs together via their internal interfaces to achieve the
egress packet processing function. This provides the flexibility to complete ingress-to-egress packet processing function. This provides
spread the functions across multiple FEs and interconnect them the flexibility to spread the functions across multiple FEs and
together later for certain applications. interconnect them together later for certain applications.
While the inter-FE communication protocol is out of scope for ForCES, While the inter-FE communication protocol is out of scope for ForCES,
it is up to the CE to query and understand how multiple FEs are it is up to the CE to query and understand how multiple FEs are
inter-connected to perform a complete ingress-egress packet inter-connected to perform a complete ingress-egress packet
processing function, such as the one described in Figure 13. The processing function, such as the one described in Figure 13. The
inter-FE topology information may be provided by FEs, may be hard- inter-FE topology information may be provided by FEs, may be hard-
coded into CE, or may be provided by some other entity (e.g., a bus coded into CE, or may be provided by some other entity (e.g., a bus
manager) independent of the FEs. So while the ForCES Protocol [2] manager) independent of the FEs. So while the ForCES protocol
supports FE topology query from FEs, it is optional for the CE to use [RFC5810] supports FE topology query from FEs, it is optional for the
it, assuming the CE has other means to gather such topology CE to use it, assuming that the CE has other means to gather such
information. topology information.
+-----------------------------------------------------+ +-----------------------------------------------------+
| +---------+ +------------+ +---------+ | | +---------+ +------------+ +---------+ |
input| | | | | | output | input| | | | | | output |
---+->| Ingress |-->|Header |-->|IPv4 |---------+--->+ ---+->| Ingress |-->|Header |-->|IPv4 |---------+--->+
| | port | |Decompressor| |Forwarder| FE | | | | port | |Decompressor| |Forwarder| FE | |
| +---------+ +------------+ +---------+ #1 | | | +---------+ +------------+ +---------+ #1 | |
+-----------------------------------------------------+ V +-----------------------------------------------------+ V
| |
+-----------------------<-----------------------------+ +-----------------------<-----------------------------+
| |
| +----------------------------------------+ | +----------------------------------------+
V | +------------+ +----------+ | V | +------------+ +----------+ |
| input | | | | output | | input | | | | output |
+->--+->|Header |-->| Egress |---------+--> +->--+->|Header |-->| Egress |---------+-->
| |Compressor | | port | FE | | |Compressor | | port | FE |
| +------------+ +----------+ #2 | | +------------+ +----------+ #2 |
+----------------------------------------+ +----------------------------------------+
Figure 13: An example of two FEs connected together Figure 13: An example of two FEs connected together.
Once the inter-FE topology is discovered by the CE after this query, Once the inter-FE topology is discovered by the CE after this query,
it is assumed that the inter-FE topology remains static. However, it it is assumed that the inter-FE topology remains static. However, it
is possible that an FE may go down during the NE operation, or a is possible that an FE may go down during the NE operation, or a
board may be inserted and a new FE activated, so the inter-FE board may be inserted and a new FE activated, so the inter-FE
topology will be affected. It is up to the ForCES protocol to topology will be affected. It is up to the ForCES protocol to
provide a mechanism for the CE to detect such events and deal with provide a mechanism for the CE to detect such events and deal with
the change in FE topology. FE topology is outside the scope of the the change in FE topology. FE topology is outside the scope of the
FE model. FE model.
7.2. FE Capability Declarations 7.2. FE Capability Declarations
FEs will have many types of limitations. Some of the limitations FEs will have many types of limitations. Some of the limitations
must be expressed to the CEs as part of the capability model. The must be expressed to the CEs as part of the capability model. The
CEs must be able to query these capabilities on a per-FE basis. CEs must be able to query these capabilities on a per-FE basis.
Examples: Examples are the following:
o Metadata passing capabilities of the FE. Understanding these o Metadata passing capabilities of the FE. Understanding these
capabilities will help the CE to evaluate the feasibility of LFB capabilities will help the CE to evaluate the feasibility of LFB
topologies, and hence to determine the availability of certain topologies, and hence to determine the availability of certain
services. services.
o Global resource query limitations (applicable to all LFBs of the o Global resource query limitations (applicable to all LFBs of the
FE). FE).
o LFB supported by the FE. o LFB supported by the FE.
o LFB class instantiation limit. o LFB class instantiation limit.
o LFB topological limitations (linkage constraint, ordering etc.) o LFB topological limitations (linkage constraint, ordering, etc.).
7.3. LFB Topology and Topology Configurability Query 7.3. LFB Topology and Topology Configurability Query
The ForCES protocol must provide the means for the CEs to discover The ForCES protocol must provide the means for the CEs to discover
the current set of LFB instances in an FE and the interconnections the current set of LFB instances in an FE and the interconnections
between the LFBs within the FE. In addition, sufficient information between the LFBs within the FE. In addition, sufficient information
should be available to determine whether the FE supports any CE- should be available to determine whether the FE supports any CE-
initiated (dynamic) changes to the LFB topology, and if so, determine initiated (dynamic) changes to the LFB topology, and if so, determine
the allowed topologies. Topology configurability can also be the allowed topologies. Topology configurability can also be
considered as part of the FE capability query as described in Section considered as part of the FE capability query as described in Section
9.3. 7.2.
7.4. LFB Capability Declarations 7.4. LFB Capability Declarations
LFB class specifications define a generic set of capabilities. When LFB class specifications define a generic set of capabilities. When
an LFB instance is implemented (instantiated) on a vendor's FE, some an LFB instance is implemented (instantiated) on a vendor's FE, some
additional limitations may be introduced. Note that we discuss only additional limitations may be introduced. Note that we discuss only
those limitations that are within the flexibility of the LFB class those limitations that are within the flexibility of the LFB class
specification. That is, the LFB instance will remain compliant with specification. That is, the LFB instance will remain compliant with
the LFB class specification despite these limitations. For example, the LFB class specification despite these limitations. For example,
certain features of an LFB class may be optional, in which case it certain features of an LFB class may be optional, in which case it
must be possible for the CE to determine if an optional feature is must be possible for the CE to determine whether or not an optional
supported by a given LFB instance or not. Also, the LFB class feature is supported by a given LFB instance. Also, the LFB class
definitions will probably contain very few quantitative limits (e.g., definitions will probably contain very few quantitative limits (e.g.,
size of tables), since these limits are typically imposed by the size of tables), since these limits are typically imposed by the
implementation. Therefore, quantitative limitations should always be implementation. Therefore, quantitative limitations should always be
expressed by capability arguments. expressed by capability arguments.
LFB instances in the model of a particular FE implementation will LFB instances in the model of a particular FE implementation will
possess limitations on the capabilities defined in the corresponding possess limitations on the capabilities defined in the corresponding
LFB class. The LFB class specifications must define a set of LFB class. The LFB class specifications must define a set of
capability arguments, and the CE must be able to query the actual capability arguments, and the CE must be able to query the actual
capabilities of the LFB instance via querying the value of such capabilities of the LFB instance via querying the value of such
skipping to change at page 115, line 38 skipping to change at page 117, line 39
field classifier LFB class may define a large number of field classifier LFB class may define a large number of
classification fields, but a given FE may support only a subset of classification fields, but a given FE may support only a subset of
those fields. those fields.
o Quantitative restrictions, such as the maximum size of tables, o Quantitative restrictions, such as the maximum size of tables,
etc. etc.
The capability parameters that can be queried on a given LFB class The capability parameters that can be queried on a given LFB class
will be part of the LFB class specification. The capability will be part of the LFB class specification. The capability
parameters should be regarded as special components of the LFB. The parameters should be regarded as special components of the LFB. The
actual values of these components may be, therefore, obtained using actual values of these components may, therefore, be obtained using
the same component query mechanisms as used for other LFB components. the same component query mechanisms as used for other LFB components.
Capability components are read-only arguments. In cases where some Capability components are read-only arguments. In cases where some
implementations may allow CE modification of the value, the implementations may allow CE modification of the value, the
information must be represented as an operational component, not a information must be represented as an operational component, not a
capability component. capability component.
Assuming that capabilities will not change frequently, the efficiency Assuming that capabilities will not change frequently, the efficiency
of the protocol/schema/encoding is of secondary concern. of the protocol/schema/encoding is of secondary concern.
Much of this restrictive information is captured by the component Much of this restrictive information is captured by the component
property information, and so can be access uniformly for all property information, and so can be accessed uniformly for all
information within the model. information within the model.