draft-ietf-forces-model-01.txt   draft-ietf-forces-model-02.txt 
Internet Draft L. Yang Internet Draft L. Yang
Expiration: April 2004 Intel Labs Expiration: July 2004 Intel Corp.
File: draft-ietf-forces-model-01.txt J. Halpern File: draft-ietf-forces-model-02.txt J. Halpern
Working Group: ForCES Megisto Systems Working Group: ForCES Megisto Systems
R. Gopal R. Gopal
Nokia Nokia
A. DeKok A. DeKok
IDT Inc. IDT Inc.
Z. Haraszti Z. Haraszti
S. Blake S. Blake
Ericsson Ericsson
October 2003 E. Deleganes
Intel Corp.
February 2004
ForCES Forwarding Element Model ForCES Forwarding Element Model
draft-ietf-forces-model-01.txt draft-ietf-forces-model-02.txt
Status of this Memo Status of this Memo
This document is an Internet-Draft and is in full conformance with This document is an Internet-Draft and is in full conformance with
all provisions of Section 10 of RFC2026. Internet-Drafts are all provisions of Section 10 of RFC2026. Internet-Drafts are
working documents of the Internet Engineering Task Force (IETF), working documents of the Internet Engineering Task Force (IETF),
its areas, and its working groups. Note that other groups may also its areas, and its working groups. Note that other groups may also
distribute working documents as Internet-Drafts. distribute working documents as Internet-Drafts.
Internet-Drafts are draft documents valid for a maximum of six Internet-Drafts are draft documents valid for a maximum of six
skipping to change at page 2, line ? skipping to change at page 2, line ?
present in an FE, what capabilities these functions support, and present in an FE, what capabilities these functions support, and
how these functions are or can be interconnected. This FE model is how 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 the ForCES
requirements draft [1]. A list of the basic logical functional requirements draft [1]. A list of the basic logical functional
blocks (LFBs) is also defined in the LFB class library to aid the blocks (LFBs) is also defined in the LFB class library to aid the
effort in defining individual LFBs. effort in defining individual LFBs.
Table of Contents Table of Contents
Abstract.........................................................1 Abstract.........................................................1
1. Definitions...................................................3 1. Definitions...................................................4
2. Introduction..................................................5 2. Introduction..................................................6
2.1. Requirements on the FE model.............................6 2.1. Requirements on the FE model.............................6
2.2. The FE Model in Relation to FE Implementations...........6 2.2. The FE Model in Relation to FE Implementations...........6
2.3. The FE Model in Relation to the ForCES Protocol..........6 2.3. The FE Model in Relation to the ForCES Protocol..........7
2.4. Modeling Language for FE Model...........................7 2.4. Modeling Language for FE Model...........................8
2.5. Document Structure.......................................8 2.5. Document Structure.......................................8
3. FE Model Concepts.............................................8 3. FE Model Concepts.............................................8
3.1. State Model and Capability Model.........................8 3.1. State Model and Capability Model.........................9
3.2. LFB Modeling............................................11 3.2. LFB (Logical Functional Block) Modeling.................11
3.2.1. LFB Input and Input Group..........................13 3.2.1. LFB Input and Input Group..........................14
3.2.2. LFB Output and Output Group........................15 3.2.2. LFB Output and Output Group........................15
3.2.3. Packet Type........................................16 3.2.3. Packet Type........................................16
3.2.4. Metadata...........................................16 3.2.4. Metadata...........................................16
3.2.5. LFB Versioning.....................................18 3.2.5. LFB Versioning.....................................22
3.2.6. LFB Inheritance....................................18 3.2.6. LFB Inheritance....................................23
3.3. FE Datapath Modeling....................................19 3.3. FE Datapath Modeling....................................24
3.3.1. Alternative Approaches for Modeling FE Datapaths...19 3.3.1. Alternative Approaches for Modeling FE Datapaths...24
3.3.2. Configuring the LFB Topology.......................23 3.3.2. Configuring the LFB Topology.......................29
4. LFB Model -- LFB and Associated Data Definitions.............27 4. Model and Schema for LFB Classes.............................33
4.1. General Data Type Definitions...........................28 4.1. Namespace...............................................33
4.1.1. Arrays.............................................29 4.2. <LFBLibrary> Element....................................33
4.1.2. Structures.........................................29 4.3. <load> Element..........................................35
4.1.3. Augmentations......................................30 4.4. <frameDefs> Element for Frame Type Declarations.........35
4.2. Metadata Definitions....................................30 4.5. <dataTypeDefs> Element for Data Type Definitions........36
4.3. Frame Format Definitions................................30 4.5.1. <typeRef> Element for Aliasing Existing Data Types.38
4.4. LFB Class Definitions...................................31 4.5.2. <atomic> Element for Deriving New Atomic Types.....39
4.4.1. LFB Inheritance....................................31 4.5.3. <array> Element to Define Arrays...................39
4.4.2. LFB Inputs.........................................31 4.5.4. <struct> Element to Define Structures..............41
4.4.3. LFB Outputs........................................32 4.5.5. <union> Element to Define Union Types..............42
4.4.4. LFB Attributes.....................................33 4.5.6. Augmentations......................................42
4.4.5. LFB Operational Specification......................34 4.6. <metadataDefs> Element for Metadata Definitions.........43
5. LFB Topology Model (To be written)...........................34 4.7. <LFBClassDefs> Element for LFB Class Definitions........44
6. FE Level Attributes (To be written)..........................35 4.7.1. <derivedFrom> Element to Express LFB Inheritance...45
7. LFB Class Library............................................35 4.7.2. <inputPorts> Element to Define LFB Inputs..........46
7.1. Port LFB................................................35 4.7.3. <outputPorts> Element to Define LFB Outputs........48
7.2. Dropper LFB.............................................36 4.7.4. <attributes> Element to Define LFB Operational
7.3. Redirector (de-MUX) LFB.................................36 Attributes................................................50
7.4. Scheduler LFB...........................................36 4.7.5. <capabilities> Element to Define LFB Capability
7.5. Queue LFB...............................................36 Attributes................................................53
7.6. Counter LFB.............................................37 4.7.6. <description> Element for LFB Operational
7.7. Meter LFB and Policer LFB...............................37 Specification.............................................54
7.8. Classifier LFB..........................................37 4.8. XML Schema for LFB Class Library Documents..............54
7.9. Modifier LFB............................................38 5. FE Attributes and Capabilities...............................63
7.10. Packet Header Rewriter LFB.............................38 5.1. XML Schema for FE Attribute Documents...................64
8. Satisfying the Requirements on FE Model......................39 5.2. FEDocument..............................................68
8.1. Port Functions..........................................39 5.2.1. FECapabilities.....................................68
8.2. Forwarding Functions....................................40 5.2.2. FEAttributes.......................................71
8.3. QoS Functions...........................................41 5.3. Sample FE Attribute Document............................73
8.4. Generic Filtering Functions.............................41 6. LFB Class Library............................................76
8.5. Vendor Specific Functions...............................42 6.1. Port LFB................................................76
8.6. High-Touch Functions....................................42 6.2. L2 Interface LFB........................................77
8.7. Security Functions......................................42 6.3. IP interface LFB........................................79
8.8. Off-loaded Functions....................................43 6.4. Classifier LFB..........................................80
8.9. IPFLOW/PSAMP Functions..................................43 6.5. Next Hop LFB............................................81
9. Using the FE model in the ForCES Protocol....................43 6.6. Rate Meter LFB..........................................83
9.1. FE Topology Query.......................................45 6.7. Redirector (de-MUX) LFB.................................84
9.2. FE Capability Declarations..............................46 6.8. Packet Header Rewriter LFB..............................84
9.3. LFB Topology and Topology Configurability Query.........47 6.9. Counter LFB.............................................85
9.4. LFB Capability Declarations.............................47 6.10. Dropper LFB............................................85
9.5. State Query of LFB Attributes...........................48 6.11. IPv4 Fragmenter LFB....................................86
9.6. LFB Attribute Manipulation..............................48 6.12. L2 Address Resolution LFB..............................86
9.7. LFB Topology Re-configuration...........................49 6.13. Queue LFB..............................................86
10. Acknowledgments.............................................49 6.14. Scheduler LFB..........................................87
11. Security Considerations.....................................49 6.15. MPLS ILM/Decapsulation LFB.............................88
12. Normative References........................................49 6.16. MPLS Encapsulation LFB.................................88
13. Informative References......................................50 6.17. Tunnel Encapsulation/Decapsulation LFB.................88
14. Authors' Addresses..........................................50 6.18. Replicator LFB.........................................89
15. Intellectual Property Right.................................51 7. Satisfying the Requirements on FE Model......................89
16. IANA consideration..........................................51 7.1. Port Functions..........................................90
7.2. Forwarding Functions....................................90
7.3. QoS Functions...........................................91
7.4. Generic Filtering Functions.............................91
7.5. Vendor Specific Functions...............................91
7.6. High-Touch Functions....................................91
7.7. Security Functions......................................91
7.8. Off-loaded Functions....................................92
7.9. IPFLOW/PSAMP Functions..................................92
8. Using the FE model in the ForCES Protocol....................92
8.1. FE Topology Query.......................................94
8.2. FE Capability Declarations..............................96
8.3. LFB Topology and Topology Configurability Query.........96
8.4. LFB Capability Declarations.............................96
8.5. State Query of LFB Attributes...........................97
8.6. LFB Attribute Manipulation..............................98
8.7. LFB Topology Re-configuration...........................98
9. Acknowledgments..............................................98
10. Security Considerations.....................................99
11. Normative References........................................99
12. Informative References......................................99
13. Authors' Addresses.........................................100
14. Intellectual Property Right................................101
15. IANA consideration.........................................101
Conventions used in this document Conventions used in this document
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in
this document are to be interpreted as described in [RFC-2119]. this document are to be interpreted as described in [RFC-2119].
1. Definitions 1. Definitions
A set of terminology associated with the ForCES requirements is A set of terminology associated with the ForCES requirements is
defined in [1] and is not copied here. The following list of defined in [1] and is not copied here. The following list of
terminology is relevant to the FE model defined in this document. terminology is relevant to the FE model defined in this document.
FE Model -- The FE model is designed to model the logical FE Model -- The FE model is designed to model the logical
processing functions of an FE. The FE model proposed in this processing functions of an FE. The FE model proposed in this
document includes three components: the modeling of individual document includes three components: the modeling of individual
logical functional blocks (LFB model), the logical interconnection logical functional blocks (LFB model), the logical interconnection
between LFBs (LFB topology) and the FE level attributes including between LFBs (LFB topology) and the FE level attributes, including
FE capabilities. The FE model provides the basis to define the FE capabilities. The FE model provides the basis to define the
information elements exchanged between the CE and the FE in the information elements exchanged between the CE and the FE in the
ForCES protocol. ForCES protocol.
Datapath -- A conceptual path taken by packets within the Datapath -- A conceptual path taken by packets within the
forwarding plane, inside an FE. There might exist more than one forwarding plane inside an FE. Note that more than one datapath
datapath within an FE. can exist within an FE.
LFB (Logical Function Block) class (or type) -- A template LFB (Logical Function Block) class (or type) -- A template
representing a fine-grained, logically separable and well-defined representing a fine-grained, logically separable and well-defined
packet processing operation in the datapath. LFB classes are the packet processing operation in the datapath. LFB classes are the
basic building blocks of the FE model. basic building blocks of the FE model.
LFB (Logical Function Block) Instance -- As a packet flows through LFB (Logical Function Block) Instance -- As a packet flows through
an FE along a datapath, it flows through one or multiple LFB an FE along a datapath, it flows through one or multiple LFB
instances, with each implementing an instance of a certain LFB instances, with each implementing an instance of a certain LFB
class. There may be multiple instances of the same LFB in an FE's class. There may be multiple instances of the same LFB in an FE's
datapath. Note that we often refer to LFBs without distinguishing datapath. Note that we often refer to LFBs without distinguishing
between LFB class and LFB instance when we believe the implied between LFB class and LFB instance when we believe the implied
reference is obvious for the given context. reference is obvious for the given context.
LFB Model -- The LFB model describes the content and structures in LFB Model -- The LFB model describes the content and structures in
LFB and associated data definition. There are four types of an LFB, plus the associated data definition. There are four types
information defined in the LFB model. The core part of the LFB of information defined in the LFB model. The core part of the LFB
model is LFB class definitions while the other three are to define model is the LFB class definitions; the other three types define
the associated data including common data types, supported frame the associated data including common data types, supported frame
formats and metadata. formats and metadata.
LFB Metadata -- Metadata is used to communicate per-packet state LFB Metadata -- Metadata is used to communicate per-packet state
from one LFB to another, but is not sent across the network. The from one LFB to another, but is not sent across the network. The
FE model defines how such metadata is identified, produced and FE model defines how such metadata is identified, produced and
consumed by the LFBs, but not how metadata is encoded within an consumed by the LFBs, but not how metadata is encoded within an
implementation. implementation.
LFB Attribute -- Operational parameters of the LFBs that must be LFB Attribute -- Operational parameters of the LFBs that must be
visible to the CEs are conceptualized in the FE model as the LFB visible to the CEs are conceptualized in the FE model as the LFB
attributes. The LFB attributes include, for example, flags, single attributes. The LFB attributes include, for example, flags, single
parameter arguments, complex arguments, and tables that the CE can parameter arguments, complex arguments, and tables that the CE can
read or/and write via the ForCES protocol. read or/and write via the ForCES protocol.
LFB Topology -- Representation of how the LFB instances are LFB Topology -- Representation of how the LFB instances are
logically interconnected and placed along the datapath within one logically interconnected and placed along the datapath within one
FE. Sometimes it is also called intra-FE topology, to be FE. Sometimes it is also called intra-FE topology, to be
distinguished from inter-FE topology. LFB topology is outside of distinguished from inter-FE topology. LFB topology is outside of
the LFB model, but part of the FE model. the LFB model, but is part of the FE model.
FE Topology -- Representation of how the multiple FEs in a single FE Topology -- A representation of how the multiple FEs within a
NE are interconnected. Sometimes it is called inter-FE topology, single NE are interconnected. Sometimes this is called inter-FE
to be distinguished from intra-FE topology (i.e., LFB topology). topology, to be distinguished from intra-FE topology (i.e., LFB
Individual FE may not have the global knowledge of full FE topology). An individual FE might not have the global knowledge of
topology, but the local view of its connectivity with other FEs are the full FE topology, but the local view of its connectivity with
considered part of the FE model. FE topology is discovered by the other FEs is considered to be part of the FE model. The FE
ForCES base protocol or some other means. topology is discovered by the ForCES base protocol or some other
means.
Inter-FE Topology -- See FE Topology. Inter-FE Topology -- See FE Topology.
Intra-FE Topology -- See LFB Topology. Intra-FE Topology -- See LFB Topology.
LFB class library -- A set of LFB classes that are identified as LFB class library -- A set of LFB classes that is identified as the
the most common functions found in most FEs and hence should be most common functions found in most FEs and hence should be defined
defined first by the ForCES Working Group. first by the ForCES Working Group.
2. Introduction 2. Introduction
[2] specifies a framework by which control elements (CEs) can [2] specifies a framework by which control elements (CEs) can
configure and manage one or more separate forwarding elements (FEs) configure and manage one or more separate forwarding elements (FEs)
within a networking element (NE) using the ForCES protocol. The within a networking element (NE) using the ForCES protocol. The
ForCES architecture allows Forwarding Elements of varying ForCES architecture allows Forwarding Elements of varying
functionality to participate in a ForCES network element. The functionality to participate in a ForCES network element. The
implication of this varying functionality is that CEs can make only implication of this varying functionality is that CEs can make only
minimal assumptions about the functionality provided by FEs in a minimal assumptions about the functionality provided by FEs in an
NE. Before CEs can configure and control the forwarding behavior NE. Before CEs can configure and control the forwarding behavior
of FEs, CEs need to query and discover the capabilities and states of FEs, CEs need to query and discover the capabilities and states
of their FEs. [1] mandates that the capabilities, states and of their FEs. [1] mandates that the capabilities, states and
configuration information be expressed in the form of an FE model. configuration information be expressed in the form of an FE model.
RFC 3444 [11] made the observation that information models (IMs) RFC 3444 [11] made the observation that information models (IMs)
and data models (DMs) are different because they serve different and data models (DMs) are different because they serve different
purposes. "The main purpose of an IM is to model managed objects purposes. "The main purpose of an IM is to model managed objects
at a conceptual level, independent of any specific implementations at a conceptual level, independent of any specific implementations
or protocols used". "DMs, conversely, are defined at a lower level or protocols used". "DMs, conversely, are defined at a lower level
of abstraction and include many details. They are intended for of abstraction and include many details. They are intended for
implementors and include protocol-specific constructs." Sometimes implementors and include protocol-specific constructs." Sometimes
it is difficult to draw a clear line between the two. The FE model it is difficult to draw a clear line between the two. The FE model
described in this document is first and foremost an information described in this document is first and foremost an information
model, but it also has a flavor of a data model as it contains model, but it also includes some aspects of a data model, such as
explicit definition of the LFB class schema and other data explicit definitions of the LFB class schema and FE schema. It is
structures. It is expected that this FE model will be used as the expected that this FE model will be used as the basis to define the
basis to define the payload for information exchange between the CE payload for information exchange between the CE and FE in the
and FE in the ForCES protocol. ForCES protocol.
2.1. Requirements on the FE model 2.1. Requirements on the FE model
[1] defines requirements which must be satisfied by a ForCES FE [1] defines requirements, which must be satisfied by a ForCES FE
model. To summarize, an FE model must define: model. To summarize, an FE model must define:
. Logically separable and distinct packet forwarding operations . Logically separable and distinct packet forwarding operations
in an FE datapath (logical functional blocks or LFBs); in an FE datapath (logical functional blocks or LFBs);
. The possible topological relationships (and hence the sequence . The possible topological relationships (and hence the sequence
of packet forwarding operations) between the various LFBs; of packet forwarding operations) between the various LFBs;
. The possible operational capabilities (e.g., capacity limits, . The possible operational capabilities (e.g., capacity limits,
constraints, optional features, granularity of configuration) constraints, optional features, granularity of configuration)
of each type of LFB; of each type of LFB;
. The possible configurable parameters (i.e., attributes) of . The possible configurable parameters (i.e., attributes) of
each type of LFB; each type of LFB;
. Metadata that may be exchanged between LFBs. . Metadata that may be exchanged between LFBs.
2.2. The FE Model in Relation to FE Implementations 2.2. The FE Model in Relation to FE Implementations
The FE model proposed here is based on an abstraction of distinct The FE model proposed here is based on an abstraction of distinct
logical functional blocks (LFBs), interconnected in a directed logical functional blocks (LFBs), which are interconnected in a
graph, and receiving, processing, modifying, and transmitting directed graph, and receive, process, modify, and transmit packets
packets along with metadata. Note that a real forwarding datapath along with metadata. Note that a real forwarding datapath
implementation should not be constrained by the model. On the implementation should not be constrained by the model. On the
contrary, the FE model should be designed such that different contrary, the FE model should be designed such that different
implementations of the forwarding datapath can all be logically implementations of the forwarding datapath can all be logically
mapped onto the model with the functionality and sequence of mapped onto the model with the functionality and sequence of
operations correctly captured. However, the model itself does not operations correctly captured. However, the model itself does not
directly address the issue of how a particular implementation maps directly address the issue of how a particular implementation maps
to an LFB topology. This is left to the forwarding plane vendors to an LFB topology. It is left to the forwarding plane vendors to
as to how the FE functionality is represented using the FE model. define how the FE functionality is represented using the FE model.
Nevertheless, we do strive to design the FE model such that it is Nevertheless, we do strive to design the FE model such that it is
flexible enough to accommodate most common implementations. flexible enough to accommodate most common implementations.
The LFB topology model for a particular datapath implementation The LFB topology model for a particular datapath implementation
MUST correctly capture the sequence of operations on the packet. MUST correctly capture the sequence of operations on the packet.
Metadata generation (by certain LFBs) must always precede any use Metadata generation (by certain LFBs) must always precede any use
of that metadata (by subsequent LFBs in the topology graph); this of that metadata (by subsequent LFBs in the topology graph); this
is required for logically consistent operation. Further, is required for logically consistent operation. Further,
modifications of packet fields that are subsequently used as inputs modifications of packet fields that are subsequently used as inputs
for further processing must occur in the order specified in the for further processing must occur in the order specified in the
model for that particular implementation to ensure correctness. model for that particular implementation to ensure correctness.
2.3. The FE Model in Relation to the ForCES Protocol 2.3. The FE Model in Relation to the ForCES Protocol
The ForCES base protocol is used by the CEs and FEs to maintain the The ForCES base protocol is used by the CEs and FEs to maintain the
communication channel between the CEs and FEs. The ForCES protocol communication channel between the CEs and FEs. The ForCES protocol
may be used to query and discover the inter-FE topology. The may be used to query and discover the inter-FE topology. The
details of a particular datapath implementation inside an FE details of a particular datapath implementation inside an FE,
including the LFB topology, along with the operational capabilities including the LFB topology, along with the operational capabilities
and attributes of each individual LFB, are conveyed to the CE and attributes of each individual LFB, are conveyed to the CE
within information elements in the ForCES protocol. The model of within information elements in the ForCES protocol. The model of
an LFB class should define all of the information that would need an LFB class should define all of the information that would need
to be exchanged between an FE and a CE for the proper configuration to be exchanged between an FE and a CE for the proper configuration
and management of that LFB. and management of that LFB.
Definition of the various payloads of ForCES messages (irrespective Definition of the various payloads of ForCES messages (irrespective
of the transport protocol ultimately selected) cannot proceed in a of the transport protocol ultimately selected) cannot proceed in a
systematic fashion until a formal definition of the objects being systematic fashion until a formal definition of the objects being
configured and managed (the FE and the LFBs within) is undertaken. configured and managed (the FE and the LFBs within) is undertaken.
The FE Model document defines a set of classes and attributes for The FE Model document defines a set of classes and attributes for
describing and manipulating the state of the LFBs of an FE. These describing and manipulating the state of the LFBs of an FE. These
class definitions themselves will generally not appear in the class definitions themselves will generally not appear in the
Forces protocol. Rather, Forces protocol operations will ForCES protocol. Rather, ForCES protocol operations will reference
references classes defined in this model, including relevant classes defined in this model, including relevant attributes (and
attributes (and operations if such are defined). operations if such are defined).
Section 9 provides more detailed discussion on how the FE model Section 8 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 FE Model 2.4. Modeling Language for FE Model
Even though not absolutely required, it is beneficial to use a Even though not absolutely required, it is beneficial to use a
formal data modeling language to represent the conceptual FE model formal data modeling language to represent the conceptual FE model
described in this document and a full specification will be written described in this document and a full specification will be written
using such a data modeling language. Using a formal language can using such a data modeling language. Using a formal language can
help in enforcing consistency and logical compatibility among LFBs. help to enforce consistency and logical compatibility among LFBs.
In addition, formal definition of the LFB classes has the potential In addition, the formal definition of the LFB classes has the
to facilitate the eventual automation of some part of the code potential to facilitate the eventual automation of some part of the
generation process and the functional validation of arbitrary LFB code generation process and the functional validation of arbitrary
topologies. LFB topologies.
The modeling language is used for writing the specification but not
necessarily for encoding the data over-the-wire between FEs and
CEs. When selecting the specification language, human readability
is very important, while there are no performance requirements on
the language for encoding, decoding, and transmission on the
language. XML is used as the specification language in this
document, because XML has the advantage of being human and machine
readable with widely available tools support.
The encoding method for over the wire transport is an issue Human readability was the most important factor considered when
independent of the specification language chosen here. It is selecting the specification language. Encoding, decoding and
transmission performance was not a selection factor for the
language because the encoding method for over the wire transport is
an issue independent of the specification language chosen. It is
outside the scope of this document and up to the ForCES protocol to outside the scope of this document and up to the ForCES protocol to
define. define.
XML was chosen as the specification language in this document,
because XML has the advantage of being both human and machine
readable with widely available tools support.
2.5. Document Structure 2.5. Document Structure
Section 3 provides conceptual overview of the FE model, laying the Section 3 provides a conceptual overview of the FE model, laying
foundation for the more detailed discussion and specifications in the foundation for the more detailed discussion and specifications
the sections that follow. Section 4, 5, and 6 together constitute in the sections that follow. Section 4 and 5 constitute the core of
the core of the FE model, detailing the three major components in the FE model, detailing the two major components in the FE model:
the FE model: LFB model, LFB topology, and FE level attributes LFB model and FE level attributes including capability and LFB
including capability. Section 7 presents a list of LFB classes in topology. Section 6 presents a list of LFB classes in the LFB
the LFB class library that will be further specified according to class library that will be further specified in separate documents
the FE model presented in earlier Sections (4, 5 and 6). Section 8 according to the FE model presented in Sections 4 and 5. Section 7
directly addresses the model requirements imposed by the ForCES directly addresses the model requirements imposed by the ForCES
requirement draft [1] while Section 9 explains how the FE model requirement draft [1] while Section 8 explains how the FE model
should be used in the ForCES protocol. should be used in the ForCES protocol.
3. FE Model Concepts 3. FE Model Concepts
Some of the most important concepts used throughout this document Some of the important concepts used throughout this document are
are introduced in this section. Section 3.1 explains the introduced in this section. Section 3.1 explains the difference
difference between a state model and a capability model, and how between a state model and a capability model, and how the two can
the two can be combined in the FE model. Section 3.2 introduces be combined in the FE model. Section 3.2 introduces the concept of
the concept of LFBs (Logical Functional Blocks) as the basic LFBs (Logical Functional Blocks) as the basic functional building
functional building blocks in the FE model. Section 3.3 discusses blocks in the FE model. Section 3.3 discusses the logical inter-
the logical inter-connection and ordering between LFB instances connection and ordering between LFB instances within an FE, that
within an FE, that is, the LFB topology. is, the LFB topology.
The FE model proposed in this document is comprised of these three The FE model proposed in this document is comprised of two major
components: LFB model, LFB topology and FE attributes including FE components: LFB model, and FE level attributes including FE
capabilities. The LFB model provides the content and data capabilities and LFB topology. The LFB model provides the content
structures to define each individual LFB class; LFB topology and data structures to define each individual LFB class. FE
provides a mean to express the logical inter-connection between the
LFB instances along the datapath(s) within the FE; and FE
attributes provide information at the FE level and the capabilities attributes provide information at the FE level and the capabilities
about what the FE can or cannot do at a coarse level. Details on about what the FE can or cannot do at a coarse level. Part of the
each of the three components are described in Section 4, 5 and 6, FE level information is the LFB topology which expresses the
respectively. The intention of this section is to discuss these logical inter-connection between the LFB instances along the
concepts at the high level and lay the foundation for the detailed datapath(s) within the FE. Details on these components are
description in the following sections. described in Section 4 and 5. The intention of this section is to
discuss these concepts at the high level and lay the foundation for
the detailed description in the following sections.
3.1. State Model and Capability Model 3.1. State Model and Capability Model
The FE capability model describes the capabilities and capacities The FE capability model describes the capabilities and capacities
of an FE in terms of variations of functions supported or of an FE in terms of variations of functions supported or
limitations contained. Conceptually, the FE capability model limitations contained. Conceptually, the FE capability model
presents the many possible states allowed on an FE with capacity presents the many possible states allowed on an FE with capacity
information indicating certain quantitative limits or constraints. information indicating certain quantitative limits or constraints.
For example, an FE capability model may describe the FE at a coarse For example, an FE capability model may describe the FE at a coarse
level such as: level such as:
. this FE can handle IPv4 and IPv6 forwarding; . this FE can handle IPv4 and IPv6 forwarding;
. this FE can perform classification on the following fields: . this FE can perform classification on the following fields:
source IP address, destination IP address, source port number, source IP address, destination IP address, source port number,
destination port number, etc; destination port number, etc;
. this FE can perform metering; . this FE can perform metering;
. this FE can handle up to N queues (capacity); . this FE can handle up to N queues (capacity);
. this FE can add and remove encapsulating headers of types . this FE can add and remove encapsulating headers of types
including IPSec, GRE, L2TP. including IPSec, GRE, L2TP.
skipping to change at page 9, line 33 skipping to change at page 10, line 12
. the given classifier results in packets being metered in a . the given classifier results in packets being metered in a
certain way, and then marked in a certain way; certain way, and then marked in a certain way;
. the packets coming from specific markers are delivered into a . the packets coming from specific markers are delivered into a
shared queue for handling, while other packets are delivered shared queue for handling, while other packets are delivered
to a different queue; to a different queue;
. a specific scheduler with specific behavior and parameters . a specific scheduler with specific behavior and parameters
will service these collected queues. will service these collected queues.
The information on the capabilities and capacities of the FE helps The information on the capabilities and capacities of the FE helps
the CE understand the flexibility and limitations of the FE the CE understand the flexibility and limitations of the FE
functions, so that the CE knows at a coarse level what functions, so that the CE knows at a coarse level which
configurations are applicable to the FEs and what are not. Where configurations are applicable to the FEs and which ones are not.
it gets more complicated is for the capability model to cope with It gets more complicated for the capability model to cope with the
the detailed limits, issues such as how many classifiers the FE can detailed limits, such as the maximum number of the following items:
handle, how many queues, and how many buffer pools the FE can classifiers, queues, buffer pools, and meters the FE can provide.
support, how many meters the FE can provide.
While one could try to build an object model for representing While one could try to build an object model to fully represent the
capabilities in full, other efforts have found this to be a FE capabilities, other efforts have found this to be a significant
significant undertaking. A middle of the road approach is to define undertaking. A middle of the road approach is to define coarse-
coarse-grained capabilities and simple capacity measures. Then, if grained capabilities and simple capacity measures. Then, if the CE
the CE attempts to instruct the FE to set up some specific behavior attempts to instruct the FE to set up some specific behavior it is
it is not capable of, the FE will return an error indicating the not capable of, the FE will return an error indicating the problem.
problem. Examples of such approach include Framework Policy Examples of this approach include Framework Policy Information Base
Information Base (PIB) [RFC3318) and Differentiated Services QoS (PIB) [RFC3318) and Differentiated Services QoS Policy Information
Policy Information Base [4]. The capability reporting classes in Base [4]. The capability reporting classes in the DiffServ and
the DiffServ and Framework PIBs are all meant to allow the device Framework PIBs are all meant to allow the device to indicate some
to indicate some general guidelines about what it can or cannot do, general guidelines about what it can or cannot do, but do not
but do not necessarily allow it to indicate every possible necessarily allow it to indicate every possible configuration that
configuration that it can or cannot support. If a device receives it can or cannot support. If a device receives a configuration
a configuration that it cannot implement, it can reject such that it cannot implement, it can reject that configuration by
configuration by replying with a failure report. responding with a failure report.
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 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 state, capabilities and configuration Figure 1. Illustration of FE state, capabilities and configuration
exchange in the context of CE-FE communication via ForCES. exchange in the context of CE-FE communication via ForCES.
The ForCES FE model must include both a state model and some flavor The ForCES FE model must include both a state model and a
of a capability model. We believe that a good balance between capability model. We believe that a good balance between
simplicity and flexibility can be achieved for the FE model by simplicity and flexibility can be achieved for the FE model by
combining the coarse level capability reporting with the error combining the coarse level capability reporting with the error
reporting mechanism. Examples of similar approach include DiffServ reporting mechanism. Examples of similar approaches include
PIB [4] and Framework PIB [5]. DiffServ PIB [4] and Framework PIB [5].
The concepts of LFB and LFB topology will be discussed in the rest The concepts of LFB and LFB topology will be discussed in the rest
of this section. It will become clear that some flavor of of this section. It will become clear that a capability model is
capability model is needed at both the FE level and LFB level. needed at both the FE level and LFB level.
Capability information at the LFB level is an integral part of the Capability information at the LFB level is an integral part of the
LFB model, and is modeled the same way as the other operational LFB model, and is modeled the same way as the other operational
parameters inside an LFB. For example, certain features of an LFB parameters inside an LFB. For example, certain features of an LFB
class may be optional, in which case it must be possible for the CE class may be optional, in which case it must be possible for the CE
to determine if an optional feature is supported by a given LFB to determine whether or not an optional feature is supported by a
instance or not. Such capability information can be modeled as a given LFB instance. Such capability information can be modeled as
read-only attribute in the LFB instance. See Section 4.4.4 for a read-only attribute in the LFB instance, see Section 4.7.5 for
more details on LFB attributes. details.
Capability information at the FE level may describe what LFB Capability information at the FE level may describe the LFB classes
classes the FE can instantiate; how many instances of each can be the FE can instantiate; the number of instances of each can be
created; the topological (i.e., linkage) limitations between these created; the topological (i.e., linkage) limitations between these
LFB instances, etc. Section 6 defines the FE level attributes LFB instances, etc. Section 5 defines the FE level attributes
including capability information. including capability information.
Once the FE capability is described to the CE, the FE state Once the FE capability is described to the CE, the FE state
information can be represented by two levels. The first level is information can be represented by two levels. The first level is
the logically separable and distinctive packet processing the logically separable and distinctive packet processing
functions, and we call these individual functions Logical functions, and we call these individual functions Logical
Functional Blocks (LFBs). The second level of information is about Functional Blocks (LFBs). The second level of information is about
how these individual LFBs are ordered and placed along the datapath how these individual LFBs are ordered and placed along the datapath
to deliver a complete forwarding plane service. The to deliver a complete forwarding plane service. The
interconnection and ordering of the LFBs is called LFB Topology. interconnection and ordering of the LFBs is called LFB Topology.
Section 3.2 discuss high level concepts around LFBs while Section Section 3.2 discuss high level concepts around LFBs while Section
3.3 discuss issues around LFB topology. 3.3 discuss issues around LFB topology.
3.2. LFB Modeling 3.2. LFB (Logical Functional Block) Modeling
Each LFB (Logical Functional Block) performs a well-defined action Each LFB performs a well-defined action or computation on the
or computation on the packets passing through it. Upon completion packets passing through it. Upon completion of such a function,
of such function, either the packets are modified in certain ways either the packets are modified in certain ways (e.g.,
(like decapsulator, marker), or some results are generated and decapsulator, marker), or some results are generated and stored,
stored, probably in the form of metadata (like classifier). Each probably in the form of metadata (like a classifier). Each LFB
LFB typically does one thing and one thing only. Classifiers, typically does one thing and one thing only. Classifiers, shapers,
shapers, meters are all examples of LFB. Modeling LFB at such fine meters are all examples of LFBs. Modeling LFBs at such a fine
granularity allows us to use a small number of LFBs to create the granularity allows us to use a small number of LFBs to create the
higher-order FE functions (like IPv4 forwarder) precisely, which in higher-order FE functions (such as an IPv4 forwarder) precisely,
turn can describe more complex networking functions and vendor which in turn can describe more complex networking functions and
implementations of software and hardware. vendor implementations of software and hardware. Section 6 provides
a list of useful LFBs with such granularity.
(Editor's note: We need to revisit the granularity issue around LFB
later and provide a practical design guideline as how to partition
the FE functions into LFB classes. We will gain more insight on
the subject once we debate and settle on the LFB list in the LFB
class library, described in Section 7. So the text around
granularity here might be revised to reflect the lessons we learn.)
An LFB has one or more inputs, each of which takes a packet P, and An LFB has one or more inputs, each of which takes a packet P, and
optionally metadata M; and produces one or more outputs, each of optionally metadata M; and produces one or more outputs, each of
which carries a packet P', and optionally metadata M'. Metadata is which carries a packet P', and optionally metadata M'. Metadata is
data associated with the packet in the network processing device data associated with the packet in the network processing device
(router, switch, etc.) and passed between one LFB to the next, but (router, switch, etc.) and passed from one LFB to the next, but not
not sent across the network. It is most likely that there are sent across the network. It is most likely that there are multiple
multiple LFBs within one FE, as shown in Figure 2, and all the LFBs LFBs within one FE, as shown in Figure 2, and all the LFBs share
share the same ForCES protocol termination point that implements the same ForCES protocol termination point that implements the
the ForCES protocol logic and maintains the communication channel ForCES protocol logic and maintains the communication channel to
to and from the CE. and from the CE.
An LFB, as shown in Figure 2, has inputs, outputs and attributes
that can be queried and manipulated by the CE indirectly via Fp
reference point (defined in [2]) and the ForCES protocol
termination point. The horizontal axis is in the forwarding plane
for connecting the inputs and outputs of LFBs within the same FE.
The vertical axis between the CE and the FE denotes the Fp
reference point where bidirectional communication between the CE
and FE happens: the CE to FE communication is for configuration,
control and packet injection while the FE to CE is for packet re-
direction to the control plane, monitoring and accounting
information, errors, etc. Note that the interaction between the CE
and the LFB is only abstract and indirect. The result of such
interaction is for the CE to indirectly manipulate the attributes
of the LFB instances.
+-----------+ +-----------+
| CE | | CE |
+-----------+ +-----------+
^ ^
| Fp reference point | Fp reference point
| |
+--------------------------|-----------------------------------+ +--------------------------|-----------------------------------+
| FE | | | FE | |
| v | | v |
| +----------------------------------------------------------+ | | +----------------------------------------------------------+ |
| | ForCES protocol | | | | ForCES protocol | |
| | termination point | | | | termination point | |
| +----------------------------------------------------------+ | | +----------------------------------------------------------+ |
| ^ ^ | | ^ ^ |
| : : Internal control | | : : Internal control |
| : : | | : : |
| +---:----------+ +---:----------+ | | +---:----------+ +---:----------| |
| | :LFB1 | | : LFB2 | | | | :LFB1 | | : LFB2 | |
| =====>| v |============>| v |======>...| | =====>| v |============>| v |======>...|
| Inputs| +----------+ |Outputs | +----------+ | | | Inputs| +----------+ |Outputs | +----------+ | |
| (P,M) | |Attributes| |(P',M') | |Attributes| |(P",M") | | (P,M) | |Attributes| |(P',M') | |Attributes| |(P",M") |
| | +----------+ | | +----------+ | | | | +----------+ | | +----------+ | |
| +--------------+ +--------------+ | | +--------------+ +--------------+ |
| | | |
+--------------------------------------------------------------+ +--------------------------------------------------------------+
Figure 2. Generic LFB Diagram Figure 2. Generic LFB Diagram
An LFB, as shown in Figure 2, has inputs, outputs and attributes
that can be queried and manipulated by the CE indirectly via Fp
reference point (defined in [2]) and the ForCES protocol
termination point. The horizontal axis is in the forwarding plane
for connecting the inputs and outputs of LFBs within the same FE.
The vertical axis between the CE and the FE denotes the Fp
reference point where bidirectional communication between the CE
and FE happens: the CE to FE communication is for configuration,
control and packet injection while FE to CE communication is used
for packet re-direction to the control plane, monitoring and
accounting information, errors, etc. Note that the interaction
between the CE and the LFB is only abstract and indirect. The
result of such interaction is for the CE to indirectly manipulate
the attributes of the LFB instances.
A namespace is used to associate a unique name or ID with each LFB A namespace is used to associate a unique name or ID with each LFB
class. The namespace must be extensible so that new LFB class can class. The namespace must be extensible so that new LFB class can
also be added later to accommodate future innovation in the also be added later to accommodate future innovation in the
forwarding plane. forwarding plane.
LFB operation must be specified in the model to allow the CE to LFB operation must be specified in the model to allow the CE to
understand the behavior of the forwarding datapath. For instance, understand the behavior of the forwarding datapath. For instance,
the CE must understand at what point in the datapath the IPv4 the CE must understand at what point in the datapath the IPv4
header TTL is decremented (i.e., it needs to know if a control header TTL is decremented (i.e., it needs to know if a control
packet could be delivered to the CE either before or after this packet could be delivered to the CE either before or after this
point in the datapath). In addition, the CE must understand where point in the datapath). In addition, the CE must understand where
and what type of header modifications (e.g., tunnel header append and what type of header modifications (e.g., tunnel header append
or strip) are performed by the FEs. Further, the CE must verify or strip) are performed by the FEs. Further, the CE must verify
that various LFB along a datapath within an FE are compatible to that various LFBs along a datapath within an FE are compatible to
link together. link together.
There is value to vendors if the operation of LFB classes can be There is value to vendors if the operation of LFB classes can be
expressed in sufficient detail so that physical devices expressed in sufficient detail so that physical devices
implementing different LFB functions can be integrated easily into implementing different LFB functions can be integrated easily into
a FE design. Therefore, semi-formal specification is needed; that an FE design. Therefore, a semi-formal specification is needed;
is, a text description of the LFB operation (human readable), but that is, a text description of the LFB operation (human readable),
sufficiently specific and unambiguous to allow conformance testing but sufficiently specific and unambiguous to allow conformance
and efficient design (i.e., eliminate guess-work), so that testing and efficient design (i.e., eliminate guess-work), so that
interoperability between different CEs and FEs can be achieved. interoperability between different CEs and FEs can be achieved.
The LFB class model specifies information like: The LFB class model specifies information like:
. number of inputs and outputs (and whether they are . number of inputs and outputs (and whether they are
configurable) configurable)
. metadata read/consumed from inputs; . metadata read/consumed from inputs;
. metadata produced at the outputs; . metadata produced at the outputs;
. packet type(s) accepted at the inputs and emitted at the . packet type(s) accepted at the inputs and emitted at the
outputs; outputs;
. packet content modifications (including encapsulation or . packet content modifications (including encapsulation or
decapsulation); decapsulation);
. packet routing criteria (when multiple outputs on an LFB are . packet routing criteria (when multiple outputs on an LFB are
present); present);
. packet timing modifications; . packet timing modifications;
. packet flow ordering modifications; . packet flow ordering modifications;
. LFB capability information; . LFB capability information;
. LFB operational attributes, etc. . LFB operational attributes, etc.
Section 5 of this document provides detailed discussion on the LFB Section 4 of this document provides a detailed discussion of the
model with a formal specification of LFB class schema. The rest of LFB model with a formal specification of LFB class schema. The
Section 3.2 here only intends to provide conceptual overview of rest of Section 3.2 only intends to provide a conceptual overview
some important issues in LFB modeling, without covering all the of some important issues in LFB modeling, without covering all the
specific details. specific details.
3.2.1. LFB Input and Input Group 3.2.1. LFB Input and Input Group
An LFB input is a conceptual port of the LFB where the LFB can An LFB input is a conceptual port of the LFB where the LFB can
receive information from other LFBs. The information is typically a receive information from other LFBs. The information is typically a
packet (or frame in general) and associated metadata, although in packet (or frame in general) and associated metadata, although in
some cases it might consist of only metadata, i.e., with a Null- some cases it might consist of only metadata, i.e., with a Null-
packet. packet.
skipping to change at page 15, line 7 skipping to change at page 15, line 28
|LFB2+---+ +----+ | +-----------+ |LFB2+---+ +----+ | +-----------+
+----+ |LFB2+---+ +----+ |LFB2+---+
+----+ +----+
(a) without input group (b) with input group (a) without input group (b) with input group
Figure 3. An example of using input group. Figure 3. An example of using input group.
Consider the following two cases in Figure 3(a) and (b). In Figure Consider the following two cases in Figure 3(a) and (b). In Figure
3(a), the output from two LFBs are directly connected into one 3(a), the output from two LFBs are directly connected into one
input of LFB3, assuming that it can be guaranteed no two packets input of LFB3, assuming that it can be guaranteed that no two
arrive at the same time instance. If LFB3 must do something packets arrive at the same time instance. If LFB3 must do
different based on the source of the packet (LFB1 or LFB2), the something different based on the source of the packet (LFB1 or
only way to model that is to make LFB1 and LFB2 to pass some LFB2), the only way to model that is to make LFB1 and LFB2 pass
metadata with different values so that LFB3 can make the some metadata with different values so that LFB3 can make the
differentiation based on the metadata. In Figure 3(b), that differentiation based on that metadata. In Figure 3(b), that
differentiation can be elegantly expressed within LFB3 using the differentiation can be elegantly expressed within LFB3 using the
input group concept where the instance id can server as the input group concept where the instance id can server as the
differentiating key. For example, a scheduler LFB can potentially differentiating key. For example, a scheduler LFB can potentially
use an input group consisting of a variable number of inputs to use an input group consisting of a variable number of inputs to
differentiate the queues from which the packets are coming. differentiate the queues from which the packets are coming.
3.2.2. LFB Output and Output Group 3.2.2. LFB Output and Output Group
An LFB output is a conceptual port of the LFB where it can send An LFB output is a conceptual port of the LFB that can send
information to some other LFBs. The information is typically a information to some other LFBs. The information is typically a
packet (or frame in general) and associated metadata, although in packet (or frame in general) and associated metadata, although in
some cases it might emit only metadata,, i.e., with a Null-packet. some cases it might emit only metadata, i.e., with a Null-packet.
We assume that a single LFB output can be connected to only one LFB We assume that a single LFB output can be connected to only one LFB
input (this is required to make the packet flow through the LFB input (this is required to make the packet flow through the LFB
topology unambiguous). Therefore, to allow any non-trivial topology unambiguous). Therefore, to allow any non-trivial
topology, multiple outputs must be allowed for an LFB class. If topology, multiple outputs must be allowed for an LFB class. If
there are multiple outputs with the same output type, we model them there are multiple outputs with the same output type, we model them
as output group, that is, multiple instances of the same output as output group, that is, multiple instances of the same output
type. For illustration of output group, consider the hypothetical type. For illustration of output group, consider the hypothetical
LFB in Figure 4. The LFB has two types of outputs, one of which LFB in Figure 4. The LFB has two types of outputs, one of which
can be instantiated to form an output group. can be instantiated to form an output group.
skipping to change at page 16, line 28 skipping to change at page 17, line 4
Note that each LFB has a set of packet types that it operates on, Note that each LFB has a set of packet types that it operates on,
but it does not care about whether the underlying implementation is but it does not care about whether the underlying implementation is
passing a greater portion of the packets. For example, an IPv4 LFB passing a greater portion of the packets. For example, an IPv4 LFB
might only operate on IPv4 packets, but the underlying might only operate on IPv4 packets, but the underlying
implementation may or may not be stripping the L2 header before implementation may or may not be stripping the L2 header before
handing it over -- whether that is happening or not is opaque to handing it over -- whether that is happening or not is opaque to
the CE. the CE.
3.2.4. Metadata 3.2.4. Metadata
Metadata is the per-packet state that is passed from one LFB to
another. The metadata is passed with the packet to assist with
further processing of that packet. The ForCES model must capture
how the per-packet state information is propagated from one LFB to
other LFBs. Practically, such metadata propagation can happen
within one FE, or cross the FE boundary between two interconnected
FEs. We believe that the same metadata model can be used for both
situations, however, our focus here is for intra-FE metadata.
Metadata is used to communicate per-packet state from one LFB to Each metadata can be conveniently modeled as a <label, value> pair,
another. To ensure inter-operability among LFBs, the LFB class where the label identifies the type of information, (e.g.,
"color"), and its value holds the actual information (e.g., "red").
The tag here is shown as a textual label, but it can be replaced or
associated with a unique numeric value (identifier).
The metadata life-cycle is defined in this model using three types
of events: "write", "read" and "consume". The first "write"
initializes the value of the metadata (implicitly creating and/or
initializing the metadata), and hence starts the life-cycle. The
explicit "consume" event terminates the life-cycle. Within the
life-cycle, that is, after a "write" event, but before the next
"consume" event, there can be an arbitrary number of "write" and
"read" events. These "read" and "write" events can be mixed in an
arbitrary order within the life-cycle. Outside of the life-cycle of
the metadata, that is, before the first "write" event, or between a
"consume" event and the next "write" event, the metadata should be
regarded non-existent or non-initialized. Thus, reading a metadata
outside of its life-cycle is considered an error.
To ensure inter-operability between LFBs, the LFB class
specification must define what metadata the LFB class "reads" or specification must define what metadata the LFB class "reads" or
"consumes" on its input(s) and what metadata it "produces" on its "consumes" on its input(s) and what metadata it "produces" on its
output(s). For that purpose, metadata types must be identified. output(s). For maximum extensibility, this definition should not
For example, an META_IFID, passed from a port LFB to an IPv4 specify which LFBs the metadata is expected to come from for a
processing LFB (with the IP packet) can be one of the defined consumer LFB, or which LFBs are expected to consume metadata for a
metadata types. producer LFB.
Symbolic names can be assigned for common metadata types. In While it is important to define the metadata types passing between
addition, additional information such as numeric data type, maximum LFBs, it is not necessary to define the exact encoding mechanism
and minimum accepted values, and special values should be defined used by LFBs for that metadata. Different implementations are
for each metadata value. Some of these constraints will be defined allowed to use different encoding mechanisms for metadata. For
in the LFB class model, and some of them may be specific example, one implementation may store metadata in registers or
capabilities of a particular LFB instance. shared memory, while another implementation may encode metadata in-
band as a preamble in the packets.
While it is important to define the metadata passing between LFB in At any link between two LFBs, the packet is marked with a finite
terms of its name, value and interpretation, it is not necessary to set of active metadata, where active means the metadata is within
define the exact encoding mechanism used by LFBs for metadata. its life-cycle. (i.e., the metadata has been properly initialized
Different implementations are allowed to use different encoding and has not been consumed yet.) There are two corollaries of this
mechanisms for metadata. For example, one implementation may store model:
metadata in registers or shared memory, while another
implementation may encode metadata in-band as preamble in the
packets.
A given LFB may require a certain metadata at its inputs for its 1. No uninitialized metadata exists in the model.
internal processing. What should happen with the metadata after it
is read by the LFB? In particular, should the metadata be
propagated along with the packet when the packet is forwarded from
the LFB to the next LFB, or should it be removed (consumed) by the
LFB?
In certain cases, passing the metadata along is desirable. For 2. No more than one occurrence of each metadata tag can be
example, a META_CLASSID metadata may denote the result of a associated with a packet at any given time.
classification LFB and used in more than one downstream LFBs to
trigger the proper operation on the packet. In this case the first
LFB that uses the META_CLASSID should also allow the META_CLASSID
to be passed with the packet to the next LFB, and so on. On the
other hand, it is easy to see that if metadata is never consumed by
LFBs, then as the packet trickles through the datapath, a large
number of metadata will potentially be accumulated by the packet.
We believe that one way to accommodate both scenarios is to specify 3.2.4.1. LFB Operations on Metadata
the propagation mode for each element of metadata utilized by an
LFB class. Metadata elements which are not propagated are
specified with the CONSUME mode, while elements which are
propagated are specified with the PROPAGATE mode.
However, whether a metadata is useful beyond an LFB may depend on When the packet is processed by an LFB (i.e., between the time it
the actual LFB topology, i.e., what other LFBs are placed is received and forwarded by the LFB), the LFB may perform read,
downstream. So the propagation mode of metadata should be write and/or consume operations on any active metadata associated
configurable. with the packet. If the LFB is considered to be a black box, one of
the following operations is performed on each active metadata.
A packet may arrive to an LFB with metadata that is not meaningful - IGNORE: ignores and forwards the metadata
to that LFB, but may be important to some other downstream LFBs. - READ: reads and forwards the metadata
To cater to such cases it should be the assumed (default) behavior - READ/RE-WRITE: reads, over-writes and forwards the metadata
of all LFB classes that they transparently propagate any metadata - WRITE: writes and forwards the metadata
elements that they do not utilize internally. (can also be used to create new metadata)
- READ-AND-CONSUME: reads and consumes the metadata
- CONSUME consumes metadata without reading
Actual implementations of LFBs in hardware may have limitations on The last two operations terminate the life-cycle of the metadata,
how much metadata they can pass through. The limitation may be meaning that the metadata is not forwarded with the packet when the
expressed in terms of total framesize (packet + metadata), metadata packet is sent to the next LFB.
total size, number of metadata elements, or a combination of these.
The limitation may be on the FE level or may be specific to LFBs
within an FE. The pass-through capabilities of LFB instances and
FEs can be queried as part of the capability discovery process.
(Editor's note: The definition of metadata here is only preliminary In our model, a new metadata is generated by an LFB when the LFB
and the authors intend to work on the subject in more detail. applies a WRITE operation into a metadata type that was not present
Input is most welcome.) when the packet was received by the LFB. Such implicit creation may
be unintentional by the LFB, that is, the LFB may apply the WRITE
operation without knowing or caring if the given metadata existed
or not. If it existed, the metadata gets over-written; if it did
not exist, the metadata gets created.
3.2.5. LFB Versioning For source-type LFBs (i.e., an LFB that inserts packets into the
model), WRITE is the only meaningful metadata operation.
Sink-type LFBs (i.e., an LFB that removes the packet from the
model), may either READ-AND-CONSUME (read) or CONSUME (ignore) each
active metadata associated with the packet.
3.2.4.2. Metadata Production and Consumption
For a given metadata on a given packet path, there must be at least
one producer LFB that creates that metadata and should be at least
one consumer LFB that needs the metadata. In this model, the
producer and consumer LFBs of a metadata are not required to be
adjacent. There may be multiple consumers for the same metadata and
there may be multiple producers of the same metadata. When a packet
path involves multiple producers of the same metadata, then the
second, third, etc. producers overwrite that metadata value.
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 generate the metadata on the port group, or may generate it
only under certain conditions. We call the former an
"unconditional" metadata, whereas the latter is a "conditional"
metadata. In the case of conditional metadata, it should be
possible to determine from the definition of the LFB when a
"conditional" metadata is produced.
The consumer behavior of an LFB, that is, the metadata that the LFB
needs for its operation, is defined in the LFB class definition on
a per input port group basis. An input port group may "require" a
given metadata, or may treat it as "optional" information. In the
latter case, the LFB class definition must explicitly define what
happens if an optional metadata is not provided. One approach is to
specify a default value for each optional metadata, and assume that
the default value is used if the metadata is not provided with the
packet.
When a consumer requires a given metadata, it has dependencies on
its up-stream LFBs. That is, the consumer LFB can only function if
there is at least one producer of that metadata and no intermediate
LFB consumes the metadata.
The model should expose this inter-dependency. Furthermore, it
should be possible to take this inter-dependency into consideration
when constructing LFB topologies, and also that the dependency can
be verified when validating topologies.
For extensibility reasons, the LFB specification should define what
metadata the LFB requires without specifying which LFB(s) it expect
a certain metadata to come from. Similarly, LFBs should specify
what metadata they produce without specifying which LFBs the
metadata is meant for.
When specifying the metadata tags, some harmonization effort must
be made so that the producer LFB class uses the same tag as its
intended consumer(s), or vice versa.
3.2.4.3. Fixed, Variable and Configurable Tag
When the produced metadata is defined for a given LFB class, most
metadata will be specified with a fixed tag. For example, a Rate
Meter LFB will always produce the "Color" metadata.
A small subset of LFBs need to have the capability to produce one
or more of their metadata with tags that are not fixed in the LFB
class definition, but instead can be selected per LFB instance. An
example of such an LFB class is a Generic Classifier LFB. We call
this variable tag metadata production. If an LFB produces metadata
with variable tag, a corresponding LFB attribute--called the tag
selector--specifies the tag for each such metadata. This mechanism
is to improve the versatility of certain multi-purpose LFB classes,
since it allows the same LFB class be used in different topologies,
producing the right metadata tags according to the needs of the
topology.
Depending on the capability of the FE, the tag selector can be a
read-only or a read-write attribute. In the former case, the tag
cannot be modified by the CE. In the latter case the tag can be
configured by the CE, hence we call this "configurable tag metadata
production." (Note that in this definition configurable tag
metadata production is a subset of variable tag metadata
production.)
Similar concepts can be introduced for the consumer LFBs to satisfy
the different metadata needs. Most LFB classes will specify their
metadata needs using fixed metadata tags. For example, a Next Hop
LFB may always require a "NextHopId" metadata; but the Redirector
LFB may need to use a "ClassID" metadata in one instance, and a
"ProtocolType" metadata in another instance as a basis for
selecting the right output port. In this case, an LFB attribute is
used to provide the required metadata tag at run-time. This
metadata tag selector attribute may be read-only or read-write,
depending on the capabilities of the LFB instance and the FE.
3.2.4.4. Metadata Usage Categories
Depending on the role and usage of a metadata, various amount of
encoding information must be provided when the metadata is defined,
and some cases offer less flexibility in the value selection than
others.
As far as usage of a metadata is concerned, three types of metadata
exist:
- Relational (or binding) metadata
- Enumerated metadata
- Explicit/external value metadata
The purpose of the relational metadata is to refer in one LFB
instance (producer LFB) to a "thing" in another downstream LFB
instance (consumer LFB), where the "thing" is typically an entry in
a table attribute of the consumer LFB.
For example, the Prefix Lookup LFB executes an LPM search using its
prefix table and resolves to a next-hop reference. This reference
needs to be passed as metadata by the Prefix Lookup LFB (producer)
to the Next Hop LFB (consumer), and must refer to a specific entry
in the next-hop table within the consumer.
Expressing and propagating such binding relationship is probably
the most common usage of metadata. One or more objects in the
producer LFB are related (bound) to a specific object in the
consumer LFB. Such a relation is established by the CE very
explicitly, i.e., by properly configuring the attributes in both
LFBs. Available methods include the following:
The binding may be expressed by tagging the involved objects in
both LFBs with the same unique (but otherwise arbitrary)
identifier. The value of the tag is explicitly configured (written
by the CE) into both LFBs, and this value is also the value that
the metadata carries between the LFBs.
Another way of setting up binding relations is to use a naturally
occurring unique identifier of the consumer's object (for example,
the array index of a table entry) as a reference (and as a value of
the metadata. In this case, the index is obtained (read) or
inferred by the CE by communicating with the consumer LFB. Once the
CE obtains the index, it needs to plug (write) it into the producer
LFB to establish the binding.
Important characteristics of the binding usage of metadata are:
- The value of the metadata shows up in the CE-FE communication for
BOTH the consumer and the producer. That is, the metadata value
must be carried over the ForCES protocol. Using the tagging
technique, the value is WRITTEN to both LFBs. Using the other
technique, the value is WRITTEN to only the producer LFB and may be
READ from the consumer LFB.
- The actual value is irrelevant for the CE, the binding is simply
expressed by using the SAME value at the consumer and producer
LFBs.
- Hence the definition of the metadata does not have to include
value assignments. The only exception is when some special value(s)
of the metadata must be reserved to convey special events. Even
though these special cases must be defined with the metadata
specification, their encoded values can be selected arbitrarily.
For example, for the Prefix Lookup LFB example, a special value may
be reserved to signal the NO-MATCH case, and the value of zero may
be assigned for this purpose.
The second class of metadata is the enumerated type. An example is
the "Color" metadata that is produced by a Meter LFB and consumed
by some other LFBs. As the name suggests, enumerated metadata has a
relatively small number of possible values, each with a very
specific meaning. All of the possible cases must be enumerated when
defining this class of metadata. Although a value encoding must be
included in the specification, the actual values can be selected
arbitrarily (e.g., <Red=0, Yellow=1, Green=2> and <Red=3, Yellow=2,
Green 1> would be both valid encodings, what is important is that
an encoding is specified).
The value of the enumerated metadata may or may not be conveyed via
the ForCES protocol between the CE and FE.
The third class of metadata is the explicit type. This refers to
cases where the value of the metadata is explicitly used by the
consumer LFB to change some packet header fields. In other words,
its value has a direct and explicit impact on some field and will
be visible externally when the packet leaves the NE. Examples are:
TTL increment given to a Header Modifier LFB, and DSCP value for a
Remarker LFB. For explicit metadata, the value encoding must be
explicitly provided in the metadata definition, where the values
cannot be selected arbitrarily, but rather they should conform to
what is commonly expected. For example, a TTL increment metadata
should encode with zero for the no increment case, by one for the
single increment case, etc. A DSCP metadata should use 0 to encode
DSCP=0, 1 to encode DSCP=1, etc.
3.2.5. 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. Unlike inheritance (discussed next in Section 3.2.6), LFB classes. Unlike inheritance (discussed next in Section 3.2.6),
where it assumed that an FE datapath model containing an LFB where it assumed that an FE datapath model containing an LFB
instance of a particular class C could also simultaneously contain instance of a particular class C could also simultaneously contain
an LFB instance of a class C' inherited from class C; with an LFB instance of a class C' inherited from class C; with
versioning, an FE would not be allowed to contain an LFB instance versioning, an FE would not be allowed to contain an LFB instance
for more than one version of a particular class. for more than one version of a particular class.
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 backwards compatibility the class definition. CEs may support backwards compatibility
skipping to change at page 24, line 47 skipping to change at page 30, line 5
capability. Even if an FE supports configurable LFB topology, it capability. Even if an FE supports configurable LFB topology, it
is expected that there will be FE-specific limitations on what can is expected that there will be FE-specific limitations on what can
actually be configured. Performance-optimized hardware actually be configured. Performance-optimized hardware
implementation may have zero or very limited configurability, while implementation may have zero or very limited configurability, while
FE implementations running on network processors may provide more FE implementations running on network processors may provide more
flexibility and configurability. It is entirely up to the FE flexibility and configurability. It is entirely up to the FE
designers to decide whether or not the FE actually implements such designers to decide whether or not the FE actually implements such
reconfiguration and how much. Whether it is a simple runtime reconfiguration and how much. Whether it is a simple runtime
switch to enable or disable (i.e., bypass) certain LFBs, or more switch to enable or disable (i.e., bypass) certain LFBs, or more
flexible software reconfiguration is all implementation detail flexible software reconfiguration is all implementation detail
internal to the FE but outside of the scope of FE model. In either internal to the FE and outside of the scope of FE model. In either
case, the CE(s) must be able to learn the FE's configuration case, the CE(s) must be able to learn the FE's configuration
capabilities. Therefore, the FE model must provide a mechanism for capabilities. Therefore, the FE model must provide a mechanism for
describing the LFB topology configuration capabilities of an FE. describing the LFB topology configuration capabilities of an FE.
These capabilities may include (see Section 6 for details): These capabilities may include (see Section 5 for full details):
. What LFB classes can the FE instantiate? . What LFB classes can the FE instantiate?
. How many instances of the same LFB class can be created? . How many instances of the same LFB class can be created?
. What are the topological limitations? For example: . What are the topological limitations? For example:
o How many instances of the same class or any class can be o How many instances of the same class or any class can be
created on any given branch of the graph? created on any given branch of the graph?
o Ordering restrictions on LFBs (e.g., any instance of LFB o Ordering restrictions on LFBs (e.g., any instance of LFB
class A must be always downstream of any instance of LFB class A must be always downstream of any instance of LFB
class B). class B).
Even if the CE is allowed to configure LFB topology for an FE, how Even if the CE is allowed to configure LFB topology for an FE, how
can the CE interpret an arbitrary LFB topology (presented to the CE can the CE interpret an arbitrary LFB topology (presented to the CE
by the FE) and know what to do with it? In another word, how does by the FE) and know what to do with it? In other words, how does
the CE know the mapping between an LFB topology and a particular NE the CE know the mapping between an LFB topology and a particular NE
service or application (e.g., VPN, DiffServ, etc.)? We argue that service or application (e.g., VPN, DiffServ, etc.)? We argue that
first of all, it is unlikely that an FE can support any arbitrary first of all, it is unlikely that an FE can support any arbitrary
LFB topology; secondly, once the CE understands the coarse LFB topology; secondly, once the CE understands the coarse
capability of an FE, it is up to the CE to configure the LFB capability of an FE, it is up to the CE to configure the LFB
topology according to the network service the NE is supposed to topology according to the network service the NE is supposed to
provide. So the more important mapping that the CE has to provide. So the more important mapping that the CE has 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. Do we expect the CE has the topology, not the other way around. Do we expect the CE has the
ultimate intelligence to translate any high level service policy ultimate intelligence to translate any high level service policy
skipping to change at page 27, line 44 skipping to change at page 33, line 21
Once the FE reports such capability and capacity to the CE, it is Once the FE reports such capability and capacity to the CE, it is
now up to the CE to translate the QoS policy into the desirable now up to the CE to translate the QoS policy into the desirable
configuration for the FE. Figure 7(a) depicts the FE capability configuration for the FE. Figure 7(a) depicts the FE capability
while 7(b) and 7(c) depict two different topologies that the FE while 7(b) and 7(c) depict two different topologies that the FE
might be asked to configure to. Note that both the ingress and might be asked to configure to. Note that both the ingress and
egress are omitted in (b) and (c) for simple representation. The egress are omitted in (b) and (c) for simple representation. The
topology in 7(c) is considerably more complex than 7(b) but both topology in 7(c) is considerably more complex than 7(b) but both
are feasible within the FE capabilities, and so the FE should are feasible within the FE capabilities, and so the FE should
accept either configuration request from the CE. accept either configuration request from the CE.
4. LFB Model -- LFB and Associated Data Definitions 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 is facilitated using the concept of LFBs which are instantiated
from LFB classes. The LFB model is defined in this section to from LFB classes. LFB classes and associated definitions will be
describe the content and structures in LFB and associated data type provided in a collection of XML documents. The collection of these
definition. XML documents is called a LFB class library, and each document is
called an LFB class library document (or library document, for
short). Each of the library documents will conform to the schema
presented in this section. The root element of the library document
is the <LFBLibrary> element.
The core part of the model is the definition of LFB classes. It is not expected that library documents will be exchanged between
Section 4.4 provides more discussion on what will be part of an LFB FEs and CEs "over-the-wire". But the model will serve as an
class definition. important reference for the design and development of the CEs
(software) and FEs (mostly the software part). It will also serve
as a design input when specifying the ForCES protocol elements for
CE-FE communication.
Operational parameters of the LFBs that must be visible to the CEs 4.1. Namespace
are conceptualized in the model as the LFB attributes. These
include, for example, flags, single parameter arguments, complex
arguments, and tables. The definition of the attributes of an LFB
MUST be part of the LFB class definition. To promote consistent and
terse definitions of the attributes of LFB classes, commonly used
attribute types SHOULD be defined in the model outside of the LFB
class definitions, so that LFB class definitions can "share" these
type definitions by simply referring to the types. What will
comprise a data type definition is further discussed in Section
4.1.
LFBs form a directed graph with each other by sending and receiving The LFBLibrary element and all of its sub-elements are defined in
packets and associated metadata. To provide consistency and logical the following namespace:
inter-operability among LFB classes, packet types (generic frame
types) and metadata types MUST BE specified outside of the LFB
class definitions (but part of the LFB model), so that the LFB
class definitions can simply refer to these types. These blocks are
further discussed in Section 4.3 and Section 4.2, respectively.
In summary, the LFB model will consist of the following four
categories of definitions:
1) Common data type definitions (Section 4.1)
2) Metadata definitions (Section 4.2);
3) Frame format definitions (Section 4.3);
4) LFB class definitions (Section 4.4).
It is not expected that the above information is exchanged between http://ietf.org/forces/1.0/lfbmodel
FEs and CEs "over-the-wire". But the model will serve as an
important reference for the design and development of the CEs
(software) and FEs (mostly the software part).
4.1. General Data Type Definitions 4.2. <LFBLibrary> Element
Data types will be used to describe the LFB attributes (see Section The <LFBLibrary> element serves as a root element of all library
4.4.4). This is similar to the concept of having a common header documents. It contains one or more of the following main blocks:
file for shared data types. Data types will include atomic data
types (e.g. integer, ASCII string), as well as compound or derived . <frameTypeDefs> for the frame declarations;
data types (such as arrays and structures). Given that the FORCES . <dataTypeDefs> for defining common data types;
protocol will be getting and setting attribute values, all atomic . <metadataDefs> for defining metadata, and
data types used here must be able to be conveyed in the FORCES . <LFBClassDefs> for defining LFB classes.
protocol. Further, the FORCES protocol will need a mechanism to
convey compound data types. Details of such representation are for Each block is optional, that is, one library may contain only
the protocol document, not the model documents. metadata defintions, another may contain only LFB class
definitions, yet another may contain all of the above.
In addition to the above main blocks, a library document can import
other library documents if it needs to refer to definitions
contained in the included document. This concept is similar to the
"#include" directive in C. Importing is expressed by the <load>
elements, which must precede all the above elements in the
document. For unique referencing, each LFBLibrary instance document
has a unique label defined in the "provide" attribute of the
LFBLibrary element.
The <LFBLibrary> element also includes an optional <description>
element, which can be used to provide textual description about the
library.
Following is a skeleton of a library document:
<?xml version="1.0" encoding="UTF-8"?>
<LFBLibrary xmlns="http://ietf.org/forces/1.0/lfbmodel"
provides="this_library">
<description>
...
</description>
<!-- Loading external libraries (optional) -->
<load library="another_library"/>
...
<!-- FRAME TYPE DEFINITIONS (optional) -->
<frameTypeDefs>
...
</frameTypeDefs>
<!-- DATA TYPE DEFINITIONS (optional) -->
<dataTypeDefs>
...
</dataTypeDefs>
<!-- METADATA DEFINITIONS (optional) -->
<metadataDefs>
...
</metadataDefs>
<!—LFB CLASS DEFINITIONS (optional) -->
<LFBCLassDefs>
...
</LFBCLassDefs>
</LFBLibrary>
4.3. <load> Element
This element is used to refer to another LFB library document.
Similar to the "include" directive in C, this makes the objects
(metadata types, data types, etc.) defined in the referred library
available for referencing in the current document.
The load element must contain the label of the library to be
included and may contain a URL to specify where the library can be
retrieved. The load element can be repeated unlimited times. Three
examples for the <load> elements:
<load library="a_library"/>
<load library="another_library" location="another_lib.xml"/>
<load library="yetanother_library"
location="http://www.petrimeat.com/forces/1.0/lfbmodel/lpm.xml"/>
4.4. <frameDefs> Element for Frame Type Declarations
Frame names are used in the LFB definition to define what types of
frames the LFB expects at its input port(s) and emits at its output
port(s). The <frameDefs> optional element in the library document
contains one or more <frameDef> elements, each declaring one frame
type.
Each frame definition contains a unique name (NMTOKEN) and a brief
synopsis. In addition, an optional detailed description may be
provided.
Uniqueness of frame types must be ensured among frame types defined
in the same library document and in all directly or indirectly
included library documents.
The following example defines two frame types:
<frameDefs>
<frameDef>
<name>ipv4</name>
<synopsis>IPv4 packet</synopsis>
<description>
This frame type refers to an IPv4 packet.
</description>
</frameDef>
<frameDef>
<name>ipv6</name>
<synopsis>IPv6 packet</synopsis>
<description>
This frame type refers to an IPv6 packet.
</description>
</frameDef>
...
</frameDefs>
4.5. <dataTypeDefs> Element for Data Type Definitions
The (optional) <dataTypeDefs> element can be used to define
commonly used data types. It contains one or more <dataTypeDef>
elements, each defining a data type with a unique name. Such data
types can be used in several places in the library documents,
including:
. Defining other data types
. Defining metadata
. Defining attributes of LFB classes
This is similar to the concept of having a common header file for
shared data types.
Each <dataTypeDef> element contains a unique name (NMTOKEN), a
brief
synopsis, an optional longer description, and a type definition
element. The name must be unique among all data types defined in
the same library document and in any directly or indirectly
included library documents. For example:
<dataTypeDefs>
<dataTypeDef>
<name>ieeemacaddr</name>
<synopsis>48-bit IEEE MAC address</synopsis>
... type definition ...
</dataTypeDef>
<dataTypeDef>
<name>ipv4addr</name>
<synopsis>IPv4 address</synopsis>
... type definition ...
</dataTypeDef>
...
</dataTypeDefs>
There are two kinds of data types: atomic and compound. Atomic
data types are appropriate for single-value variables (e.g.
integer, ASCII string, byte array).
The following built-in atomic data types are provided, but
additional atomic data types can be defined with the <typeRef> and
<atomic> elements:
<name> Meaning
---- -------
char 8-bit signed integer
uchar 8-bit unsigned integer
int16 16-bit signed integer
uint16 16-bit unsigned integer
int32 32-bit signed integer
uint32 32-bit unsigned integer
int64 64-bit signed integer
uint64 64-bit unisgned integer
string[N] ASCII null-terminated string with
buffer of N characters (string max
length is N-1)
byte[N] A byte array of N bytes
float16 16-bit floating point number
float32 32-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
LFB attributes, but can also be used as building blocks when
defining new data types.
Compound data types can build on atomic data types and other Compound data types can build on atomic data types and other
compound data types. There are three ways that compound data types compound data types. There are four ways that compound data types
can be defined. They may be defined as an array of elements of can be defined. They may be defined as an array of elements of
some compound or atomic data type. They may be a structure of some compound or atomic data type. They may be a structure of
named elements of compound or atomic data types (ala C structures). named elements of compound or atomic data types (ala C structures).
They may also be defined as augmentations (explained below in They may be a union of named elements of compound or atomic data
4.1.3) of existing compound data types. types (ala C unions). They may also be defined as augmentations
(explained below in 4.5.6) of existing compound data types.
In addition, any data type may be used to define a new type by Given that the FORCES protocol will be getting and setting
restricting the range of values that an instance of the data type attribute values, all atomic data types used here must be able to
can take on, and specifying specific semantics that go with that. be conveyed in the FORCES protocol. Further, the FORCES protocol
This is similar to the SNMP notion of a textual convention. will need a mechanism to convey compound data types. However, the
details of such representations are for the protocol document, not
the model documents.
For each data type the following information MUST be provided: For the definition of the actual type in the <dataTypeDef> element,
. Symbolic name of data type. Example: "T_IPV4ADDRESS". the following elements are available: <typeRef>, <atomic>, <array>,
. Actual type declaration. <struct>, and <union>.
In addition, a data type definition MAY include the following: [EDITOR: How to support augmentation is for further study.]
. Range restrictions.
. A set of symbolic names for special values. Example:
"IPV4ADDR_LOOPBACK".
Note that not all attributes will exist at all times in all 4.5.1. <typeRef> Element for Aliasing Existing Data Types
implementations. While the capabilities will frequently indicate
this non-existence, CEs may attempt to reference non-existent or
non-permitted attributes anyway. The FORCES protocol mechanisms
should include appropriate error indicators for this case.
4.1.1. Arrays The <typeRef> element refers to an existing data type by its name.
The referred data type must be defined either in the same library
document, or in one of the included library documents. If the
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
compound type, the new type will also be a compound. Some usage
examples:
Compound data types can be defined as arrays of compound or atomic <dataTypeDef>
data types. Arrays can only be subscripted by integers, and will <name>short</name>
be presumed to start with subscript 0. The mechanism defined above <synopsis>Alias to int16</synopsis>
for non-supported attributes can also apply to attempts to <typeRef>int16</typeRef>
reference non-existent array elements or to set non-permitted </dataTypeDef>
elements. The valid range of the subscripts of the array must be <dataTypeDef>
defined either in the definition of the array or in the LFB class <name><name>ieeemacaddr</name>
which uses the compound type definition. <synopsis>48-bit IEEE MAC address</synopsis>
<typeRef>byte[6]</typeRef>
</dataTypeDef>
4.5.2. <atomic> Element for Deriving New Atomic Types
4.1.2. Structures The <atomic> element allows the definition of a new atomic type
from an existing atomic type, applying range restrictions and/or
providing special enumerated values. Note that the <atomic>
element can only use atomic types as base types, and its result is
always another atomic type.
For example, the following snippet defines a new "dscp" data type:
<dataTypeDef>
<name>dscp</name>
<synopsis>Diffserv code point.</synopsis>
<atomic>
<baseType>uchar</baseType>
<rangeRestriction>
<allowedRange min="0" max="63"/>
</rangeRestriction>
<specialValues>
<specialValue value="0">
<name>DSCP-BE</name>
<synopsis>Best Effort</synopsis>
</specialValue>
...
</specialValues>
</atomic>
</dataTypeDef>
4.5.3. <array> Element to Define Arrays
The <array> element can be used to create a new compound data type
as an array of a compound or an atomic data type. The type of the
array entry can be specified either by referring to an existing
type (using the <typeRef> element) or defining an unnamed type
inside the <array> element using any of the <atomic>, <array>,
<struct>, or <union> elements.
The array can be "fixed-size" or "variable-size", which is
specified by the "type" attribute of the <array> element. The
default is "variable-size". For variable size arrays an optional
"max-length" attribute can specify the maximum allowed length. This
attribute should be used to encode semantic limitations, and not
implementation limitations. The latter should be handled by
capability attributes of LFB classes, and should never be included
in data type definitions. If the "max-length" attribute is not
provided, the array is regarded as of unlimited-size.
For fixed-size arrays a "length" attribute must be provided which
specifies the constant size of the array.
The result of this construct is always a compound type, even if the
array has a fixed size of 1.
Arrays can only be subscripted by integers, and will be presumed to
start with index 0.
The following example shows the definition of a fixed size array
with pre-defined data type as array elements:
<dataTypeDef>
<name>dscp-mapping-table</name>
<synopsys>
A table of 64 DSCP values, used to re-map code space.
</synopsis>
<array type="fixed-size" length="64">
<typeRef>dscp</typeRef>
</array>
</dataTypeDef>
The following example defines a variable size array with an upper
limit on its size:
<dataTypeDef>
<name>mac-alias-table </name>
<synopsys>A table with up to 8 IEEE MAC addresses</synopsis>
<array type="variable-size" max-length="8">
<typeRef>ieeemacaddr</typeRef>
</array>
</dataTypeDef>
The following example shows the definition of an array with local
(unnamed) type definition:
<dataTypeDef>
<name>classification-table</name>
<synopsys>
A table of classification rules and result opcodes.
</synopsis>
<array type="variable-size">
<struct>
<element>
<name>rule</name>
<synopsis>The rule to match</synopsis>
<typeRef>classrule</typeRef>
</element>
<element>
<name>opcode</name>
<synopsis>The result code</synopsis>
<typeRef>opcode</typeRef>
</element>
</struct>
</array>
</dataTypeDef>
In the above example each entry of the array is a <struct> of two
fileds ("rule" and "opcode").
4.5.4. <struct> Element to Define Structures
A structure is comprised of a collection of data elements. Each A structure is comprised of a collection of data elements. Each
data element has a data type (either an atomic type or an existing data element has a data type (either an atomic type or an existing
compound type.) and is assigned a name unique within the scope of compound type) and is assigned a name unique within the scope of
the compound data type being defined. These serve the same the compound data type being defined. These serve the same function
function as "struct" in C, etc. as "struct" in C, etc.
4.1.3. Augmentations The actual type of the field can be defined by referring to an
existing type (using the <typeDef> element), or can be a locally
defined (unnamed) type created by any of the <atomic>, <array>,
<struct>, or <union> elements.
The result of this construct is always regarded a compound type,
even if the <struct> contains only one field.
An example:
<dataTypeDef>
<name>ipv4prefix</name>
<synopsis>
IPv4 prefix defined by an address and a prefix length
</synopsis>
<struct>
<element>
<name>address</name>
<synopsis>Address part</synopsis>
<typeRef>ipv4addr</typeRef>
</element>
<element>
<name>prefixlen</name>
<synopsis>Prefix length part</synopsis>
<atomic>
<baseType>uchar</baseType>
<rangeRestriction>
<allowedRange min="0" max="32"/>
</rangeRestriction>
</atomic>
</element>
</struct>
</dataTypeDef>
4.5.5. <union> Element to Define Union Types
Similar to the union declaration in C, this construct allows the
definition of overlay types. Its format is identical to the
<struct> element.
The result of this construct is always regarded a compound type,
even if the union contains only one element.
4.5.6. Augmentations
Compound types can also be defined as augmentations of existing Compound types can also be defined as augmentations of existing
compound types. If the existing compound type is a structure, compound types. If the existing compound type is a structure,
augmentation may add new elements to the type. They may replace augmentation may add new elements to the type. They may replace
the type of an existing element with an augmentation derived from the type of an existing element with an augmentation derived from
the current type. They may not delete an existing element, nor may the current type. They may not delete an existing element, nor may
they replace the type of an existing element with one that is not they replace the type of an existing element with one that is not
an augmentation of the type that the element has in the basis for an augmentation of the type that the element has in the basis for
the augmentation. If the existing compound type is an array, the augmentation. If the existing compound type is an array,
augmentation means augmentation of the array element type. augmentation means augmentation of the array element type.
skipping to change at page 30, line 30 skipping to change at page 42, line 47
One consequence of this is that augmentations are compatible with One consequence of this is that augmentations are compatible with
the compound type from which they are derived. As such, the compound type from which they are derived. As such,
augmentations are useful in defining attributes for LFB subclasses augmentations are useful in defining attributes for LFB subclasses
with backward compatibility. In addition to adding new attributes with backward compatibility. In addition to adding new attributes
to a class, the data type of an existing attribute may be replaced to a class, the data type of an existing attribute may be replaced
by an augmentation of that attribute, and still meet the by an augmentation of that attribute, and still meet the
compatibility rules for subclasses. compatibility rules for subclasses.
For example, consider a simple base LFB class A that has only one For example, consider a simple base LFB class A that has only one
attribute (attr1) of type X. One way to derive class A1 from A can attribute (attr1) of type X. One way to derive class A1 from A can
be simply adding a second attribute (of any type). Another way to be by simply adding a second attribute (of any type). Another way
derive a class A2 from A can be replacing the original attribute to derive a class A2 from A can be by replacing the original
(attr1) in A of type X with one of type Y, where Y is an attribute (attr1) in A of type X with one of type Y, where Y is an
augmentation of X. Both classes A1 and A2 are backward compatible augmentation of X. Both classes A1 and A2 are backward compatible
with class A. with class A.
4.2. Metadata Definitions [EDITOR: How to support the concept of augmentation in the XML
schema is for further study.]
For each metadata type, the following MUST be specified: 4.6. <metadataDefs> Element for Metadata Definitions
. Metadata symbolic name. Used to refer to the metadata type in
LFB type specifications. Example: META_CLASSID.
. Brief synopsis of the metadata. Example: "Result of
classification (0 means no match)".
. Data type and valid range.
In addition, the following information MAY BE part of the metadata The (optional) <metadataDefs> element in the library document
definition: contains one or more <metadataDef> elements. Each <metadataDef>
. Symbolic definitions for frequently used or special values of element defines a metadata.
the metadata.
4.3. Frame Format Definitions Each <metadataDef> element contains a unique name (NMTOKEN).
This part of the LFB model will list packet types (frame types in Uniqueness is defined over all metadata defined in this library
general) that LFB classes can receive at their inputs and/or emit document and in all directly or indirectly included library
at their outputs. documents. The <metadataDef> element also contains a brief
synopsis, an optional detailed description, and a compulsory type
definition information. Only atomic data types can be used as value
types for metadata.
For each distinct frame type, the following MUST be provided: Two forms of type definitions are allowed. The first form uses the
. Symbolic name of frame type. Example: FRAME_IPV4. <typeRef> element to refer to an existing atomic data type defined
. Brief synopsis of the frame type. Example: "IPv4 packet". in the <dataTypeDefs> element of the same library document or in
one of the included library documents. The usage of the <typeRef>
element is identical to how it is used in the <dataTypeDef>
elements, except here it can only refer to atomic types.
4.4. LFB Class Definitions [EDITOR: The latter restriction is not yet enforced by the XML
schema.]
Each LFB Class definition must provide the following information: The second form is an explicit type definition using the <atomic>
. Symbolic name of LFB class. Example: "LFB_IPV4_LPM" element. This element is used here in the same way as in the
. Short synopsis of LFB class. Example: "IPv4 LPM Lookup LFB" <dataTypeDef> elements.
. Version indicator
. Inheritance indicator (see discussion in Section 4.4.1)
. Inputs (see discussion in Section 4.4.2)
. Outputs (see discussion in Section 4.4.3)
. Attributes (see discussion in Section 4.4.4)
. Operational specification (see discussion in Section 4.4.5)
4.4.1. LFB Inheritance The following example shows both usages:
To support LFB class inheritance, the LFB specification must have a <metadataDefs>
place holder for indicating the base class and its version. It is <metadataDef>
assumed that the derived class is backward compatible with the base <name>NEXTHOPID</name>
class. <synopsis>Refers to a Next Hop entry in NH LFB</synopsis>
<typeRef>int32</typeRef>
</metadataDef>
<metadataDef>
<name>CLASSID</name>
<synopsis>
Result of classification (0 means no match).
4.4.2. LFB Inputs </synopsis>
<atomic>
<baseType>int32</baseType>
<specialValues>
<specialValue value="0">
<name>NOMATCH</name>
<synopsis>
Classification didn’t result in match.
</synopsis>
</specialValue>
</specialValues>
</atomic>
</metadataDef>
</metadataDefs>
An LFB class may have zero, one, or more inputs. We assume that 4.7. <LFBClassDefs> Element for LFB Class Definitions
most LFBs will have exactly one input. Multiple inputs with the
same input type are modeled as one input group. The input group
should count as one entry in the input specification. The number
of inputs (including input groups) is fixed.
Multiple inputs with different input type should be avoided if The (optional) <LFBClassDefs> element can be used to define one or
more LFB classes using <LFBClassDef> elements. Each <LFBClassDef>
element defines an LFB class and includes the following elements:
. <name> provides the symbolic name of the LFB class. Example:
"ipv4lpm"
. <synopsis> provides a short synopsis of the LFB class.
Example: "IPv4 Longest Prefix Match Lookup LFB"
. <version> is the version indicator
. <derivedFrom> is the inheritance indicator
. <inputPorts> lists the input ports and their specifications
. <outputPorts> lists the output ports and their specifications
. <attributes> defines the operational attributes of the LFB
. <capabilities> defines the capability attributes of the LFB
. <description> contains the operational specification of the
LFB
[EDITOR: LFB class names should be unique not only among classes
defined in this document and in all included documents, but also
unique across a large collection of libraries. Obviously some
global control is needed to ensure such uniqueness. This subject
requires further study.]
Here is a skeleton of an example LFB class definition:
<LFBClassDefs>
<LFBClassDef>
<name>ipv4lpm</name>
<synopsis>IPv4 Longest Prefix Match Lookup LFB</synopsis>
<version>1.0</version>
<derivedFrom>baseclass</derivedFrom>
<inputPorts>
...
</inputPorts>
<outputPorts>
...
</outputPorts>
<attributes>
...
</attributes>
<capabilities>
...
</capabilities>
<description>
This LFB represents the IPv4 longest prefix match lookup
operation.
The modeled behavior is as follows:
Blah-blah-blah.
</description>
</LFBClassDef>
...
</LFBClassDefs>
Except the <name>, <synopsis>, and <version> elements, all other
elements are optional in <LFBClassDef>, though when they are
present, they must occur in the above order.
4.7.1. <derivedFrom> Element to Express LFB Inheritance
The optional <derivedFrom> element can be used to indicate that
this class is a derivative of some other class. The content of this
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 one of the included library documents.
[EDITOR: The <derivedFrom> element will likely need to specify the
version of the ancestor, which is not included in the schema yet.
The process and rules of class derivation are still being studied.]
It is assumed that the derived class is backwards compatible with
the base class.
4.7.2. <inputPorts> Element to Define LFB Inputs
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
no input ports, the <inputPorts> elements must be omitted. The
<inputPorts> element can contain one or more <inputPort> elements,
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
modeled as one input group. Input groups are defined the same way
as input ports by the <inputPort> element, differentiated only by
an optional "group" attribute.
Multiple inputs with different input types should be avoided if
possible (see discussion in Section 3.2.1). Some special LFBs will possible (see discussion in Section 3.2.1). Some special LFBs will
have no inputs at all. For example, a packet generator LFB does have no inputs at all. For example, a packet generator LFB does not
not need an input. need an input.
The LFB class definition MUST specify whether or not the number of Single input ports and input port groups are both defined by the
inputs of the LFB is fixed, and the exact number if fixed. For each <inputPort> element, they are differentiated by only an optional
LFB input (group), the following MUST be specified: "group" attribute.
. Symbolic name of input. Example: "PKT_IN". Note that this The <inputPort> element contains the following elements:
symbolic name must be unique only within the scope of the LFB . <name> provides the symbolic name of the input. Example: "in".
class. Note that this symbolic name must be unique only within the
. Brief synopsis of the input. Example: "Normal packet input". scope of the LFB class.
. Indication of whether this input is an input group (i.e., if . <synopsis> contains a brief description of the input. Example:
it is allowed to be instantiated). "Normal packet input".
. List of allowed frame formats. Example: "{FRAME_IPV4, . <expectation> lists all allowed frame formats. Example: {"ipv4"
FRAME_IPV6}". Note that this list should refer to symbols and "ipv6"}. Note that this list should refer to names
specified in the frame definition of the LFB model (see specified in the <frameDefs> element of the same library
Section 4.3). document or in any included library documents. The <expectation>
. List of required metadata. Example: {META_CLASSID, META_IFID}. element can also provide a list of required metadata. Example:
This list should refer to symbols specified in the metadata {"classid", "vifid"}. This list should refer to names of
definition of the LFB model (see Section 4.2). For each metadata defined in the <metadataDefs> element in the same
metadata it should be specified whether the metadata is library document or in any included library documents. For each
required or optional. For each optional metadata a default metadata it must be specified whether the metadata is required
value MAY BE specified, which is used by the LFB if the or optional. For each optional metadata a default value must be
metadata is not provided at the input. specified, which is used by the LFB if the metadata is not
provided with a packet.
4.4.3. LFB Outputs In addition, the optional "group" attribute of the <inputPort>
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 "yes"
value (the default value is "no").
An LFB class may have zero, one, or more outputs. If there are An example <inputPorts> element, defining two input ports, the
multiple outputs with the same output type, we model them as output second one being an input port group:
<inputPorts>
<inputPort>
<name>in</name>
<synopsis>Normal input</synopsis>
<expectation>
<frameExpected>
<ref>ipv4</ref>
<ref>ipv6</ref>
</frameExpected>
<metadataExpected>
<ref>classid</ref>
<ref>vifid</ref>
<ref dependency="optional" defaultValue="0">vrfid</ref>
</metadataExpected>
</expectation>
</inputPort>
<inputPort group="yes">
... another input port ...
</inputPort>
</inputPorts>
For each <inputPort>, the frame type expectations are defined by
the <frameExpected> element using one or more <ref> elements (see
example above). When multiple frame types are listed, it means that
"one of these" frame types are expected. A packet of any other
frame type is regarded as incompatible with this input port of the
LFB class. The above example list two frames as expected frame
types: "ipv4" and "ipv6".
Metadata expectations are specified by the <metadataExpected>
element. In its simplest form this element can contain a list of
<ref> elements, each referring to a metadata. When multiple
instances of metadata are listed by <ref> elements, it means that
"all of these" metadata must be received with each packet (except
metadata that are marked as "optional" by the "dependency"
attribute of the corresponding <ref> element). For a metadata that
is specified "optional", a default value must be provided using the
"defaultValue" attribute. The above example lists three metadata as
expected metadata, two of which are mandatory ("classid" and
"vifid"), and one being optional ("vrfid").
[EDITOR: How to express default values for byte[N] atomic types is
yet to be defined.]
The schema also allows for more complex definitions of metadata
expectations. For example, using the <one-of> element, a list of
metadata can be specified to express that at least one of the
specified metadata must be present with any packet. For example:
<metadataExpected>
<one-of>
<ref>prefixmask</ref>
<ref>prefixlen</ref>
</one-of>
</metadataExpected>
The above example specifies that either the "prefixmask" or the
"prefixlen" metadata must be provided with any packet.
The two forms can also be combined, as it is shown in the following
example:
<metadataExpected>
<ref>classid</ref>
<ref>vifid</ref>
<ref dependency="optional" defaultValue="0">vrfid</ref>
<one-of>
<ref>prefixmask</ref>
<ref>prefixlen</ref>
</one-of>
</metadataExpected>
Although the schema is constructed to allow even more complex
definition of metadata expectations, we do not discuss these here.
4.7.3. <outputPorts> Element to Define LFB Outputs
The optional <outputPorts> element is used to define output ports.
An LFB class may have zero, one, or more outputs. If the LFB class
has no output ports, the <outputPorts> element must be omitted. The
<outputPorts> element can contain one or more <outputPort>
elements, 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 special LFBs may have no outputs at all (e.g., group. Some special LFBs may have no outputs at all (e.g.,
Dropper). Dropper).
The number of outputs may be fixed for some LFB types and may be Single output ports and output port groups are both defined by the
configurable for others. The LFB Class definition MUST specify the <outputPort> element, they are differentiated by only an optional
number of outputs (or output types) of the LFB. The output group "group" attribute.
should count as one entry in the output specification, but the
entry should indicate that instantiation of the output is
allowed.
For each LFB output (group) the following MUST be specified: The <outputPort> element contains the following elements:
. Symbolic name of the output. Example: "UNPROC". In case of an . <name> provides the symbolic name of the output. Example: "out".
output group, the symbolic name is the prefix used to Note that the symbolic name must be unique only within the scope
construct unique symbols for each output instance. Example: of the LFB class.
"PKTOUT". Note that the symbolic name must be unique only . <synopsis> contains a brief description of the output port.
within the scope of the LFB class. Example: "Normal packet output".
. Brief synopsis of the output. Example: "Normal packet output". . <product> lists the allowed frame formats. Example: {"ipv4",
. Indication of whether this output is an output group (i.e., if "ipv6"}. Note that this list should refer to symbols specified
it is allowed to be instantiated). in the <frameDefs> element in the same library document or in
. List of allowed frame formats. Example: "{FRAME_IPV4, any included library documents. The <product> element may also
FRAME_IPV6}". Note that this list should refer to symbols contain the list of emitted (generated) metadata. Example:
specified in the frame definition of the LFB model (see {"classid", "color"}. This list should refer to names of
Section 4.3). metadata specified in the <metadataDefs> element in the same
. List of emitted (generated) metadata. Example: {META_CLASSID, library document or in any included library documents. For each
META_IFID}. This list should refer to symbols specified in the generated metadata, it should be specified whether the metadata
metadata definition of the LFB model (see Section 4.2). For is always generated or generated only in certain conditions.
each generated metadata, it should be specified whether the This information is important when assessing compatibility
metadata is always generated or generated only in certain between LFBs.
conditions. This information is important when assessing
compatibility between LFBs.
4.4.4. LFB Attributes In addition, the optional "group" attribute of the <outputPort>
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 "yes"
value (the default value is "no").
The operational state of the LFB is modeled by the variables of the The following example specifies two output ports, the second being
LFB, collectively called attributes. Note that the attributes here an output port group:
refer to the operational parameters of the LFBs that must be
visible to the CEs. The other variables that are internal to LFB
implementation are not included here in the LFB attributes and are
not modeled here.
Attribute types will include the following three categories: <outputPorts>
. Capability attributes (see Section 9.4 for more on LFB <outputPort>
capabilities). Examples: <name>out</name>
* Supported optional features of the LFB class; <synopsis>Normal output</synopsis>
* Maximum number of configurable outputs for an output group; <product>
* Metadata pass-through limitations of the LFB; <frameProduced>
* Maximum size of configurable attribute tables; <ref>ipv4</ref>
* Supported access modes of certain attributes (see below). <ref>ipv4bis</ref>
. Operational attributes, some of them are configurable by the </frameProduced>
CE, while others might be internally maintained state which <metadataProduced>
are read-only for the CE and necessary for the CE to operate <ref>nhid</ref>
properly. Examples: <ref>nhtabid</ref>
* Configurable flags and switches selecting between </metadataProduced>
operational modes of the LFB; </product>
* ARP tables; </outputPort>
* Number of outputs in an output group; <outputPort group="yes">
* Metadata CONSUME vs. PROPAGATE mode selector. <name>exc</name>
. Statistical attributes (collected by the FE and provided for <synopsis>Exception output port group</synopsis>
reading to the CE). Examples: <product>
* Packet and byte counters; <frameProduced>
* Other event counters. <ref>ipv4</ref>
<ref>ipv4bis</ref>
</frameProduced>
<metadataProduced>
<ref availability="conditional">errorid</ref>
</metadataProduced>
</product>
</outputPort>
</outputPorts>
Some of the attributes will be generically available in all LFBs What types of frames and metadata the port produces are defined
while others will be specific to the LFB class. Examples of inside the <product> element in each <outputPort>. Within the
generic LFB attributes are: <product> element, the list of frame types the port produces is
. LFB class inheritance information (see Section 4.4.1) listed in the <frameProduced> element. When more than one frame is
. Number and type of inputs (in case the LFB is self- listed, it means that "one of" these frames will be produced.
descriptive)
. Number and type of outputs (in case the LFB is self- The list of metadata that is produced with each packet is listed in
descriptive) the optional <metadataProduced> element of the <product>. In its
. Number of current outputs for each output group simplest form, this element can contain a list of <ref> elements,
each referring to a metadata type. The meaning of such a list is
that "all of" these metadata are provided with each packet, except
those that are listed with the optional "availability" attribute
set to "conditional." Similar to the <metadataExpected> element of
the <inputPort>, the <metadataProduced> element supports more
complex forms, which we do not discuss here further.
4.7.4. <attributes> Element to Define LFB Operational Attributes
Operational parameters of the LFBs that must be visible to the CEs
are conceptualized in the model as the LFB attributes. These
include, for example, flags, single parameter arguments, complex
arguments, and tables. Note that the attributes here refer to only
those operational parameters of the LFBs that must be visible to
the CEs. Other variables that are internal to LFB implementation
are not regarded as LFB attributes and hence are not covered.
Some examples for LFB attributes are:
. Configurable flags and switches selecting between operational
modes of the LFB
. Number of inputs or ouputs in a port group
. Metadata CONSUME vs. PROPAGATE mode selectors
. Various configurable lookup tables, including interface
tables, prefix tables, classification tables, DSCP mapping
tables, MAC address tables, etc.
. Packet and byte counters
. Various event counters
. Number of current inputs or outputs for each input or output
group
. Metadata CONSUME/PROPAGATE mode selector . Metadata CONSUME/PROPAGATE mode selector
There may be various access permission restrictions on what the CE There may be various access permission restrictions on what the CE
can do with an LFB attribute. The following categories may be can do with an LFB attribute. The following categories may be
supported: supported:
. No-access attributes. This is useful when multiple access . No-access attributes. This is useful when multiple access
modes maybe defined for a given attribute to allow some modes maybe defined for a given attribute to allow some
flexibility for different implementations. flexibility for different implementations.
. Read-only attributes. . Read-only attributes.
. Read-write attributes. . Read-write attributes.
. Write-only attributes. This could be any configurable data . Write-only attributes. This could be any configurable data
for which read capability is not provided to the CEs. (??? Do for which read capability is not provided to the CEs. (e.g.,
we have good example???) the security key information)
. Read-reset attributes. The CE can read and reset this . Read-reset attributes. The CE can read and reset this
resource, but cannot set it to an arbitrary value. Example: resource, but cannot set it to an arbitrary value. Example:
Counters. Counters.
. Firing-only attributes. A write attempt to this resource will . Firing-only attributes. 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. (??? Example???) written is ignored.
The LFB class may define more than one possible access mode for a The LFB class may define more than one possible access mode for a
given attribute (for example, write-only and read-write), in which given attribute (for example, "write-only" and "read-write"), in
case it is left to the actual implementation to pick one of the which case it is left to the actual implementation to pick one of
modes. In such cases a corresponding capability parameter must the modes. In such cases a corresponding capability attribute must
inform the CE of which mode the actual LFB instance supports. inform the CE about the access mode the actual LFB instance
The attributes of the LFB class must be defined as a list. For each supports (see next subsection on capability attributes).
attribute the following information MUST be provided:
. Reference to the data type (e.g., specified in the generic
data type block of the LFB model or in an LFB specific data
type block).
. Access permission(s).
. Additional range restrictions (i.e., beyond what is specified
by the data type definition).
. Default value. Applied when the LFB is initialized or reset.
The actual structuring of LFB attributes requires further study. The attributes of the LFB class are listed in the <attributes>
element. Each attribute is defined by an <attribute> element. An
<attribute> element contains the following elements:
. <name> defines the name of the attribute. This name must be
unique among the attributes of the LFB class. Example:
"version".
. <synopsis> should provide a brief description of the purpose
of the attribute.
. The data type of the attribute can be defined either via a
reference to a predefined data type or providing a local
definition of the type. The former is provided by using the
<typeRef> element, which must refer to the unique name of an
existing data type defined in the <dataTypeDefs> element in
the same library document or in any of the included library
documents. When the data type is defined locally (unnamed
type), one of the following elements can be used: <atomic>,
<array>, <struct>, and <union>. Their usage is identical to
how they are used inside <dataTypeDef> elements (see Section
4.5).
. The optional <defaultValue> element can specify a default
value for the attribute, which is applied when the LFB is
initialized or reset. [EDITOR: A convention to define default
values for compound data types and byte[N] atomic types is yet
to be defined.]
4.4.5. LFB Operational Specification In addition to the above elements, the <attribute> element includes
an optional "access" attribute, which can take any of the following
values or even a list of these values: "read-only", "read-write",
"write-only", "read-reset", and "trigger-only". The default access
mode is "read-write".
This section of the model should verbally describe what the LFB The following example defines two attributes for an LFB:
does. This will most likely be embedded in an unstructured text
field in the model.
5. LFB Topology Model (To be written) <attributes>
<attribute access="read-only">
<name>foo</name>
<synopsis>number of things</synopsis>
<typeRef>uint32</typeRef>
</attribute>
<attribute access="read-write write-only">
<name>bar</name>
<synopsis>number of this other thing</synopsis>
<atomic>
<baseType>uint32</baseType>
<rangeRestriction>
<allowedRange min="10" max="2000"/>
</rangeRestriction>
</atomic>
<defaultValue>10</defaultValue>
</attribute>
</attributes>
(Editor's note: This is a place holder to describe the details on The first attribute ("foo") is a read-only 32-bit unsigned integer,
how to model LFB topology.) defined by referring to the built-in "uint32" atomic type. The
6. FE Level Attributes (To be written) second attribute ("bar") is also an integer, but uses the <atomic>
element to provide additional range restrictions. This attribute
has two possible access modes, "read-write" or "write-only". A
default value of 10 is provided.
(Editor's note: This is a place holder to describe the FE level Note that not all attributes are likely to exist at all times in a
attributes including FE capabilities, for examples: particular implementation. While the capabilities will frequently
. How this FE is connected with other FEs (if known by the FE)? indicate this non-existence, CEs may attempt to reference non-
. What LFB classes can the FE instantiate? existent or non-permitted attributes anyway. The FORCES protocol
. How many instances of the same LFB class can be created? mechanisms should include appropriate error indicators for this
. What are the topological limitations? For example: case.
o How many instances of the same class or any class can be
created on any given branch of the graph?
o Ordering restrictions on LFBs (e.g., any instance of LFB
class A must be always downstream of any instance of LFB
class B).
)
7. LFB Class Library The mechanism defined above for non-supported attributes can also
apply to attempts to reference non-existent array elements or to
set read-only elements.
A set of LFB classes are identified here in the LFB class library 4.7.5. <capabilities> Element to Define LFB Capability Attributes
as necessary to build common FE functions.
The LFB class specification will provide some flexibility for the
FE implementation regarding how the LFB class is implemented. For
example the class may define some features optional, in which case
the actual implementation may or may not provide the given feature.
In these cases the CE must be able to query the LFB instance about
the availability of the feature. In addition, the instance may have
some limitations that are not inherent from the class definition,
but rather the result of some implementation limitations. For
example, an array attribute may be defined in the class definition
as "unlimited" size, but the physical implementation may impose a
hard limit on the size of the array.
Such capability related information is expressed by the capability
attributes of the LFB class. The capability attributes are always
read-only attributes, and they are listed in a separate
<capabilities> element in the <LFBClassDef>. The <capabilities>
element contains one or more <capability> elements, each defining
one capability attribute. The format of the <capability> element is
almost the same as the <attribute> element, it differs in two
aspects: it lacks the access mode attribute (because it is always
read-only), and it lacks the <defaultValue> element (because
default value is not applicable to read-only attributes).
Some examples of capability attributes:
. The version of the LFB class that this LFB instance complies
with;
. Supported optional features of the LFB class;
. Maximum number of configurable outputs for an output group;
. Metadata pass-through limitations of the LFB;
. Maximum size of configurable attribute tables;
. Additional range restriction on operational attributes;
. Supported access modes of certain attributes (if the access
mode of an operational attribute is specified as a list of two
or mode modes).
The following example lists two capability attributes:
<capabilities>
<capability>
<name>version</name>
<synopsis>
LFB class version this instance is compliant with.
</synopsis>
<typeRef>version</typeRef>
</capability>
<capability>
<name>limitBar</name>
<synopsis>
Maximum value of the "bar" attribute.
</synopsis>
<typeRef>uint16</typeRef>
</capability>
</capabilities>
4.7.6. <description> Element for LFB Operational Specification
The <description> element of the <LFBClass> provides unstructured
text (in XML sense) to verbally describe what the LFB does.
4.8. XML Schema for LFB Class Library Documents
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://ietf.org/forces/1.0/lfbmodel"
xmlns:lfb="http://ietf.org/forces/1.0/lfbmodel"
targetNamespace="http://ietf.org/forces/1.0/lfbmodel"
attributeFormDefault="unqualified"
elementFormDefault="qualified">
<xsd:annotation>
<xsd:documentation xml:lang="en">
Schema for Defining LFB Classes and associated types (frames,
data types for LFB attributes, and metadata).
</xsd:documentation>
</xsd:annotation>
<xsd:element name="description" type="xsd:string"/>
<xsd:element name="synopsis" type="xsd:string"/>
<!-- Document root element: LFBLibrary -->
<xsd:element name="LFBLibrary">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="description" minOccurs="0"/>
<xsd:element name="load" type="loadType" minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="frameDefs" type="frameDefsType"
minOccurs="0"/>
<xsd:element name="dataTypeDefs" type="dataTypeDefsType"
minOccurs="0"/>
<xsd:element name="metadataDefs" type="metadataDefsType"
minOccurs="0"/>
<xsd:element name="LFBClassDefs" type="LFBClassDefsType"
minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="provides" type="xsd:Name" use="required"/>
</xsd:complexType>
<!-- Uniqueness constraints -->
<xsd:key name="frame">
<xsd:selector xpath="lfb:frameDefs/lfb:frameDef"/>
<xsd:field xpath="lfb:name"/>
</xsd:key>
<xsd:key name="dataType">
<xsd:selector xpath="lfb:dataTypeDefs/lfb:dataTypeDef"/>
<xsd:field xpath="lfb:name"/>
</xsd:key>
<xsd:key name="metadataDef">
<xsd:selector xpath="lfb:metadataDefs/lfb:metadataDef"/>
<xsd:field xpath="lfb:name"/>
</xsd:key>
<xsd:key name="LFBClassDef">
<xsd:selector xpath="lfb:LFBClassDefs/lfb:LFBClassDef"/>
<xsd:field xpath="lfb:name"/>
</xsd:key>
</xsd:element>
<xsd:complexType name="loadType">
<xsd:attribute name="library" type="xsd:Name" use="required"/>
<xsd:attribute name="location" type="xsd:anyURI" use="optional"/>
</xsd:complexType>
<xsd:complexType name="frameDefsType">
<xsd:sequence>
<xsd:element name="frameDef" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element ref="description" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="dataTypeDefsType">
<xsd:sequence>
<xsd:element name="dataTypeDef" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element ref="description" minOccurs="0"/>
<xsd:group ref="typeDeclarationGroup"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<!--
Predefined (built-in) atomic data-types are:
char, uchar, int16, uint16, int32, uint32, int64, uint64,
string[N], byte[N],
float16, float32, float64
-->
<xsd:group name="typeDeclarationGroup">
<xsd:choice>
<xsd:element name="typeRef" type="typeRefNMTOKEN"/>
<xsd:element name="atomic" type="atomicType"/>
<xsd:element name="array" type="arrayType"/>
<xsd:element name="struct" type="structType"/>
<xsd:element name="union" type="structType"/>
</xsd:choice>
</xsd:group>
<xsd:simpleType name="typeRefNMTOKEN">
<xsd:restriction base="xsd:token">
<xsd:pattern value="\c+"/>
<xsd:pattern value="string\[\d+\]"/>
<xsd:pattern value="byte\[\d+\]"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="atomicType">
<xsd:sequence>
<xsd:element name="baseType" type="typeRefNMTOKEN"/>
<xsd:element name="rangeRestriction"
type="rangeRestrictionType minOccurs="0"/>
<xsd:element name="specialValues" type="specialValuesType"
minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="rangeRestrictionType">
<xsd:sequence>
<xsd:element name="allowedRange" maxOccurs="unbounded">
<xsd:complexType>
<xsd:attribute name="min" type="xsd:integer"
use="required"/>
<xsd:attribute name="max" type="xsd:integer"
use="required"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="specialValuesType">
<xsd:sequence>
<xsd:element name="specialValue" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
</xsd:sequence>
<xsd:attribute name="value" type="xsd:token"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="arrayType">
<xsd:sequence>
<xsd:group ref="typeDeclarationGroup"/>
</xsd:sequence>
<xsd:attribute name="type" use="optional"
default="variable-size">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="fixed-size"/>
<xsd:enumeration value="variable-size"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="length" type="xsd:integer" use="optional"/>
<xsd:attribute name="maxLength" type="xsd:integer"
use="optional"/>
</xsd:complexType>
<xsd:complexType name="structType">
<xsd:sequence>
<xsd:element name="element" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:group ref="typeDeclarationGroup"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="metadataDefsType">
<xsd:sequence>
<xsd:element name="metadataDef" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element ref="description" minOccurs="0"/>
<xsd:choice>
<xsd:element name="typeRef" type="typeRefNMTOKEN"/>
<xsd:element name="atomic" type="atomicType"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="LFBClassDefsType">
<xsd:sequence>
<xsd:element name="LFBClassDef" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element name="version" type="versionType"/>
<xsd:element name="derivedFrom" type="xsd:NMTOKEN"
minOccurs="0"/>
<xsd:element name="inputPorts" type="inputPortsType"
minOccurs="0"/>
<xsd:element name="outputPorts" type="outputPortsType"
minOccurs="0"/>
<xsd:element name="attributes" type="LFBAttributesType"
minOccurs="0"/>
<xsd:element name="capabilities"
type="LFBCapabilitiesType"
minOccurs="0"/>
<xsd:element ref="description" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<!-- Key constraint to ensure unique attribute names within
a class:
-->
<xsd:key name="attributes">
<xsd:selector xpath="lfb:attributes/lfb:attribute"/>
<xsd:field xpath="lfb:name"/>
</xsd:key>
<xsd:key name="capabilities">
<xsd:selector xpath="lfb:capabilities/lfb:capability"/>
<xsd:field xpath="lfb:name"/>
</xsd:key>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:simpleType name="versionType">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:pattern value="[1-9][0-9]*\.([1-9][0-9]*|0)"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="inputPortsType">
<xsd:sequence>
<xsd:element name="inputPort" type="inputPortType"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="inputPortType">
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element name="expectation" type="portExpectationType"/>
<xsd:element ref="description" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="group" type="booleanType" use="optional"
default="no"/>
</xsd:complexType>
<xsd:complexType name="portExpectationType">
<xsd:sequence>
<xsd:element name="frameExpected" minOccurs="0">
<xsd:complexType>
<xsd:sequence>
<!-- ref must refer to a name of a defined frame type -->
<xsd:element name="ref" type="xsd:string"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="metadataExpected" minOccurs="0">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="metadataInputRefType"/>
<xsd:element name="one-of"
type="metadataInputChoiceType"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="metadataInputChoiceType">
<xsd:choice minOccurs="2" maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="xsd:NMTOKEN"/>
<xsd:element name="one-of" type="metadataInputChoiceType"/>
<xsd:element name="metadataSet" type="metadataInputSetType"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="metadataInputSetType">
<xsd:choice minOccurs="2" maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="metadataInputRefType"/>
<xsd:element name="one-of" type="metadataInputChoiceType"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="metadataInputRefType">
<xsd:simpleContent>
<xsd:extension base="xsd:NMTOKEN">
<xsd:attribute name="dependency" use="optional"
default="required">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="required"/>
<xsd:enumeration value="optional"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="defaultValue" type="xsd:token"
use="optional"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<xsd:complexType name="outputPortsType">
<xsd:sequence>
<xsd:element name="outputPort" type="outputPortType"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="outputPortType">
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element name="product" type="portProductType"/>
<xsd:element ref="description" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="group" type="booleanType" use="optional"
default="no"/>
</xsd:complexType>
<xsd:complexType name="portProductType">
<xsd:sequence>
<xsd:element name="frameProduced">
<xsd:complexType>
<xsd:sequence>
<!-- ref must refer to a name of a defined frame type -->
<xsd:element name="ref" type="xsd:NMTOKEN"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="metadataProduced" minOccurs="0">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="metadataOutputRefType"/>
<xsd:element name="one-of"
type="metadataOutputChoiceType"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="metadataOutputChoiceType">
<xsd:choice minOccurs="2" maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="xsd:NMTOKEN"/>
<xsd:element name="one-of" type="metadataOutputChoiceType"/>
<xsd:element name="metadataSet" type="metadataOutputSetType"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="metadataOutputSetType">
<xsd:choice minOccurs="2" maxOccurs="unbounded">
<!-- ref must refer to a name of a defined metadata -->
<xsd:element name="ref" type="metadataOutputRefType"/>
<xsd:element name="one-of" type="metadataOutputChoiceType"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="metadataOutputRefType">
<xsd:simpleContent>
<xsd:extension base="xsd:NMTOKEN">
<xsd:attribute name="availability" use="optional"
default="unconditional">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="unconditional"/>
<xsd:enumeration value="conditional"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<xsd:complexType name="LFBAttributesType">
<xsd:sequence>
<xsd:element name="attribute" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element ref="description" minOccurs="0"/>
<xsd:group ref="typeDeclarationGroup"/>
<xsd:element name="defaultValue" type="xsd:token"
minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="access" use="optional"
default="read-write">
<xsd:simpleType>
<xsd:list itemType="accessModeType"/>
</xsd:simpleType>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:simpleType name="accessModeType">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="read-only"/>
<xsd:enumeration value="read-write"/>
<xsd:enumeration value="write-only"/>
<xsd:enumeration value="read-reset"/>
<xsd:enumeration value="trigger-only"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="LFBCapabilitiesType">
<xsd:sequence>
<xsd:element name="capability" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:NMTOKEN"/>
<xsd:element ref="synopsis"/>
<xsd:element ref="description" minOccurs="0"/>
<xsd:group ref="typeDeclarationGroup"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:simpleType name="booleanType">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="yes"/>
<xsd:enumeration value="no"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
5. FE Attributes and Capabilities
A ForCES forwarding element handles traffic on behalf of a ForCES
control element. While the standards will describe the protocol
and mechanisms for this control, different implementations and
different instances will have different capabilities. The CE needs
to be able to determine what each instance it is responsible for is
actually capable of doing. As stated previously, this is an
approximation. The CE is expected to be prepared to cope with
errors in requests and variations in detail not captured by the
capabilities information about an FE.
In addition to its capabilities, an FE will have some information
(attributes) that can be used in understanding and controlling the
forwarding operations. Some of the attributes will be read only,
while others will also be writeable.
The ForCES protocol will define the actual mechanism for getting
and setting attribute information. This model defines the starting
set of information that will be available. This definition
includes the semantics and the structuring of the information. It
also provides for extensions to this information.
In order to crisply define the attribute information and structure,
this document describes the attributes as information in an
abstract XML document. Conceptually, each FE contains such a
document. The document structure is defined by the XML Schema
contained in this model. Operationally, the ForCES protocol refers
to information contained in that document in order to read or write
FE attributes and capabilities. This document is an abstract
representation of the information. There is no requirement that
such a document actually exist in memory. Unless the ForCES
protocol calls for transfer of the information in XML, the
information is not required to ever be represented in the FE in
XML. The XML schema serves only to identify the elements and
structure of the information.
The subsections in this part of the document provide the details on
this aspect of the FE model. 5.1 gives the XML schema for the
abstract FE attribute document. 5.2 elaborates on each of the
defined attributes of the FE, following the hierarchy of the
schema. 5.3 provides an example XML FE attribute document to
clarify the meaning of 5.1 and 5.2.
5.1. XML Schema for FE Attribute Documents
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:annotation>
<xsd:documentation xml:lang="en">
Schema for the Abstract FE Attributes and Capabilities Document
</xsd:documentation>
</xsd:annotation>
<xsd:element name="FEDocument">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="FECapabilities" type="FECapabilitiesType"
minOccurs="0" maxOccurs="1"/>
<xsd:element name="FEAttributes" type="FEAttributesType"
minOccurs="0" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="FECapabilitiesType">
<xsd:sequence>
<xsd:element name="ModifiableLFBTopology" type="xsd:boolean"
minOccurs="0" maxOccurs="1"/>
<xsd:element name="SupportedLFBs" minOccurs="0" maxOccurs="1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="SupportedLFB" type="SupportedLFBType"
minOccurs="1" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="SupportedAttributes"
type="SupportedAttributesType"
minOccurs="0" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="SupportedLFBType">
<xsd:sequence>
<!-- the name of a supported LFB -->
<xsd:element name="LFBName" type="xsd:NMTOKEN"/>
<!-- how many of this LFB class can exist -->
<xsd:element name="LFBOccurrenceLimit"
type="xsd:nonNegativeInteger" minOccurs="0" maxOccurs="1"/>
<!-- For each port group, how many ports can exist -->
<xsd:element name="PortGroupLimits" minOccurs="0" maxOccurs="1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="PortGroupLimit" minOccurs="0"
maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="PortGroupName" type="xsd:NMTOKEN"/>
<xsd:element name="MinPortCount"
type="xsd:nonNegativeInteger"
minOccurs="0" maxOccurs="1"/>
<xsd:element name="MaxPortCount"
type="xsd:nonNegativeInteger"
minOccurs="0" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!-- for the named LFB Class, the LFB Classes it may follow -->
<xsd:element name="CanOccurAfters" minOccurs="0" maxOccurs="1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="CanOccurAfter"
type="LFBAdjacencyLimitType"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!-- for the named LFB Class, which LFB Classes may follow -->
<xsd:element name="CanOccurBefores" minOccurs="0" maxOccurs="1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="CanOccurBefore"
type="LFBAdjacencyLimitType"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!-- information defined by the Class Definition -->
<xsd:element name="LFBClassCapabilities" type="xsd:anyType"
minOccurs="0" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="LFBAdjacencyLimitType">
<xsd:sequence>
<xsd:element name="NeighborLFB" type="xsd:NMTOKEN"/>
<xsd:element name="viaPort" type="xsd:NMTOKEN"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="SupportedAttributesType">
<xsd:sequence>
<xsd:element name="SupportedAttribute"
minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="AttributeName" type="xsd:NMTOKEN"/>
<xsd:element name="AccessModes" type="xsd:NMTOKEN"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="FEAttributesType">
<xsd:sequence>
<xsd:element name="Vendor" type="xsd:string" minOccurs="0"/>
<xsd:element name="Model" type="xsd:string" minOccurs="0"/>
<xsd:element name="FEStatus" type="FEStateType" minOccurs="0"/>
<xsd:element name="LFBInstances" minOccurs="0" maxOccurs="1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="LFBInstance" minOccurs="0"
maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="LFBClassName" type="xsd:NMTOKEN"/>">
<xsd:element name="LFBInstanceID" type="xsd:NMTOKEN"/>">
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="LFBTopology" type="LFBTopologyType"
minOccurs="0" maxOccurs="1"/>
<xsd:element name="FEConfiguredNeighbors" minOccurs="0"
maxOccurs="1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="FEConfiguredNeighbor"
type="FEConfiguredNeighborType"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="LFBTopologyType">
<xsd:sequence>
<xsd:element name="LFBLink" minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="FromLFBID" type="xsd:NMTOKEN"/>
<xsd:element name="FromPortGroup" type="xsd:NMTOKEN"/>
<xsd:element name="FromPortIndex"
type="xsd:nonNegativeInteger"/>
<xsd:element name="ToLFBID" type="xsd:NMTOKEN"/>
<xsd:element name="ToPortGroup" type="xsd:NMTOKEN"/>
<xsd:element name="ToPortIndex"
type="xsd:nonNegativeInteger"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="FEConfiguredNeighborType">
<xsd:sequence>
<xsd:element name="NeighborID" type="xsd:anyType"/>
<xsd:element name="NeighborInterface" type="xsd:anyType"/>
<xsd:element name="NeighborNetworkAddress" type="xsd:anyType"
minOccurs="0" maxOccurs="1"/>
<xsd:element name="NeighborMACAddress" type="xsd:anyType"
minOccurs="0" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
<!-- The values for the simple state attribute -->
<!-- These should probably be directly encodable in the -->
<!-- protocol so they may end up numeric instead of strings -->
<xsd:simpleType name="FEStateType">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="AdminDisable"/>
<xsd:enumeration value="OperDisable"/>
<xsd:enumeration value="OperEnable"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
5.2. FEDocument
An instance of this document captures the capabilities and FE level
attribute / state information about a given FE. Currently, two
elements are allowed in the FEDocument, FECapabilities and
FEAttributes.
At the moment, all capability and attribute information in this
abstract document is defined as optional. We may wish to mandate
support for some capability and/or attribute information.
If a protocol using binary encoding of this information is adopted
by the ForCES working group, then each relevant element defined in
the schema will have a "ProtocolEncoding" attribute added, with a
"Fixed" value providing the value that is used in the protocol for
that element, so that the XML and the on the wire protocol can be
correlated.
5.2.1. FECapabilities
This element, which if it occurs must occur only once, contains all
the capability related information about the FE. Capability
information is always considered to be read-only.
The currently defined elements allowed within the FECapabilities
element are ModifiableLFBTopology, LFBsSupported,
WriteableAttributes and ReadableAttributes.
5.2.1.1. ModifiableLFBTopology
This element has a boolean value. This element indicates whether
the LFB topology of the FE may be changed by the CE. If the
element is absent, the default value is assumed to be true, and the
CE presumes the LFB topology may be changed. If the value is
present and set to false, the LFB topology of the FE is fixed. In
that case, the LFBs supported clause may be omitted, and the list
of supported LFBs is inferred by the CE from the LFB topology
information. If the list of supported LFBs is provided when
ModifiableLFBTopology is false, the CanOccurBefore and
CanOccurAfter information should be omitted.
5.2.1.2. SupportedLFBs and SupportedLFB
One capability that the FE should include is the list of supported
LFB classes. The SupportedLFBs element, which occurs at most once,
serves as a wrapper for the list of LFB classes supported. Each
class is described in a SupportedLFB element.
Each occurrence of the SupportedLFB element describes an LFB class
that the FE supports. In addition to indicating that the FE
supports the class, FEs with modifiable LFB topology should include
information about how LFBs of the specified class may be connected
to other LFBs. This information should describe which LFB classes
the specified LFB class may succeed or precede in the LFB topology.
The FE should include information as to which port groups may be
connected to the given adjacent LFB class. If port group
information is omitted, it is assumed that all port groups may be
used.
5.2.1.2.1. LFBName
This element has as its value the name of the LFB being described.
5.2.1.2.2. LFBOccurrenceLimit
This element, if present, indicates the largest number of instances
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
omitted or be the same as the number of LFB instances of this class
contained in the LFB list attribute.
5.2.1.2.3. PortGroupLimits and PortGroupLimit
The PortGroupLimits element is the wrapper to hold information
about the port groups supported by the LFB class. It holds multiple
occurrences of the PortGroupLimit element.
Each occurrence of the PortGroupLimit element contains the port
occurrence information for a single port group of the LFB class.
Each occurrence has the name of the port group in the PortGroupName
element, the fewest number of ports that can exist in the group in
the MinPortCount element, and the largest number of ports that can
exist in the group in the MaxPortCount element.
5.2.1.2.4.CanOccurAfters and CanOccurAfter
The CanOccurAfters element is a wrapper to hold the multiple
occurrences of the CanOccurAfter permissible placement information.
The CanOccurAfter element describes a permissible positioning of
the SupportedLFB. Specifically, it names an LFB that can
topologically precede the SupportedLFB. That is, the SupportedLFB
can have an input port connected to an output port of the LFB that
it CanOccurAfter. The LFB class that the SupportedLFB can follow is
identified by the NeighborLFB element of the CanOccurAfter element.
If this neighbor can only be connected to a specific set of input
port groups, then the viaPort element is included. This element
occurs once for each input port group of the SupportedLFB that can
be connected to an output port of the NeighborLFB.
[e.g., Within a SupportedLFB element, each CanOccurAfter element
must have a unique NeighborLFB, and within each CanOccurAfter
element each viaPort must represent a unique and valid input port
group of the SupportedLFB. The "unique" clauses for this have not
yet been added to the schema.]
5.2.1.2.5. CanOccurBefores and CanOccurBefore
The CanOccurBefores element is a wrapper to hold the multiple
occurrences of the CanOccurBefore permissible placement
information.
The CanOccurBefore element similarly lists those LFB classes that
the SupportedLFB may precede in the topology. In this element, the
viaPort element represents the output port group of the
SupportedLFB that may be connected to the NeighborLFB. As with
CanOccurAfter, viaPort may occur multiple times if multiple output
ports may legitimately connect to the given NeighborLFB class.
[And a similar set of uniqueness constraints apply to the
CanOccurBefore clauses, even though an LFB may occur both in
CanOccurAfter and CanOccurBefore.]
5.2.1.2.6. LFBClassCapabilities
This element contains capability information about the subject LFB
class whose structure and semantics are defined by the LFB class
definition.
5.2.1.3. SupportedAttributes
This element serves as a wrapper to hold the information about
attributed related capabilities. Specifically, attributes should be
described in this element if:
a) they are optional elements in the standard and are supported
by the FE, or
b) the standard allows for a range of access permissions (for
example, read-only or read-write).
Each attribute so described is contained in the SupportedAttributes
element. That element contains an AttributeName element whose value
is the name of the element being described and an AccessModes
element, whose value is the list of permissions.
5.2.2. FEAttributes
The FEAttributes element contains the attributes of the FE that are
not considered "capabilities". Some of these attributes are
writeable, and some are read-only, which should be indicated by the
capability information. At the moment, the set of attributes is
woefully incomplete. Each attribute is identified by a unique
element tag, and the value of the element is the value of the
attribute.
5.2.2.1. FEStatus
This attribute carries the overall state of the FE. For now, it is
restricted to the strings AdminDisable, OperDisable and OperEnable.
5.2.2.2.LFBInstances and LFBInstance
The LFBInstances element serves as a wrapper to hold the multiple
occurrences of the LFBInstance information about individual LFB
instances on the FE.
Each occurrence of the LFBInstance element describes a single LFB
instance. Each element contains an LFBClassName indicating what
class this instance has, and an LFBInstanceID indicating the ID
used for referring to this instance. For now, the ID uses the
NMTOKEN construction. Further protocol work is likely to replace
this with a range restricted integer.
5.2.2.3. LFBTopology and LFBLink
This optional element contains the information about each inter-LFB
link inside the FE. Each link is described in an LFBLink element.
This element contains sufficient information to identify precisely
the end points of a link. The FromLFBID and ToLFBID fields indicate
the LFB instances at each end of the link, and must reference LFBs
in the LFB instance table. The FromPortGroup and ToPortGroup must
identify output and input port groups defined in the LFB classes of
the LFB instances identified by the FromLFBID and ToLFBID. The
FromPortIndex and ToPortIndex fields select the elements from the
port groups that this link connects. All links are uniquely
identified by the FromLFBID, FromPortGroup, and FromPortIndex
fields. Multiple links may have the same ToLFBID, ToPortGroup, and
ToPortIndex as this model supports fan in of inter-LFB links but
not fan out.
5.2.2.4. FEConfiguredNeighbors an FEConfiguredNeighbor
The FEConfiguredNeighbors element is a wrapper to hold the
configuration information that one or more FEConfiguredNeighbor
elements convey about the configured FE topology.
The FEConfiguredNeighbor element occurs once for each configured FE
neighbor the FE knows about. It should not be filled in based on
FE level protocol operations. In general, neighbor discovery
operation on the FE should be represented and manipulated as an
LFB. However, for FEs that include neighbor discovery and do not
have such an LFB, it is permitted to fill in the information in
this table based on such protocols.
Similarly, the MAC address information in the table is intended to
be used in situations where neighbors are configured by MAC
address. Resolution of network layer to MAC address information
should be captured in ARP LFBs, not duplicated in this table. Note
that the same neighbor may be reached through multiple interfaces
or at multiple addresses. There is no uniqueness requirement of
any sort on occurrences of the FEConfiguredNeighbor element.
Information about the intended forms of exchange with a given
neighbor is not captured here, only the adjacency information is
included.
5.2.2.4.1.NeighborID
This is the ID in some space meaningful to the CE for the neighbor.
If this table remains, we probably should add an FEID from the same
space as an attribute of the FE.
5.2.2.4.2.NeighborInterface
This identifies the interface through which the neighbor is
reached.
[Editors note: As the port structures become better defined, the
type for this should be filled in with the types necessary to
reference the various possible neighbor interfaces, include
physical interfaces, logical tunnels, virtual circuits, etc.]
5.2.2.4.3. NeighborNetworkAddress
Neighbor configuration is frequently done on the basis of a network
layer address. For neighbors configured in that fashion, this is
where that address is stored.
5.2.2.4.4.NeighborMacAddress
Neighbors are sometimes configured using MAC level addresses
(Ethernet MAC address, circuit identifiers, etc.) If such
addresses are used to configure the adjacency, then that
information is stored here. Note that over some ports such as
physical point to point links or virtual circuits considered as
individual interfaces, there is no need for either form of address.
5.3. Sample FE Attribute Document
<?xml version="1.0">
<fm:FEDocument xmlns:fm="http://www.ietf.org/...theschema...">
<fm:FECapabilities>
<fm:ModifiableLFBTopology> true </fm:ModifiableLFBTopology>
<fm:SupportedLFBs>
<fm:SupportedLFB>
<!-- A simple single-input multi-output classifier -->
<fm:LFBName> Classifier </fm:LFBName>
<fm:LFBOccurrenceLimit> 3 </fm:LFBOccurrenceLimit>
<fm:PortGroupLimits>
<fm:PortGroupLimit>
<!-- The input port -->
<fm:PortGroupName> InputPortGroup </fm:PortGroupName>
<fm:MinPortCount> 1 </fm:MinPortCount>
<fm:MaxPortCount> 1 </fm:MaxPortCount>
</fm:PortGroupLimit>
<fm:PortGroupLimit>
<!--The normal output ports -->
<fm:PortGroupName> OutputPortGroup </fm:PortGroupName>
<fm:MinPortCount> 0 </fm:MinPortCount>
<fm:MaxPortCount> 32 </fm:MaxPortCount>
</fm:PortGroupLimit>
<fm:PortGroupLimit>
<!-- The optional error port -->
<fm:PortGroupName> ErrorPortGroup </fm:PortGroupName>
<fm:MinPortCount> 0 </fm:MinPortCount>
<fm:MaxPortCount> 1 </fm:MaxPortCount>
</fm:PortGroupLimit>
</fm:PortGroupLimits>
<fm:CanOccurAfters>
<fm:CanOccurAfter>
<fm:NeighborLFB> Port </fm:NeighborLFB>
<!-- omitted viaPort -->
</fm:CanOccurAfter>
<fm:CanOccurAfter
<fm:NeighborLFB> InternalSource </fm:NeighborLFB>
<!-- omitted viaPort -->
</fm:CanOccurAfter>
</fm:CanOccurAfters>
<fm:CanOccurBefores>
<fm:CanOccurBefore>
<fm:NeighborLFB> Marker </fm:NeighborLFB>
<!-- omitted viaPort -->
</fm:CanOccurBefore>
</fm:CanOccurBefores>
</fm:SupportedLFB>
<!-- then Supported LFB elements for Port, InternalSource -->
<!-- Marker, ... -->
</fm:SupportedLFBs>
<fm:SupportedAttributes>
<fm:SupportedAttribute>
<fm:AttributeName> FEStatus </fm:AttributeName>
<fm:AccessModes> read write </fm:AccessModes>
</fm:SupportedAttribute>
<fm:SupportedAttribute>
<fm:AttributeName> Vendor </fm:AttributeName>
<fm:AccessModes> read </fm:AccessModes>
</fm:SupportedAttribute
<fm:SupportedAttribute>
<fm:AttributeName> Model </fm:AttributeName>
<fm:AccessModes> read </fm:AccessModes>
</fm:SupportedAttribute>
</fm:SupportedAttributes>
</fm:FECapabilities>
<fm:FEAttributes>
<fm:Vendor> World Wide Widgets </fm:Vendor>
<fm:Model> Foo Forward Model 6 </fm:Model>
<fm:FEStatus> OperEnable </fm:FEStatus>
<fm:LFBInstances>
<fm:LFBInstance>
<fm:LFBClassName> Classifier </fm:LFBClassName>
<fm:LFBInstanceID> Inst5 </fm:LFBInstanceID>
</fm:LFBInstance>
<fm:LFBInstance>
<fm:LFBClassName> Interface </fm:LFBClassName>
<fm:LFBInstanceID> Inst11 </fm:LFBInstanceID>
</fm:LFBInstance>
<fm:LFBInstance>
<fm:LFBClassName> Meter </fm:LFBClassName>
<fm:LFBInstanceID> Inst17 </fm:LFBInstanceID>
</fm:LFBInstance>
</fm:LFBIntances>
<fm:LFBTopology>
<fm:LFBLink>
<fm:FromLFBID> Inst11 </fm:fromLFBID>
<fm:FromPortGroup> IFOnwardGroup </fm:FromPortGroup>
<fm:FromPortIndex> 1 </fm:FromPortIndex>
<fm:ToLFBID> Inst5 </fm:ToLFBID>
<fm:ToPortGroup> InputPortGroup </fm:ToPortGroup>
<fm:ToPortIndex> 1 </fm:ToPortIndex>
</fm:LFBLink>
<fm:LFBLink>
<fm:FromLFBID> Inst5 </fm:fromLFBID>
<fm:FromPortGroup> OutputGroup </fm:FromPortGroup>
<fm:FromPortIndex> 1 </fm:FromPortIndex>
<fm:ToLFBID> Inst17 </fm:ToLFBID>
<fm:ToPortGroup> InMeterGroup </fm:ToPortGroup>
<fm:ToPortIndex> 1 </fm:ToPortIndex>
</fm:LFBLink>
</fm:LFBTopology>
</fm:FEAttributes>
</fm:FEDocument>
6. LFB Class Library
A set of initial LFB classes are identified here in the LFB class
library as necessary to build common FE functions. Some of the LFB
classes described here are abstract base classes from which
specific LFB sub-classes will be derived. Hence, the base classes
may not be used directly in a particular FE's model, but the sub-
classes (yet to be defined) could be. This initial list attempts
to describe LFB classes at the expected level of granularity. This
list is neither exhaustive nor sufficiently detailed.
Several working groups in the IETF have already done some relevant Several working groups in the IETF have already done some relevant
work in modeling the provisioning policy data for some of the work in modeling the provisioning policy data for some of the
functions we are interested in, for example, DiffServ functions we are interested in, for example, the DiffServ
(Differentiated Services) PIB [4], IPSec PIB [8]. Whenever (Differentiated Services) PIB [4] and IPSec PIB [8]. Whenever
possible, we should try to reuse the work done elsewhere instead of possible, we have tried to reuse the work done elsewhere instead of
reinventing the wheel. reinventing the wheel.
7.1. Port LFB 6.1. Port LFB
A Port LFB is used to map a physical port into the LFB model. A Port LFB is used to model physical I/O ports on the FE. It is
both a source of data "received" by the FE and a sink of data
"transmitted" by the FE. The Port LFB contains a number of static
attributes, which may include, but are not limited to, the
following items:
. the number of physical ports on this LFB
. physical port type
. physical port link speed (may be variable; e.g., 10/100/1000
Ethernet).
The Port LFB maps sources and sinks of packets from outside the LFB In addition, the Port LFB contains a number of configurable
model onto one logical block which defines and models a physical attributes, including:
port implementing those functions. . physical port current status (up or down)
. physical port loopback
. physical port mapping to L2 interface.
The Port LFB contains a number of configurable parameters, which The Port LFB can be sub-classed into technology specific LFB
may include, but are not limited to, the following items: classes, with additional static and configurable attributes.
. the number of ports on this LFB; Examples of possible sub-classes include:
. the sub-interfaces if any; . Ethernet
. the static attributes of each port (e.g., port type, . Packet-over-SONET OC-N
direction, link speed); . ATM-over-SONET/SDN OC-N
. the configurable attributes of each port (e.g., IP address, . T3
administrative status); . E3
. the statistics collected on each port (e.g., number of packets . T1
received); . E1
. the current status (up or down). . CSIX-L1 switching fabric port (Fi interface)
. CE-FE port (for Fp interface).
The Port LFB can have three modes of operation: LFB class inheritance can be used to sub-class derived LFB classes
. ingress only with additional properties, such as TDM channelization.
. egress only
. hybrid (contains ingress and egress functions)
7.2. Dropper LFB The Port LFB "receives" (sources) and "transmits" (sinks) frames in
technology specific formats (described in the respective LFB class
definition but not otherwise modeled) into/out of the FE. Packets
"received" from a physical port are sourced on (one of) the LFB's
output port(s), while packets to be "transmitted" on a physical
port are sinked on (one of) the LFB's input port(s). The Port LFB
is unique among LFB classes in that packets accepted on a LFB input
port are not emitted back out on an LFB output port (except in the
case of physical port loopback operation).
A dropper LFB has one input, and no outputs. It discards all The Port LFB transmits technology specific L2 frames to
packets that it receives without any modification or examination of topologically adjacent LFB instances (i.e., no frame
those packets. decapsulation/encapsulation is modeled in this LFB class). When
transmitting a frame to an adjacent downstream LFB, the Port LFB
provides two items of metadata: the frame length and the L2
interface identifier. When receiving frames from an adjacent
upstream LFB, the frame is accompanied by two items of metadata:
frame length and outgoing port identifier.
The purpose of a dropper LFB is to allow the description of "sinks" Statistics are not maintained by the Port LFB; statistics
within the model, where those sinks do not result in the packet associated with a particular port may be maintained by an L2
being sent into any object external to the model. interface LFB (see Section 6.2).
7.3. Redirector (de-MUX) LFB 6.2. L2 Interface LFB
A redirector LFB has one input, and N outputs. The L2 Interface LFB models an L2 protocol termination. The L2
Interface LFB performs two sets of functions: decapsulation and
demultiplexing as needed on the receive side of an FE, and
encapsulation and multiplexing as needed on the transmit side.
Hence the LFB has two distinct sets of inputs and outputs tailored
for these separate functions. The L2 Interface LFB is not modeled
as two separate (receive/transmit) LFBs because there are shared
attributes between the decapsulation and encapsulation functions.
The purpose of the redirector LFB is to explicitly represent a On the decapsulation input(s), the LFB accepts an L2 protocol
place in the LFB Topology where the redirection process occurs, and specific frame, along with frame length and L2 interface metadata.
where it may be configured. The LFB decapsulates the L2 frame by removing any L2
header/trailers (while simultaneously applying any checksum/CRC
functions), determines the L2 or L3 protocol type of the next-layer
packet (based on a PID or Ethertype within the L2 frame header),
adjusts the frame length metadata, and uses the L2 interface
metadata to select an L2 interface attribute. The L2 interface
attribute supports a number of additional attributes, including:
. L2 MTU
. supported next-layer L2 or L3 protocols
. L2-specific receive counters (byte, packet)
. counting mode
. L2 or L3 interface metadata for next-layer packet
. LFB output port.
The LFB may support multiple decapsulation output ports within two
output groups; one for normal forwarding, and one for exception
packets. The LFB emits the decapsulated packet along with the
modified frame length metadata, an L2 or L3 protocol type metadata,
and an L2 or L3 interface metadata.
The redirector LFB takes an input packet P, and uses the metadata M On the encapsulation input(s), the LFB accepts a packet along with
to redirect that packet to one or more of N outputs, e.g. unicast frame length, protocol type, and L2 interface metadata. The L2
forwarding, multicast, or broadcast. interface metadata is used to select an L2 interface attribute
which supports a number of additional attributes, including:
. L2-specific transmit counters (byte, packet)
. counting mode (may be taken from receive counters mode)
. L2 or L3 interface metadata for next-layer frame (we assume
that L2
. protocols could be layered on top of an L3 protocol; e.g.,
L2TP or
. PWE3), or port metadata.
. LFB output port.
The LFB encapsulates the packet using the appropriate L2
header/trailer and protocol type information (calculating
checksums/CRCs as necessary), and provides the frame to the next
LFB along with incremented frame length metadata, updated protocol
type metadata, and updated interface (or port) metadata, on a
configurable LFB encapsulation output.
Note that other LFBs may also have redirecting functionality, if As in the case of the Port LFB, technology specific variants of the
they have multiple outputs. L2 interface LFB will be sub-classes of the L2 Interface LFB.
Example sub-classes include:
. Ethernet/802.1Q
. PPP
. ATM AAL5.
7.4. Scheduler LFB Each sub-class will likely support static and configurable
attributes specific to the L2 technology; for example the
Ethernet/802.1Q Interface LFB will support a per-interface MAC
address attribute. Note that each technology specific sub-class
may require additional metadata. For example, the Ethernet/802.1Q
Interface LFB requires an outgoing MAC destination address to
generate an outgoing Ethernet header.
A Scheduler LFB has multiple inputs and one output. The purpose of The L2 interface management function is separated into a distinct
the Scheduler LFB is to perform time-dependent packet forwarding. LFB from the Port LFB because L2 encapsulations can be nested
The Scheduler LFB multiplexes from its inputs onto its output(s), within frames; e.g., PPP-over-Ethernet-over-ATM AAL5 (PPPoEoA).
based on internal configuration such as packet priority, etc. The
packet is not modified during this process.
7.5. Queue LFB 6.3. IP interface LFB
The Queue LFB has one input and one output. It takes input packets The IP Interface LFB models a container for IP interface-specific
and places them onto queues. These packets are later forwarded to attributes. These may include:
the output(s) of the LFB, based on back-pressure from the next LFB . IP protocols supported (IPv4 and/or IPv6)
which typically is a scheduler LFB. . IP MTU
. interface MIB counters
. table metadata for associated forwarding tables (LPM,
multicast)
. table metadata for associated classification tables.
The IP Interface LFB also performs basic protocol-specific packet
heade validation functions (e.g., IP version, IPv4 header length,
IPv4 header checksum, MTU, TTL=0, etc.). The IP Interface LFB
class supports three different L3 protocols: IPv4, IPv6, and MPLS,
although individual LFB instances might support a subset of these
protocols, configurable on each interface attribute.
7.6. Counter LFB As with the L2 Interface LFB, the IP Interface LFB supports two
modes of operation: one needed on the receive side of an FE, and
one on the transmit side, using separate sets of LFB inputs and
outputs. In the first mode of operation (for FE receive
processing), the IP Interface LFB accepts IP packets along with
frame length, L3 protocol type, and interface metadata (possibly
including additional metadata items such as L2-derived class
metadata). The interface metadata is used to select an interface
attribute, and the protocol type is checked against the protocols
supported for this interface. Error checks are applied, including
whether the particular protocol type is supported on this
interface, and if no errors occur, the appropriate counters are
incremented and the protocol type is used to select the outgoing
LFB output from a set dedicated to the first mode of operation. The
IP header protocol type/next header field may also be used to
select an LFB output; for example, IPv4 packets with AH header may
be directed to a particular next LFB, or IPv6 packets with Hop-by-
Hop Options. If errors do occur, the appropriate error counters
are incremented, and the error type is used to select a specific
exception LFB output.
A counter LFB updates its statistical attributes, by counting In the second mode of operation (for FE transmit processing), the
packets, or metadata. The packet is not modified, and the metadata IP Interface LFB accepts an IP packet along with frame length,
may, or may not, be modified. protocol type, and interface metadata. Again, the interface
metadata is used to select an interface attribute. The interface
attribute stores the outgoing L2 or IP interface (e.g., tunnel)
interface metadata. The IP MTU of the outgoing interface is
checked, along with the protocol type of the packet. If no errors
occur, the appropriate counters are incremented, and the next level
interface metadata may be used to select an IP Interface LFB output
dedicated to the second mode of operation. Otherwise, the
appropriate error counters are incremented, and the error type is
used to select an exception output.
The purpose of a Counter LFB is to record simple accounting of Because the IP Interface LFB is the repository for the interface
events on the FE. MIB counters, two special pairs of inputs are provided for packets
which have been selected to be discarded further downstream (one
each for the receive and transmit counters). Packets arriving on
these LFB inputs must be accompanied by frame length and L3
interface metadata. An exception output on the LFB should be
connected to a dropper LFB.
A counter LFB is independent of time 't', in that it does not 6.4. Classifier LFB
perform any time-dependent counting. The time at which a count is
made may, however, be associated with that count.
7.7. Meter LFB and Policer LFB The function of classification is to logically partition packets
into one of N different classes, based on some sequence of one or
more mathematical operations applied to the packet and its
associated metadata. Various LFBs perform an intrinsic
classification function. Where this function is a well-defined
protocol operation, a separate LFB may be defined (e.g., IP
Interface LFB, which performs header verification).
A Meter LFB is a counter LFB that is time dependent. That is, it Several common applications need to classify packets using a
meters the rate over time at which packets or metadata flow through particular mathematical operation (e.g., longest prefix match (LPM)
the LFB. The purpose of the Meter LFB is to record time-dependent or ternary match) against a fixed set of fields in a packet's
accounting of events on the FE. header plus metadata, or an easily recognized part of the packet
payload. Two example applications are classification for
Differentiated Services or for security processing. Typically the
packet is evaluated against a potentially large set of rules
(called "filters") which are processed in a particular order to
ensure a deterministic result. This sort of classification
functionalit is modeled by the Classifier LFB.
When a Meter LFB has multiple outputs, with one output being a The Classifier LFB accepts an input packet and metadata, and
marker, or dropping the packet, then the Meter LFB becomes a produces the unmodified packet along with a class metadata, which
Policer LFB, performing a policing function. may be used to map the packet to a particular LFB output.
7.8. Classifier LFB The Classifier LFB supports multiple classifier attributes. Each
classifier is parameterized by one or more filters. Classification
is performed by selecting the classifier to use on a particular
packet (e.g., by metadata lookup on a configurable metadata item),
and by evaluating the selected contents of the accepted packet
against that classifier's filters. A filter decides if the input
packet satisfies particular criteria. According to [DiffServ], "a
filter consists of a set of conditions on the component values of a
packet's classification key (the header values, contents, and
attributes relevant for classification)".
A Classifier LFB uses its attributes to classify the packet into Note that other LFBs may perform simple classification on the
one of N different logical classes. packet or its metadata. The purpose of the Classifier LFB is to
model an LFB that "digests" large amounts of input data (packet,
metadata), to produce a "summary" of the classification results, in
the form of additional (or modified) metadata. Other LFBs can then
use this summary information to quickly and simply perform trivial
classification operations.
The purpose of a Classifier LFB is to logically partition packets The Classifier LFB can be sub-classed into several function-
into one or more classes. The result of this partitioning is that specific LFB classes which perform common classification functions.
the Classifier LFB produces metadata that describes the classes These may include:
into which the packet has been partitioned. The packet is not . Longest Prefix Match (LPM)
modified during this process. . IP Multicast lookup (S,G)
. Multifield Exact Match
. Multifield Ternary Match.
A Classifier LFB takes an input packet and metadata, and produces 6.5. Next Hop LFB
the same packet with new or more metadata. A classifier is
parameterized by filters. Classification is done by matching the
contents of the incoming packets according to the filters, and the
result of classification is produced in the form of metadata. Note
that this classifier is modeled solely based on its internal
processing, and not on its inputs and outputs. The block is a
single-exit classifier that does NOT physically redirect the
packet. In contrast, a DiffServ-like classifier is a 1:N (fan-out)
device: It takes a single traffic stream as input and generate N
logically separate traffic streams as output. That kind of multi-
exit classifier can be modeled by combining this classifier with a
redirector (see Section 6.1.6).
A filter decides if input packets match particular criteria. That The Next Hop LFB is used to resolve next hop information following
is, it "marks" a packet as either matching, or non-matching to the a forwarding lookup. Next Hop information normally includes the
filter criteria. According to [DiffServ], "a filter consists of a outgoing interface (or interfaces, in the case of multicast), as
set of conditions on the component values of a packet's well as the outgoing IP address(es). This next hop information
classification key (the header values, contents, and attributes associated with a forwarding prefix or classification rule is often
relevant for classification)". separated into a separate data structure in implementations to
allow the two pieces of information to be decoupled, because there
is frequently a fan-in relationship between forwarding prefix/rule
entries and next hop information, and decoupling them can permit
more efficient data structure management.
Note that other FE LFBs MAY perform simple classification on the The Next Hop LFB maintains next hop attributes organized into
packet or metadata. The purpose of the FE Classifier LFB is to multiple next hop tables. The relevant table for a packet is
model an LFB that "digests" large amounts of input data (packet, selected based on next hop table metadata. A set of one or more
metadata), to produce a "summary" of the classification results, in next hop attributes is selected based on next hop index metadata.
the form of additional metadata. Other FE LFBs can then use this Each next hop attribute stores the following information:
summary information to quickly and simply perform trivial . a list of one or more outgoing interfaces
"classifications". . next hop IP addresses, or, an index to a table of this
information
. that is maintained at a downstream LFB
. a list of outgoing MTUs
. TTL decrement value
The requirement for a unique and separate FE Classifier LFB comes The Next Hop LFB has two primary operations. The first is to map
about because it would not make sense to model a classifier LFB the incoming next hop table and next hop index metadata into a
inside each of every other LFB. Such a model would be highly configurable next hop attribute. This mapping may be direct (one
redundant. We therefore specifically model a complex metadata pair to one next hop attribute). If the next hop index
classification LFB, and explicitly state that other blocks may make metadata selects a set of next hop attributes, final attribute
decisions based on the parameters S, t, and M, but not on P. resolution depends on a selection algorithm that uses some
additional metadata, or an internal classification operation, to
select among a set of possible next hop attributes. One example is
weighted next hop selection, where individual packets are mapped to
particular next hop attributes in the set according to weights and
to some flow order-preserving function (e.g., such as an address
pair hash). Another alternative is class-based next hop selection,
based on some class metadata.
Note that a classifier LFB may have multiple outputs. In that The second operation is a derivative of the first. The next hop
case, it may redirect input packets to one (or more) of the table and next hop index metadata are used to select a set of one
outputs, and may not associate any metadata with those output or more next hop attributes. Then the outgoing interface values
packets. stored in those attributes are compared against the incoming
interface metadata provided to the Next Hop LFB, to determine
whether the incoming interface is in the set. This operation, in
combination with a IP source address forwarding lookup (which
provides the next hop table/index metadata), can be used to perform
a reverse path forwarding (RPF) check.
7.9. Modifier LFB The Next Hop LFB has two inputs: one for normal next hop
resolution, and one for the incoming interface metadata test (e.g.,
RPF). The LFB requires incoming interface, frame length, next hop
table, and next hop index metadata. There are two normal output
groups, one for the normal next hop resolution, and another for the
RPF check. No additional metadata is produced for the latter, but
for the former, the following metadata may be produced:
. outgoing interface(s)
. next hop IP address(es)
. TTL decrement value (if TTL decrement is not performed by the
Next Hop LFB)
An alternative mode of operation produces index metadata instead of
outgoing interface and next hop IP address metadata. This index
metadata is used to access a cache of the outgoing interface and
next hop IP address that may be stored on the egress FE (this
permits more efficient communication across the Fi interface).
This index metadata can also be used as input metadata to a MPLS
Encapsulation LFB.
A modifier LFB modifies incoming packets and sends them out. The Next Hop LFB supports an exception output port group.
Usually the metadata is used to determine how to modify the packet. Exception conditions include:
. RPF test failed
. No route to host
. No route to network
. Packet too big
. TTL expired
The mapping between exception conditions and exception outputs is
configurable, and an exception code metadata is produced on these
outputs.
This LFB is defined in a generic manner, and we expect that 6.6. Rate Meter LFB
specific examples of packet and/or metadata modification will be
described as a subclass of the modifier LFB.
For example, we may have an explicit LFB for packet compression and The Rate Meter LFB is used to meter the packet flow through the LFB
decompression, or for encryption and decryption, or for packet according to a rate- and time-dependent function. Packets are
encapsulation. The decision as to how best to model these provided to the Rate Meter LFB along with packet length metadata
functions will be made based on further investigation of the LFB (and optional color metadata) and are associated with a meter
model, and with practical experience using it. attribute either statically (based on LFB input) or via some other
configurable metadata item. The metering algorithm of the
associated meter attribute is applied to the packet, using the
packet length and the current time as inputs, along with previous
state maintained by the attribute. A color metadata is associated
with the packet in accordance with the metering algorithm used.
The color metadata is optionally emitted with the packet, or used
to map the packet to a particular LFB output. Color-aware metering
algorithms use color metadata if provided with the packet (e.g., by
a Classifier LFB), or assume a default color value.
7.10. Packet Header Rewriter LFB The Rate Meter LFB supports a number of static attributes,
This LFB is used to re-write fields on the packet header, such as including:
IPv4 TTL decrementing, checksum calculation, or TCP/IP NAT. . supported metering algorithms
. maximum number of meter attributes.
We may want to have multiple LFBs for different kinds of header re- The Rate Meter LFB supports a number of configurable attributes,
writing. including:
. number of LFB inputs
. number of LFB outputs
. mapping of LFB input to meter attribute (when mapped
statically)
. metadata item to select for mapping to meter attribute
. mapping of metadata value to meter attribute
. default meter attribute (when not mapped statically or via
correct
. metadata)
. per-attribute metering algorithm
. per-attribute metering paramters, including:
. minimum rate
. maximum rate
. burst size
. color metadata enable
. mapping of packet color to LFB output.
8. Satisfying the Requirements on FE Model A Rate Meter LFB can be used to implement a policing function, by
connecting a LFB output directly to a Dropper LFB, and mapping non-
conforming (e.g., "red") traffic to that output.
(Editor's Note: The text in this section is very preliminary but 6.7. Redirector (de-MUX) LFB
we decide to leave it as is because it is too early to understand
how to model all the functions as dictated in [1] when Section 7
is still very much work in progress. This section should be
revised once Section 7 is more settled.)
A minimum set of FE functions is defined in [1] that must be The Redirector LFB is used to select between alternative datapaths
supported by any proposed FE model. In this section, we based on the value of some metadata item. The Redirector LFB
demonstrate how the three components in FE model as described in accepts an input packet P, and uses associated metadata item M to
Section 4, 5, 6 along with the LFB class library defined in Section demultiplex that packet onto one of N outputs; e.g., unicast
7 can be used to express all the logical functions required in [1]. forwarding, multicast, or broadcast. Configurable attributes
include:
. number of LFB output ports (N)
. metadata item to demultiplex on (M)
. mapping of metadata value to output port
. default output port (for un-matched input metadata values).
8.1. Port Functions Note that other LFBs may include demultiplexing functionality
(i.e., if they have multiple outputs in an output group). The
Redirector LFB is especially useful for demultiplexing based on
metadata items that are not generated or modified by an immediate
upstream LFB.
Every FE contains a certain number of interfaces (ports), including 6.8. Packet Header Rewriter LFB
both the inter-NE interfaces and intra-NE interfaces. The inter-NE
interfaces are the external interfaces for the NE to
receive/forward packets from/to the external world. The intra-NE
interfaces are used for FE-FE or FE-CE communications. Same model
should be used for both the inter-FE and intra-FE interfaces, but
it is necessary to make the distinction between the two known to
the CE so that the CE can do different configuration.
The port LFB class is designed to model the specific physical ports The Packet Header Rewriter LFB is used to re-write fields in a
while the source/sink LFB can be used to model the logical packet's header. Function-specific sub-classes of the Packet
interface. Header Rewriter LFB may be specified as sub-classes of the Modifier
LFB. These may include:
. IPv4 TTL/IPv6 Hop Count
. IPv4 header checksum
. DSCP
. IPv4 NAT
The intra-NE interfaces that are used for FE-FE communications The precise means by which the packet header rewriting functions
should be modeled just like the inter-NE interfaces. The ForCES will be specified is TBD.
base protocol will include FE topology query so that the CE can
learn of how the multiple FEs are interconnected via such
interfaces. But the intra-NE interfaces that are used for FE-CE
communications are part of the ForCES protocol entity on the FE and
so it is not necessary to model them explicitly. It is assumed
that every FE will have at least one internal interface to
communicate to the CE and such interface do not have to be visible
in the FE model.
8.2. Forwarding Functions 6.9. Counter LFB
Support for IPv4 and IPv6 unicast and multicast forwarding The Counter LFB is used to maintain packet and/or byte statistics
functions must be provided by the model. on the packet flow through the LFB. Packets are provided to the
Counter LFB on an LFB input along with packet length metadata and
are associated with a count attribute either statically (based on
the LFB input) or via some other configurable metadata item. The
Counter LFB modifies neither the packet nor any associated
metadata.
Typically, the control plane maintains the Routing Information Base The Counter LFB supports a number of static attributes, including:
(RIB), which contains all the routes discovered by all the routing . supported counting modes (e.g., byte, packet, both)
protocols with all kinds of attributes relevant to the routes. The . supported logging modes (e.g., last recorded packet time)
forwarding plane uses a different database, the Forwarding . maximum number of count attributes
Information Base (FIB), which contains only the active subset of
those routes (only the best routes chosen for forwarding) with
attributes that are only relevant for forwarding. A component in
the control plane, termed Route Table Manager (RTM), is responsible
to manage the RIB in the CE and maintain the FIB used by the FEs.
Therefore, the most important aspect in modeling the forwarding
functions is the data model for the FIB. The model also needs to
support the possibility of multiple paths.
At the very minimum, each route in the FIB needs to contain the The Counter LFB supports a number of configurable attributes,
following layer-3 information: including:
. the prefix of the destination IP address; . number of LFB inputs
. the length of the prefix; . mapping of LFB input to count attribute (when mapped
. the number of equal-cost multi-path; statically)
. the next hop IP address and the egress interface for each . metadata item to select for mapping to count attribute
path. . mapping of metadata value to count attribute
. default count attribute (when not mapped statically or via
correct
. metadata)
. counting mode per-attribute
. logging mode per-attribute.
Another aspect of the forwarding functions is the method to resolve The Counter LFB does not perform any time-dependent counting. The
a next hop destination IP address into the associated media time at which a count is made may, however, be logged as part of
address. There are many ways to resolve Layer 3 to Layer 2 address the count attribute.
mapping depending upon link layer. For example, in case of Ethernet
links, the Address Resolution Protocol (ARP, defined in RFC 826) is
used for IPv4 address resolution.
Assuming a separate table is maintained in the FEs for address Other LFBs may maintain internal statistics (e.g., interface LFBs).
resolution, the following information is necessary for each address The Counter LFB is especially useful for maintain counts associated
resolution entry: with QoS policy.
. the next hop IP address;
. the media address.
Different implementation may have different ways to maintain the 6.10. Dropper LFB
FIB and the resolution table. For example, a FIB may consist of two
separate tables, one to match the prefix to the next hop and the
other to match the next hop to the egress interface. Another
implementation may use one table instead. Our approach of using
the fine-grained FE blocks to model the forwarding functions allow
such flexibility.
For example, a combination of a classifier, followed by a modifier A Dropper LFB has one input, and no outputs. It discards all
and a redirector can model the forwarding function. packets that it accepts without any modification or examination of
those packets.
8.3. QoS Functions The purpose of a Dropper LFB is to allow the description of "sinks"
within the model, where those sinks do not result in the packet
being sent into any object external to the model.
The IETF community has already done lots work in modeling the QoS The Dropper LFB has no configurable attributes.
functions in the datapath. The IETF DiffServ working group has
defined an informal data model [3]for QoS-related functions like
classification, metering, marking, actions of marking, dropping,
counting and multiplexing, queueing, etc. The latest work on
DiffServ PIB (Policy Information Base) [4] defines a set of
provisioning classes to provide policy control of resources
implementing the Diferentiated Services Architecture. DiffServ PIB
also has an element of capability flavor to it. The IETF Policy
Framework working group is also defining an informational model [6]
to describe the QoS mechanisms inherent in different network
devices, including hosts. This model is intended to be used with
the QoS Policy Information Model [7] to model how policies can be
defined to manage and configure the QoS mechanisms present in the
datapath of devices.
Here is a list of QoS functions that should be supported by the FE 6.11. IPv4 Fragmenter LFB
model:
. Classifier
. Meter
. Marker
. Dropper
. Counter
. Queue and Scheduler
. Shaper
LFB class library as described in Section 7 already supports most The IPv4 Fragmenter LFB fragments IPv4 packets according to the MTU
of these functions directly. of the outgoing interface. The IPv4 Fragmenter LFB accepts packets
with frame length and MTU metadata, and produces a sequence of one
or more valid IPv4 packets properly fragmented, each along with
corrected frame length metadata.
Note that A shaper should be modeled as a queue feeding a scheduler The source of the outgoing interface MTU is TBD. The IPv4
input that is serviced using a non-work-conserving policy. The fragmentation function is not incorporated into the IP Interface
queue LFB would include multiple FIFO queue resources (selected by LFB because forwarding implementations may include additional
META_QUEUE_ID) and AQManagers assigned to queues. The scheduler forwarding functions between fragmentation and final output
LFB would include multiple input resources with associated service interface processing.
policies. Queue outputs would be bound to scheduler inputs via
passing META_SCHED_ID with the packet at the output of the queue.
The metadata is only there to allow correlation in configuration
parameters between the queueing LFB and the scheduler LFB (assign
queue X to scheduler input Y by configuring queue X to emit
META_SCHED_ID Y).
8.4. Generic Filtering Functions 6.12. L2 Address Resolution LFB
A combination of classifier, redirector, modifier etc. can model
complex set of filtering functions. For example, Figure 8
represents a filtering function that classifies packets into one of
two logical classes: forward, and drop. These logical classes are
represented as meta data M1, and M2. The re-director uses this
meta data to re-direct the packet to one of two outputs. The first
sinks the packet back into the network. The second silently drops
the packets.
classifier -> redirector ---M1--- sink The L2 Address Resolution LFB is used to map an next hop IP address
\ into an L2 address. The LFB accepts packets with output L2
\-M2--- dropper interface and next hop IP address metadata, and produces the packet
along with the correct L2 destination address. The L2 Address
Resolution LFB maintains multiple address resolution table
attributes accessed by the output L2 interface metadata. Each
table attribute maintains a set of configurable L2 address
attributes, accessed by the next hop IP address.
Figure 8. A filtering function example. The L2 Address Resolution LFB has a normal output group which
produces the L2 destination address metadata, as well as an
exception output. This exception output can be used to divert the
packet to another LFB (e.g., an ARP/ND Protocol LFB, or a Port LFB
used to reach the CE) for address resolution.
8.5. Vendor Specific Functions 6.13. Queue LFB
New LFB class can always be defined according to the LFB model as The Queue LFB is used to represent queueing points in the packet
described in Section 7 to support vendor specific functions. New datapath. It is always used in combination with one or more
LFB class can also be derived from an existing LFB class by Scheduler LFBs. The Queue LFB manages one or more FIFO packet
queues as configurable attributes. The Queue LFB provides one or
more LFB inputs, and packets are mapped from LFB inputs to queues,
either statically, or via queue metadata. Each queue attribute is
mapped one-to-one with a scheduling input on a downstream Scheduler
LFB. The Queue LFB provides one or more LFB outputs, along with
optional scheduling input metadata.
Additional per-queue configurable attributes include the following:
. maximum depth discard behavior (tail drop/head drop/Active
Queue Management (AQM))
. AQM parameters (specific to the AQM algorithm; e.g., RED)
. Explicit Congestion Notification (ECN) enable.
Packets are provided to the Queue LFB along with a packet length
metadata and an optional queue metadata. Because the Queue LFB can
model sophisticated AQM mechanisms such as per-color marking
thresholds (e.g., Weighted RED), packets may also be accompanied
with color metadata.
If ECN is enabled on a queue serving IP packets, then the IP packet
header is modified if congestion is marked. A protocol type
metadata must accompany the packet to indicate the packet protocol
(e.g., IPv4, IPv6, Ethernet), so that the implementation can
determine the location of the ECN bits in the header [RFC3168]. In
the case of IPv4, if congestion is signaled, the header checksum
must be modified. The Queue LFB supports a capability to indicate
whether it corrects the IPv4 header checksum after marking
congestion experienced. Support for the checksum fixup is not
mandatory since the checksum may be recalculated in another LFB
further downstream.
6.14. Scheduler LFB
The Scheduler LFB is used to perform packet scheduling at queueing
points in the packet datapath, and hence is always used in
combination with one or more upstream Queue or Scheduler LFBs. The
Scheduler LFB supports one or more logical scheduling inputs. A
scheduling input can be mapped one-to-one to a Scheduler LFB input,
or the scheduling input can be selected via metadata (and both
mechanisms may be used in combination).
The Scheduler LFB multiplexes its scheduling inputs onto a single
LFB output, based on its scheduling algorithm along with the per-
input scheduling configuration. The packet is not modified during
the scheduling process.
Packets are provided to the Scheduler LFB along with a packet
length metadata and an optional scheduling input metadata.
Configurable attributes include:
. number of logical scheduler inputs
. number of LFB inputs
. mapping of LFB input to scheduler input
. scheduling algorithm
. per-input scheduling parameters, including:
. priority
. minimum service rate
. maximum service rate
. burst duration (at maximum service rate).
Hierarchical scheduling configurations can be created by cascading
two or more Scheduler LFBs.
6.15. MPLS ILM/Decapsulation LFB
The MPLS Incoming Label Map (ILM)/Decapsulation LFB accepts MPLS-
encapsulated packets, examines (and possibly removes) the top-most
label, and emits the packet on one output within an output group,
along with configurable index and class metadata. The configurable
metadata can be used as input for an IP Interface LFB, a Next Hop
LFB, or the same (or another) MPLS ILM/Decapsulation LFB. This
allows the FE to terminate, forward, or "pop and lookup" on the
value of the top-most label. The LFB maintains a set of ILM table
attributes indexed by incoming IP interface metadata. Each ILM
table entry is an attribute specifying whether to remove the label,
and which output port to emit the packet on. An exception output
is provided for packets with expired TTL.
6.16. MPLS Encapsulation LFB
The MPLS Encapsulation LFB accepts IP or MPLS-encapsulated packets
and appends an MPLS label stack, which is selected by output
interface and configurable index metadata. The TTL of the accepted
packet is copied from the outermost header into the labels in the
label stack, and the S bit is set on the bottom label if the
accepted packet is IP. The MPLS EXP bits are copied (or mapped)
according to per-stack attributes.
The MPLS Encapsulation LFB maintains multiple stack table
attributes indexed by output interface metadata. Entry attributes
within a table are indexed by configurable index metadata. Each
entry attribute maintains a label stack, along with a configurable
attribute for EXP bit handling, and possibly class and/or queue
metadata to emit with the packet.
MPLS ILM/decapsulation and encapsulation functions are modeled in
separate LFBs because some implementations split these operations
across FEs.
6.17. Tunnel Encapsulation/Decapsulation LFB
The Tunnel Encapsulation/Decapsulation LFB models tunnel header
encapsulation and decapsulation/demultiplexing. The LFB maintains
separate encapsulation and decapsulation input and output groups.
The encapsulation input group accepts packets with tunnel metadata,
appends a tunnel header that is stored in a configurable attribute
indexed by the tunnel metadata, and emits the packet on an
encapsulation output. The decapsulation input group accepts
packets encapsulated with a tunnel header along with tunnel
metadata, removes the tunnel header (performing any tunnel-
protocol-specific classification) according to attributes
configured on a per-tunnel basis and accessed via the tunnel
metadata, and emits the packet along with configurable metadata.
For example, the configurable metadata that is output may be used
as input interface metadata by a downstream IP or L2 Interface LFB.
A decapsulation exception output is available and is used in the
event that decapsulation fails.
The Tunnel Encapsulation/Decapsulation LFB may be sub-classed into
tunnel-protocol-specific LFBs, including:
. IP-IP
. GRE
. L2TP
. Generic IPv6 Tunnels
6.18. Replicator LFB
The Replicator LFB is used to replicate accepted packets and emit
them on one or more outputs in an output group. Packets are
accepted along with replicator index metadata. The LFB maintains
an attribute table indexed by this metadata. Each table entry
attribute specifies the number of times the packet must be
replicated, the outputs (within the output group) that each
replicated packet should be emitted on, and configurable metadata
to be associated with each replicated packet.
The Replicator LFB can be used for multicast replication, or for
transparent packet interception.
7. Satisfying the Requirements on FE Model
This section describes how the proposed FE model meets the
requirements outlined in Section 5 of RFC 3654 [1]. The
requirements can be separated into general requirements (Sections
5, 5.1 - 5.4) and the specification of the minimal set of logical
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 logical packet processing capability of the FE,
through both a capability and a state model. In addition, the FE
model is expected to allow flexible implementations and be
extensible to allow defining new logical functions.
A major component of the proposed FE model is the Logical Function
Block (LFB) model. Each distinct logical function in an FE is
modeled as an LFB. Operational parameters of the LFB that must be
visible to the CE are conceptualized as LFB attributes. These
attributes support flexible implementations by allowing an FE to
specify supported optional features and to indicate which
attributes are configurable by the CE for an LFB class (e.g.,
express the capability of the FE). Configurable attributes also
provide the CE some flexibility in specifying the behavior of a
LFB. When multiple LFBs belonging to the same LFB class are
instantiated on an FE, each of those LFBs could be configured with
different attribute settings. By querying the settings of the
attributes for an instantiated LFB, one can determine the state of
that LFB.
Instantiated LFBs are interconnected in a directed graph that
describes the ordering of the functions within an FE. This
directed graph is described by the topology model. The combination
of the attributes of the instantiated LFBs and the topology
describe the packet processing functions available on the FE
(current state).
Another key component of the FE model is the FE attributes. The FE
attributes are used mainly to describe the capabilities of the FE,
but they also convey information about the FE state.
The FE model also includes a definition of the minimal set of LFBs
that is required by Section 5.5 of [1]. The sections that follow
provide more detail on the specifics of each of those LFBs.
7.1. Port Functions
The FE model can be used to define a Port LFB class and its
technology-specific subclasses (see Section 6.1) to map the
physical port of the device to the LFB model with both static and
configurable attributes. The static attributes model the type of
port, link speed etc. The configurable attributes model the
addressing, administrative status etc.
7.2. Forwarding Functions
Because forwarding function is one of the most common and important
functions in the forwarding plane, it requires special attention in
modeling to allow design flexibility, implementation efficiency,
modeling accuracy and configuration simplicity. Toward that end,
it is recommended that the core forwarding function being modeled
by the combination of two LFBs -- Longest Prefix Match (LPM)
classifier LFB (see Section 6.4) and Next Hop LFB (see Section
6.5). Special header writer LFB (see Section 6.8) is also needed
to take care of TTL decrement and checksum etc.
7.3. QoS Functions
The LFB class library already includes descriptions of the Meter
(Section 6.6.), Queue (Section 6.13), Scheduler (Section 6.14),
Counter (Section 6.9) and Dropper (Section 6.10) LFBs to support
the QoS functions in the forwarding path. FE model can also be
used to define other useful QoS functions as needed. These LFBs
allow the CE to manipulate the attributes to model IntServ or
DiffServ functions.
7.4. Generic Filtering Functions
Various combinations of Classifier (Section 6.4), Redirector
(Section 6.7), Meter (Section 6.6.) and Dropper (Section 6.10) LFBs
can model a complex set of filtering functions.
7.5. Vendor Specific Functions
New LFB classes can be defined according to the LFB model as
described in Section 4 to support vendor specific functions. A new
LFB class can also be derived from an existing LFB class through
inheritance. inheritance.
8.6.High-Touch Functions 7.6.High-Touch Functions
High-touch functions are those that take action on the contents or High-touch functions are those that take action on the contents or
headers of a packet based on content other than what is found in headers of a packet based on content other than what is found in
the IP header. Examples of such functions include NAT, ALG, the IP header. Examples of such functions include NAT, ALG,
firewall, tunneling and L7 content recognition. firewall, tunneling and L7 content recognition. It is not
practical to include all possible high touch functions in the
The ForCES working group first needs to agree upon a small set of initial LFB library in Section 6 due to the number and complexity.
common high-touch functions with well-defined behavior to be However, the flexibility of the LFB model and the power of
included in the LFB class library. Here is a list of candidate interconnection in LFB topology should make it possible to model
blocks: any high-touch functions.
. NAT
. Firewall
. Encapsulator
. Decapsulator
8.7. Security Functions
The FE model must be able to describe the types of encryption 7.7. Security Functions
and/or decryption functions that an FE supports and the associated Security functions are not included in the initial LFB class
attributes for such functions. library. However, the FE model is flexible and powerful enough to
model the types of encryption and/or decryption functions that an
FE supports and the associated attributes for such functions.
The IP Security Policy (IPSP) Working Group in the IETF has started The IP Security Policy (IPSP) Working Group in the IETF has started
work in defining the IPSec Policy Information Base [8]. Further work in defining the IPSec Policy Information Base [8]. We should
study on this is needed to determine whether it can be reused here try to reuse the work as much as we can.
and any other additional work is needed.
8.8. Off-loaded Functions 7.8. Off-loaded Functions
In addition to the packet processing functions that are typical to In addition to the packet processing functions that are typical to
find on the FEs, some logical functions may also be executed find on the FEs, some logical functions may also be executed
asynchronously by some FEs, according to a certain finite-state asynchronously by some FEs, according to a certain finite-state
machine, triggered not only by packet events, but by timer events machine, triggered not only by packet events, but by timer events
as well. Examples of such functions include finite-state machine as well. Examples of such functions include finite-state machine
execution required by TCP termination or OSPF Hello processing off- execution required by TCP termination or OSPF Hello processing off-
loaded from the CE. The FE model must be capable of expressing loaded from the CE. By defining LFBs for such functions, the FE
these asynchronous functions, so that the CE may take advantage of model is capable of expressing these asynchronous functions, so
such off-loaded functions on the FEs. that the CE may take advantage of such off-loaded functions on the
FEs.
The ForCES working group first needs to agree upon a small set of
such off-loaded functions with well-understood behavior and
interactions with the control plane.
8.9. IPFLOW/PSAMP Functions 7.9. IPFLOW/PSAMP Functions
[9] defines architecture for IP traffic flow monitoring, measuring [9] defines architecture for IP traffic flow monitoring, measuring
and exporting. The LFB model supports statistics collection on the and exporting. The LFB model supports statistics collection on the
LFB by including statistical attributes (Section 4.4.4) for all the LFB by including statistical attributes (Section 4.7.4) in the LFB
LFB class definitions, and meter LFB (Section 7.2.2) and counter class definitions; in addition, special statistics collection LFBs
LFB (Section 7.2.1) can also be used to support accounting such as meter LFB (Section 7.2.2) and counter LFB (Section 7.2.1)
functions in the FE. can also be used to support accounting functions in the FE.
[10] describes a framework to define a standard set of capabilities [10] describes a framework to define a standard set of capabilities
for network elements to sample subsets of packets by statistical for network elements to sample subsets of packets by statistical
and other methods. Time event generation, filter LFB, and and other methods. Time event generation, filter LFB, and
counter/meter LFB are the elements needed to support packet counter/meter LFB are the elements needed to support packet
filtering and sampling functions -- these elements are all included filtering and sampling functions -- these elements can all be
in the FE model. supported in the FE model.
9. Using the FE model in the ForCES Protocol 8. Using the FE model in the ForCES Protocol
The actual model of the forwarding plane in a given NE is The actual model of the forwarding plane in a given NE is something
something the CE must learn and control via communicating with the the CE must learn and control by communicating with the FEs (or by
FEs (or by other means). Most of this communication will happen in other means). Most of this communication will happen in the post-
the post-association phase using the ForCES protocol. The association phase using the ForCES protocol. The following types of
following types of information must be exchanged between CEs and information must be exchanged between CEs and FEs via the ForCES
FEs via the ForCES protocol: protocol:
1) FE topology query; 1) FE topology query;
2) FE capability declaration; 2) FE capability declaration;
3) LFB topology (per FE) and configuration capabilities query; 3) LFB topology (per FE) and configuration capabilities query;
4) LFB capability declaration; 4) LFB capability declaration;
5) State query of LFB attributes; 5) State query of LFB attributes;
6) Manipulation of LFB attributes; 6) Manipulation of LFB attributes;
7) LFB topology reconfiguration. 7) LFB topology reconfiguration.
Items 1) through 5) are query exchanges, the main flow of Items 1) through 5) are query exchanges, where the main flow of
information being 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 association (PA) phase, though they may be repeatedly queried at
any time in the PA phase. Item 5) (state query) will be used at any time in the PA phase. Item 5) (state query) will be used at the
the beginning of the PA phase, and often frequently during the PA beginning of the PA phase, and often frequently during the PA phase
phase (especially for the query of statistical counters). (especially for the query of statistical counters).
Items 6) and 7) are "command" type of exchanges, the main flow of Items 6) and 7) are "command" types of exchanges, where the main
information being from the CEs to the FEs. Messages in Item 6) flow of information is from the CEs to the FEs. Messages in Item 6)
(the LFB re-configuration commands) are expected to be used (the LFB re-configuration commands) are expected to be used
frequently. Item 7) (LFB topology re-configuration) is needed frequently. Item 7) (LFB topology re-configuration) is needed only
only if dynamic LFB topologies are supported by the FEs and it is if dynamic LFB topologies are supported by the FEs and it is
expected to be used infrequently. expected to be used infrequently.
Among the seven types of payload information the ForCES protocol Among the seven types of payload information the ForCES protocol
carries between CEs and FEs, the FE model covers all of them carries between CEs and FEs, the FE model covers all of them except
except item 1), which concerns the inter-FE topology. The FE item 1), which concerns the inter-FE topology. The FE model
model focuses on the LFB and LFB topology within a single FE. focuses on the LFB and LFB topology within a single FE. Since the
Since the information of item 1) requires global knowledge about information related to item 1) requires global knowledge about all
all the FEs and their inter-connection with each other, this of the FEs and their inter-connection with each other, this
exchange is made part of the ForCES base protocol instead of the exchange is part of the ForCES base protocol instead of the FE
FE model. model.
The relationship between the FE model and the seven post- The relationship between the FE model and the seven post-
association messages are visualized in Figure 9: association messages are visualized in Figure 9:
+--------+ +--------+
..........-->| 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 9. Relationship between FE model and the ForCES protocol Figure 9. 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 and beyond the scope of the FE model. Their discussion is protocol and beyond the scope of the FE model. Their discussion is
nevertheless important here for the following reasons: nevertheless important here for the following reasons:
. These PA model components have considerable impact on the FE . 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 attributes of the LFBs, in which case such represented as attributes of the LFBs, in which case such
attributes must be defined in the LFB classes. attributes must be defined in the LFB classes.
. The understanding of the type of information that must be . 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 appropriate protocol format and the actual encoding method (such as
(such as XML, TLVs). XML, TLVs).
. Understanding the frequency of these types of messages should . 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).
An important part of the FE model is the port the FE uses for its
message exchanges to and from the CE. In the case that a dedicated
port is used for CE-FE communication, we propose to use a special
port LFB, called the CE-FE Port LFB (a subclass of the general Port
LFB in Section 6.1), to model this dedicated CE-FE port. The CE-FE
Port LFB acts as both a source and sink for the traffic from and to
the CE. Sometimes the CE-FE traffic does not have its own
dedicated port, instead the data fabric is shared for the data
plane traffic and the CE-FE traffic. A special processing LFB can
be used to model the ForCES packet encapsulation and decapsulation
in such cases.
The remaining sub-sections of this section address each of the The remaining sub-sections of this section address each of the
seven message types. seven message types.
9.1. FE Topology Query 8.1. FE Topology Query
(Editor's Note: It is still an open issue where the FE topology
information query belongs -- it can be either supported as part of
FE attributes in the FE model, or it can be supported by the ForCES
protocol explicitly. Hence the text here is tentative and subject
to change per WG discussion.)
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 Similarly, an FE may contain zero, one or more external egress
ports. In another word, not every FE has to contain any external ports. In other words, not every FE has to contain any external
ingress or egress interfaces. For example, Figure 10 shows two ingress or egress interfaces. For example, Figure 10 shows two
cascading FEs. FE #1 contains one external ingress interface but cascading FEs. FE #1 contains one external ingress interface but
no external egress interface, while FE #2 contains one external no external egress interface, while FE #2 contains one external
egress interface but no ingress interfce. It is possible to egress interface but no ingress interface. It is possible to
connect these two FEs together via their internal interfaces to connect these two FEs together via their internal interfaces to
achieve the complete ingress-to-egress packet processing function. achieve the complete ingress-to-egress packet processing function.
This provides the flexibility to spread the functions across This provides the flexibility to spread the functions across
multiple FEs and interconnect them together later for certain multiple FEs and interconnect them together later for certain
applications. applications.
While the inter-FE communication protocol is out of scope for 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 ForCES, it is up to the CE to query and understand how multiple FEs
are inter-connected to perform a complete ingress-egress packet are inter-connected to perform a complete ingress-egress packet
processing function, like that described in Figure 10. The inter- processing function, such as the one described in Figure 10. The
FE topology information may be provided by FEs, may be hard-coded inter-FE topology information may be provided by FEs, may be hard-
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 manager) independent of the FEs. So while the ForCES protocol
supports FE topology query from FEs, it is optional for the CE to supports FE topology query from FEs, it is optional for the CE to
use it, assuming the CE has other means to gather such topology use it, assuming the CE has other means to gather such topology
information. information.
+-----------------------------------------------------+ +-----------------------------------------------------+
| +---------+ +------------+ +---------+ | | +---------+ +------------+ +---------+ |
input| | | | | | output | input| | | | | | output |
---+->| Ingress |-->|Header |-->|IPv4 |---------+--->+ ---+->| Ingress |-->|Header |-->|IPv4 |---------+--->+
| | port | |Decompressor| |Forwarder| FE | | | | port | |Decompressor| |Forwarder| FE | |
skipping to change at page 46, line 32 skipping to change at page 96, line 10
| +------------+ +----------+ #2 | | +------------+ +----------+ #2 |
+----------------------------------------+ +----------------------------------------+
Figure 10. An example of two FEs connected together. Figure 10. An example of two FEs connected together.
Once the inter-FE topology is discovered by the CE after this Once the inter-FE topology is discovered by the CE after this
query, it is assumed that the inter-FE topology remains static. query, it is assumed that the inter-FE topology remains static.
However, it is possible that an FE may go down during the NE However, it is possible that an FE may go down during the NE
operation, or a board may be inserted and a new FE activated, so operation, or a board may be inserted and a new FE activated, so
the inter-FE topology will be affected. It is up to the ForCES the inter-FE topology will be affected. It is up to the ForCES
protocol to provide mechanism for the CE to detect such events and protocol to provide a mechanism for the CE to detect such events
deal with the change in FE topology. FE topology is outside the and deal with the change in FE topology. FE topology is outside
scope of the FE model. the scope of the FE model.
9.2. FE Capability Declarations 8.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:
. Metadata passing capabilities of the FE. Understanding these . Metadata passing capabilities of the FE. Understanding these
capabilities will help the CE to evaluate the feasibility of capabilities will help the CE to evaluate the feasibility of
LFB topologies, and hence to determine the availability of LFB topologies, and hence to determine the availability of
certain services. certain services.
. Global resource query limitations (applicable to all LFBs of . Global resource query limitations (applicable to all LFBs of
skipping to change at page 47, line 4 skipping to change at page 96, line 28
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:
. Metadata passing capabilities of the FE. Understanding these . Metadata passing capabilities of the FE. Understanding these
capabilities will help the CE to evaluate the feasibility of capabilities will help the CE to evaluate the feasibility of
LFB topologies, and hence to determine the availability of LFB topologies, and hence to determine the availability of
certain services. certain services.
. Global resource query limitations (applicable to all LFBs of . Global resource query limitations (applicable to all LFBs of
the FE). the FE).
. LFB supported by the FE. . LFB supported by the FE.
. LFB class instantiation limit. . LFB class instantiation limit.
. LFB topological limitations (linkage constraint, ordering . LFB topological limitations (linkage constraint, ordering
etc.) etc.)
9.3. LFB Topology and Topology Configurability Query 8.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, there should be between the LFBs within the FE. In addition, sufficient
sufficient information provided on whether the FE supports any CE- information should be available to determine whether the FE
initiated (dynamic) changes to the LFB topology, and if so, what supports any CE-initiated (dynamic) changes to the LFB topology,
are the allowed topologies. Topology configurability can also be and if so, determine the allowed topologies. Topology
considered as part of the FE capability query as described in configurability can also be considered as part of the FE capability
Section 9.3. query as described in Section 9.3.
9.4. LFB Capability Declarations 8.4. LFB Capability Declarations
LFB class specifications will define a generic set of capabilities. LFB class specifications define a generic set of capabilities.
When an LFB instance is implemented (instantiated) on a vendor's When an LFB instance is implemented (instantiated) on a vendor's
FE, some additional limitations may be introduced. Note that we FE, some additional limitations may be introduced. Note that we
discuss here only limitations that are within the flexibility of discuss only those limitations that are within the flexibility of
the LFB class specification, that is, the LFB instance will remain the LFB class specification. That is, the LFB instance will remain
compliant with the LFB class specification despite these compliant with the LFB class specification despite these
limitations. For example, certain features of an LFB class may be limitations. For example, certain features of an LFB class may be
optional, in which case it must be possible for the CE to determine optional, in which case it must be possible for the CE to determine
if an optional feature is supported by a given LFB instance or not. if an optional feature is supported by a given LFB instance or not.
Also, the LFB class definitions will probably contain very few Also, the LFB class definitions will probably contain very few
quantitative limits (e.g., size of tables), since these limits are quantitative limits (e.g., size of tables), since these limits are
typically imposed by the implementation. Therefore, quantitative typically imposed by the implementation. Therefore, quantitative
limitations should always be expressed by capability arguments. limitations should always be 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
skipping to change at page 48, line 24 skipping to change at page 97, line 47
attributes. attributes.
Capability attributes will typically be read-only arguments, but in Capability attributes will typically be read-only arguments, but in
certain cases they may be configurable. For example, the size of a certain cases they may be configurable. For example, the size of a
lookup table may be limited by the hardware (read-only), in other lookup table may be limited by the hardware (read-only), in other
cases it may be configurable (read-write, within some hard limits). cases it may be configurable (read-write, within some hard limits).
Assuming that capabilities will not change frequently, the Assuming that capabilities will not change frequently, the
efficiency of the protocol/schema/encoding is of secondary concern. efficiency of the protocol/schema/encoding is of secondary concern.
9.5. State Query of LFB Attributes 8.5. State Query of LFB Attributes
This feature must be provided by all FEs. The ForCES protocol and This feature must be provided by all FEs. The ForCES protocol and
the data schema/encoding conveyed by the protocol must together the data schema/encoding conveyed by the protocol must together
satisfy the following requirements to facilitate state query of the satisfy the following requirements to facilitate state query of the
LFB attributes: LFB attributes:
. Must permit FE selection. This is primarily to refer to a . Must permit FE selection. This is primarily to refer to a
single FE, but referring to a group of (or all) FEs may single FE, but referring to a group of (or all) FEs may
optional be supported. optional be supported.
. Must permit LFB instance selection. This is primarily to refer . Must permit LFB instance selection. This is primarily to refer
to a single LFB instance of an FE, but optionally addressing to a single LFB instance of an FE, but optionally addressing
of a group of LFBs (or all) may be supported. of a group of LFBs (or all) may be supported.
. Must support addressing of individual attribute of an LFB. . Must support addressing of individual attribute of an LFB.
. Must provide efficient encoding and decoding of the addressing . Must provide efficient encoding and decoding of the addressing
info and the configured data. info and the configured data.
. Must provide efficient data transmission of the attribute . Must provide efficient data transmission of the attribute
state over the wire (to minimize communication load on the CE- state over the wire (to minimize communication load on the CE-
FE link). FE link).
9.6. LFB Attribute Manipulation 8.6. LFB Attribute Manipulation
This is a place-holder for all operations that the CE will use to This is a place-holder for all operations that the CE will use to
populate, manipulate, and delete attributes of the LFB instances on populate, manipulate, and delete attributes of the LFB instances on
the FEs. This is how the CE configures an individual LFB instance. the FEs. This is how the CE configures an individual LFB instance.
The same set of requirements as described in Section 9.5 for The same set of requirements as described in Section 9.5 for
attribute query applies here for attribute manipulation as well. attribute query applies here for attribute manipulation as well.
Support for various levels of feedback from the FE to the CE (e.g., Support for various levels of feedback from the FE to the CE (e.g.,
request received, configuration completed), as well as multi- request received, configuration completed), as well as multi-
attribute configuration transactions with atomic commit and attribute configuration transactions with atomic commit and
rollback, may be necessary in some circumstances. rollback, may be necessary in some circumstances.
(Editor's note: It remains an open issue as to whether or not other (Editor's note: It remains an open issue as to whether or not other
methods are needed in addition to "get attribute" and "set methods are needed in addition to "get attribute" and "set
attribute" (such as multi-attribute transactions). If the answer attribute" (such as multi-attribute transactions). If the answer
to that question is yes, it is not clear whether such methods to that question is yes, it is not clear whether such methods
should be supported by the FE model itself or the ForCES protocol.) should be supported by the FE model itself or the ForCES protocol.)
9.7. LFB Topology Re-configuration 8.7. LFB Topology Re-configuration
Operations that will be needed to reconfigure LFB topology: Operations that will be needed to reconfigure LFB topology:
. Create a new instance of a given LFB class on a given FE. . Create a new instance of a given LFB class on a given FE.
. Connect a given output of LFB x to the given input of LFB y. . Connect a given output of LFB x to the given input of LFB y.
. Disconnect: remove a link between a given output of an LFB and . Disconnect: remove a link between a given output of an LFB and
a given input of another LFB. a given input of another LFB.
. Delete a given LFB (automatically removing all interconnects . Delete a given LFB (automatically removing all interconnects
to/from the LFB). to/from the LFB).
10. Acknowledgments 9. Acknowledgments
Many of the colleagues in our companies and participants in the
The authors would also like to thank the following individuals for ForCES mailing list have provided invaluable input into this work.
their invaluable technical input: David Putzolu, Hormuzd Khosravi,
Eric Johnson, David Durham, Andrzej Matejko, T. Sridhar, Jamal Hadi
Salim, Alex Audu, Gamil Cain.
11. Security Considerations 10. Security Considerations
The FE model describes the representation and organization of data The FE model describes the representation and organization of data
sets and attributes in the FEs. ForCES framework document [2] sets and attributes in the FEs. ForCES framework document [2]
provides a comprehensive security analysis for the overall ForCES provides a comprehensive security analysis for the overall ForCES
architecture. For example, the ForCES protocol entities must be architecture. For example, the ForCES protocol entities must be
authenticated per the ForCES requirements before they can access authenticated per the ForCES requirements before they can access
the information elements described in this document via ForCES. the information elements described in this document via ForCES.
The access to the information contained in the FE model is The access to the information contained in the FE model is
accomplished via the ForCES protocol which will be defined in accomplished via the ForCES protocol which will be defined in
separate documents and so the security issues will be addressed separate documents and so the security issues will be addressed
there. there.
12. Normative References 11. Normative References
[1] Khosravi, H. et al., "Requirements for Separation of IP Control [1] Khosravi, H. et al., "Requirements for Separation of IP Control
and Forwarding", work in progress, July 2003, <draft-ietf-forces- and Forwarding", RFC 3654, November 2003.
requirements-10.txt>.
13. Informative References
[2] Yang, L. et al., "Forwarding and Control Element Separation [2] Yang, L. et al.