idnits 2.17.1 draft-ietf-forces-model-16.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- ** It looks like you're using RFC 3978 boilerplate. You should update this to the boilerplate described in the IETF Trust License Policy document (see https://trustee.ietf.org/license-info), which is required now. -- Found old boilerplate from RFC 3978, Section 5.1 on line 16. -- Found old boilerplate from RFC 3978, Section 5.5, updated by RFC 4748 on line 5990. -- Found old boilerplate from RFC 3979, Section 5, paragraph 1 on line 6001. -- Found old boilerplate from RFC 3979, Section 5, paragraph 2 on line 6008. -- Found old boilerplate from RFC 3979, Section 5, paragraph 3 on line 6014. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- ** The abstract seems to contain references ([2], [6]), which it shouldn't. Please replace those with straight textual mentions of the documents in question. == There are 1 instance of lines with non-RFC6890-compliant IPv4 addresses in the document. If these are example addresses, they should be changed. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust Copyright Line does not match the current year == The document seems to lack the recommended RFC 2119 boilerplate, even if it appears to use RFC 2119 keywords. (The document does seem to have the reference to RFC 2119 which the ID-Checklist requires). -- The document seems to lack a disclaimer for pre-RFC5378 work, but may have content which was first submitted before 10 November 2008. If you have contacted all the original authors and they are all willing to grant the BCP78 rights to the IETF Trust, then this is fine, and you can ignore this comment. If not, you may need to add the pre-RFC5378 disclaimer. (See the Legal Provisions document at https://trustee.ietf.org/license-info for more information.) -- The document date (October 7, 2008) is 5680 days in the past. Is this intentional? Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) -- Looks like a reference, but probably isn't: 'N' on line 3895 -- Looks like a reference, but probably isn't: '1-9' on line 4078 -- Looks like a reference, but probably isn't: '0-9' on line 4078 -- No information found for draft-ietf - is the name correct? -- Possible downref: Normative reference to a draft: ref. '2' -- Possible downref: Non-RFC (?) normative reference: ref. '4' -- Possible downref: Non-RFC (?) normative reference: ref. '5' Summary: 2 errors (**), 0 flaws (~~), 3 warnings (==), 14 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 Working Group: ForCES J. Halpern 3 Internet-Draft Self 4 Intended status: Standards Track J. Hadi Salim 5 Expires: April 10, 2009 Znyx Networks 6 October 7, 2008 8 ForCES Forwarding Element Model 9 draft-ietf-forces-model-16.txt 11 Status of this Memo 13 By submitting this Internet-Draft, each author represents that any 14 applicable patent or other IPR claims of which he or she is aware 15 have been or will be disclosed, and any of which he or she becomes 16 aware will be disclosed, in accordance with Section 6 of BCP 79. 18 Internet-Drafts are working documents of the Internet Engineering 19 Task Force (IETF), its areas, and its working groups. Note that 20 other groups may also distribute working documents as Internet- 21 Drafts. 23 Internet-Drafts are draft documents valid for a maximum of six months 24 and may be updated, replaced, or obsoleted by other documents at any 25 time. It is inappropriate to use Internet-Drafts as reference 26 material or to cite them other than as "work in progress." 28 The list of current Internet-Drafts can be accessed at 29 http://www.ietf.org/ietf/1id-abstracts.txt. 31 The list of Internet-Draft Shadow Directories can be accessed at 32 http://www.ietf.org/shadow.html. 34 This Internet-Draft will expire on April 10, 2009. 36 Comments are solicited and should be addressed to the working group's 37 mailing list at forces@peach.ease.lsoft.com and/or the author(s). 39 Abstract 41 This document defines the forwarding element (FE) model used in the 42 Forwarding and Control Element Separation (ForCES) protocol [2]. The 43 model represents the capabilities, state and configuration of 44 forwarding elements within the context of the ForCES protocol, so 45 that control elements (CEs) can control the FEs accordingly. More 46 specifically, the model describes the logical functions that are 47 present in an FE, what capabilities these functions support, and how 48 these functions are or can be interconnected. This FE model is 49 intended to satisfy the model requirements specified in the ForCES 50 requirements document, RFC3654 [6]. 52 Table of Contents 54 1. Definitions . . . . . . . . . . . . . . . . . . . . . . . . . 5 55 2. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 7 56 2.1. Requirements on the FE model . . . . . . . . . . . . . . 7 57 2.2. The FE Model in Relation to FE Implementations . . . . . 8 58 2.3. The FE Model in Relation to the ForCES Protocol . . . . . 8 59 2.4. Modeling Language for the FE Model . . . . . . . . . . . 9 60 2.5. Document Structure . . . . . . . . . . . . . . . . . . . 10 61 3. ForCES Model Concepts . . . . . . . . . . . . . . . . . . . . 10 62 3.1. ForCES Capability Model and State Model . . . . . . . . . 11 63 3.1.1. FE Capability Model and State Model . . . . . . . . . 12 64 3.1.2. Relating LFB and FE Capability and State Model . . . 13 65 3.2. Logical Functional Block (LFB) Modeling . . . . . . . . . 14 66 3.2.1. LFB Outputs . . . . . . . . . . . . . . . . . . . . . 17 67 3.2.2. LFB Inputs . . . . . . . . . . . . . . . . . . . . . 20 68 3.2.3. Packet Type . . . . . . . . . . . . . . . . . . . . . 23 69 3.2.4. Metadata . . . . . . . . . . . . . . . . . . . . . . 24 70 3.2.5. LFB Events . . . . . . . . . . . . . . . . . . . . . 26 71 3.2.6. Component Properties . . . . . . . . . . . . . . . . 28 72 3.2.7. LFB Versioning . . . . . . . . . . . . . . . . . . . 28 73 3.2.8. LFB Inheritance . . . . . . . . . . . . . . . . . . . 29 74 3.3. ForCES Model Addressing . . . . . . . . . . . . . . . . . 30 75 3.3.1. Addressing LFB Components: Paths and Keys . . . . . . 31 76 3.4. FE Datapath Modeling . . . . . . . . . . . . . . . . . . 32 77 3.4.1. Alternative Approaches for Modeling FE Datapaths . . 32 78 3.4.2. Configuring the LFB Topology . . . . . . . . . . . . 36 79 4. Model and Schema for LFB Classes . . . . . . . . . . . . . . 40 80 4.1. Namespace . . . . . . . . . . . . . . . . . . . . . . . . 41 81 4.2. Element . . . . . . . . . . . . . . . . . . 41 82 4.3. Element . . . . . . . . . . . . . . . . . . . . . 43 83 4.4. Element for Frame Type Declarations . . . . . 44 84 4.5. Element for Data Type Definitions . . . . 44 85 4.5.1. Element for Renaming Existing Data Types . 48 86 4.5.2. Element for Deriving New Atomic Types . . . 48 87 4.5.3. Element to Define Arrays . . . . . . . . . . 49 88 4.5.4. Element to Define Structures . . . . . . . . 53 89 4.5.5. Element to Define Union Types . . . . . . . . 55 90 4.5.6. Element . . . . . . . . . . . . . . . . . . . 55 91 4.5.7. Augmentations . . . . . . . . . . . . . . . . . . . . 56 92 4.6. Element for Metadata Definitions . . . . . 57 93 4.7. Element for LFB Class Definitions . . . . 58 94 4.7.1. Element to Express LFB Inheritance . . 61 95 4.7.2. Element to Define LFB Inputs . . . . . . 61 96 4.7.3. Element to Define LFB Outputs . . . . . 64 97 4.7.4. Element to Define LFB Operational 98 Components . . . . . . . . . . . . . . . . . . . . . 66 99 4.7.5. Element to Define LFB Capability 100 Components . . . . . . . . . . . . . . . . . . . . . 69 101 4.7.6. Element for LFB Notification Generation . . 70 102 4.7.7. Element for LFB Operational 103 Specification . . . . . . . . . . . . . . . . . . . . 77 104 4.8. Properties . . . . . . . . . . . . . . . . . . . . . . . 77 105 4.8.1. Basic Properties . . . . . . . . . . . . . . . . . . 78 106 4.8.2. Array Properties . . . . . . . . . . . . . . . . . . 80 107 4.8.3. String Properties . . . . . . . . . . . . . . . . . . 80 108 4.8.4. Octetstring Properties . . . . . . . . . . . . . . . 81 109 4.8.5. Event Properties . . . . . . . . . . . . . . . . . . 82 110 4.8.6. Alias Properties . . . . . . . . . . . . . . . . . . 85 111 4.9. XML Schema for LFB Class Library Documents . . . . . . . 86 112 5. FE Components and Capabilities . . . . . . . . . . . . . . . 97 113 5.1. XML for FEObject Class definition . . . . . . . . . . . . 98 114 5.2. FE Capabilities . . . . . . . . . . . . . . . . . . . . . 104 115 5.2.1. ModifiableLFBTopology . . . . . . . . . . . . . . . . 105 116 5.2.2. SupportedLFBs and SupportedLFBType . . . . . . . . . 105 117 5.3. FE Components . . . . . . . . . . . . . . . . . . . . . . 108 118 5.3.1. FEState . . . . . . . . . . . . . . . . . . . . . . . 108 119 5.3.2. LFBSelectors and LFBSelectorType . . . . . . . . . . 108 120 5.3.3. LFBTopology and LFBLinkType . . . . . . . . . . . . . 109 121 5.3.4. FENeighbors and FEConfiguredNeighborType . . . . . . 109 122 6. Satisfying the Requirements on FE Model . . . . . . . . . . . 110 123 7. Using the FE model in the ForCES Protocol . . . . . . . . . . 111 124 7.1. FE Topology Query . . . . . . . . . . . . . . . . . . . . 113 125 7.2. FE Capability Declarations . . . . . . . . . . . . . . . 114 126 7.3. LFB Topology and Topology Configurability Query . . . . . 114 127 7.4. LFB Capability Declarations . . . . . . . . . . . . . . . 114 128 7.5. State Query of LFB Components . . . . . . . . . . . . . . 116 129 7.6. LFB Component Manipulation . . . . . . . . . . . . . . . 116 130 7.7. LFB Topology Re-configuration . . . . . . . . . . . . . . 116 131 8. Example LFB Definition . . . . . . . . . . . . . . . . . . . 117 132 8.1. Data Handling . . . . . . . . . . . . . . . . . . . . . . 124 133 8.1.1. Setting up a DLCI . . . . . . . . . . . . . . . . . . 125 134 8.1.2. Error Handling . . . . . . . . . . . . . . . . . . . 125 135 8.2. LFB Components . . . . . . . . . . . . . . . . . . . . . 126 136 8.3. Capabilities . . . . . . . . . . . . . . . . . . . . . . 126 137 8.4. Events . . . . . . . . . . . . . . . . . . . . . . . . . 127 138 9. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 128 139 9.1. URN Namespace Registration . . . . . . . . . . . . . . . 128 140 9.2. LFB Class Names and LFB Class Identifiers . . . . . . . . 128 141 10. Authors Emeritus . . . . . . . . . . . . . . . . . . . . . . 129 142 11. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 130 143 12. Security Considerations . . . . . . . . . . . . . . . . . . . 130 144 13. References . . . . . . . . . . . . . . . . . . . . . . . . . 130 145 13.1. Normative References . . . . . . . . . . . . . . . . . . 130 146 13.2. Informative References . . . . . . . . . . . . . . . . . 131 147 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 131 148 Intellectual Property and Copyright Statements . . . . . . . . . 132 150 1. Definitions 152 The use of compliance terminology (MUST, SHOULD, MAY, MUST NOT) is 153 used in accordance with RFC2119 [1]. Such terminology is used in 154 describing the required behavior of ForCES forwarding elements or 155 control elements in supporting or manipulating information described 156 in this model. 158 Terminology associated with the ForCES requirements is defined in 159 RFC3654 [6] and is not copied here. The following list of 160 terminology relevant to the FE model is defined in this section. 162 FE Model -- The FE model is designed to model the logical processing 163 functions of an FE. The FE model proposed in this document includes 164 three components: the modeling of individual logical functional 165 blocks (LFB model), the logical interconnection between LFBs (LFB 166 topology) and the FE level attributes, including FE capabilities. 167 The FE model provides the basis to define the information elements 168 exchanged between the CE and the FE in the ForCES Protocol [2]. 170 Datapath -- A conceptual path taken by packets within the forwarding 171 plane inside an FE. Note that more than one datapath can exist 172 within an FE. 174 LFB (Logical Functional Block) Class (or type) -- A template that 175 represents a fine-grained, logically separable aspect of FE 176 processing. Most LFBs relate to packet processing in the data path. 177 LFB classes are the basic building blocks of the FE model. 179 LFB Instance -- As a packet flows through an FE along a datapath, it 180 flows through one or multiple LFB instances, where each LFB is an 181 instance of a specific LFB class. Multiple instances of the same LFB 182 class can be present in an FE's datapath. Note that we often refer 183 to LFBs without distinguishing between an LFB class and LFB instance 184 when we believe the implied reference is obvious for the given 185 context. 187 LFB Model -- The LFB model describes the content and structures in an 188 LFB, plus the associated data definition. XML is used to provide a 189 formal definition of the necessary structures for the modeling. Four 190 types of information are defined in the LFB model. The core part of 191 the LFB model is the LFB class definitions; the other three types of 192 information define constructs associated with and used by the class 193 definition. These are reusable data types, supported frame (packet) 194 formats, and metadata. 196 Element -- Element is generally used in this document in accordance 197 with the XML usage of the term. It refers to an XML tagged part of 198 an XML document. For a precise definition, please see the full set 199 of XML specifications from the W3C. This term is included in this 200 list for completeness because the ForCES formal model uses XML. 202 Attribute -- Attribute is used in the ForCES formal modelling in 203 accordance with standard XML usage of the term. i.e, to provide 204 attribute information include in an XML tag. 206 LFB Metadata -- Metadata is used to communicate per-packet state from 207 one LFB to another, but is not sent across the network. The FE model 208 defines how such metadata is identified, produced and consumed by the 209 LFBs, but not how the per-packet state is implemented within actual 210 hardware. Metadata is sent between the FE and the CE on redirect 211 packets. 213 ForCES Component -- a ForCES Component is a well-defined, uniquely 214 identifiable and addressable ForCES model building block. A 215 component has a 32-bit ID, name, type and an optional synopsis 216 description. These are often referred to simply as components. 218 LFB Component -- A ForCES component that defines the Operational 219 parameters of the LFBs that must be visible to the CEs. 221 Structure Component -- A ForCES component that is part of a complex 222 data structure to be used in LFB data definitions. The individual 223 parts which make up a structured set of data are referred to as 224 Structure Components. These can themselves be of any valid data 225 type, including tables and structures. 227 Property -- ForCES components have properties associated with them, 228 such as readability. Other examples include lengths for variable 229 sized components. These properties are acessed by the CE for reading 230 (or, where appropriate, writing.) Details on the ForCES properties 231 are found in section 4.8. 233 LFB Topology -- A representation of the logical interconnection and 234 the placement of LFB instances along the datapath within one FE. 235 Sometimes this representation is called intra-FE topology, to be 236 distinguished from inter-FE topology. LFB topology is outside of the 237 LFB model, but is part of the FE model. 239 FE Topology -- A representation of how multiple FEs within a single 240 NE (Network Element) are interconnected. Sometimes this is called 241 inter-FE topology, to be distinguished from intra-FE topology (i.e., 242 LFB topology). An individual FE might not have the global knowledge 243 of the full FE topology, but the local view of its connectivity with 244 other FEs is considered to be part of the FE model. The FE topology 245 is discovered by the ForCES base protocol or by some other means. 247 Inter-FE Topology -- See FE Topology. 249 Intra-FE Topology -- See LFB Topology. 251 LFB class library -- A set of LFB classes that has been identified as 252 the most common functions found in most FEs and hence should be 253 defined first by the ForCES Working Group. 255 2. Introduction 257 RFC3746 [7] specifies a framework by which control elements (CEs) can 258 configure and manage one or more separate forwarding elements (FEs) 259 within a networking element (NE) using the ForCES protocol. The 260 ForCES architecture allows Forwarding Elements of varying 261 functionality to participate in a ForCES network element. The 262 implication of this varying functionality is that CEs can make only 263 minimal assumptions about the functionality provided by FEs in an NE. 264 Before CEs can configure and control the forwarding behavior of FEs, 265 CEs need to query and discover the capabilities and states of their 266 FEs. RFC3654 [6] mandates that the capabilities, states and 267 configuration information be expressed in the form of an FE model. 269 RFC3444 [10] observed that information models (IMs) and data models 270 (DMs) are different because they serve different purposes. "The main 271 purpose of an IM is to model managed objects at a conceptual level, 272 independent of any specific implementations or protocols used". 273 "DMs, conversely, are defined at a lower level of abstraction and 274 include many details. They are intended for implementors and include 275 protocol-specific constructs." Sometimes it is difficult to draw a 276 clear line between the two. The FE model described in this document 277 is primarily an information model, but also includes some aspects of 278 a data model, such as explicit definitions of the LFB class schema 279 and FE schema. It is expected that this FE model will be used as the 280 basis to define the payload for information exchange between the CE 281 and FE in the ForCES protocol. 283 2.1. Requirements on the FE model 285 RFC3654 [6]defines requirements that must be satisfied by a ForCES FE 286 model. To summarize, an FE model must define: 288 o Logically separable and distinct packet forwarding operations in 289 an FE datapath (logical functional blocks or LFBs); 291 o The possible topological relationships (and hence the sequence of 292 packet forwarding operations) between the various LFBs; 294 o The possible operational capabilities (e.g., capacity limits, 295 constraints, optional features, granularity of configuration) of 296 each type of LFB; 298 o The possible configurable parameters (e.g., components) of each 299 type of LFB; 301 o Metadata that may be exchanged between LFBs. 303 2.2. The FE Model in Relation to FE Implementations 305 The FE model proposed here is based on an abstraction using distinct 306 logical functional blocks (LFBs), which are interconnected in a 307 directed graph, and receive, process, modify, and transmit packets 308 along with metadata. The FE model is designed, and any defined LFB 309 classes should be designed, such that different implementations of 310 the forwarding datapath can be logically mapped onto the model with 311 the functionality and sequence of operations correctly captured. 312 However, the model is not intended to directly address how a 313 particular implementation maps to an LFB topology. It is left to the 314 forwarding plane vendors to define how the FE functionality is 315 represented using the FE model. Our goal is to design the FE model 316 such that it is flexible enough to accommodate most common 317 implementations. 319 The LFB topology model for a particular datapath implementation must 320 correctly capture the sequence of operations on the packet. Metadata 321 generation by certain LFBs MUST always precede any use of that 322 metadata by subsequent LFBs in the topology graph; this is required 323 for logically consistent operation. Further, modification of packet 324 fields that are subsequently used as inputs for further processing 325 MUST occur in the order specified in the model for that particular 326 implementation to ensure correctness. 328 2.3. The FE Model in Relation to the ForCES Protocol 330 The ForCES base Protocol [2] is used by the CEs and FEs to maintain 331 the communication channel between the CEs and FEs. The ForCES 332 protocol may be used to query and discover the intra-FE topology. 333 The details of a particular datapath implementation inside an FE, 334 including the LFB topology, along with the operational capabilities 335 and attributes of each individual LFB, are conveyed to the CE within 336 information elements in the ForCES protocol. The model of an LFB 337 class should define all of the information that needs to be exchanged 338 between an FE and a CE for the proper configuration and management of 339 that LFB. 341 Specifying the various payloads of the ForCES messages in a 342 systematic fashion is difficult without a formal definition of the 343 objects being configured and managed (the FE and the LFBs within). 344 The FE Model document defines a set of classes and components for 345 describing and manipulating the state of the LFBs within an FE. 346 These class definitions themselves will generally not appear in the 347 ForCES protocol. Rather, ForCES protocol operations will reference 348 classes defined in this model, including relevant components and the 349 defined operations. 351 Section 7 provides more detailed discussion on how the FE model 352 should be used by the ForCES protocol. 354 2.4. Modeling Language for the FE Model 356 Even though not absolutely required, it is beneficial to use a formal 357 data modeling language to represent the conceptual FE model described 358 in this document. Use of a formal language can help to enforce 359 consistency and logical compatibility among LFBs. A full 360 specification will be written using such a data modeling language. 361 The formal definition of the LFB classes may facilitate the eventual 362 automation of some of the code generation process and the functional 363 validation of arbitrary LFB topologies. These class definitions form 364 the LFB Library. Documents which describe LFB Classes are therefore 365 referred to as LFB Library documents. 367 Human readability was the most important factor considered when 368 selecting the specification language, whereas encoding, decoding and 369 transmission performance was not a selection factor. The encoding 370 method for over the wire transport is not dependent on the 371 specification language chosen and is outside the scope of this 372 document and up to the ForCES protocol to define. 374 XML is chosen as the specification language in this document, because 375 XML has the advantage of being both human and machine readable with 376 widely available tools support. This document uses an XML Schema to 377 define the structure of the LFB Library documents, as defined in [11] 378 and [4] and [5]. While these LFB Class definitions are not sent in 379 the ForCES protocol, these definitions comply with the 380 recommendations in RFC3470 [11] on the use of XML in IETF protocols. 382 By useing XML Schema to define the structure for the LFB Library 383 documents, we have a very clear set of syntactic restrictions to go 384 with the desired semantic descriptions and restrictions covered in 385 this document. As a corrolary to that, if it is determined that a 386 change in the syntax is needed then a new schema will be required. 387 This would be identified by a different URN to identify the namespace 388 for such a new schema. 390 2.5. Document Structure 392 Section 3 provides a conceptual overview of the FE model, laying the 393 foundation for the more detailed discussion and specifications in the 394 sections that follow. Section 4 and Section 5 constitute the core of 395 the FE model, detailing the two major aspects of the FE model: a 396 general LFB model and a definition of the FE Object LFB, with its 397 components, including FE capabilities and LFB topology information. 398 Section 6 directly addresses the model requirements imposed by the 399 ForCES requirements defined in RFC3654 [6] while Section 7 explains 400 how the FE model should be used in the ForCES protocol. 402 3. ForCES Model Concepts 404 Some of the important ForCES concepts used throughout this document 405 are introduced in this section. These include the capability and 406 state abstraction, the FE and LFB model construction, and the unique 407 addressing of the different model structures. Details of these 408 aspects are described in Section 4 and Section 5. The intent of this 409 section is to discuss these concepts at the high level and lay the 410 foundation for the detailed description in the following sections. 412 The ForCES FE model includes both a capability and a state 413 abstraction. 415 o The FE/LFB capability model describes the capabilities and 416 capacities of an FE/LFB by specifying the variation in functions 417 supported and any limitations. Capacity describes the limits of 418 specific components (an example would be a table size limit). 420 o The state model describes the current state of the FE/LFB, that 421 is, the instantaneous values or operational behavior of the FE/ 422 LFB. 424 Section 3.1 explains the difference between a capability model and a 425 state model, and describes how the two can be combined in the FE 426 model. 428 The ForCES model construction laid out in this document allows an FE 429 to provide information about its structure for operation. This can 430 be thought of as FE level information and information about the 431 individual instances of LFBs provided by the FE. 433 o The ForCES model includes the constructions for defining the class 434 of logical function blocks (LFBS) that an FE may support. These 435 classes are defined in this and other documents. The definition 436 of such a class provides the information content for monitoring 437 and controlling instances of the LFB class for ForCES purposes. 438 Each LFB model class formally defines the operational LFB 439 components, LFB capabilities, and LFB events. Essentially, 440 Section 3.2 introduces the concept of LFBs as the basic functional 441 building blocks in the ForCES model. 443 o The FE model also provides the construction necessary to monitor 444 and control the FE as a whole for ForCES purposes. For 445 consistency of operation and simplicity, this information is 446 represented as an LFB, the FE Object LFB class and a singular LFB 447 instance of that class, defined using the LFB model. The FE 448 Object class defines the components to provide information at the 449 FE level, particularly the capabilities of the FE at a coarse 450 level, i.e., not all possible capabilities nor all details about 451 the capabilities of the FE. Part of the FE level information is 452 the LFB topology, which expresses the logical inter-connection 453 between the LFB instances along the datapath(s) within the FE. 454 Section 3.3 discusses the LFB topology. The FE Object also 455 includes information about what LFB classes the FE can support. 457 The ForCES model allows for unique identification of the different 458 constructs it defines. This includes identification of the LFB 459 classes, and of LFB instances within those classes, as well as 460 identification of components within those instances. 462 The ForCES Protocol [2] encapsulates target address(es) to eventually 463 get to a fine-grained entity being referenced by the CE. The 464 addressing hierarchy is broken into the following: 466 o An FE is uniquely identified by a 32 bit FEID. 468 o Each Class of LFB is uniquely identified by a 32 bit LFB ClassID. 469 The LFB ClassIDs are global within the Network Element and may be 470 issued by IANA. 472 o Within an FE, there can be multiple instances of each LFB class. 473 Each LFB Class instance is identified by a 32 bit identifier which 474 is unique within a particular LFB class on that FE. 476 o All the components within an LFB instance are further defined 477 using 32 bit identifiers. 479 Refer to Section 3.3 for more details on addressing. 481 3.1. ForCES Capability Model and State Model 483 Capability and state modelling applies to both the FE and LFB 484 abstraction. 486 Figure 1 shows the concepts of FE state, capabilities and 487 configuration in the context of CE-FE communication via the ForCES 488 protocol. 490 +-------+ +-------+ 491 | | FE capabilities: what it can/cannot do. | | 492 | |<-----------------------------------------| | 493 | | | | 494 | CE | FE state: what it is now. | FE | 495 | |<-----------------------------------------| | 496 | | | | 497 | | FE configuration: what it should be. | | 498 | |----------------------------------------->| | 499 +-------+ +-------+ 501 Figure 1: Illustration of FE capabilities, state and configuration 502 exchange in the context of CE-FE communication via ForCES. 504 3.1.1. FE Capability Model and State Model 506 Conceptually, the FE capability model tells the CE which states are 507 allowed on an FE, with capacity information indicating certain 508 quantitative limits or constraints. Thus, the CE has general 509 knowledge about configurations that are applicable to a particular 510 FE. 512 3.1.1.1. FE Capability Model 514 The FE capability model may be used to describe an FE at a coarse 515 level. For example, an FE might be defined as follows: 517 o the FE can handle IPv4 and IPv6 forwarding; 519 o the FE can perform classification based on the following fields: 520 source IP address, destination IP address, source port number, 521 destination port number, etc.; 523 o the FE can perform metering; 525 o the FE can handle up to N queues (capacity); 527 o the FE can add and remove encapsulating headers of types including 528 IPsec, GRE, L2TP. 530 While one could try to build an object model to fully represent the 531 FE capabilities, other efforts found this approach to be a 532 significant undertaking. The main difficulty arises in describing 533 detailed limits, such as the maximum number of classifiers, queues, 534 buffer pools, and meters that the FE can provide. We believe that a 535 good balance between simplicity and flexibility can be achieved for 536 the FE model by combining coarse level capability reporting with an 537 error reporting mechanism. That is, if the CE attempts to instruct 538 the FE to set up some specific behavior it cannot support, the FE 539 will return an error indicating the problem. Examples of similar 540 approaches include DiffServ PIB RFC3317 [8] and Framework PIB RFC3318 541 [9]. 543 3.1.1.2. FE State Model 545 The FE state model presents the snapshot view of the FE to the CE. 546 For example, using an FE state model, an FE might be described to its 547 corresponding CE as the following: 549 o on a given port, the packets are classified using a given 550 classification filter; 552 o the given classifier results in packets being metered in a certain 553 way and then marked in a certain way; 555 o the packets coming from specific markers are delivered into a 556 shared queue for handling, while other packets are delivered to a 557 different queue; 559 o a specific scheduler with specific behavior and parameters will 560 service these collected queues. 562 3.1.1.3. LFB Capability and State Model 564 Both LFB Capability and State information are defined formally using 565 the LFB modelling XML schema. 567 Capability information at the LFB level is an integral part of the 568 LFB model and provides for powerful semantics. For example, when 569 certain features of an LFB class are optional, the CE needs to be 570 able to determine whether those optional features are supported by a 571 given LFB instance. The schema for the definition of LFB classes 572 provides a means for identifying such components. 574 State information is defined formally using LFB component constructs. 576 3.1.2. Relating LFB and FE Capability and State Model 578 Capability information at the FE level describes the LFB classes that 579 the FE can instantiate, the number of instances of each that can be 580 created, the topological (linkage) limitations between these LFB 581 instances, etc. Section 5 defines the FE level components including 582 capability information. Since all information is represented as 583 LFBs, this is provided by a single instance of the FE Object LFB 584 Class. By using a single instance with a known LFB Class and a known 585 instance identification, the ForCES protocol can allow a CE to access 586 this information whenever it needs to, including while the CE is 587 establishing the control of the FE. 589 Once the FE capability is described to the CE, the FE state 590 information can be represented at two levels. The first level is the 591 logically separable and distinct packet processing functions, called 592 LFBs. The second level of information describes how these individual 593 LFBs are ordered and placed along the datapath to deliver a complete 594 forwarding plane service. The interconnection and ordering of the 595 LFBs is called LFB Topology. Section 3.2 discusses high level 596 concepts around LFBs, whereas Section 3.3 discusses LFB topology 597 issues. This topology information is represented as components of 598 the FE Object LFB instance, to allow the CE to fetch and manipulate 599 this. 601 3.2. Logical Functional Block (LFB) Modeling 603 Each LFB performs a well-defined action or computation on the packets 604 passing through it. Upon completion of its prescribed function, 605 either the packets are modified in certain ways (e.g., decapsulator, 606 marker), or some results are generated and stored, often in the form 607 of metadata (e.g., classifier). Each LFB typically performs a single 608 action. Classifiers, shapers and meters are all examples of such 609 LFBs. Modeling LFBs at such a fine granularity allows us to use a 610 small number of LFBs to express the higher-order FE functions (such 611 as an IPv4 forwarder) precisely, which in turn can describe more 612 complex networking functions and vendor implementations of software 613 and hardware. These fine grained LFBs will be defined in detail in 614 one or more documents to be published separately, using the material 615 in this model. 617 It is also the case that LFBs may exist in order to provide a set of 618 components for control of FE operation by the CE (i.e., a locus of 619 control), without tying that control to specific packets or specific 620 parts of the data path. An example of such an LFB is the FE Object 621 which provides the CE with information about the FE as a whole, and 622 allows the FE to control some aspects of the FE, such as the datapath 623 itself. Such LFBs will not have the packet oriented properties 624 described in this section. 626 In general, multiple LFBs are contained in one FE, as shown in 627 Figure 2, and all the LFBs share the same ForCES protocol (Fp) 628 termination point that implements the ForCES protocol logic and 629 maintains the communication channel to and from the CE. 631 +-----------+ 632 | CE | 633 +-----------+ 634 ^ 635 | Fp reference point 636 | 637 +--------------------------|-----------------------------------+ 638 | FE | | 639 | v | 640 | +----------------------------------------------------------+ | 641 | | ForCES protocol | | 642 | | termination point | | 643 | +----------------------------------------------------------+ | 644 | ^ ^ | 645 | : : Internal control | 646 | : : | 647 | +---:----------+ +---:----------| | 648 | | :LFB1 | | : LFB2 | | 649 | =====>| v |============>| v |======>...| 650 | Inputs| +----------+ |Outputs | +----------+ | | 651 | (P,M) | |Components| |(P',M') | |Components| |(P",M") | 652 | | +----------+ | | +----------+ | | 653 | +--------------+ +--------------+ | 654 | | 655 +--------------------------------------------------------------+ 657 Figure 2: Generic LFB Diagram 659 An LFB, as shown in Figure 2, may have inputs, outputs and components 660 that can be queried and manipulated by the CE via an Fp reference 661 point (defined in RFC3746 [7]) and the ForCES protocol termination 662 point. The horizontal axis is in the forwarding plane for connecting 663 the inputs and outputs of LFBs within the same FE. P (with marks to 664 indicate modification) indicates a data packet, while M (with marks 665 to indicate modification) indicates the metadata associated with a 666 packet. The vertical axis between the CE and the FE denotes the Fp 667 reference point where bidirectional communication between the CE and 668 FE occurs: the CE to FE communication is for configuration, control, 669 and packet injection, while FE to CE communication is used for packet 670 redirection to the control plane, reporting of monitoring and 671 accounting information, reporting of errors, etc. Note that the 672 interaction between the CE and the LFB is only abstract and indirect. 673 The result of such an interaction is for the CE to manipulate the 674 components of the LFB instances. 676 An LFB can have one or more inputs. Each input takes a pair of a 677 packet and its associated metadata. Depending upon the LFB input 678 port definition, the packet or the metadata may be allowed to be 679 empty (or equivalently to not be provided.) When input arrives at an 680 LFB, either the packet or its associated metadata must be non-empty 681 or there is effectively no input. (LFB operation generally may be 682 triggered by input arrival, by timers, or by other system state. It 683 is only in the case where the goal is to have input drive operation 684 that the input must be non-empty.) 686 The LFB processes the input, and produces one or more outputs, each 687 of which is a pair of a packet and its associated metadata. Again, 688 depending upon the LFB output port definition, either the packet or 689 the metadata may be allowed to be empty (or equivalently to be 690 absent.) Metadata attached to packets on output may be metadata that 691 was received, or may be information about the packet processing that 692 may be used by later LFBs in the FEs packet processing. 694 A namespace is used to associate a unique name and ID with each LFB 695 class. The namespace MUST be extensible so that a new LFB class can 696 be added later to accommodate future innovation in the forwarding 697 plane. 699 LFB operation is specified in the model to allow the CE to understand 700 the behavior of the forwarding datapath. For instance, the CE needs 701 to understand at what point in the datapath the IPv4 header TTL is 702 decremented by the FE. That is, the CE needs to know if a control 703 packet could be delivered to it either before or after this point in 704 the datapath. In addition, the CE needs to understand where and what 705 type of header modifications (e.g., tunnel header append or strip) 706 are performed by the FEs. Further, the CE works to verify that the 707 various LFBs along a datapath within an FE are compatible to link 708 together. Connecting incompatible LFB instances will produce a non- 709 working data path. So the model is designed to provide sufficient 710 information for the CE to make this determination. 712 Selecting the right granularity for describing the functions of the 713 LFBs is an important aspect of this model. There is value to vendors 714 if the operation of LFB classes can be expressed in sufficient detail 715 so that physical devices implementing different LFB functions can be 716 integrated easily into an FE design. However, the model, and the 717 associated library of LFBs, must not be so detailed and so specific 718 as to significantly constrain implementations. Therefore, a semi- 719 formal specification is needed; that is, a text description of the 720 LFB operation (human readable), but sufficiently specific and 721 unambiguous to allow conformance testing and efficient design, so 722 that interoperability between different CEs and FEs can be achieved. 724 The LFB class model specifies information such as: 726 o number of inputs and outputs (and whether they are configurable) 728 o metadata read/consumed from inputs; 730 o metadata produced at the outputs; 732 o packet type(s) accepted at the inputs and emitted at the outputs; 734 o packet content modifications (including encapsulation or 735 decapsulation); 737 o packet routing criteria (when multiple outputs on an LFB are 738 present); 740 o packet timing modifications; 742 o packet flow ordering modifications; 744 o LFB capability information components; 746 o events that can be detected by the LFB, with notification to the 747 CE; 749 o LFB operational components; 751 o etc. 753 Section 4 of this document provides a detailed discussion of the LFB 754 model with a formal specification of LFB class schema. The rest of 755 Section 3.2 only intends to provide a conceptual overview of some 756 important issues in LFB modeling, without covering all the specific 757 details. 759 3.2.1. LFB Outputs 761 An LFB output is a conceptual port on an LFB that can send 762 information to another LFB. The information sent on that port is a 763 pair of a packet and associated metadata, one of which may be empty. 764 (If both were empty, there would be no output.) 766 A single LFB output can be connected to only one LFB input. This is 767 required to make the packet flow through the LFB topology 768 unambiguous. 770 Some LFBs will have a single output, as depicted in Figure 3.a. 772 +---------------+ +-----------------+ 773 | | | | 774 | | | OUT +--> 775 ... OUT +--> ... | 776 | | | EXCEPTIONOUT +--> 777 | | | | 778 +---------------+ +-----------------+ 780 a. One output b. Two distinct outputs 782 +---------------+ +-----------------+ 783 | | | EXCEPTIONOUT +--> 784 | OUT:1 +--> | | 785 ... OUT:2 +--> ... OUT:1 +--> 786 | ... +... | OUT:2 +--> 787 | OUT:n +--> | ... +... 788 +---------------+ | OUT:n +--> 789 +-----------------+ 791 c. One output group d. One output and one output group 793 Figure 3: Examples of LFBs with various output combinations. 795 To accommodate a non-trivial LFB topology, multiple LFB outputs are 796 needed so that an LFB class can fork the datapath. Two mechanisms 797 are provided for forking: multiple singleton outputs and output 798 groups, which can be combined in the same LFB class. 800 Multiple separate singleton outputs are defined in an LFB class to 801 model a pre-determined number of semantically different outputs. 802 That is, the LFB class definition MUST include the number of outputs, 803 implying the number of outputs is known when the LFB class is 804 defined. Additional singleton outputs cannot be created at LFB 805 instantiation time, nor can they be created on the fly after the LFB 806 is instantiated. 808 For example, an IPv4 LPM (Longest-Prefix-Matching) LFB may have one 809 output (OUT) to send those packets for which the LPM look-up was 810 successful, passing a META_ROUTEID as metadata; and have another 811 output (EXCEPTIONOUT) for sending exception packets when the LPM 812 look-up failed. This example is depicted in Figure 3.b. Packets 813 emitted by these two outputs not only require different downstream 814 treatment, but they are a result of two different conditions in the 815 LFB and each output carries different metadata. This concept assumes 816 the number of distinct outputs is known when the LFB class is 817 defined. For each singleton output, the LFB class definition defines 818 the types of frames (packets) and metadata the output emits. 820 An output group, on the other hand, is used to model the case where a 821 flow of similar packets with an identical set of permitted metadata 822 needs to be split into multiple paths. In this case, the number of 823 such paths is not known when the LFB class is defined because it is 824 not an inherent property of the LFB class. An output group consists 825 of a number of outputs, called the output instances of the group, 826 where all output instances share the same frame (packet) and metadata 827 emission definitions (see Figure 3.c). Each output instance can 828 connect to a different downstream LFB, just as if they were separate 829 singleton outputs, but the number of output instances can differ 830 between LFB instances of the same LFB class. The class definition 831 may include a lower and/or an upper limit on the number of outputs. 832 In addition, for configurable FEs, the FE capability information may 833 define further limits on the number of instances in specific output 834 groups for certain LFBs. The actual number of output instances in a 835 group is an component of the LFB instance, which is read-only for 836 static topologies, and read-write for dynamic topologies. The output 837 instances in a group are numbered sequentially, from 0 to N-1, and 838 are addressable from within the LFB. To use Output Port groups, the 839 LFB has to have a built-in mechanism to select one specific output 840 instance for each packet. This mechanism is described in the textual 841 definition of the class and is typically configurable via some 842 attributes of the LFB. 844 For example, consider a redirector LFB, whose sole purpose is to 845 direct packets to one of N downstream paths based on one of the 846 metadata associated with each arriving packet. Such an LFB is fairly 847 versatile and can be used in many different places in a topology. 848 For example, given LFBs which record the type of packet in a 849 FRAMETYPE metadatum, or a packet rate class in a COLOR metadatum, one 850 may uses these metadata for branching. A redirector can be used to 851 divide the data path into an IPv4 and an IPv6 path based on a 852 FRAMETYPE metadatum (N=2), or to fork into rate specific paths after 853 metering using the COLOR metadatum (red, yellow, green; N=3), etc. 855 Using an output group in the above LFB class provides the desired 856 flexibility to adapt each instance of this class to the required 857 operation. The metadata to be used as a selector for the output 858 instance is a property of the LFB. For each packet, the value of the 859 specified metadata may be used as a direct index to the output 860 instance. Alternatively, the LFB may have a configurable selector 861 table that maps a metadatum value to output instance. 863 Note that other LFBs may also use the output group concept to build 864 in similar adaptive forking capability. For example, a classifier 865 LFB with one input and N outputs can be defined easily by using the 866 output group concept. Alternatively, a classifier LFB with one 867 singleton output in combination with an explicit N-output re- 868 director LFB models the same processing behavior. The decision of 869 whether to use the output group model for a certain LFB class is left 870 to the LFB class designers. 872 The model allows the output group to be combined with other singleton 873 output(s) in the same class, as demonstrated in Figure 3.d. The LFB 874 here has two types of outputs, OUT, for normal packet output, and 875 EXCEPTIONOUT for packets that triggered some exception. The normal 876 OUT has multiple instances, thus, it is an output group. 878 In summary, the LFB class may define one output, multiple singleton 879 outputs, one or more output groups, or a combination thereof. 880 Multiple singleton outputs should be used when the LFB must provide 881 for forking the datapath and at least one of the following conditions 882 hold: 884 o the number of downstream directions is inherent from the 885 definition of the class and hence fixed; 887 o the frame type and set of permitted metadata emitted on any of the 888 outputs are different from what is emitted on the other outputs 889 (i.e., they cannot share their frametype and permitted metadata 890 definitions). 892 An output group is appropriate when the LFB must provide for forking 893 the datapath and at least one of the following conditions hold: 895 o the number of downstream directions is not known when the LFB 896 class is defined; 898 o the frame type and set of metadata emitted on these outputs are 899 sufficiently similar or, ideally, identical, such they can share 900 the same output definition. 902 3.2.2. LFB Inputs 904 An LFB input is a conceptual port on an LFB on which the LFB can 905 receive information from other LFBs. The information is typically a 906 pair of a packet and its associated metadata. Either the packet, or 907 the metadata, may for some LFBs and some situations be empty. They 908 can not both be empty, as then there is no input. 910 For LFB instances that receive packets from more than one other LFB 911 instance (fan-in) there are three ways to model fan-in, all supported 912 by the LFB model and can all be combined in the same LFB: 914 o Implicit multiplexing via a single input 916 o Explicit multiplexing via multiple singleton inputs 918 o Explicit multiplexing via a group of inputs (input group) 920 The simplest form of multiplexing uses a singleton input 921 (Figure 4.a). Most LFBs will have only one singleton input. 922 Multiplexing into a single input is possible because the model allows 923 more than one LFB output to connect to the same LFB input. This 924 property applies to any LFB input without any special provisions in 925 the LFB class. Multiplexing into a single input is applicable when 926 the packets from the upstream LFBs are similar in frametype and 927 accompanying metadata, and require similar processing. Note that 928 this model does not address how potential contention is handled when 929 multiple packets arrive simultaneously. If contention handling needs 930 to be explicitly modeled, one of the other two modeling solutions 931 must be used. 933 The second method to model fan-in uses individually defined singleton 934 inputs (Figure 4.b). This model is meant for situations where the 935 LFB needs to handle distinct types of packet streams, requiring 936 input-specific handling inside the LFB, and where the number of such 937 distinct cases is known when the LFB class is defined. For example, 938 an LFB which can perform both Layer 2 decapsulation (to Layer 3) and 939 Layer 3 encapsulation (to Layer 2) may have two inputs, one for 940 receiving Layer 2 frames for decapsulation, and one for receiving 941 Layer 3 frames for encapsulation. This LFB type expects different 942 frames (L2 vs. L3) at its inputs, each with different sets of 943 metadata, and would thus apply different processing on frames 944 arriving at these inputs. This model is capable of explicitly 945 addressing packet contention by defining how the LFB class handles 946 the contending packets. 948 +--------------+ +------------------------+ 949 | LFB X +---+ | | 950 +--------------+ | | | 951 | | | 952 +--------------+ v | | 953 | LFB Y +---+-->|input Meter LFB | 954 +--------------+ ^ | | 955 | | | 956 +--------------+ | | | 957 | LFB Z |---+ | | 958 +--------------+ +------------------------+ 960 (a) An LFB connects with multiple upstream LFBs via a single input. 962 +--------------+ +------------------------+ 963 | LFB X +---+ | | 964 +--------------+ +-->|layer2 | 965 +--------------+ | | 966 | LFB Y +------>|layer3 LFB | 967 +--------------+ +------------------------+ 969 (b) An LFB connects with multiple upstream LFBs via two separate 970 singleton inputs. 972 +--------------+ +------------------------+ 973 | Queue LFB #1 +---+ | | 974 +--------------+ | | | 975 | | | 976 +--------------+ +-->|in:0 \ | 977 | Queue LFB #2 +------>|in:1 | input group | 978 +--------------+ |... | | 979 +-->|in:N-1 / | 980 ... | | | 981 +--------------+ | | | 982 | Queue LFB #N |---+ | Scheduler LFB | 983 +--------------+ +------------------------+ 985 (c) A Scheduler LFB uses an input group to differentiate which queue 986 LFB packets are coming from. 988 Figure 4: Examples of LFBs with various input combinations. 990 The third method to model fan-in uses the concept of an input group. 991 The concept is similar to the output group introduced in the previous 992 section and is depicted in Figure 4.c. An input group consists of a 993 number of input instances, all sharing the properties (same frame and 994 metadata expectations). The input instances are numbered from 0 to 995 N-1. From the outside, these inputs appear as normal inputs, i.e., 996 any compatible upstream LFB can connect its output to one of these 997 inputs. When a packet is presented to the LFB at a particular input 998 instance, the index of the input where the packet arrived is known to 999 the LFB and this information may be used in the internal processing. 1000 For example, the input index can be used as a table selector, or as 1001 an explicit precedence selector to resolve contention. As with 1002 output groups, the number of input instances in an input group is not 1003 defined in the LFB class. However, the class definition may include 1004 restrictions on the range of possible values. In addition, if an FE 1005 supports configurable topologies, it may impose further limitations 1006 on the number of instances for particular port group(s) of a 1007 particular LFB class. Within these limitations, different instances 1008 of the same class may have a different number of input instances. 1009 The number of actual input instances in the group is a component 1010 defined in the LFB class, which is read-only for static topologies, 1011 and is read-write for configurable topologies. 1013 As an example for the input group, consider the Scheduler LFB 1014 depicted in Figure 4.c. Such an LFB receives packets from a number 1015 of Queue LFBs via a number of input instances, and uses the input 1016 index information to control contention resolution and scheduling. 1018 In summary, the LFB class may define one input, multiple singleton 1019 inputs, one or more input groups, or a combination thereof. Any 1020 input allows for implicit multiplexing of similar packet streams via 1021 connecting multiple outputs to the same input. Explicit multiple 1022 singleton inputs are useful when either the contention handling must 1023 be handled explicitly, or when the LFB class must receive and process 1024 a known number of distinct types of packet streams. An input group 1025 is suitable when contention handling must be modeled explicitly, but 1026 the number of inputs is not inherent from the class (and hence is not 1027 known when the class is defined), or when it is critical for LFB 1028 operation to know exactly on which input the packet was received. 1030 3.2.3. Packet Type 1032 When LFB classes are defined, the input and output packet formats 1033 (e.g., IPv4, IPv6, Ethernet, etc.) MUST be specified. These are the 1034 types of packets that a given LFB input is capable of receiving and 1035 processing, or that a given LFB output is capable of producing. This 1036 model requires that distinct packet types be uniquely labeled with a 1037 symbolic name and/or ID. 1039 Note that each LFB has a set of packet types that it operates on, but 1040 does not care whether the underlying implementation is passing a 1041 greater portion of the packets. For example, an IPv4 LFB might only 1042 operate on IPv4 packets, but the underlying implementation may or may 1043 not be stripping the L2 header before handing it over. Whether such 1044 processing is happening or not is opaque to the CE. 1046 3.2.4. Metadata 1048 Metadata is state that is passed from one LFB to another alongside a 1049 packet. The metadata passed with the packet assists subsequent LFBs 1050 to process that packet. 1052 The ForCES model defines metadata as precise atomic definitions in 1053 the form of label, value pairs. 1055 The ForCES model provides to the authors of LFB classes a way to 1056 formally define how to achieve metadata creation, modification, 1057 reading, as well as consumption (deletion). 1059 Inter-FE metadata, i.e, metadata crossing FEs, while it is likely to 1060 be semantically similar to this metadata, is out of scope for this 1061 document. 1063 Section 4 has informal details on metadata. 1065 3.2.4.1. Metadata Lifecycle Within the ForCES Model 1067 Each metadatum is modeled as a pair, where the label 1068 identifies the type of information, (e.g., "color"), and its value 1069 holds the actual information (e.g., "red"). The label here is shown 1070 as a textual label, but for protocol processing it is associated with 1071 a unique numeric value (identifier). 1073 To ensure inter-operability between LFBs, the LFB class specification 1074 must define what metadata the LFB class "reads" or "consumes" on its 1075 input(s) and what metadata it "produces" on its output(s). For 1076 maximum extensibility, this definition should neither specify which 1077 LFBs the metadata is expected to come from for a consumer LFB, nor 1078 which LFBs are expected to consume metadata for a given producer LFB. 1080 3.2.4.2. Metadata Production and Consumption 1082 For a given metadatum on a given packet path, there MUST be at least 1083 one producer LFB that creates that metadatum and SHOULD be at least 1084 one consumer LFB that needs that metadatum. 1086 In the ForCES model, the producer and consumer LFBs of a metadatum 1087 are not required to be adjacent. In addition, there may be multiple 1088 producers and consumers for the same metadatum. When a packet path 1089 involves multiple producers of the same metadatum, then subsequent 1090 producers overwrite that metadatum value. 1092 The metadata that is produced by an LFB is specified by the LFB class 1093 definition on a per-output-port-group basis. A producer may always 1094 generate the metadata on the port group, or may generate it only 1095 under certain conditions. We call the former "unconditional" 1096 metadata, whereas the latter is a "conditional" metadata. For 1097 example, deep packet inspection LFB might produce several pieces of 1098 metadata about the packet. The first metadatum might be the IP 1099 protocol (TCP, UDP, SCTP, ...) being carried, and two additional 1100 metadata items might be the source and destination port number. 1101 These additional metadata items are conditional on the value of the 1102 first metadatum (IP carried protocol) as they are only produced for 1103 protocols which use port numbers. In the case of conditional 1104 metadata, it should be possible to determine from the definition of 1105 the LFB when "conditional" metadata is produced. The consumer 1106 behavior of an LFB, that is, the metadata that the LFB needs for its 1107 operation, is defined in the LFB class definition on a per-input- 1108 port-group basis. An input port group may "require" a given 1109 metadatum, or may treat it as "optional" information. In the latter 1110 case, the LFB class definition MUST explicitly define what happens if 1111 any optional metadata is not provided. One approach is to specify a 1112 default value for each optional metadatum, and assume that the 1113 default value is used for any metadata which is not provided with the 1114 packet. 1116 When specifying the metadata tags, some harmonization effort must be 1117 made so that the producer LFB class uses the same tag as its intended 1118 consumer(s). 1120 3.2.4.3. LFB Operations on Metadata 1122 When the packet is processed by an LFB (i.e., between the time it is 1123 received and forwarded by the LFB), the LFB may perform read, write, 1124 and/or consume operations on any active metadata associated with the 1125 packet. If the LFB is considered to be a black box, one of the 1126 following operations is performed on each active metadatum. 1128 * IGNORE: ignores and forwards the metadatum 1130 * READ: reads and forwards the metadatum 1131 * READ/RE-WRITE: reads, over-writes and forwards the metadatum 1133 * WRITE: writes and forwards the metadatum (can also be used to 1134 create new metadata) 1136 * READ-AND-CONSUME: reads and consumes the metadatum 1138 * CONSUME consumes metadatum without reading 1140 The last two operations terminate the life-cycle of the metadatum, 1141 meaning that the metadatum is not forwarded with the packet when the 1142 packet is sent to the next LFB. 1144 In the ForCES model, a new metadatum is generated by an LFB when the 1145 LFB applies a WRITE operation to a metadatum type that was not 1146 present when the packet was received by the LFB. Such implicit 1147 creation may be unintentional by the LFB, that is, the LFB may apply 1148 the WRITE operation without knowing or caring if the given metadatum 1149 existed or not. If it existed, the metadatum gets over-written; if 1150 it did not exist, the metadatum is created. 1152 For LFBs that insert packets into the model, WRITE is the only 1153 meaningful metadata operation. 1155 For LFBs that remove the packet from the model, they may either READ- 1156 AND-CONSUME (read) or CONSUME (ignore) each active metadatum 1157 associated with the packet. 1159 3.2.5. LFB Events 1161 During operation, various conditions may occur that can be detected 1162 by LFBs. Examples range from link failure or restart to timer 1163 expiration in special purpose LFBs. The CE may wish to be notified 1164 of the occurrence of such events. The description of how such 1165 messages are sent, and their format, is part of the Forwarding and 1166 Control Element Separation (ForCES) protocol [2] document. 1167 Indicating how such conditions are understood is part of the job of 1168 this model. 1170 Events are declared in the LFB class definition. The LFB event 1171 declaration constitutes: 1173 o a unique 32 bit identifier. 1175 o An LFB component which is used to trigger the event. This entity 1176 is known as the event target. 1178 o A condition that will happen to the event target that will result 1179 in a generation of an event to the CE. Examples of a condition 1180 include something getting created, deleted, config change, etc. 1182 o What should be reported to the CE by the FE if the declared 1183 condition is met. 1185 The declaration of an event within an LFB class essentially defines 1186 what part of the LFB component(s) need to be monitored for events, 1187 what condition on the LFB monitored LFB component an FE should detect 1188 to trigger such an event, and what to report to the CE when the event 1189 is triggered. 1191 While events may be declared by the LFB class definition, runtime 1192 activity is controlled using built-in event properties using LFB 1193 component Properties (discussed in Section 3.2.6). A CE subscribes 1194 to the events on an LFB class instance by setting an event property 1195 for subscription. Each event has a subscription property which is by 1196 default off. A CE wishing to receive a specific event needs to turn 1197 on the subscription property at runtime. 1199 Event properties also provide semantics for runtime event filtering. 1200 A CE may set an event property to further suppress events to which it 1201 has already subscribed. The LFB model defines such filters to 1202 include threshold values, hysteresis, time intervals, number of 1203 events, etc. 1205 The contents of reports with events are designed to allow for the 1206 common, closely related information that the CE can be strongly 1207 expected to need to react to the event. It is not intended to carry 1208 information that the CE already has, nor large volumes of 1209 information, nor information related in complex fashions. 1211 From a conceptual point of view, at runtime, event processing is 1212 split into: 1214 1. detection of something happening to the (declared during LFB 1215 class definition) event target. Processing the next step happens 1216 if the CE subscribed (at runtime) to the event. 1218 2. checking of the (declared during LFB class definition) condition 1219 on the LFB event target. If the condition is met, proceed with 1220 the next step. 1222 3. checking (runtime set) event filters if they exist to see if the 1223 event should be reported or suppressed. If the event is to be 1224 reported proceed to the next step. 1226 4. Submitting of the declared report to the CE. 1228 Section 4.7.6 discusses events in more details. 1230 3.2.6. Component Properties 1232 LFBs and structures are made up of Components, containing the 1233 information that the CE needs to see and/or change about the 1234 functioning of the LFB. These Components, as described in detail in 1235 Section 4.7, may be basic values, complex structures (containing 1236 multiple Components themselves, each of which can be values, 1237 structures, or tables), or tables (which contain values, structures 1238 or tables). Components may be defined such that their appearence in 1239 LFB instances is optional. Components may be readable or writable at 1240 the discretion of the FE implementation. The CE needs to know these 1241 properties. Additionally, certain kinds of Components (arrays / 1242 tables, aliases, and events) have additional property information 1243 that the CE may need to read or write. This model defines the 1244 structure of the property information for all defined data types. 1246 Section 4.8 describes properties in more details. 1248 3.2.7. LFB Versioning 1250 LFB class versioning is a method to enable incremental evolution of 1251 LFB classes. In general, an FE is not allowed to contain an LFB 1252 instance for more than one version of a particular class. 1253 Inheritance (discussed next in Section 3.2.8) has special rules. If 1254 an FE datapath model containing an LFB instance of a particular class 1255 C also simultaneously contains an LFB instance of a class C' 1256 inherited from class C; C could have a different version than C'. 1258 LFB class versioning is supported by requiring a version string in 1259 the class definition. CEs may support multiple versions of a 1260 particular LFB class to provide backward compatibility, but FEs MUST 1261 NOT support more than one version of a particular class. 1263 Versioning is not restricted to making backwards compatible changes. 1264 It is specifically expected to be used to make changes that cannot be 1265 represented by inheritance. Often this will be to correct errors, 1266 and hence may not be backwards compatible. It may also be used to 1267 remove components which are not considered useful (particularly if 1268 they were previously mandatory, and hence were an implementation 1269 impediment.) 1271 3.2.8. LFB Inheritance 1273 LFB class inheritance is supported in the FE model as a method to 1274 define new LFB classes. This also allows FE vendors to add vendor- 1275 specific extensions to standardized LFBs. An LFB class specification 1276 MUST specify the base class and version number it inherits from (the 1277 default is the base LFB class). Multiple inheritance is not allowed, 1278 however, to avoid unnecessary complexity. 1280 Inheritance should be used only when there is significant reuse of 1281 the base LFB class definition. A separate LFB class should be 1282 defined if little or no reuse is possible between the derived and the 1283 base LFB class. 1285 An interesting issue related to class inheritance is backward 1286 compatibility between a descendant and an ancestor class. Consider 1287 the following hypothetical scenario where a standardized LFB class 1288 "L1" exists. Vendor A builds an FE that implements LFB "L1" and 1289 vendor B builds a CE that can recognize and operate on LFB "L1". 1290 Suppose that a new LFB class, "L2", is defined based on the existing 1291 "L1" class by extending its capabilities incrementally. Let us 1292 examine the FE backward compatibility issue by considering what would 1293 happen if vendor B upgrades its FE from "L1" to "L2" and vendor C's 1294 CE is not changed. The old L1-based CE can interoperate with the new 1295 L2-based FE if the derived LFB class "L2" is indeed backward 1296 compatible with the base class "L1". 1298 The reverse scenario is a much less problematic case, i.e., when CE 1299 vendor B upgrades to the new LFB class "L2", but the FE is not 1300 upgraded. Note that as long as the CE is capable of working with 1301 older LFB classes, this problem does not affect the model; hence we 1302 will use the term "backward compatibility" to refer to the first 1303 scenario concerning FE backward compatibility. 1305 Backward compatibility can be designed into the inheritance model by 1306 constraining LFB inheritance to require the derived class be a 1307 functional superset of the base class (i.e. the derived class can 1308 only add functions to the base class, but not remove functions). 1309 Additionally, the following mechanisms are required to support FE 1310 backward compatibility: 1312 1. When detecting an LFB instance of an LFB type that is unknown to 1313 the CE, the CE MUST be able to query the base class of such an 1314 LFB from the FE. 1316 2. The LFB instance on the FE SHOULD support a backward 1317 compatibility mode (meaning the LFB instance reverts itself back 1318 to the base class instance), and the CE SHOULD be able to 1319 configure the LFB to run in such a mode. 1321 3.3. ForCES Model Addressing 1323 Figure 5 demonstrates the abstraction of the different ForCES model 1324 entities. The ForCES protocol provides the mechanism to uniquely 1325 identify any of the LFB Class instance components. 1327 FE Address = FE01 1328 +--------------------------------------------------------------+ 1329 | | 1330 | +--------------+ +--------------+ | 1331 | | LFB ClassID 1| |LFB ClassID 91| | 1332 | | InstanceID 3 |============>|InstanceID 3 |======>... | 1333 | | +----------+ | | +----------+ | | 1334 | | |Components| | | |Components| | | 1335 | | +----------+ | | +----------+ | | 1336 | +--------------+ +--------------+ | 1337 | | 1338 +--------------------------------------------------------------+ 1340 Figure 5: FE Entity Hierarchy 1342 At the top of the addressing hierachy is the FE identifier. In the 1343 example above, the 32-bit FE identifier is illustrated with the 1344 mnemonic FE01. The next 32-bit entity selector is the LFB ClassID. 1345 In the illustration above, two LFB classes with identifiers 1 and 91 1346 are demonstrated. The example above further illustrates one instance 1347 of each of the two classes. The scope of the 32-bit LFB class 1348 instance identifier is valid only within the LFB class. To emphasize 1349 that point, each of class 1 and 91 has an instance of 3. 1351 Using the described addressing scheme, a message could be sent to 1352 address FE01, LFB ClassID 1, LFB InstanceID 3, utilizing the ForCES 1353 protocol. However, to be effective, such a message would have to 1354 target entities within an LFB. These entities could be carrying 1355 state, capability, etc. These are further illustrated in Figure 6 1356 below. 1358 LFB Class ID 1,InstanceID 3 Components 1359 +-------------------------------------+ 1360 | | 1361 | LFB ComponentID 1 | 1362 | +----------------------+ | 1363 | | | | 1364 | +----------------------+ | 1365 | | 1366 | LFB ComponentID 31 | 1367 | +----------------------+ | 1368 | | | | 1369 | +----------------------+ | 1370 | | 1371 | LFB ComponentID 51 | 1372 | +----------------------+ | 1373 | | LFB ComponentID 89 | | 1374 | | +-----------------+ | | 1375 | | | | | | 1376 | | +-----------------+ | | 1377 | +----------------------+ | 1378 | | 1379 | | 1380 +-------------------------------------+ 1382 Figure 6: LFB Hierarchy 1384 Figure 6 zooms into the components carried by LFB Class ID 1, LFB 1385 InstanceID 3 from Figure 5. 1387 The example shows three components with 32-bit component identifiers 1388 1, 31, and 51. LFB ComponentID 51 is a complex structure 1389 encapsulating within it an entity with LFB ComponentID 89. LFB 1390 ComponentID 89 could be a complex structure itself but is restricted 1391 in the example for the sake of clarity. 1393 3.3.1. Addressing LFB Components: Paths and Keys 1395 As mentioned above, LFB components could be complex structures, such 1396 as a table, or even more complex structures such as a table whose 1397 cells are further tables, etc. The ForCES model XML schema 1398 (Section 4) allows for uniquely identifying anything with such 1399 complexity, utilizing the concept of dot-annotated static paths and 1400 content addressing of paths as derived from keys. As an example, if 1401 the LFB Component 51 were a structure, then the path to LFB 1402 ComponentID 89 above will be 51.89. 1404 LFB ComponentID 51 might represent a table (an array). In that case, 1405 to select the LFB Component with ID 89 from within the 7th entry of 1406 the table, one would use the path 51.7.89. In addition to supporting 1407 explicit table element selection by including an index in the dotted 1408 path, the model supports identifying table elements by their 1409 contents. This is referred to as using keys, or key indexing. So, 1410 as a further example, if ComponentID 51 was a table which was key 1411 index-able, then a key describing content could also be passed by the 1412 CE, along with path 51 to select the table, and followed by the path 1413 89 to select the table structure element, which upon computation by 1414 the FE would resolve to the LFB ComponentID 89 within the specified 1415 table entry. 1417 3.4. FE Datapath Modeling 1419 Packets coming into the FE from ingress ports generally flow through 1420 one or more LFBs before leaving out of the egress ports. How an FE 1421 treats a packet depends on many factors, such as type of the packet 1422 (e.g., IPv4, IPv6, or MPLS), header values, time of arrival, etc. 1423 The result of LFB processing may have an impact on how the packet is 1424 to be treated in downstream LFBs. This differentiation of packet 1425 treatment downstream can be conceptualized as having alternative 1426 datapaths in the FE. For example, the result of a 6-tuple 1427 classification performed by a classifier LFB could control which rate 1428 meter is applied to the packet by a rate meter LFB in a later stage 1429 in the datapath. 1431 LFB topology is a directed graph representation of the logical 1432 datapaths within an FE, with the nodes representing the LFB instances 1433 and the directed link depicting the packet flow direction from one 1434 LFB to the next. Section 3.4.1 discusses how the FE datapaths can be 1435 modeled as LFB topology; while Section 3.4.2 focuses on issues 1436 related to LFB topology reconfiguration. 1438 3.4.1. Alternative Approaches for Modeling FE Datapaths 1440 There are two basic ways to express the differentiation in packet 1441 treatment within an FE, one represents the datapath directly and 1442 graphically (topological approach) and the other utilizes metadata 1443 (the encoded state approach). 1445 o Topological Approach 1447 Using this approach, differential packet treatment is expressed by 1448 splitting the LFB topology into alternative paths. In other words, 1449 if the result of an LFB operation controls how the packet is further 1450 processed, then such an LFB will have separate output ports, one for 1451 each alternative treatment, connected to separate sub-graphs, each 1452 expressing the respective treatment downstream. 1454 o Encoded State Approach 1456 An alternate way of expressing differential treatment is by using 1457 metadata. The result of the operation of an LFB can be encoded in a 1458 metadatum, which is passed along with the packet to downstream LFBs. 1459 A downstream LFB, in turn, can use the metadata and its value (e.g., 1460 as an index into some table) to determine how to treat the packet. 1462 Theoretically, either approach could substitute for the other, so one 1463 could consider using a single pure approach to describe all datapaths 1464 in an FE. However, neither model by itself results in the best 1465 representation for all practically relevant cases. For a given FE 1466 with certain logical datapaths, applying the two different modeling 1467 approaches will result in very different looking LFB topology graphs. 1468 A model using only the topological approach may require a very large 1469 graph with many links or paths, and nodes (i.e., LFB instances) to 1470 express all alternative datapaths. On the other hand, a model using 1471 only the encoded state model would be restricted to a string of LFBs, 1472 which is not an intuitive way to describe different datapaths (such 1473 as MPLS and IPv4). Therefore, a mix of these two approaches will 1474 likely be used for a practical model. In fact, as we illustrate 1475 below, the two approaches can be mixed even within the same LFB. 1477 Using a simple example of a classifier with N classification outputs 1478 followed by other LFBs, Figure 7.a shows what the LFB topology looks 1479 like when using the pure topological approach. Each output from the 1480 classifier goes to one of the N LFBs where no metadata is needed. 1481 The topological approach is simple, straightforward and graphically 1482 intuitive. However, if N is large and the N nodes following the 1483 classifier (LFB#1, LFB#2, ..., LFB#N) all belong to the same LFB type 1484 (e.g., meter), but each has its own independent components, the 1485 encoded state approach gives a much simpler topology representation, 1486 as shown in Figure 7.b. The encoded state approach requires that a 1487 table of N rows of meter components is provided in the Meter node 1488 itself, with each row representing the attributes for one meter 1489 instance. A metadatum M is also needed to pass along with the packet 1490 P from the classifier to the meter, so that the meter can use M as a 1491 look-up key (index) to find the corresponding row of the attributes 1492 that should be used for any particular packet P. 1494 What if those N nodes (LFB#1, LFB#2, ..., LFB#N) are not of the same 1495 type? For example, if LFB#1 is a queue while the rest are all 1496 meters, what is the best way to represent such datapaths? While it 1497 is still possible to use either the pure topological approach or the 1498 pure encoded state approach, the natural combination of the two 1499 appears to be the best option. Figure 7.c depicts two different 1500 functional datapaths using the topological approach while leaving the 1501 N-1 meter instances distinguished by metadata only, as shown in 1502 Figure 7.c. 1504 +----------+ 1505 P | LFB#1 | 1506 +--------->|(Compon-1)| 1507 +-------------+ | +----------+ 1508 | 1|------+ P +----------+ 1509 | 2|---------------->| LFB#2 | 1510 | classifier 3| |(Compon-2)| 1511 | ...|... +----------+ 1512 | N|------+ ... 1513 +-------------+ | P +----------+ 1514 +--------->| LFB#N | 1515 |(Compon-N)| 1516 +----------+ 1518 (a) Using pure topological approach 1520 +-------------+ +-------------+ 1521 | 1| | Meter | 1522 | 2| (P, M) | (Compon-1) | 1523 | 3|---------------->| (Compon-2) | 1524 | ...| | ... | 1525 | N| | (Compon-N) | 1526 +-------------+ +-------------+ 1528 (b) Using pure encoded state approach to represent the LFB 1529 topology in 5(a), if LFB#1, LFB#2, ..., and LFB#N are of the 1530 same type (e.g., meter). 1532 +-------------+ 1533 +-------------+ (P, M) | queue | 1534 | 1|------------->| (Compon-1) | 1535 | 2| +-------------+ 1536 | 3| (P, M) +-------------+ 1537 | ...|------------->| Meter | 1538 | N| | (Compon-2) | 1539 +-------------+ | ... | 1540 | (Compon-N) | 1541 +-------------+ 1543 (c) Using a combination of the two, if LFB#1, LFB#2, ..., and 1544 LFB#N are of different types (e.g., queue and meter). 1546 Figure 7: An example of how to model FE datapaths 1548 From this example, we demonstrate that each approach has a distinct 1549 advantage depending on the situation. Using the encoded state 1550 approach, fewer connections are typically needed between a fan-out 1551 node and its next LFB instances of the same type because each packet 1552 carries metadata the following nodes can interpret and hence invoke a 1553 different packet treatment. For those cases, a pure topological 1554 approach forces one to build elaborate graphs with many more 1555 connections and often results in an unwieldy graph. On the other 1556 hand, a topological approach is the most intuitive for representing 1557 functionally different datapaths. 1559 For complex topologies, a combination of the two is the most 1560 flexible. A general design guideline is provided to indicate which 1561 approach is best used for a particular situation. The topological 1562 approach should primarily be used when the packet datapath forks to 1563 distinct LFB classes (not just distinct parameterizations of the same 1564 LFB class), and when the fan-outs do not require changes, such as 1565 adding/removing LFB outputs, or require only very infrequent changes. 1566 Configuration information that needs to change frequently should be 1567 expressed by using the internal attributes of one or more LFBs (and 1568 hence using the encoded state approach). 1570 +---------------------------------------------+ 1571 | | 1572 +----------+ V +----------+ +------+ | 1573 | | | | |if IP-in-IP| | | 1574 ---->| ingress |->+----->|classifier|---------->|Decap.|---->---+ 1575 | ports | | |---+ | | 1576 +----------+ +----------+ |others +------+ 1577 | 1578 V 1579 (a) The LFB topology with a logical loop 1581 +-------+ +-----------+ +------+ +-----------+ 1582 | | | |if IP-in-IP | | | | 1583 --->|ingress|-->|classifier1|----------->|Decap.|-->+classifier2|-> 1584 | ports | | |----+ | | | | 1585 +-------+ +-----------+ |others +------+ +-----------+ 1586 | 1587 V 1588 (b)The LFB topology without the loop utilizing two independent 1589 classifier instances. 1591 Figure 8: An LFB topology example. 1593 It is important to point out that the LFB topology described here is 1594 the logical topology, not the physical topology of how the FE 1595 hardware is actually laid out. Nevertheless, the actual 1596 implementation may still influence how the functionality is mapped to 1597 the LFB topology. Figure 8 shows one simple FE example. In this 1598 example, an IP-in-IP packet from an IPSec application like VPN may go 1599 to the classifier first and have the classification done based on the 1600 outer IP header; upon being classified as an IP-in-IP packet, the 1601 packet is then sent to a decapsulator to strip off the outer IP 1602 header, followed by a classifier again to perform classification on 1603 the inner IP header. If the same classifier hardware or software is 1604 used for both outer and inner IP header classification with the same 1605 set of filtering rules, a logical loop is naturally present in the 1606 LFB topology, as shown in Figure 8.a. However, if the classification 1607 is implemented by two different pieces of hardware or software with 1608 different filters (i.e., one set of filters for the outer IP header 1609 and another set for the inner IP header), then it is more natural to 1610 model them as two different instances of classifier LFB, as shown in 1611 Figure 8.b. 1613 3.4.2. Configuring the LFB Topology 1615 While there is little doubt that an individual LFB must be 1616 configurable, the configurability question is more complicated for 1617 LFB topology. Since the LFB topology is really the graphic 1618 representation of the datapaths within an FE, configuring the LFB 1619 topology means dynamically changing the datapaths, including changing 1620 the LFBs along the datapaths on an FE (e.g., creating/instantiating, 1621 updating or deleting LFBs) and setting up or deleting 1622 interconnections between outputs of upstream LFBs to inputs of 1623 downstream LFBs. 1625 Why would the datapaths on an FE ever change dynamically? The 1626 datapaths on an FE are set up by the CE to provide certain data plane 1627 services (e.g., DiffServ, VPN, etc.) to the Network Element's (NE) 1628 customers. The purpose of reconfiguring the datapaths is to enable 1629 the CE to customize the services the NE is delivering at run time. 1630 The CE needs to change the datapaths when the service requirements 1631 change, such as adding a new customer or when an existing customer 1632 changes their service. However, note that not all datapath changes 1633 result in changes in the LFB topology graph. Changes in the graph 1634 are dependent on the approach used to map the datapaths into LFB 1635 topology. As discussed in Section 3.4.1, the topological approach 1636 and encoded state approach can result in very different looking LFB 1637 topologies for the same datapaths. In general, an LFB topology based 1638 on a pure topological approach is likely to experience more frequent 1639 topology reconfiguration than one based on an encoded state approach. 1640 However, even an LFB topology based entirely on an encoded state 1641 approach may have to change the topology at times, for example, to 1642 bypass some LFBs or insert new LFBs. Since a mix of these two 1643 approaches is used to model the datapaths, LFB topology 1644 reconfiguration is considered an important aspect of the FE model. 1646 We want to point out that allowing a configurable LFB topology in the 1647 FE model does not mandate that all FEs are required to have this 1648 capability. Even if an FE supports configurable LFB topology, the FE 1649 may impose limitations on what can actually be configured. 1650 Performance-optimized hardware implementations may have zero or very 1651 limited configurability, while FE implementations running on network 1652 processors may provide more flexibility and configurability. It is 1653 entirely up to the FE designers to decide whether or not the FE 1654 actually implements reconfiguration and if so, how much. Whether a 1655 simple runtime switch is used to enable or disable (i.e., bypass) 1656 certain LFBs, or more flexible software reconfiguration is used, is 1657 an implementation detail internal to the FE and outside of the scope 1658 of FE model. In either case, the CE(s) MUST be able to learn the 1659 FE's configuration capabilities. Therefore, the FE model MUST 1660 provide a mechanism for describing the LFB topology configuration 1661 capabilities of an FE. These capabilities may include (see Section 5 1662 for full details): 1664 o Which LFB classes the FE can instantiate 1666 o The maximum number of instances of the same LFB class that can be 1667 created 1669 o Any topological limitations, for example: 1671 * The maximum number of instances of the same class or any class 1672 that can be created on any given branch of the graph 1674 * Ordering restrictions on LFBs (e.g., any instance of LFB class 1675 A must be always downstream of any instance of LFB class B). 1677 The CE needs some programming help in order to cope with the range of 1678 complexity. In other words, even when the CE is allowed to configure 1679 LFB topology for the FE, the CE is not expected to be able to 1680 interpret an arbitrary LFB topology and determine which specific 1681 service or application (e.g. VPN, DiffServ, etc.) is supported by 1682 the FE. However, once the CE understands the coarse capability of an 1683 FE, the CE MUST configure the LFB topology to implement the network 1684 service the NE is supposed to provide. Thus, the mapping the CE has 1685 to understand is from the high level NE service to a specific LFB 1686 topology, not the other way around. The CE is not expected to have 1687 the ultimate intelligence to translate any high level service policy 1688 into the configuration data for the FEs. However, it is conceivable 1689 that within a given network service domain, a certain amount of 1690 intelligence can be programmed into the CE to give the CE a general 1691 understanding of the LFBs involved to allow the translation from a 1692 high level service policy to the low level FE configuration to be 1693 done automatically. Note that this is considered an implementation 1694 issue internal to the control plane and outside the scope of the FE 1695 model. Therefore, it is not discussed any further in this draft. 1697 +----------+ +-----------+ 1698 ---->| Ingress |---->|classifier |--------------+ 1699 | | |chip | | 1700 +----------+ +-----------+ | 1701 v 1702 +-------------------------------------------+ 1703 +--------+ | Network Processor | 1704 <----| Egress | | +------+ +------+ +-------+ | 1705 +--------+ | |Meter | |Marker| |Dropper| | 1706 ^ | +------+ +------+ +-------+ | 1707 | | | 1708 +----------+-------+ | 1709 | | | 1710 | +---------+ +---------+ +------+ +---------+ | 1711 | |Forwarder|<------|Scheduler|<--|Queue | |Counter | | 1712 | +---------+ +---------+ +------+ +---------+ | 1713 +--------------------------------------------------------------+ 1715 Figure 9: The Capability of an FE as reported to the CE 1717 Figure 9 shows an example where a QoS-enabled router has several line 1718 cards that have a few ingress ports and egress ports, a specialized 1719 classification chip, and a network processor containing codes for FE 1720 blocks like meter, marker, dropper, counter, queue, scheduler, and 1721 IPv4 forwarder. Some of the LFB topology is already fixed and has to 1722 remain static due to the physical layout of the line cards. For 1723 example, all of the ingress ports might be hardwired into the 1724 classification chip so all packets flow from the ingress port into 1725 the classification engine. On the other hand, the LFBs on the 1726 network processor and their execution order are programmable. 1727 However, certain capacity limits and linkage constraints could exist 1728 between these LFBs. Examples of the capacity limits might be: 1730 o 8 meters 1732 o 16 queues in one FE 1734 o the scheduler can handle at most up to 16 queues 1735 o The linkage constraints might dictate that: 1737 * the classification engine may be followed by: 1739 + a meter 1741 + marker 1743 + dropper 1745 + counter 1747 + queue or IPv4 forwarder, but not a scheduler 1749 * queues can only be followed by a scheduler 1751 * a scheduler must be followed by the IPv4 forwarder 1753 * the last LFB in the datapath before going into the egress ports 1754 must be the IPv4 forwarder 1756 +-----+ +-------+ +---+ 1757 | A|--->|Queue1 |--------------------->| | 1758 ------>| | +-------+ | | +---+ 1759 | | | | | | 1760 | | +-------+ +-------+ | | | | 1761 | B|--->|Meter1 |----->|Queue2 |------>| |->| | 1762 | | | | +-------+ | | | | 1763 | | | |--+ | | | | 1764 +-----+ +-------+ | +-------+ | | +---+ 1765 classifier +-->|Dropper| | | IPv4 1766 +-------+ +---+ Fwd. 1767 Scheduler 1769 Figure 10: An LFB topology as configured by the CE and accepted by 1770 the FE 1772 Once the FE reports these capabilities and capacity limits to the CE, 1773 it is now up to the CE to translate the QoS policy into a desirable 1774 configuration for the FE. Figure 9 depicts the FE capability while 1775 Figure 10 and Figure 11 depict two different topologies that the CE 1776 may request the FE to configure. Note that Figure 11 is not fully 1777 drawn, as inter-LFB links are included to suggest potential 1778 complexity, without drawing in the endpoints of all such links. 1780 Queue1 1781 +---+ +--+ 1782 | A|------------------->| |--+ 1783 +->| | | | | 1784 | | B|--+ +--+ +--+ +--+ | 1785 | +---+ | | | | | | 1786 | Meter1 +->| |-->| | | 1787 | | | | | | 1788 | +--+ +--+ | Ipv4 1789 | Counter1 Dropper1 Queue2| +--+ Fwd. 1790 +---+ | +--+ +--->|A | +-+ 1791 | A|---+ | |------>|B | | | 1792 ------>| B|------------------------------>| | +-->|C |->| |-> 1793 | C|---+ +--+ | +>|D | | | 1794 | D|-+ | | | +--+ +-+ 1795 +---+ | | +---+ Queue3 | |Scheduler 1796 Classifier1 | | | A|------------> +--+ | | 1797 | +->| | | |-+ | 1798 | | B|--+ +--+ +-------->| | | 1799 | +---+ | | | | +--+ | 1800 | Meter2 +->| |-+ | 1801 | | | | 1802 | +--+ Queue4 | 1803 | Marker1 +--+ | 1804 +---------------------------->| |---+ 1805 | | 1806 +--+ 1808 Figure 11: Another LFB topology as configured by the CE and accepted 1809 by the FE 1811 Note that both the ingress and egress are omitted in Figure 10 and 1812 Figure 11 to simplify the representation. The topology in Figure 11 1813 is considerably more complex than Figure 10 but both are feasible 1814 within the FE capabilities, and so the FE should accept either 1815 configuration request from the CE. 1817 4. Model and Schema for LFB Classes 1819 The main goal of the FE model is to provide an abstract, generic, 1820 modular, implementation-independent representation of the FEs. This 1821 is facilitated using the concept of LFBs, which are instantiated from 1822 LFB classes. LFB classes and associated definitions will be provided 1823 in a collection of XML documents. The collection of these XML 1824 documents is called a LFB class library, and each document is called 1825 an LFB class library document (or library document, for short). Each 1826 of the library documents MUST conform to the schema presented in this 1827 section. The schema here, and the rules for confoming to the schema 1828 are those defined by the W3C in the definitions of XML schema in XML 1829 Schema [4] and XML Schema DataTypes [5]. The root element of the 1830 library document is the element. 1832 It is not expected that library documents will be exchanged between 1833 FEs and CEs "over-the-wire". But the model will serve as an 1834 important reference for the design and development of the CEs 1835 (software) and FEs (mostly the software part). It will also serve as 1836 a design input when specifying the ForCES protocol elements for CE-FE 1837 communication. 1839 The following sections describe the portions of an LFBLibrary XML 1840 Document. The descriptions primarily provide the necessary semantic 1841 information to understand the meaning and uses of the XML elements. 1842 The XML Schema below provides the final definition on what elements 1843 are permitted, and their base syntax. Unfortunately, due to the 1844 limitations of english and XML, there are constraints described in 1845 the semantic sections which are not fully captured in the XML Schema, 1846 so both sets of information need to be used to build a compliant 1847 library document. 1849 4.1. Namespace 1851 A namespace is needed to uniquely identify the LFB type in the LFB 1852 class library. The reference to the namespace definition is 1853 contained in Section 9, IANA Considerations. 1855 4.2. Element 1857 The element serves as a root element of all library 1858 documents. A library document contains a sequence of top level 1859 elements. The following is a list of all the elements which can 1860 occur directly in the element. If they occur, they must 1861 occur in the order listed. 1863 o providing a text description of the purpose of the 1864 library document. 1866 o for loading information from other library documents. 1868 o for the frame declarations; 1870 o for defining common data types; 1872 o for defining metadata, and 1873 o for defining LFB classes. 1875 Each element is optional. One library document may contain only 1876 metadata definitions, another may contain only LFB class definitions, 1877 yet another may contain all of the above. 1879 A library document can import other library documents if it needs to 1880 refer to definitions contained in the included document. This 1881 concept is similar to the "#include" directive in C. Importing is 1882 expressed by the use of elements, which must precede all the 1883 above elements in the document. For unique referencing, each 1884 LFBLibrary instance document has a unique label defined in the 1885 "provide" attribute of the LFBLibrary element. Note that what this 1886 performs is a ForCES inclusion, not an XML inclusion. The semantic 1887 content of the library referenced by the element is included, 1888 not the xml content. Also, in terms of the conceptual processing of 1889 elements, the total set of documents loaded are considered to 1890 form a single document for processing. A given document is included 1891 in this set only once, even if it is referenced by elements 1892 several times, even from several different files. As the processing 1893 of LFBLibrary information is not order dependent, the order for 1894 processing loaded elements is up to the implementor, as long as the 1895 total effect is as if all of the information from all the files were 1896 available for referencing when needed. Note that such computer 1897 processing of ForCES model library documents may be helpful for 1898 various implementations, but is not required to define the libraries, 1899 or for the actual operation of the protocol itself. 1901 The following is a skeleton of a library document: 1903 1904 1907 1909 1911 1912 1913 ... 1915 1916 1917 ... 1918 1920 1921 1922 ... 1923 1925 1926 1927 ... 1928 1930 1934 1936 1937 1939 4.3. Element 1941 This element is used to refer to another LFB library document. 1942 Similar to the "#include" directive in C, this makes the objects 1943 (metadata types, data types, etc.) defined in the referred library 1944 document available for referencing in the current document. 1946 The load element MUST contain the label of the library document to be 1947 included and MAY contain a URL to specify where the library can be 1948 retrieved. The load element can be repeated unlimited times. Three 1949 examples for the elements: 1951 1952 1953 1956 4.4. Element for Frame Type Declarations 1958 Frame names are used in the LFB definition to define the types of 1959 frames the LFB expects at its input port(s) and emits at its output 1960 port(s). The optional element in the library document 1961 contains one or more elements, each declaring one frame 1962 type. 1964 Each frame definition MUST contain a unique name (NMTOKEN) and a 1965 brief synopsis. In addition, an optional detailed description MAY be 1966 provided. 1968 Uniqueness of frame types MUST be ensured among frame types defined 1969 in the same library document and in all directly or indirectly 1970 included library documents. 1972 The following example defines two frame types: 1974 1975 1976 ipv4 1977 IPv4 packet 1978 1979 This frame type refers to an IPv4 packet. 1980 1981 1982 1983 ipv6 1984 IPv6 packet 1985 1986 This frame type refers to an IPv6 packet. 1987 1988 1989 ... 1990 1992 4.5. Element for Data Type Definitions 1994 The (optional) element can be used to define commonly 1995 used data types. It contains one or more elements, 1996 each defining a data type with a unique name. Such data types can be 1997 used in several places in the library documents, including: 1999 o Defining other data types 2001 o Defining components of LFB classes 2003 This is similar to the concept of having a common header file for 2004 shared data types. 2006 Each element MUST contain a unique name (NMTOKEN), a 2007 brief synopsis, and a type definition element. The name MUST be 2008 unique among all data types defined in the same library document and 2009 in any directly or indirectly included library documents. The 2010 element MAY also include an optional longer 2011 description, For example: 2013 2014 2015 ieeemacaddr 2016 48-bit IEEE MAC address 2017 ... type definition ... 2018 2019 2020 ipv4addr 2021 IPv4 address 2022 ... type definition ... 2023 2024 ... 2025 2027 There are two kinds of data types: atomic and compound. Atomic data 2028 types are appropriate for single-value variables (e.g. integer, 2029 string, byte array). 2031 The following built-in atomic data types are provided, but additional 2032 atomic data types can be defined with the and 2033 elements: 2035 Meaning 2036 ---- ------- 2037 char 8-bit signed integer 2038 uchar 8-bit unsigned integer 2039 int16 16-bit signed integer 2040 uint16 16-bit unsigned integer 2041 int32 32-bit signed integer 2042 uint32 32-bit unsigned integer 2043 int64 64-bit signed integer 2044 uint64 64-bit unsigned integer 2045 boolean A true / false value where 2046 0 = false, 1 = true 2047 string[N] A UTF-8 string represented in at most 2048 N Octets. 2049 string A UTF-8 string without a configured 2050 storage length limit. 2051 byte[N] A byte array of N bytes 2052 octetstring[N] A buffer of N octets, which MAY 2053 contain fewer than N octets. Hence 2054 the encoded value will always have 2055 a length. 2056 float16 16-bit floating point number 2057 float32 32-bit IEEE floating point number 2058 float64 64-bit IEEE floating point number 2060 These built-in data types can be readily used to define metadata or 2061 LFB attributes, but can also be used as building blocks when defining 2062 new data types. The boolean data type is defined here because it is 2063 so common, even though it can be built by sub-ranging the uchar data 2064 type, as defined under atomic types (Section 4.5.2). 2066 Compound data types can build on atomic data types and other compound 2067 data types. Compound data types can be defined in one of four ways. 2068 They may be defined as an array of components of some compound or 2069 atomic data type. They may be a structure of named components of 2070 compound or atomic data types (c.f. C structures). They may be a 2071 union of named components of compound or atomic data types (c.f. C 2072 unions). They may also be defined as augmentations (explained in 2073 Section 4.5.7) of existing compound data types. 2075 Given that the ForCES protocol will be getting and setting component 2076 values, all atomic data types used here must be able to be conveyed 2077 in the ForCES protocol. Further, the ForCES protocol will need a 2078 mechanism to convey compound data types. However, the details of 2079 such representations are for the ForCES Protocol [2] document to 2080 define, not the model document. Strings and octetstrings must be 2081 conveyed by the protocol with their length, as they are not 2082 delimited, the value does not itself include the length, and these 2083 items are variable length. 2085 With regard to strings, this model defines a small set of 2086 restrictions and definitions on how they are structured. String and 2087 octetstring length limits can be specified in the LFB Class 2088 definitions. The component properties for string and octetstring 2089 components also contain actual lengths and length limits. This 2090 duplication of limits is to allow for implementations with smaller 2091 limits than the maximum limits specified in the LFB Class definition. 2092 In all cases, these lengths are specified in octets, not in 2093 characters. In terms of protocol operation, as long as the specified 2094 length is within the FE's supported capabilities, the FE stores the 2095 contents of a string exactly as provided by the CE, and returns those 2096 contents when requested. No canonicalization, transformations, or 2097 equivalences are performed by the FE. Components of type string (or 2098 string[n]) MAY be used to hold identifiers for correlation with 2099 components in other LFBs. In such cases, an exact octet for octet 2100 match is used. No equivalences are used by the FE or CE in 2101 performing that matching. The ForCES Protocol [2] does not perform 2102 or require validation of the content of UTF-8 strings. However, 2103 UTF-8 strings SHOULD be encoded in the shortest form to avoid 2104 potential security issues described in [12]. Any entity displaying 2105 such strings is expected to perform its own validation (for example 2106 for correct multi-byte characters, and for ensuring that the string 2107 does not end in the middle of a multi-byte sequence.) Specific LFB 2108 class definitions MAY restrict the valid contents of a string as 2109 suited to the particular usage (for example, a component that holds a 2110 DNS name would be restricted to hold only octets valid in such a 2111 name.) FEs should validate the contents of SET requests for such 2112 restricted components at the time the set is performed, just as range 2113 checks for range limited components are performed. The ForCES 2114 protocol behavior defines the normative processing for requests using 2115 that protocol. 2117 For the definition of the actual type in the element, 2118 the following elements are available: , , , 2119 , and . 2121 The predefined type alias is somewhere between the atomic and 2122 compound data types. Alias is used to allow a component inside an 2123 LFB to be an indirect reference to another component inside the same 2124 or a different LFB class or instance. The alias component behaves 2125 like a structure, one component of which has special behavior. Given 2126 that the special behavior is tied to the other parts of the 2127 structure, the compound result is treated as a predefined construct. 2129 4.5.1. Element for Renaming Existing Data Types 2131 The element refers to an existing data type by its name. 2132 The referred data type MUST be defined either in the same library 2133 document, or in one of the included library documents. If the 2134 referred data type is an atomic data type, the newly defined type 2135 will also be regarded as atomic. If the referred data type is a 2136 compound type, the new type will also be compound. Some usage 2137 examples follow: 2139 2140 short 2141 Alias to int16 2142 int16 2143 2144 2145 ieeemacaddr 2146 48-bit IEEE MAC address 2147 byte[6] 2148 2150 4.5.2. Element for Deriving New Atomic Types 2152 The element allows the definition of a new atomic type from 2153 an existing atomic type, applying range restrictions and/or providing 2154 special enumerated values. Note that the element can only 2155 use atomic types as base types, and its result MUST be another atomic 2156 type. 2158 For example, the following snippet defines a new "dscp" data type: 2160 2161 dscp 2162 Diffserv code point. 2163 2164 uchar 2165 2166 2167 2168 2169 2170 DSCP-BE 2171 Best Effort 2172 2173 ... 2174 2175 2176 2178 4.5.3. Element to Define Arrays 2180 The element can be used to create a new compound data type as 2181 an array of a compound or an atomic data type. Depending upon 2182 context, this document, and others, refer to such arrays as tables or 2183 arrays interchangeably, without semantic or syntactic implication. 2184 The type of the array entry can be specified either by referring to 2185 an existing type (using the element) or defining an unnamed 2186 type inside the element using any of the , , 2187 , or elements. 2189 The array can be "fixed-size" or "variable-size", which is specified 2190 by the "type" attribute of the element. The default is 2191 "variable-size". For variable size arrays, an optional "maxlength" 2192 attribute specifies the maximum allowed length. This attribute 2193 should be used to encode semantic limitations, not implementation 2194 limitations. The latter (support for implementation constraints) 2195 should be handled by capability components of LFB classes, and should 2196 never be included as the maxlength in a data type array which is 2197 regarded as being of unlimited size. 2199 For fixed-size arrays, a "length" attribute MUST be provided that 2200 specifies the constant size of the array. 2202 The result of this construct is always a compound type, even if the 2203 array has a fixed size of 1. 2205 Arrays MUST only be subscripted by integers, and will be presumed to 2206 start with index 0. 2208 In addition to their subscripts, arrays MAY be declared to have 2209 content keys. Such a declaration has several effects: 2211 o Any declared key can be used in the ForCES protocol to select a 2212 component for operations (for details, see the ForCES Protocol 2213 [2]). 2215 o In any instance of the array, each declared key MUST be unique 2216 within that instance. That is, no two components of an array may 2217 have the same values on all the fields which make up a key. 2219 Each key is declared with a keyID for use in the ForCES Protocol [2], 2220 where the unique key is formed by combining one or more specified key 2221 fields. To support the case where an array of an atomic type with 2222 unique values can be referenced by those values, the key field 2223 identifier MAY be "*" (i.e., the array entry is the key). If the 2224 value type of the array is a structure or an array, then the key is 2225 one or more components of the value type, each identified by name. 2227 Since the field MAY be a component of the contained structure, a 2228 component of a component of a structure, or further nested, the field 2229 name is actually a concatenated sequence of component identifiers, 2230 separated by decimal points ("."). The syntax for key field 2231 identification is given following the array examples. 2233 The following example shows the definition of a fixed size array with 2234 a pre-defined data type as the array content type: 2236 2237 dscp-mapping-table 2238 2239 A table of 64 DSCP values, used to re-map code space. 2240 2241 2242 dscp 2243 2244 2246 The following example defines a variable size array with an upper 2247 limit on its size: 2249 2250 mac-alias-table 2251 A table with up to 8 IEEE MAC addresses 2252 2253 ieeemacaddr 2254 2255 2257 The following example shows the definition of an array with a local 2258 (unnamed) content type definition: 2260 2261 classification-table 2262 2263 A table of classification rules and result opcodes. 2264 2265 2266 2267 2268 rule 2269 The rule to match 2270 classrule 2271 2272 2273 opcode 2274 The result code 2275 opcode 2276 2277 2278 2279 2281 In the above example, each entry of the array is a of two 2282 components ("rule" and "opcode"). 2284 The following example shows a table of IP Prefix information that can 2285 be accessed by a multi-field content key on the IP Address, prefix 2286 length, and information source. This means that in any instance of 2287 this table, no two entries can have the same IP address, prefix 2288 length, and information source. 2290 2291 ipPrefixInfo_table 2292 2293 A table of information about known prefixes 2294 2295 2296 2297 2298 address-prefix 2299 the prefix being described 2300 ipv4Prefix 2301 2302 2303 source 2304 2305 the protocol or process providing this information 2306 2307 uint16 2308 2309 2310 prefInfo 2311 the information we care about 2312 hypothetical-info-type 2313 2314 2315 2316 address-prefix.ipv4addr 2317 address-prefix.prefixlen 2318 source 2319 2320 2321 2323 Note that the keyField elements could also have been simply address- 2324 prefix and source, since all of the fields of address-prefix are 2325 being used. 2327 4.5.3.1. Key Field References 2329 In order to use key declarations, one must refer to components that 2330 are potentially nested inside other components in the array. If 2331 there are nested arrays, one might even use an array element as a key 2332 (but great care would be needed to ensure uniqueness.) 2334 The key is the combination of the values of each field declared in a 2335 keyField element. 2337 Therefore, the value of a keyField element MUST be a concatenated 2338 Sequence of field identifiers, separated by a "." (period) character. 2339 Whitespace is permitted and ignored. 2341 A valid string for a single field identifier within a keyField 2342 depends upon the current context. Initially, in an array key 2343 declaration, the context is the type of the array. Progressively, 2344 the context is whatever type is selected by the field identifiers 2345 processed so far in the current key field declaration. 2347 When the current context is an array, (e.g., when declaring a key for 2348 an array whose content is an array) then the only valid value for the 2349 field identifier is an explicit number. 2351 When the current context is a structure, the valid values for the 2352 field identifiers are the names of the components of the structure. 2353 In the special case of declaring a key for an array containing an 2354 atomic type, where that content is unique and is to be used as a key, 2355 the value "*" MUST be used as the single key field identifier. 2357 In reference array or structure elements, it is possible to construct 2358 keyFields that do not exist. keyField references SHOULD never 2359 reference optional structure components. For references to array 2360 elements, care must be taken to ensure that the necessary array 2361 elements exist when creating or modifying the overall array element. 2362 Failure to do so will result in FEs returning errors on the creation 2363 attempt. 2365 4.5.4. Element to Define Structures 2367 A structure is comprised of a collection of data components. Each 2368 data components has a data type (either an atomic type or an existing 2369 compound type) and is assigned a name unique within the scope of the 2370 compound data type being defined. These serve the same function as 2371 "struct" in C, etc. These components are defined using 2372 elements. A element MAY contain an optional derivation 2373 indication, a element. The structure definition MUST 2374 contain a sequence of one or more elements. 2376 The actual type of the component can be defined by referring to an 2377 existing type (using the element), or can be a locally 2378 defined (unnamed) type created by any of the , , 2379 , or elements. 2381 The element MUST include a componentID attribute. This 2382 provides the numeric ID for this component, for use by the protocol. 2383 The MUST contain a component name and a synopsis. It MAY 2384 contain a element giving a textual description of the 2385 component. The definition MAY also include a element, 2386 which indicates that the component being defined is optional. The 2387 definition MUST contain elements to define the data type of the 2388 component, as described above. 2390 For a dataTypeDef of a struct, the structure definition MAY be 2391 inherited from, and augment, a previously defined structured type. 2392 This is indicated by including the optional derivedFrom attribute in 2393 the struct declaration before the definition of the augmenting or 2394 replacing components. The augmentation (Section 4.5.7) section 2395 describes how this is done in more detail. 2397 The componentID attribute for different components in a structure (or 2398 in an LFB) MUST be distinct. They do not need to be in order, nor do 2399 they need to be sequential. For clarity of human readability, and 2400 ease of maintanence, it is usual to define at least sequential sets 2401 of values. But this is for human ease, not a model or protocol 2402 requirement. 2404 The result of this construct is always a compound type, even when the 2405 contains only one field. 2407 An example: 2409 2410 ipv4prefix 2411 2412 IPv4 prefix defined by an address and a prefix length 2413 2414 2415 2416 address 2417 Address part 2418 ipv4addr 2419 2420 2421 prefixlen 2422 Prefix length part 2423 2424 uchar 2425 2426 2427 2428 2429 2430 2431 2433 4.5.5. Element to Define Union Types 2435 Similar to the union declaration in C, this construct allows the 2436 definition of overlay types. Its format is identical to the 2437 element. 2439 The result of this construct is always a compound type, even when the 2440 union contains only one element. 2442 4.5.6. Element 2444 It is sometimes necessary to have a component in an LFB or structure 2445 refer to information (a component) in other LFBs. This can, for 2446 example, allow an ARP LFB to share the IP->MAC Address table with the 2447 local transmission LFB, without duplicating information. Similarly, 2448 it could allow a traffic measurement LFB to share information with a 2449 traffic enforcement LFB. The declaration creates the 2450 constructs for this. This construct tells the CE and FE that any 2451 manipulation of the defined data is actually manipulation of data 2452 defined to exist in some specified part of some other LFB instance. 2453 The content of an element MUST be a named type. Whatever 2454 component the alias references (which is determined by the alias 2455 component properties, as described below) that component must be of 2456 the same type as that declared for the alias. Thus, when the CE or 2457 FE dereferences the alias component, the type of the information 2458 returned is known. The type can be a base type or a derived type. 2459 The actual value referenced by an alias is known as its target. When 2460 a GET or SET operation references the alias element, the value of the 2461 target is returned or replaced. Write access to an alias element is 2462 permitted if write access to both the alias and the target are 2463 permitted. 2465 The target of a component declared by an element is 2466 determined by the information in the component's properties. Like 2467 all components, the properties include the support / read / write 2468 permission for the alias. In addition, there are several fields 2469 (components) in the alias properties which define the target of the 2470 alias. These components are the ID of the LFB class of the target, 2471 the ID of the LFB instance of the target, and a sequence of integers 2472 representing the path within the target LFB instance to the target 2473 component. The type of the target element must match the declared 2474 type of the alias. Details of the alias property structure are 2475 described in Section 4.8 of this document on properties. 2477 Note that the read / write property of the alias refers to the value. 2478 The CE can only determine if it can write the target selection 2479 properties of the alias by attempting such a write operation. 2480 (Property components do not themselves have properties.) 2482 4.5.7. Augmentations 2484 Compound types can also be defined as augmentations of existing 2485 compound types. If the existing compound type is a structure, 2486 augmentation MAY add new elements to the type. The type of an 2487 existing component MAY be replaced in the definition of an augmenting 2488 structure, but MAY only be replaced with an augmentation derived from 2489 the current type of the existing component. An existing component 2490 cannot be deleted. If the existing compound type is an array, 2491 augmentation means augmentation of the array element type. 2493 Augmentation MUST NOT be applied to unions. 2495 One consequence of this is that augmentations are backwards 2496 compatible with the compound type from which they are derived. As 2497 such, augmentations are useful in defining components for LFB 2498 subclasses with backward compatibility. In addition to adding new 2499 components to a class, the data type of an existing component MAY be 2500 replaced by an augmentation of that component, and still meet the 2501 compatibility rules for subclasses. This compatibility constraint is 2502 why augmentations can not be applied to unions. 2504 For example, consider a simple base LFB class A that has only one 2505 component (comp1) of type X. One way to derive class A1 from A can be 2506 by simply adding a second component (of any type). Another way to 2507 derive a class A2 from A can be by replacing the original component 2508 (comp1) in A of type X with one of type Y, where Y is an augmentation 2509 of X. Both classes A1 and A2 are backward compatible with class A. 2511 The syntax for augmentations is to include a element in 2512 a structure definition, indicating what structure type is being 2513 augmented. Component names and component IDs for new components 2514 within the augmentation MUST NOT be the same as those in the 2515 structure type being augmented. For those components where the data 2516 type of an existing component is being replaced with a suitable 2517 augmenting data type, the existing Component name and component ID 2518 MUST be used in the augmentation. Other than the constraint on 2519 existing elements, there is no requirement that the new component IDs 2520 be sequential with, greater than, or in any other specific 2521 relationship to the existing component IDs except different. It is 2522 expected that using values sequential within an augmentation, and 2523 distinct from the previously used values, will be a common method to 2524 enhance human readability. 2526 4.6. Element for Metadata Definitions 2528 The (optional) element in the library document 2529 contains one or more elements. Each 2530 element defines a metadatum. 2532 Each element MUST contain a unique name (NMTOKEN). 2533 Uniqueness is defined to be over all metadata defined in this library 2534 document and in all directly or indirectly included library 2535 documents. The element MUST also contain a brief 2536 synopsis, the tag value to be used for this metadata, and value type 2537 definition information. Only atomic data types can be used as value 2538 types for metadata. The element MAY contain a detailed 2539 description element. 2541 Two forms of type definitions are allowed. The first form uses the 2542 element to refer to an existing atomic data type defined in 2543 the element of the same library document or in one of 2544 the included library documents. The usage of the element 2545 is identical to how it is used in the elements, except 2546 here it can only refer to atomic types. The latter restriction is 2547 not enforced by the XML schema. 2549 The second form is an explicit type definition using the 2550 element. This element is used here in the same way as in the 2551 elements. 2553 The following example shows both usages: 2555 2556 2557 NEXTHOPID 2558 Refers to a Next Hop entry in NH LFB 2559 17 2560 int32 2561 2562 2563 CLASSID 2564 2565 Result of classification (0 means no match). 2566 2567 21 2568 2569 int32 2570 2571 2572 NOMATCH 2573 2574 Classification didn't result in match. 2575 2576 2577 2578 2579 2580 2582 4.7. Element for LFB Class Definitions 2584 The (optional) element can be used to define one or 2585 more LFB classes using elements. Each 2586 element MUST define an LFB class and include the following elements: 2588 o provides the symbolic name of the LFB class. Example: 2589 "ipv4lpm" 2591 o provides a short synopsis of the LFB class. Example: 2592 "IPv4 Longest Prefix Match Lookup LFB" 2594 o is the version indicator 2595 o is the inheritance indicator 2597 o lists the input ports and their specifications 2599 o lists the output ports and their specifications 2601 o defines the operational components of the LFB 2603 o defines the capability components of the LFB 2605 o contains the operational specification of the LFB 2607 o The LFBClassID attribute of the LFBClassDef element defines the ID 2608 for this class. These must be globally unique. 2610 o defines the events that can be generated by instances of 2611 this LFB. 2613 LFB Class Names must be unique, in order to enable other documents to 2614 reference the classes by name, and to enable human readers to 2615 understand references to class names. While a complex naming 2616 structure could be created, simplicity is preferred. As given in the 2617 IANA considerations section of this document, the IANA will maintain 2618 a registry of LFB Class names and Class identifiers, along with a 2619 reference to the document defining the class. 2621 Below is a skeleton of an example LFB class definition. Note that in 2622 order to keep from complicating the XML Schema, the order of elements 2623 in the class definition is fixed. Elements, if they appear, must 2624 appear in the order shown. 2626 2627 2628 ipv4lpm 2629 IPv4 Longest Prefix Match Lookup LFB 2630 1.0 2631 baseclass 2633 2634 ... 2635 2637 2638 ... 2639 2641 2642 ... 2643 2645 2646 ... 2647 2649 2650 ... 2651 2653 2654 This LFB represents the IPv4 longest prefix match lookup 2655 operation. 2656 The modeled behavior is as follows: 2657 Blah-blah-blah. 2658 2660 2661 ... 2662 2664 The individual components and capabilities will have componentIDs for 2665 use by the ForCES protocol. These parallel the componentIDs used in 2666 structs, and are used the same way. Component and capability 2667 componentIDs must be unique within the LFB class definition. 2669 Note that the , , and elements are 2670 required, all other elements are optional in . However, 2671 when they are present, they must occur in the above order. 2673 The componentID attribute for different items in an LFB class 2674 definition (or components in a struct) MUST be distinct. They do not 2675 need to be in order, nor do they need to be sequential. For clarity 2676 of human readability, and ease of maintanence, it is usual to define 2677 at least sequential sets of values. But this is for human ease, not 2678 a model or protocol requirement. 2680 4.7.1. Element to Express LFB Inheritance 2682 The optional element can be used to indicate that this 2683 class is a derivative of some other class. The content of this 2684 element MUST be the unique name () of another LFB class. The 2685 referred LFB class MUST be defined in the same library document or in 2686 one of the included library documents. In the absence of a 2687 the class is conceptually derived from the common, 2688 empty, base class. 2690 It is assumed that a derived class is backwards compatible with its 2691 base class. A derived class MAY add compoents to a parent class, but 2692 can not delete components. This also applies to input and output 2693 ports, events, and to capabilities. 2695 4.7.2. Element to Define LFB Inputs 2697 The optional element is used to define input ports. An 2698 LFB class MAY have zero, one, or more inputs. If the LFB class has 2699 no input ports, the element MUST be omitted. The 2700 element can contain one or more elements, 2701 one for each port or port-group. We assume that most LFBs will have 2702 exactly one input. Multiple inputs with the same input type are 2703 modeled as one input group. Input groups are defined the same way as 2704 input ports by the element, differentiated only by an 2705 optional "group" attribute. 2707 Multiple inputs with different input types should be avoided if 2708 possible (see discussion in Section 4.7.3). Some special LFBs will 2709 have no inputs at all. For example, a packet generator LFB does not 2710 need an input. 2712 Single input ports and input port groups are both defined by the 2713 element; they are differentiated by only an optional 2714 "group" attribute. 2716 The element MUST contain the following elements: 2718 o provides the symbolic name of the input. Example: "in". 2719 Note that this symbolic name must be unique only within the scope 2720 of the LFB class. 2722 o contains a brief description of the input. Example: 2723 "Normal packet input". 2725 o lists all allowed frame formats. Example: {"ipv4" 2726 and "ipv6"}. Note that this list should refer to names specified 2727 in the element of the same library document or in any 2728 included library documents. The element can also 2729 provide a list of required metadata. Example: {"classid", 2730 "vpnid"}. This list should refer to names of metadata defined in 2731 the element in the same library document or in any 2732 included library documents. For each metadatum, it must be 2733 specified whether the metadatum is required or optional. For each 2734 optional metadatum, a default value must be specified, which is 2735 used by the LFB if the metadatum is not provided with a packet. 2737 In addition, the optional "group" attribute of the 2738 element can specify if the port can behave as a port group, i.e., it 2739 is allowed to be instantiated. This is indicated by a "true" value 2740 (the default value is "false"). 2742 An example element, defining two input ports, the second 2743 one being an input port group: 2745 2746 2747 in 2748 Normal input 2749 2750 2751 ipv4 2752 ipv6 2753 2754 2755 classid 2756 vifid 2757 vrfid 2758 2759 2760 2761 2762 ... another input port ... 2763 2764 2766 For each , the frame type expectations are defined by the 2767 element using one or more elements (see example 2768 above). When multiple frame types are listed, it means that "one of 2769 these" frame types is expected. A packet of any other frame type is 2770 regarded as incompatible with this input port of the LFB class. The 2771 above example list two frames as expected frame types: "ipv4" and 2772 "ipv6". 2774 Metadata expectations are specified by the 2775 element. In its simplest form, this element can contain a list of 2776 elements, each referring to a metadatum. When multiple 2777 instances of metadata are listed by elements, it means that 2778 "all of these" metadata must be received with each packet (except 2779 metadata that are marked as "optional" by the "dependency" attribute 2780 of the corresponding element). For a metadatum that is 2781 specified "optional", a default value MUST be provided using the 2782 "defaultValue" attribute. The above example lists three metadata as 2783 expected metadata, two of which are mandatory ("classid" and 2784 "vifid"), and one being optional ("vrfid"). 2786 The schema also allows for more complex definitions of metadata 2787 expectations. For example, using the element, a list of 2788 metadata can be specified to express that at least one of the 2789 specified metadata must be present with any packet. For example: 2791 2792 2793 prefixmask 2794 prefixlen 2795 2796 2798 The above example specifies that either the "prefixmask" or the 2799 "prefixlen" metadata must be provided with any packet. 2801 The two forms can also be combined, as it is shown in the following 2802 example: 2804 2805 classid 2806 vifid 2807 vrfid 2808 2809 prefixmask 2810 prefixlen 2811 2812 2814 Although the schema is constructed to allow even more complex 2815 definitions of metadata expectations, we do not discuss those here. 2817 4.7.3. Element to Define LFB Outputs 2819 The optional element is used to define output ports. 2820 An LFB class MAY have zero, one, or more outputs. If the LFB class 2821 has no output ports, the element MUST be omitted. The 2822 element MUST contain one or more elements, 2823 one for each port or port-group. If there are multiple outputs with 2824 the same output type, we model them as an output port group. Some 2825 special LFBs have no outputs at all (e.g., Dropper). 2827 Single output ports and output port groups are both defined by the 2828 element; they are differentiated by only an optional 2829 "group" attribute. 2831 The element MUST contain the following elements: 2833 o provides the symbolic name of the output. Example: "out". 2834 Note that the symbolic name must be unique only within the scope 2835 of the LFB class. 2837 o contains a brief description of the output port. 2838 Example: "Normal packet output". 2840 o lists the allowed frame formats. Example: {"ipv4", 2841 "ipv6"}. Note that this list should refer to symbols specified in 2842 the element in the same library document or in any 2843 included library documents. The element MAY also 2844 contain the list of emitted (generated) metadata. Example: 2845 {"classid", "color"}. This list should refer to names of metadata 2846 specified in the element in the same library 2847 document or in any included library documents. For each generated 2848 metadatum, it should be specified whether the metadatum is always 2849 generated or generated only in certain conditions. This 2850 information is important when assessing compatibility between 2851 LFBs. 2853 In addition, the optional "group" attribute of the 2854 element can specify if the port can behave as a port group, i.e., it 2855 is allowed to be instantiated. This is indicated by a "true" value 2856 (the default value is "false"). 2858 The following example specifies two output ports, the second being an 2859 output port group: 2861 2862 2863 out 2864 Normal output 2865 2866 2867 ipv4 2868 ipv4bis 2869 2870 2871 nhid 2872 nhtabid 2873 2874 2875 2876 2877 exc 2878 Exception output port group 2879 2880 2881 ipv4 2882 ipv4bis 2883 2884 2885 errorid 2886 2887 2888 2889 2891 The types of frames and metadata the port produces are defined inside 2892 the element in each . Within the 2893 element, the list of frame types the port produces is listed in the 2894 element. When more than one frame is listed, it 2895 means that "one of" these frames will be produced. 2897 The list of metadata that is produced with each packet is listed in 2898 the optional element of the . In its 2899 simplest form, this element can contain a list of elements, 2900 each referring to a metadatum type. The meaning of such a list is 2901 that "all of" these metadata are provided with each packet, except 2902 those that are listed with the optional "availability" attribute set 2903 to "conditional". Similar to the element of the 2904 , the element supports more complex 2905 forms, which we do not discuss here further. 2907 4.7.4. Element to Define LFB Operational Components 2909 Operational parameters of the LFBs that must be visible to the CEs 2910 are conceptualized in the model as the LFB components. These 2911 include, for example, flags, single parameter arguments, complex 2912 arguments, and tables. Note that the components here refer to only 2913 those operational parameters of the LFBs that must be visible to the 2914 CEs. Other variables that are internal to LFB implementation are not 2915 regarded as LFB components and hence are not covered. 2917 Some examples for LFB components are: 2919 o Configurable flags and switches selecting between operational 2920 modes of the LFB 2922 o Number of inputs or outputs in a port group 2924 o Various configurable lookup tables, including interface tables, 2925 prefix tables, classification tables, DSCP mapping tables, MAC 2926 address tables, etc. 2928 o Packet and byte counters 2930 o Various event counters 2932 o Number of current inputs or outputs for each input or output group 2934 The ForCES model supports the definition of access permission 2935 restrictions on what the CE can do with an LFB component. The 2936 following categories are supported by the model: 2938 o No-access components. This is useful for completeness, and to 2939 allow for defining objects which are used by other things, but not 2940 directly referencable by the CE. It is also useful for an FE 2941 which is reporting that certain defined, and typically accessible, 2942 Components are not supported for CE access by a reporting FE. 2944 o Read-only components. 2946 o Read-write components. 2948 o Write-only components. This could be any configurable data for 2949 which read capability is not provided to the CEs. (e.g., the 2950 security key information) 2952 o Read-reset components. The CE can read and reset this resource, 2953 but cannot set it to an arbitrary value. Example: Counters. 2955 o Firing-only components. A write attempt to this resource will 2956 trigger some specific actions in the LFB, but the actual value 2957 written is ignored. 2959 The LFB class MUST define only one possible access mode for a given 2960 component. 2962 The components of the LFB class are listed in the 2963 element. Each component is defined by an element. A 2964 element contains some or all of the following elements, 2965 some of which are mandatory: 2967 o MUST occur, and defines the name of the component. This 2968 name must be unique among the components of the LFB class. 2969 Example: "version". 2971 o is also mandatory, and provides a brief description of 2972 the purpose of the component. 2974 o is an optional element, and if present indicates that 2975 this component is optional. 2977 o The data type of the component can be defined either via a 2978 reference to a predefined data type or providing a local 2979 definition of the type. The former is provided by using the 2980 element, which must refer to the unique name of an 2981 existing data type defined in the element in the 2982 same library document or in any of the included library documents. 2983 When the data type is defined locally (unnamed type), one of the 2984 following elements can be used: , , , and 2985 . Their usage is identical to how they are used inside 2986 elements (see Section 4.5). Some form of data type 2987 definition MUST be included in the component definition. 2989 o The element is optional, and if present is used to 2990 specify a default value for a component. If a default value is 2991 specified, the FE must ensure that the component has that value 2992 when the LFB is initialized or reset. If a default value is not 2993 specified for a component, the CE MUST make no assumptions as to 2994 what the value of the component will be upon initalization. The 2995 CE must either read the value, or set the value, if it needs to 2996 know what it is. 2998 o The element MAY also appear. If included, it 2999 provides a longer description of the meaning or usage of the 3000 particular component being defined. 3002 The element also MUST have an componentID attribute, 3003 which is a numeric value used by the ForCES protocol. 3005 In addition to the above elements, the element includes 3006 an optional "access" attribute, which can take any of the following 3007 values: "read-only", "read-write", "write-only", "read-reset", and 3008 "trigger-only". The default access mode is "read-write". 3010 Whether optional components are supported, and whether components 3011 defined as read-write can actually be written can be determined for a 3012 given LFB instance by the CE by reading the property information of 3013 that component. An access control setting of "trigger-only" means 3014 that this component is included only for use in event detection. 3016 The following example defines two components for an LFB: 3018 3019 3020 foo 3021 number of things 3022 uint32 3023 3024 3025 bar 3026 number of this other thing 3027 3028 uint32 3029 3030 3031 3032 3033 10 3034 3035 3037 The first component ("foo") is a read-only 32-bit unsigned integer, 3038 defined by referring to the built-in "uint32" atomic type. The 3039 second component ("bar") is also an integer, but uses the 3040 element to provide additional range restrictions. This component has 3041 access mode of read-write allowing it to be both read and written. A 3042 default value of 10 is provided for bar. although the access for bar 3043 is read-write, some implementations MAY offer only more restrictive 3044 access, and this would be reported in the component properties. 3046 Note that not all components are likely to exist at all times in a 3047 particular implementation. While the capabilities will frequently 3048 indicate this non-existence, CEs may attempt to reference non- 3049 existent or non-permitted components anyway. The ForCES protocol 3050 mechanisms should include appropriate error indicators for this case. 3052 The mechanism defined above for non-supported components can also 3053 apply to attempts to reference non-existent array elements or to set 3054 read-only components. 3056 4.7.5. Element to Define LFB Capability Components 3058 The LFB class specification provides some flexibility for the FE 3059 implementation regarding how the LFB class is implemented. For 3060 example, the instance may have some limitations that are not inherent 3061 from the class definition, but rather the result of some 3062 implementation limitations. Some of these limitations are captured 3063 by the property information of the LFB components. The model allows 3064 for the notion of additional capability information. 3066 Such capability related information is expressed by the capability 3067 components of the LFB class. The capability components are always 3068 read-only attributes, and they are listed in a separate 3069 element in the . The 3070 element contains one or more elements, each defining one 3071 capability component. The format of the element is 3072 almost the same as the element, it differs in two 3073 aspects: it lacks the access mode attribute (because it is always 3074 read-only), and it lacks the element (because default 3075 value is not applicable to read-only attributes). 3077 Some examples of capability components follow: 3079 o The version of the LFB class that this LFB instance complies with; 3081 o Supported optional features of the LFB class; 3083 o Maximum number of configurable outputs for an output group; 3085 o Metadata pass-through limitations of the LFB; 3087 o Additional range restriction on operational components; 3089 The following example lists two capability attributes: 3091 3092 3093 version 3094 3095 LFB class version this instance is compliant with. 3096 3097 version 3098 3099 3100 limitBar 3101 3102 Maximum value of the "bar" attribute. 3103 3104 uint16 3105 3106 3108 4.7.6. Element for LFB Notification Generation 3110 The element contains the information about the occurrences 3111 for which instances of this LFB class can generate notifications to 3112 the CE. High level view on the declaration and operation of LFB 3113 events is described in Section 3.2.5. 3115 The element contains 0 or more elements, each of 3116 which declares a single event. The element has an eventID 3117 attribute giving the unique (per LFB class) ID of the event. The 3118 element will include: 3120 o element indicating which LFB field (component) is 3121 tested to generate the event; 3123 o element indicating what condition on the field will 3124 generate the event from a list of defined conditions; 3126 o element indicating what values are to be reported 3127 in the notification of the event. 3129 The example below demonstrates the different constructs. 3131 The element has a baseID attribute value, which is normally 3132 . The value of the baseID is the starting 3133 componentID for the path which identifies events. It must not be the 3134 same as the componentID of any top level components (including 3135 capabilities) of the LFB class. In derived LFBs (i.e. ones with a 3136 element) where the parent LFB class has an events 3137 declaration, the baseID must not be present in the derived LFB 3138 element. Instead, the baseID value from the parent LFB 3139 class is used. In the example shown the baseID is 7. 3141 3142 3143 Foochanged 3144 3145 An example event for a scalar 3146 3147 3148 foo 3149 3150 3151 3152 3153 3154 foo 3155 3156 3157 3159 3160 Goof1changed 3161 3162 An example event for a complex structure 3163 3164 3165 3166 goo 3167 f1 3168 3169 3170 3171 3172 3173 goo 3174 f1 3175 3176 3177 3179 3180 NewbarEntry 3181 3182 Event for a new entry created on table bar 3183 3184 3185 bar 3186 _barIndex_ 3187 3188 3189 3190 3191 bar 3192 _barIndex_ 3193 3194 3195 foo 3196 3197 3198 3200 3201 Gah11changed 3202 3203 Event for table gah, entry index 11 changing 3204 3205 3206 gah 3207 11 3208 3209 3210 3211 3212 gah 3213 11 3214 3215 3216 3218 3219 Gah10field1 3220 3221 Event for table gah, entry index 10, column field1 changing 3222 3223 3224 gah 3225 10 3226 field1 3227 3228 3229 3230 3231 gah 3232 10 3233 3235 3236 3237 3239 4.7.6.1. Element 3241 The element contains information identifying a field in 3242 the LFB that is to be monitored for events. 3244 The element contains one or more each of 3245 which MAY be followed by one or more elements. Each 3246 of these two elements represent the textual equivalent of a path 3247 select component of the LFB. 3249 The element contains the name of a component in the LFB 3250 or a component nested in an array or structure within the LFB. The 3251 name used in MUST identify a valid component within the 3252 containing LFB context. The first element in a MUST be 3253 an element. In the example shown, four LFB components 3254 foo, goo, bar and gah are used as s. 3256 In the simple case, an identifies an atomic component. 3257 This is the case illustrated in the event named Foochanged. 3258 is also used to address complex components such as 3259 arrays or structures. 3261 The first defined event, Foochanged, demonstrates how a scalar LFB 3262 component, foo, could be monitored to trigger an event. 3264 The second event, Goof1changed, demonstrates how a member of the 3265 complex structure goo could be monitored to trigger an event. 3267 The events named NewbarEntry, Gah11changed and Gah10field1 3268 represent monitoring of arrays bar and gah in differing details. 3270 If an identifies a complex component then a further 3271 MAY be used to refine the path to the target element. 3272 Defined event Goof1changed demonstrates how a second is 3273 used to point to member f1 of the structure goo. 3275 If an identifies an array then the following rules 3276 apply: 3278 o elements MUST be present as the next XML element 3279 after an which identifies an array component. 3280 MUST NOT occur other than after an array 3281 reference, as it is only meaningful in that context. 3283 o An contains either: 3285 * A numeric value to indicate that the event applies to a 3286 specific entry (by index) of the array. As an example, event 3287 Gah11changed shows how table gah's index 11 is being targeted 3288 for monitoring. 3290 * It is expected that the more common usage is to have the event 3291 being defined across all elements of the array (i.e a wildcard 3292 for all indices). In that case, the value of the 3293 MUST be a name rather than a numeric value. 3294 That same name can then be used as the value of 3295 in elements as described below. 3296 An example of a wild card table index is shown in event 3297 NewBarentry where the value is named 3298 _barIndex_ 3300 o An MAY follow an to further refine 3301 the path to the target element (Note: this is in the same spirit 3302 as the case where is used to further refine 3303 in the earlier example of a complex structure example 3304 of Goof1changed). The example event Gah10field1 illustrates how 3305 the column field1 of table gah is monitored for changes. 3307 It should be emphasized that the name in an element 3308 in defined event NewbarEntry is not a component name. It is a 3309 variable name for use in the elements (described in 3310 Section 4.7.6.3) of the given LFB definition. This name MUST be 3311 distinct from any component name that can validly occur in the 3312 clause. 3314 4.7.6.2. Element 3316 The event condition element represents a condition that triggers a 3317 notification. The list of conditions is: 3319 o the target must be an array, ending with a 3320 subscript indication. The event is generated when an entry in the 3321 array is created. This occurs even if the entry is created by CE 3322 direction. The event example NewbarEntry demonstrates the 3323 condition. 3325 o the target must be an array, ending with a 3326 subscript indication. The event is generated when an entry in the 3327 array is destroyed. This occurs even if the entry is destroyed by 3328 CE direction. 3330 o the event is generated whenever the target 3331 component changes in any way. For binary components such as up/ 3332 down, this reflects a change in state. It can also be used with 3333 numeric attributes, in which case any change in value results in a 3334 detected trigger. Event examples Foochanged, Gah11changed, and 3335 Gah10field1 illustrate the condition. 3337 o the event is generated whenever the target 3338 component becomes greater than the threshold. The threshold is an 3339 event property. 3341 o the event is generated whenever the target 3342 component becomes less than the threshold. The threshold is an 3343 event property. 3345 4.7.6.3. Element 3347 The element of an declare the information to 3348 be delivered by the FE along with the notification of the occurrence 3349 of the event. 3351 The element contains one or more 3352 elements. Each element identifies a piece of data from 3353 the LFB class to be reported. The notification carries that data as 3354 if the collection of elements had been defined in a 3355 structure. The syntax is exactly the same as used in the 3356 element, using and 3357 elements and so the same rules apply. Each element 3358 thus MUST identify a component in the LFB class. MAY 3359 contain integers. If they contain names, they MUST be names from 3360 elements of the in the event. The 3361 selection for the report will use the value for the subscript that 3362 identifies that specific element triggering the event. This can be 3363 used to reference the component causing the event, or to reference 3364 related information in parallel tables. 3366 In the example shown, in the case of the event Foochanged, the report 3367 will carry the value of foo; in the case of the defined event 3368 NewbarEntry acting on LFB component bar, which is an array, there are 3369 two items that are reported as indicated by the two 3370 declarations: 3372 o The first details what new entry was added in the 3373 table bar. Recall that _barIndex_ is declared as the event's 3374 and that by virtue of using a name 3375 instead of a numeric value, the is implied to be a 3376 wildcard and will carry whatever index of the new entry. 3378 o The second includes the value of LFB component foo 3379 at the time the new entry was created in bar. Reporting foo in 3380 this case is provided to demonstrate the flexibility of event 3381 reporting. 3383 This event reporting structure is designed to allow the LFB designer 3384 to specify information that is likely not known a priori by the CE 3385 and is likely needed by the CE to process the event. While the 3386 structure allows for pointing at large blocks of information (full 3387 arrays or complex structures) this is not recommended. Also, the 3388 variable reference/subscripting in reporting only captures a small 3389 portion of the kinds of related information. Chaining through index 3390 fields stored in a table, for example, is not supported. In general, 3391 the mechanism is an optimization for cases that have 3392 been found to be common, saving the CE from having to query for 3393 information it needs to understand the event. It does not represent 3394 all possible information needs. 3396 If any components referenced by the eventReport are optional, then 3397 the report MUST use a protocol format that supports optional elements 3398 and allows for the non-existence of such elements. Any components 3399 which do not exist are not reported. 3401 4.7.6.4. Runtime control of events 3403 The high level view of the declaration and operation of LFB events is 3404 described in Section 3.2.5. 3406 The provides additional components used in the path to 3407 reference the event. The path constitutes the baseID for events, 3408 followed by the ID for the specific event, followed by a value for 3409 each element if it exists in the . 3411 The event path will uniquely identify a specific occurrence of the 3412 event in the event notification to the CE. In the example provided 3413 above, at the end of Section 4.7.6, a notification with path of 7.7 3414 uniquely identifies the event to be that caused by the change of foo; 3415 an event with path 7.9.100 uniquely identifies the event to be that 3416 caused by a creation of table bar entry with index/subscript 100. 3418 As described in the Section 4.8.5, event elements have properties 3419 associated with them. These properties include the subscription 3420 information indicating whether the CE wishes the FE to generate event 3421 reports for the event at all, thresholds for events related to level 3422 crossing, and filtering conditions that may reduce the set of event 3423 notifications generated by the FE. Details of the filtering 3424 conditions that can be applied are given in that section. The 3425 filtering conditions allow the FE to suppress floods of events that 3426 could result from oscillation around a condition value. For FEs that 3427 do not wish to support filtering, the filter properties can either be 3428 read only or not supported. 3430 In addition to identifying the event sources, the CE also uses the 3431 event path to activate runtime control of the event via the event 3432 properties (defined in Section 4.8.5) utilizing SET-PROP as defined 3433 in ForCES Protocol [2] operation. 3435 To activate event generation on the FE, a SET-PROP message 3436 referencing the event and registration property of the event is 3437 issued to the FE by the CE with any prefix of the path of the event. 3438 So, for an event defined on the example table bar, a SET-PROP with a 3439 path of 7.9 will subscribe the CE to all occurrences of that event on 3440 any entry of the table. This is particularly useful for the 3441 and conditions on tables. Events 3442 using those conditions will generally be defined with a field/ 3443 subscript sequence that identifies an array and ends with an 3444 element. Thus, the event notification will indicate 3445 which array entry has been created or destroyed. A typical 3446 subscriber will subscribe for the array, as opposed to a specific 3447 entry in an array, so it will use a shorter path. 3449 In the example provided, subscribing to 7.8 implies receiving all 3450 declared events from table bar. Subscribing to 7.8.100 implies 3451 receiving an event when subscript/index 100 table entry is created. 3453 Threshold and filtering conditions can only be applied to individual 3454 events. For events defined on elements of an array, this 3455 specification does not allow for defining a threshold or filtering 3456 condition on an event for all elements of an array. 3458 4.7.7. Element for LFB Operational Specification 3460 The element of the provides unstructured 3461 text (in XML sense) to explain what the LFB does to a human user. 3463 4.8. Properties 3465 Components of LFBs have properties which are important to the CE. 3466 The most important property is the existence / readability / 3467 writeability of the element. Depending on the type of the component, 3468 other information may be of importance. 3470 The model provides the definition of the structure of property 3471 information. There is a base class of property information. For the 3472 array, alias, and event components there are subclasses of property 3473 information providing additional fields. This information is 3474 accessed by the CE (and updated where applicable) via the ForCES 3475 protocol. While some property information is writeable, there is no 3476 mechanism currently provided for checking the properties of a 3477 property element. Writeability can only be checked by attempting to 3478 modify the value. 3480 4.8.1. Basic Properties 3482 The basic property definition, along with the scalar dataTypeDef for 3483 accessibility is below. Note that this access permission information 3484 is generally read-only. 3486 3487 accessPermissionValues 3488 3489 The possible values of component access permission 3490 3491 3492 uchar 3493 3494 3495 None 3496 Access is prohibited 3497 3498 3499 Read-Only 3500 3501 Access to the component is read only 3502 3503 3504 3505 Write-Only 3506 3507 The component MAY be written, but not read 3508 3509 3510 3511 Read-Write 3512 3513 The component MAY be read or written 3514 3515 3516 3517 3518 3519 3520 baseElementProperties 3521 basic properties, accessibility 3522 3523 3524 accessibility 3525 3526 does the component exist, and 3527 can it be read or written 3528 3529 accessPermissionValues 3530 3531 3532 3534 4.8.2. Array Properties 3536 The properties for an array add a number of important pieces of 3537 information. These properties are also read-only. 3539 3540 arrayElementProperties 3541 Array Element Properties definition 3542 3543 baseElementProperties 3544 3545 entryCount 3546 the number of entries in the array 3547 uint32 3548 3549 3550 highestUsedSubscript 3551 the last used subscript in the array 3552 uint32 3553 3554 3555 firstUnusedSubscript 3556 3557 The subscript of the first unused array element 3558 3559 uint32 3560 3561 3562 3564 4.8.3. String Properties 3566 The properties of a string specify the actual octet length and the 3567 maximum octet length for the element. The maximum length is included 3568 because an FE implementation MAY limit a string to be shorter than 3569 the limit in the LFB Class definition. 3571 3572 stringElementProperties 3573 string Element Properties definition 3574 3575 baseElementProperties 3576 3577 stringLength 3578 the number of octets in the string 3579 uint32 3580 3581 3582 maxStringLength 3583 3584 the maximum number of octets in the string 3585 3586 uint32 3587 3588 3589 3591 4.8.4. Octetstring Properties 3593 The properties of an octetstring specify the actual length and the 3594 maximum length, since the FE implementation MAY limit an octetstring 3595 to be shorter than the LFB Class definition. 3597 3598 octetstringElementProperties 3599 octetstring Element Properties definition 3600 3601 3602 baseElementProperties 3603 3604 octetstringLength 3605 3606 the number of octets in the octetstring 3607 3608 uint32 3609 3610 3611 maxOctetstringLength 3612 3613 the maximum number of octets in the octetstring 3614 3615 uint32 3616 3617 3618 3620 4.8.5. Event Properties 3622 The properties for an event add three (usually) writeable fields. 3623 One is the subscription field. 0 means no notification is generated. 3624 Any non-zero value (typically 1 is used) means that a notification is 3625 generated. The hysteresis field is used to suppress generation of 3626 notifications for oscillations around a condition value, and is 3627 described below (Section 4.8.5.2). The threshold field is used for 3628 the and conditions. It 3629 indicates the value to compare the event target against. Using the 3630 properties allows the CE to set the level of interest. FEs which do 3631 not support setting the threshold for events will make this field 3632 read-only. 3634 3635 eventElementProperties 3636 event Element Properties definition 3637 3638 baseElementProperties 3639 3640 registration 3641 3642 has the CE registered to be notified of this event 3643 3644 uint32 3645 3646 3647 threshold 3648 comparison value for level crossing events 3649 3650 3651 uint32 3652 3653 3654 eventHysteresis 3655 region to suppress event recurrence notices 3656 3657 3658 uint32 3659 3660 3661 eventCount 3662 number of occurrences to suppress 3663 3664 3665 uint32 3666 3667 3668 eventInterval 3669 time interval in ms between notifications 3670 3671 3672 uint32 3673 3674 3675 3677 4.8.5.1. Common Event Filtering 3679 The event properties have values for controlling several filter 3680 conditions. Support of these conditions is optional, but all 3681 conditions SHOULD be supported. Events which are reliably known not 3682 to be subject to rapid occurrence or other concerns MAY not support 3683 all filter conditions. 3685 Currently, three different filter condition variables are defined. 3686 These are eventCount, eventInterval, and eventHysteresis. Setting 3687 the condition variables to 0 (their default value) means that the 3688 condition is not checked. 3690 Conceptually, when an event is triggered, all configured conditions 3691 are checked. If no filter conditions are triggered, or if any 3692 trigger conditions are met, the event notification is generated. If 3693 there are filter conditions, and no condition is met, then no event 3694 notification is generated. Event filter conditions have reset 3695 behavior when an event notification is generated. If any condition 3696 is passed, and the notification is generated, the notification reset 3697 behavior is performed on all conditions, even those which had not 3698 passed. This provides a clean definition of the interaction of the 3699 various event conditions. 3701 An example of the interaction of conditions is an event with an 3702 eventCount property set to 5 and an eventInterval property set to 500 3703 milliseconds. Suppose that a burst of occurrences of this event is 3704 detected by the FE. The first occurrence will cause a notification 3705 to be sent to the CE. Then, if four more occurrences are detected 3706 rapidly (less than 0.5 seconds) they will not result in 3707 notifications. If two more occurrences are detected, then the second 3708 of those will result in a notification. Alternatively, if more than 3709 500 milliseconds has passed since the notification and an occurrence 3710 is detected, that will result in a notification. In either case, the 3711 count and time interval suppression is reset no matter which 3712 condition actually caused the notification. 3714 4.8.5.2. Event Hysteresis Filtering 3716 Events with numeric conditions can have hysteresis filters applied to 3717 them. The hysteresis level is defined by a property of the event. 3718 This allows the FE to notify the CE of the hysteresis applied, and if 3719 it chooses, the FE can allow the CE to modify the hysteresis. This 3720 applies to for a numeric field, and to 3721 and . The content of a 3722 element is a numeric value. When supporting hysteresis, 3723 the FE MUST track the value of the element and make sure that the 3724 condition has become untrue by at least the hysteresis from the event 3725 property. To be specific, if the hysteresis is V, then 3727 o For a condition, if the last notification was for 3728 value X, then the notification MUST NOT be generated 3729 until the value reaches X +/- V. 3731 o For a condition with threshold T, once the 3732 event has been generated at least once it MUST NOT be generated 3733 again until the field first becomes less than or equal to T - V, 3734 and then exceeds T. 3736 o For a condition with threshold T, once the event 3737 has been generate at least once it MUST NOT be generated again 3738 until the field first becomes greater than or equal to T + V, and 3739 then becomes less than T. 3741 4.8.5.3. Event Count Filtering 3743 Events MAY have a count filtering condition. This property, if set 3744 to a non-zero value, indicates the number of occurrences of the event 3745 that should be considered redundant and not result in a notification. 3746 Thus, if this property is set to 1, and no other conditions apply, 3747 then every other detected occurrence of the event will result in a 3748 notification. This particular meaning is chosen so that the value 1 3749 has a distinct meaning from the value 0. 3751 A conceptual implementation (not required) for this might be an 3752 internal suppression counter. Whenever an event is triggered, the 3753 counter is checked. If the counter is 0, a notification is 3754 generated. Whether a notification is generated or not, the counter 3755 is incremented. If the counter exceeds the configured value, it is 3756 set to 0. 3758 4.8.5.4. Event Time Filtering 3760 Events MAY have a time filtering condition. This property represents 3761 the minimum time interval (in the absence of some other filtering 3762 condition being passed) between generating notifications of detected 3763 events. This condition MUST only be passed if the time since the 3764 last notification of the event is longer than the configured interval 3765 in milliseconds. 3767 Conceptually, this can be thought of as a stored timestamp which is 3768 compared with the detection time, or as a timer that is running that 3769 resets a suppression flag. In either case, if a notification is 3770 generated due to passing any condition then the time interval 3771 detection MUST be restarted. 3773 4.8.6. Alias Properties 3775 The properties for an alias add three (usually) writeable fields. 3776 These combine to identify the target component the subject alias 3777 refers to. 3779 3780 aliasElementProperties 3781 alias Element Properties defintion 3782 3783 baseElementProperties 3784 3785 targetLFBClass 3786 the class ID of the alias target 3787 uint32 3788 3789 3790 targetLFBInstance 3791 the instance ID of the alias target 3792 uint32 3793 3794 3795 targetComponentPath 3796 3797 the path to the component target 3798 each 4 octets is read as one path element, 3799 using the path construction in the ForCES protocol, 3800 [2]. 3801 3802 octetstring[128] 3803 3804 3805 3807 4.9. XML Schema for LFB Class Library Documents 3809 3810 3816 3817 3818 Schema for Defining LFB Classes and associated types (frames, 3819 data types for LFB attributes, and metadata). 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3831 3833 3835 3837 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3921 3923 3925 3926 3927 3928 3929 3930 3932 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3956 3957 3958 3960 3961 3963 3964 3965 3966 3967 3968 3969 3970 3971 3974 3975 3976 3977 3978 3979 3980 3981 3982 3984 3985 3986 3987 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 4000 4001 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4039 4041 4043 4045 4047 4049 4050 4051 4053 4054 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4096 4097 4098 4099 4100 4101 4102 4103 4105 4106 4107 4108 4109 4110 4111 4112 4113 4115 4116 4117 4118 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4141 4142 4143 4144 4145 4146 4147 4148 4150 4151 4152 4153 4154 4155 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4169 4170 4171 4172 4173 4174 4175 4177 4179 4180 4181 4182 4183 4184 4185 4187 4188 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4237 4238 4240 4241 4242 4243 4244 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4287 4288 4289 4291 4292 4293 4294 4296 4297 4298 4299 4301 4303 4305 4307 4309 4310 4311 4312 4314 4315 4316 4318 4320 4322 4323 4324 4326 4327 4328 4329 4330 4331 4332 4333 4334 4336 5. FE Components and Capabilities 4338 A ForCES forwarding element handles traffic on behalf of a ForCES 4339 control element. While the standards will describe the protocol and 4340 mechanisms for this control, different implementations and different 4341 instances will have different capabilities. The CE MUST be able to 4342 determine what each instance it is responsible for is actually 4343 capable of doing. As stated previously, this is an approximation. 4344 The CE is expected to be prepared to cope with errors in requests and 4345 variations in detail not captured by the capabilities information 4346 about an FE. 4348 In addition to its capabilities, an FE will have information that can 4349 be used in understanding and controlling the forwarding operations. 4350 Some of this information will be read only, while others parts may 4351 also be writeable. 4353 In order to make the FE information easily accessible, the 4354 information is represented in an LFB. This LFB has a class, 4355 FEObject. The LFBClassID for this class is 1. Only one instance of 4356 this class will ever be present in an FE, and the instance ID of that 4357 instance in the protocol is 1. Thus, by referencing the components 4358 of class:1, instance:1 a CE can get the general information about the 4359 FE. The FEObject LFB Class is described in this section. 4361 There will also be an FEProtocol LFB Class. LFBClassID 2 is reserved 4362 for that class. There will be only one instance of that class as 4363 well. Details of that class are defined in the ForCES Protocol [2] 4364 document. 4366 5.1. XML for FEObject Class definition 4368 4369 4372 4373 4374 LFBAdjacencyLimitType 4375 Describing the Adjacent LFB 4376 4377 4378 NeighborLFB 4379 ID for that LFB Class 4380 uint32 4381 4382 4383 ViaPorts 4384 4385 the ports on which we can connect 4386 4387 4388 string 4389 4390 4391 4392 4393 4394 PortGroupLimitType 4395 4396 Limits on the number of ports in a given group 4397 4398 4399 4400 PortGroupName 4401 Group Name 4402 string 4403 4404 4405 MinPortCount 4406 Minimum Port Count 4407 4408 uint32 4410 4411 4412 MaxPortCount 4413 Max Port Count 4414 4415 uint32 4416 4417 4418 4419 4420 SupportedLFBType 4421 table entry for supported LFB 4422 4423 4424 LFBName 4425 4426 The name of a supported LFB Class 4427 4428 string 4429 4430 4431 LFBClassID 4432 the id of a supported LFB Class 4433 uint32 4434 4435 4436 LFBVersion 4437 4438 The version of the LFB Class used 4439 by this FE. 4440 4441 string 4442 4443 4444 LFBOccurrenceLimit 4445 4446 the upper limit of instances of LFBs of this class 4447 4448 4449 uint32 4450 4451 4453 4454 PortGroupLimits 4455 Table of Port Group Limits 4456 4457 4458 PortGroupLimitType 4459 4460 4461 4462 4463 CanOccurAfters 4464 4465 List of LFB Classes that this LFB class can follow 4466 4467 4468 4469 LFBAdjacencyLimitType 4470 4471 4472 4474 4475 CanOccurBefores 4476 4477 List of LFB Classes that can follow this LFB class 4478 4479 4480 4481 LFBAdjacencyLimitType 4482 4483 4484 4485 UseableParentLFBClasses 4486 4487 List of LFB Classes from which this class has 4488 inherited, and which the FE is willing to allow 4489 for references to instances of this class. 4490 4491 4492 4493 uint32 4494 4495 4496 4497 4498 4499 FEStateValues 4500 The possible values of status 4501 4502 uchar 4503 4504 4505 AdminDisable 4506 4507 FE is administratively disabled 4508 4509 4510 4511 OperDisable 4512 FE is operatively disabled 4513 4514 4515 OperEnable 4516 FE is operating 4517 4518 4519 4520 4521 4522 FEConfiguredNeighborType 4523 Details of the FE's Neighbor 4524 4525 4526 NeighborID 4527 Neighbors FEID 4528 uint32 4529 4530 4531 InterfaceToNeighbor 4532 4533 FE's interface that connects to this neighbor 4534 4535 4536 string 4537 4538 4539 NeighborInterface 4540 4541 The name of the interface on the neighbor to 4542 which this FE is adjacent. This is required 4543 In case two FEs are adjacent on more than 4544 one interface. 4545 4546 4547 string 4548 4549 4550 4551 4552 LFBSelectorType 4553 4554 Unique identification of an LFB class-instance 4555 4556 4557 4558 LFBClassID 4559 LFB Class Identifier 4560 uint32 4561 4562 4563 LFBInstanceID 4564 LFB Instance ID 4565 uint32 4566 4567 4568 4569 4570 LFBLinkType 4571 4572 Link between two LFB instances of topology 4573 4574 4575 4576 FromLFBID 4577 LFB src 4578 LFBSelectorType 4579 4580 4581 FromPortGroup 4582 src port group 4583 string 4584 4585 4586 FromPortIndex 4587 src port index 4588 uint32 4589 4590 4591 ToLFBID 4592 dst LFBID 4593 LFBSelectorType 4594 4595 4596 ToPortGroup 4597 dst port group 4598 string 4599 4600 4601 ToPortIndex 4602 dst port index 4603 uint32 4604 4605 4606 4607 4608 4609 4610 FEObject 4611 Core LFB: FE Object 4612 1.0 4613 4614 4615 LFBTopology 4616 the table of known Topologies 4617 4618 LFBLinkType 4619 4620 4621 4622 LFBSelectors 4623 4624 table of known active LFB classes and 4625 instances 4626 4627 4628 LFBSelectorType 4629 4630 4631 4632 FEName 4633 name of this FE 4634 string[40] 4635 4636 4637 FEID 4638 ID of this FE 4639 uint32 4640 4641 4642 FEVendor 4643 vendor of this FE 4644 string[40] 4645 4646 4647 FEModel 4648 model of this FE 4649 string[40] 4651 4652 4653 FEState 4654 State of this FE 4655 FEStateValues 4656 4657 4658 FENeighbors 4659 table of known neighbors 4660 4661 4662 FEConfiguredNeighborType 4663 4664 4665 4666 4667 4668 ModifiableLFBTopology 4669 4670 Whether Modifiable LFB is supported 4671 4672 4673 boolean 4674 4675 4676 SupportedLFBs 4677 List of all supported LFBs 4678 4679 4680 SupportedLFBType 4681 4682 4683 4684 4685 4686 4688 5.2. FE Capabilities 4690 The FE Capability information is contained in the capabilities 4691 element of the class definition. As described elsewhere, capability 4692 information is always considered to be read-only. 4694 The currently defined capabilities are ModifiableLFBTopology and 4695 SupportedLFBs. Information as to which components of the FEObject 4696 LFB are supported is accessed by the properties information for those 4697 components. 4699 5.2.1. ModifiableLFBTopology 4701 This component has a boolean value that indicates whether the LFB 4702 topology of the FE may be changed by the CE. If the component is 4703 absent, the default value is assumed to be true, and the CE presumes 4704 the LFB topology may be changed. If the value is present and set to 4705 false, the LFB topology of the FE is fixed. If the topology is 4706 fixed, the SupportedLFBs element may be omitted, and the list of 4707 supported LFBs is inferred by the CE from the LFB topology 4708 information. If the list of supported LFBs is provided when 4709 ModifiableLFBTopology is false, the CanOccurBefore and CanOccurAfter 4710 information should be omitted. 4712 5.2.2. SupportedLFBs and SupportedLFBType 4714 One capability that the FE should include is the list of supported 4715 LFB classes. The SupportedLFBs component, is an array that contains 4716 the information about each supported LFB Class. The array structure 4717 type is defined as the SupportedLFBType dataTypeDef. 4719 Each entry in the SupportedLFBs array describes an LFB class that the 4720 FE supports. In addition to indicating that the FE supports the 4721 class, FEs with modifiable LFB topology SHOULD include information 4722 about how LFBs of the specified class may be connected to other LFBs. 4723 This information SHOULD describe which LFB classes the specified LFB 4724 class may succeed or precede in the LFB topology. The FE SHOULD 4725 include information as to which port groups may be connected to the 4726 given adjacent LFB class. If port group information is omitted, it 4727 is assumed that all port groups may be used. This capability 4728 information on the acceptable ordering and connection of LFBs MAY be 4729 omitted if the implementor concludes that the actual constraints are 4730 such that the information would be misleading for the CE. 4732 5.2.2.1. LFBName 4734 This component has as its value the name of the LFB Class being 4735 described. 4737 5.2.2.2. LFBClassID 4739 The numeric ID of the LFB Class being described. While conceptually 4740 redundant with the LFB Name, both are included for clarity and to 4741 allow consistency checking. 4743 5.2.2.3. LFBVersion 4745 The version string specifying the LFB Class version supported by this 4746 FE. As described above in versioning, an FE can support only a 4747 single version of a given LFB Class. 4749 5.2.2.4. LFBOccurrenceLimit 4751 This component, if present, indicates the largest number of instances 4752 of this LFB class the FE can support. For FEs that do not have the 4753 capability to create or destroy LFB instances, this can either be 4754 omitted or be the same as the number of LFB instances of this class 4755 contained in the LFB list attribute. 4757 5.2.2.5. PortGroupLimits and PortGroupLimitType 4759 The PortGroupLimits component is an array of information about the 4760 port groups supported by the LFB class. The structure of the port 4761 group limit information is defined by the PortGroupLimitType 4762 dataTypeDef. 4764 Each PortGroupLimits array entry contains information describing a 4765 single port group of the LFB class. Each array entry contains the 4766 name of the port group in the PortGroupName component, the fewest 4767 number of ports that can exist in the group in the MinPortCount 4768 component, and the largest number of ports that can exist in the 4769 group in the MaxPortCount component. 4771 5.2.2.6. CanOccurAfters and LFBAdjacencyLimitType 4773 The CanOccurAfters component is an array that contains the list of 4774 LFBs the described class can occur after. The array entries are 4775 defined in the LFBAdjacencyLimitType dataTypeDef. 4777 The array entries describe a permissible positioning of the described 4778 LFB class, referred to here as the SupportedLFB. Specifically, each 4779 array entry names an LFB that can topologically precede that LFB 4780 class. That is, the SupportedLFB can have an input port connected to 4781 an output port of an LFB that appears in the CanOccurAfters array. 4782 The LFB class that the SupportedLFB can follow is identified by the 4783 NeighborLFB component (of the LFBAdjacencyLimitType dataTypeDef) of 4784 the CanOccurAfters array entry. If this neighbor can only be 4785 connected to a specific set of input port groups, then the viaPort 4786 component is included. This component is an array, with one entry 4787 for each input port group of the SupportedLFB that can be connected 4788 to an output port of the NeighborLFB. 4790 [e.g., Within a SupportedLFBs entry, each array entry of the 4791 CanOccurAfters array must have a unique NeighborLFB, and within each 4792 such array entry each viaPort must represent a distinct and valid 4793 input port group of the SupportedLFB. The LFB Class definition 4794 schema does not include these uniqueness constraints.] 4796 5.2.2.7. CanOccurBefores and LFBAdjacencyLimitType 4798 The CanOccurBefores array holds the information about which LFB 4799 classes can follow the described class. Structurally this element 4800 parallels CanOccurAfters, and uses the same type definition for the 4801 array entries. 4803 The array entries list those LFB classes that the SupportedLFB may 4804 precede in the topology. In this component, the entries in the 4805 viaPort component of the array value represent the output port groups 4806 of the SupportedLFB that may be connected to the NeighborLFB. As 4807 with CanOccurAfters, viaPort may have multiple entries if multiple 4808 output ports may legitimately connect to the given NeighborLFB class. 4810 [And a similar set of uniqueness constraints apply to the 4811 CanOccurBefore clauses, even though an LFB may occur both in 4812 CanOccurAfter and CanOccurBefore.] 4814 5.2.2.8. UseableParentLFBClasses 4816 The UseableParentLFBClasses array, if present, is used to hold a list 4817 of parent LFB class IDs. All the entries in the list must be IDs of 4818 classes from which the SupportedLFB Class being described has 4819 inherited (either directly, or through an intermediate parent.) (If 4820 an FE includes improper values in this list, improper manipulations 4821 by the CE are likely, and operational failures are likely.) In 4822 addition, the FE, by including a given class in the last, is 4823 indicating to the CE that a given parent class may be used to 4824 manipulate an instance of this supported LFB class. 4826 By allowing such substitution, the FE allows for the case where an 4827 instantiated LFB may be of a class not known to the CE, but could 4828 still be manipulated. While it is hoped that such situations are 4829 rare, it is desirable for this to be supported. This can occur if an 4830 FE locally defines certain LFB instances, or if an earlier CE had 4831 configured some LFB instances. It can also occur if the FE would 4832 prefer to instantiate a more recent, more specific and suitable, LFB 4833 class rather than a common parent. 4835 In order to permit this, the FE MUST be more restrained in assigning 4836 LFB Instance IDs. Normally, instance IDs are qualified by the LFB 4837 class. However, if two LFB classes share a parent, and if that 4838 parent is listed in the UseableParentLFBClasses for both specific LFB 4839 classes, then all the instances of both (or any, if multiple classes 4840 are listing the common parent) MUST use distinct instances. This 4841 permits the FE to determine which LFB Instance is intended by CE 4842 manipulation operations even when a parent class is used. 4844 5.2.2.9. LFBClassCapabilities 4846 While it would be desirable to include class capability level 4847 information, this is not included in the model. While such 4848 information belongs in the FE Object in the supported class table, 4849 the contents of that information would be class specific. The 4850 currently expected encoding structures for transferring information 4851 between the CE and FE are such that allowing completely unspecified 4852 information would be likely to induce parse errors. We could specify 4853 that the information is encoded in an octetstring, but then we would 4854 have to define the internal format of that octet string. 4856 As there also are not currently any defined LFB Class level 4857 Capabilities that the FE needs to report, this information is not 4858 present now, but may be added in a future version of the FE Object. 4859 (This is an example of a case where versioning, rather than 4860 inheritance, would be needed, since the FE Object must have class ID 4861 1 and instance ID 1 so that the protocol behavior can start by 4862 finding this object.) 4864 5.3. FE Components 4866 The element is included if the class definition contains 4867 the definition of the components of the FE Object that are not 4868 considered "capabilities". Some of these components are writeable, 4869 and some are read-only, which is determinable by examining the 4870 property information of the components. 4872 5.3.1. FEState 4874 This component carries the overall state of the FE. The possible 4875 values are the strings AdminDisable, OperDisable and OperEnable. The 4876 starting state is OperDisable, and the transition to OperEnable is 4877 controlled by the FE. The CE controls the transition from OperEnable 4878 to/from AdminDisable. For details refer to the ForCES Protocol 4879 document [2]. 4881 5.3.2. LFBSelectors and LFBSelectorType 4883 The LFBSelectors component is an array of information about the LFBs 4884 currently accessible via ForCES in the FE. The structure of the LFB 4885 information is defined by the LFBSelectorType dataTypeDef. 4887 Each entry in the array describes a single LFB instance in the FE. 4888 The array entry contains the numeric class ID of the class of the LFB 4889 instance and the numeric instance ID for this instance. 4891 5.3.3. LFBTopology and LFBLinkType 4893 The optional LFBTopology component contains information about each 4894 inter-LFB link inside the FE, where each link is described in an 4895 LFBLinkType dataTypeDef. The LFBLinkType component contains 4896 sufficient information to identify precisely the end points of a 4897 link. The FromLFBID and ToLFBID components specify the LFB instances 4898 at each end of the link, and MUST reference LFBs in the LFB instance 4899 table. The FromPortGroup and ToPortGroup MUST identify output and 4900 input port groups defined in the LFB classes of the LFB instances 4901 identified by FromLFBID and ToLFBID. The FromPortIndex and 4902 ToPortIndex components select the entries from the port groups that 4903 this link connects. All links are uniquely identified by the 4904 FromLFBID, FromPortGroup, and FromPortIndex fields. Multiple links 4905 may have the same ToLFBID, ToPortGroup, and ToPortIndex as this model 4906 supports fan-in of inter- LFB links but not fan-out. 4908 5.3.4. FENeighbors and FEConfiguredNeighborType 4910 The FENeighbors component is an array of information about manually 4911 configured adjacencies between this FE and other FEs. The content of 4912 the array is defined by the FEConfiguredNeighborType dataTypeDef. 4914 This array is intended to capture information that may be configured 4915 on the FE and is needed by the CE, where one array entry corresponds 4916 to each configured neighbor. Note that this array is not intended to 4917 represent the results of any discovery protocols, as those will have 4918 their own LFBs. This component is optional. 4920 While there may be many ways to configure neighbors, the FE-ID is the 4921 best way for the CE to correlate entities. And the interface 4922 identifier (name string) is the best correlator. The CE will be able 4923 to determine the IP address and media level information about the 4924 neighbor from the neighbor directly. Omitting that information from 4925 this table avoids the risk of incorrect double configuration. 4927 Information about the intended forms of exchange with a given 4928 neighbor is not captured here, only the adjacency information is 4929 included. 4931 5.3.4.1. NeighborID 4933 This is the ID in some space meaningful to the CE for the neighbor. 4935 5.3.4.2. InterfaceToNeighbor 4937 This identifies the interface through which the neighbor is reached. 4939 5.3.4.3. NeighborInterface 4941 This identifies the interface on the neighbor through which the 4942 neighbor is reached. The interface identification is needed when 4943 either only one side of the adjacency has configuration information, 4944 or the two FEs are adjacent on more than one interface. 4946 6. Satisfying the Requirements on FE Model 4948 This section describes how the proposed FE model meets the 4949 requirements outlined in Section 5 of RFC3654 [6]. The requirements 4950 can be separated into general requirements (Section 5, 5.1 - 5.4) and 4951 the specification of the minimal set of logical functions that the FE 4952 model must support (Section 5.5). 4954 The general requirement on the FE model is that it be able to express 4955 the logical packet processing capability of the FE, through both a 4956 capability and a state model. In addition, the FE model is expected 4957 to allow flexible implementations and be extensible to allow defining 4958 new logical functions. 4960 A major component of the proposed FE model is the Logical Function 4961 Block (LFB) model. Each distinct logical function in an FE is 4962 modeled as an LFB. Operational parameters of the LFB that must be 4963 visible to the CE are conceptualized as LFB components. These 4964 components express the capability of the FE and support flexible 4965 implementations by allowing an FE to specify which optional features 4966 are supported. The components also indicate whether they are 4967 configurable by the CE for an LFB class. Configurable components 4968 provide the CE some flexibility in specifying the behavior of an LFB. 4969 When multiple LFBs belonging to the same LFB class are instantiated 4970 on an FE, each of those LFBs could be configured with different 4971 component settings. By querying the settings of the components for 4972 an instantiated LFB, the CE can determine the state of that LFB. 4974 Instantiated LFBs are interconnected in a directed graph that 4975 describes the ordering of the functions within an FE. This directed 4976 graph is described by the topology model. The combination of the 4977 components of the instantiated LFBs and the topology describe the 4978 packet processing functions available on the FE (current state). 4980 Another key component of the FE model is the FE components. The FE 4981 components are used mainly to describe the capabilities of the FE, 4982 but they also convey information about the FE state. 4984 The FE model includes only the definition of the FE Object LFB 4985 itself. Meeting the full set of working group requirements requires 4986 other LFBs. The class definitions for those LFBs will be provided in 4987 other documents. 4989 7. Using the FE model in the ForCES Protocol 4991 The actual model of the forwarding plane in a given NE is something 4992 the CE must learn and control by communicating with the FEs (or by 4993 other means). Most of this communication will happen in the post- 4994 association phase using the ForCES protocol. The following types of 4995 information must be exchanged between CEs and FEs via the ForCES 4996 Protocol [2]: 4998 1. FE topology query; 5000 2. FE capability declaration; 5002 3. LFB topology (per FE) and configuration capabilities query; 5004 4. LFB capability declaration; 5006 5. State query of LFB components; 5008 6. Manipulation of LFB components; 5010 7. LFB topology reconfiguration. 5012 Items 1) through 5) are query exchanges, where the main flow of 5013 information is from the FEs to the CEs. Items 1) through 4) are 5014 typically queried by the CE(s) in the beginning of the post- 5015 association (PA) phase, though they may be repeatedly queried at any 5016 time in the PA phase. Item 5) (state query) will be used at the 5017 beginning of the PA phase, and often frequently during the PA phase 5018 (especially for the query of statistical counters). 5020 Items 6) and 7) are "command" types of exchanges, where the main flow 5021 of information is from the CEs to the FEs. Messages in Item 6) (the 5022 LFB re-configuration commands) are expected to be used frequently. 5023 Item 7) (LFB topology re-configuration) is needed only if dynamic LFB 5024 topologies are supported by the FEs and it is expected to be used 5025 infrequently. 5027 The inter-FE topology (item 1 above) can be determined by the CE in 5028 many ways. Neither this document nor the ForCES Protocol [2] 5029 document mandates a specific mechanism. The LFB Class definition 5030 does include the capability for an FE to be configured with, and to 5031 provide to the CE in response to a query, the identity of its 5032 neighbors. There may also be defined specific LFB classes and 5033 protocols for neighbor discovery. Routing protocols may be used by 5034 the CE for adjacency determination. The CE may be configured with 5035 the relevant information. 5037 The relationship between the FE model and the seven post-association 5038 messages are visualized in Figure 12: 5040 +--------+ 5041 ..........-->| CE | 5042 /----\ . +--------+ 5043 \____/ FE Model . ^ | 5044 | |................ (1),2 | | 6, 7 5045 | | (off-line) . 3, 4, 5 | | 5046 \____/ . | v 5047 . +--------+ 5048 e.g. RFCs ..........-->| FE | 5049 +--------+ 5051 Figure 12: Relationship between the FE model and the ForCES protocol 5052 messages, where (1) is part of the ForCES base protocol, and the 5053 rest are defined by the FE model. 5055 The actual encoding of these messages is defined by the ForCES 5056 Protocol [2] document and is beyond the scope of the FE model. Their 5057 discussion is nevertheless important here for the following reasons: 5059 o These PA model components have considerable impact on the FE 5060 model. For example, some of the above information can be 5061 represented as components of the LFBs, in which case such 5062 components must be defined in the LFB classes. 5064 o The understanding of the type of information that must be 5065 exchanged between the FEs and CEs can help to select the 5066 appropriate protocol format and the actual encoding method (such 5067 as XML, TLVs). 5069 o Understanding the frequency of these types of messages should 5070 influence the selection of the protocol format (efficiency 5071 considerations). 5073 The remaining sub-sections of this section address each of the seven 5074 message types. 5076 7.1. FE Topology Query 5078 An FE may contain zero, one or more external ingress ports. 5079 Similarly, an FE may contain zero, one or more external egress ports. 5080 In other words, not every FE has to contain any external ingress or 5081 egress interfaces. For example, Figure 13 shows two cascading FEs. 5082 FE #1 contains one external ingress interface but no external egress 5083 interface, while FE #2 contains one external egress interface but no 5084 ingress interface. It is possible to connect these two FEs together 5085 via their internal interfaces to achieve the complete ingress-to- 5086 egress packet processing function. This provides the flexibility to 5087 spread the functions across multiple FEs and interconnect them 5088 together later for certain applications. 5090 While the inter-FE communication protocol is out of scope for ForCES, 5091 it is up to the CE to query and understand how multiple FEs are 5092 inter-connected to perform a complete ingress-egress packet 5093 processing function, such as the one described in Figure 13. The 5094 inter-FE topology information may be provided by FEs, may be hard- 5095 coded into CE, or may be provided by some other entity (e.g., a bus 5096 manager) independent of the FEs. So while the ForCES Protocol [2] 5097 supports FE topology query from FEs, it is optional for the CE to use 5098 it, assuming the CE has other means to gather such topology 5099 information. 5101 +-----------------------------------------------------+ 5102 | +---------+ +------------+ +---------+ | 5103 input| | | | | | output | 5104 ---+->| Ingress |-->|Header |-->|IPv4 |---------+--->+ 5105 | | port | |Decompressor| |Forwarder| FE | | 5106 | +---------+ +------------+ +---------+ #1 | | 5107 +-----------------------------------------------------+ V 5108 | 5109 +-----------------------<-----------------------------+ 5110 | 5111 | +----------------------------------------+ 5112 V | +------------+ +----------+ | 5113 | input | | | | output | 5114 +->--+->|Header |-->| Egress |---------+--> 5115 | |Compressor | | port | FE | 5116 | +------------+ +----------+ #2 | 5117 +----------------------------------------+ 5119 Figure 13: An example of two FEs connected together 5121 Once the inter-FE topology is discovered by the CE after this query, 5122 it is assumed that the inter-FE topology remains static. However, it 5123 is possible that an FE may go down during the NE operation, or a 5124 board may be inserted and a new FE activated, so the inter-FE 5125 topology will be affected. It is up to the ForCES protocol to 5126 provide a mechanism for the CE to detect such events and deal with 5127 the change in FE topology. FE topology is outside the scope of the 5128 FE model. 5130 7.2. FE Capability Declarations 5132 FEs will have many types of limitations. Some of the limitations 5133 must be expressed to the CEs as part of the capability model. The 5134 CEs must be able to query these capabilities on a per-FE basis. 5135 Examples: 5137 o Metadata passing capabilities of the FE. Understanding these 5138 capabilities will help the CE to evaluate the feasibility of LFB 5139 topologies, and hence to determine the availability of certain 5140 services. 5142 o Global resource query limitations (applicable to all LFBs of the 5143 FE). 5145 o LFB supported by the FE. 5147 o LFB class instantiation limit. 5149 o LFB topological limitations (linkage constraint, ordering etc.) 5151 7.3. LFB Topology and Topology Configurability Query 5153 The ForCES protocol must provide the means for the CEs to discover 5154 the current set of LFB instances in an FE and the interconnections 5155 between the LFBs within the FE. In addition, sufficient information 5156 should be available to determine whether the FE supports any CE- 5157 initiated (dynamic) changes to the LFB topology, and if so, determine 5158 the allowed topologies. Topology configurability can also be 5159 considered as part of the FE capability query as described in Section 5160 9.3. 5162 7.4. LFB Capability Declarations 5164 LFB class specifications define a generic set of capabilities. When 5165 an LFB instance is implemented (instantiated) on a vendor's FE, some 5166 additional limitations may be introduced. Note that we discuss only 5167 those limitations that are within the flexibility of the LFB class 5168 specification. That is, the LFB instance will remain compliant with 5169 the LFB class specification despite these limitations. For example, 5170 certain features of an LFB class may be optional, in which case it 5171 must be possible for the CE to determine if an optional feature is 5172 supported by a given LFB instance or not. Also, the LFB class 5173 definitions will probably contain very few quantitative limits (e.g., 5174 size of tables), since these limits are typically imposed by the 5175 implementation. Therefore, quantitative limitations should always be 5176 expressed by capability arguments. 5178 LFB instances in the model of a particular FE implementation will 5179 possess limitations on the capabilities defined in the corresponding 5180 LFB class. The LFB class specifications must define a set of 5181 capability arguments, and the CE must be able to query the actual 5182 capabilities of the LFB instance via querying the value of such 5183 arguments. The capability query will typically happen when the LFB 5184 is first detected by the CE. Capabilities need not be re-queried in 5185 case of static limitations. In some cases, however, some 5186 capabilities may change in time (e.g., as a result of adding/removing 5187 other LFBs, or configuring certain components of some other LFB when 5188 the LFBs share physical resources), in which case additional 5189 mechanisms must be implemented to inform the CE about the changes. 5191 The following two broad types of limitations will exist: 5193 o Qualitative restrictions. For example, a standardized multi- 5194 field classifier LFB class may define a large number of 5195 classification fields, but a given FE may support only a subset of 5196 those fields. 5198 o Quantitative restrictions, such as the maximum size of tables, 5199 etc. 5201 The capability parameters that can be queried on a given LFB class 5202 will be part of the LFB class specification. The capability 5203 parameters should be regarded as special components of the LFB. The 5204 actual values of these components may be, therefore, obtained using 5205 the same component query mechanisms as used for other LFB components. 5207 Capability components are read-only arguments. In cases where some 5208 implementations may allow CE modification of the value, the 5209 information must be represented as an operational component, not a 5210 capability component. 5212 Assuming that capabilities will not change frequently, the efficiency 5213 of the protocol/schema/encoding is of secondary concern. 5215 Much of this restrictive information is captured by the component 5216 property information, and so can be access uniformly for all 5217 information within the model. 5219 7.5. State Query of LFB Components 5221 This feature must be provided by all FEs. The ForCES protocol and 5222 the data schema/encoding conveyed by the protocol must together 5223 satisfy the following requirements to facilitate state query of the 5224 LFB components: 5226 o Must permit FE selection. This is primarily to refer to a single 5227 FE, but referring to a group of (or all) FEs may optionally be 5228 supported. 5230 o Must permit LFB instance selection. This is primarily to refer to 5231 a single LFB instance of an FE, but optionally addressing of a 5232 group of LFBs (or all) may be supported. 5234 o Must support addressing of individual components of an LFB. 5236 o Must provide efficient encoding and decoding of the addressing 5237 info and the configured data. 5239 o Must provide efficient data transmission of the component state 5240 over the wire (to minimize communication load on the CE-FE link). 5242 7.6. LFB Component Manipulation 5244 The FE Model provides for the definition of LFB Classes. Each class 5245 has a globally unique identifier. Information within the class is 5246 represented as components and assigned identifiers within the scope 5247 of that class. This model also specifies that instances of LFB 5248 Classes have identifiers. The combination of class identifiers, 5249 instance identifiers, and component identifiers are used by the 5250 protocol to reference the LFB information in the protocol operations. 5252 7.7. LFB Topology Re-configuration 5254 Operations that will be needed to reconfigure LFB topology: 5256 o Create a new instance of a given LFB class on a given FE. 5258 o Connect a given output of LFB x to the given input of LFB y. 5260 o Disconnect: remove a link between a given output of an LFB and a 5261 given input of another LFB. 5263 o Delete a given LFB (automatically removing all interconnects to/ 5264 from the LFB). 5266 8. Example LFB Definition 5268 This section contains an example LFB definition. While some 5269 properties of LFBs are shown by the FE Object LFB, this endeavors to 5270 show how a data plane LFB might be build. This example is a 5271 fictional case of an interface supporting a coarse WDM optical 5272 interface that carries Frame Relay traffic. The statistical 5273 information (including error statistics) is omitted. 5275 Later portions of this example include references to protocol 5276 operations. The operations described are operations the protocol 5277 needs to support. The exact format and fields are purely 5278 informational here, as the ForCES Protocol [2] document defines the 5279 precise syntax and semantics of its operations. 5281 5282 5285 5286 5287 FRFrame 5288 5289 A frame relay frame, with DLCI without 5290 stuffing) 5291 5292 5293 5294 IPFrame 5295 An IP Packet 5296 5297 5298 5299 5300 frequencyInformationType 5301 5302 Information about a single CWDM frequency 5303 5304 5305 5306 LaserFrequency 5307 encoded frequency(channel) 5308 uint32 5309 5310 5311 FrequencyState 5312 state of this frequency 5313 PortStatusValues 5315 5316 5317 LaserPower 5318 current observed power 5319 uint32 5320 5321 5322 FrameRelayCircuits 5323 5324 Information about circuits on this Frequency 5325 5326 5327 frameCircuitsType 5328 5329 5330 5331 5332 5333 frameCircuitsType 5334 5335 Information about a single Frame Relay circuit 5336 5337 5338 5339 DLCI 5340 DLCI of the circuit 5341 uint32 5342 5343 5344 CircuitStatus 5345 state of the circuit 5346 PortStatusValues 5347 5348 5349 isLMI 5350 is this the LMI circuit 5351 boolean 5352 5353 5354 associatedPort 5355 5356 which input / output port is associated 5357 with this circuit 5358 5359 uint32 5360 5361 5362 5363 5364 PortStatusValues 5365 5366 The possible values of status. Used for both 5367 administrative and operational status 5368 5369 5370 uchar 5371 5372 5373 Disabled 5374 the component is disabled 5375 5376 5377 Enabled 5378 FE is operatively enabled 5379 5380 5381 5382 5383 5384 5385 5386 DLCI 5387 The DLCI the frame arrived on 5388 12 5389 uint32 5390 5391 5392 LaserChannel 5393 The index of the laser channel 5394 34 5395 uint32 5396 5397 5398 5399 5400 5401 FrameLaserLFB 5402 Fictional LFB for Demonstrations 5403 1.0 5404 5405 5406 LMIfromFE 5407 5408 Ports for LMI traffic, for transmission 5409 5410 5411 5412 FRFrame 5413 5414 5415 DLCI 5416 LaserChannel 5417 5418 5419 5420 5421 DatafromFE 5422 5423 Ports for data to be sent on circuits 5424 5425 5426 5427 IPFrame 5428 5429 5430 DLCI 5431 LaserChannel 5432 5433 5434 5435 5436 5437 5438 LMItoFE 5439 5440 Ports for LMI traffic for processing 5441 5442 5443 5444 FRFrame 5445 5446 5447 DLCI 5448 LaserChannel 5449 5450 5451 5452 5453 DatatoFE 5454 5455 Ports for Data traffic for processing 5456 5457 5458 5459 IPFrame 5460 5461 5462 DLCI 5463 LaserChannel 5464 5465 5466 5467 5468 5469 5470 AdminPortState 5471 is this port allowed to function 5472 PortStatusValues 5473 5474 5475 FrequencyInformation 5476 5477 table of information per CWDM frequency 5478 5479 5480 frequencyInformationType 5481 5482 5483 5484 5485 5486 OperationalState 5487 5488 whether the port over all is operational 5489 5490 PortStatusValues 5491 5492 5493 MaximumFrequencies 5494 5495 how many laser frequencies are there 5496 5497 uint16 5498 5499 5500 MaxTotalCircuits 5501 5502 Total supportable Frame Relay Circuits, across 5503 all laser frequencies 5504 5505 5506 uint32 5508 5509 5510 5511 5512 FrequencyState 5513 5514 The state of a frequency has changed 5515 5516 5517 FrequencyInformation 5518 _FrequencyIndex_ 5519 FrequencyState 5520 5521 5522 5523 5524 5525 FrequencyInformation 5526 _FrequencyIndex_ 5527 FrequencyState 5528 5529 5530 5531 5532 CreatedFrequency 5533 A new frequency has appeared 5534 5535 FrequencyInformation> 5536 _FrequencyIndex_ 5537 5538 5539 5540 5541 FrequencyInformation 5542 _FrequencyIndex_ 5543 LaserFrequency 5544 5545 5546 5547 5548 DeletedFrequency 5549 5550 A frequency Table entry has been deleted 5551 5552 5553 FrequencyInformation 5554 _FrequencyIndex_ 5555 5556 5557 5558 5559 PowerProblem 5560 5561 there are problems with the laser power level 5562 5563 5564 FrequencyInformation 5565 _FrequencyIndex_ 5566 LaserPower 5567 5568 5569 5570 5571 FrequencyInformation 5572 _FrequencyIndex_ 5573 LaserPower 5574 5575 5576 FrequencyInformation 5577 _FrequencyIndex_ 5578 LaserFrequency 5579 5580 5581 5582 5583 FrameCircuitChanged 5584 5585 the state of an Fr circuit on a frequency 5586 has changed 5587 5588 5589 FrequencyInformation 5590 _FrequencyIndex_ 5591 FrameRelayCircuits 5592 FrameCircuitIndex 5593 CircuitStatus 5594 5595 5596 5597 5598 FrequencyInformation 5599 _FrequencyIndex_ 5600 FrameRelayCircuits 5601 FrameCircuitIndex 5602 CircuitStatus 5603 5604 5605 FrequencyInformation 5606 _FrequencyIndex_ 5607 FrameRelayCircuits 5608 FrameCircuitIndex 5609 DLCI 5610 5611 5612 5613 5614 5615 5616 5618 8.1. Data Handling 5620 This LFB is designed to handle data packets coming in from or going 5621 out to the external world. It is not a full port, and it lacks many 5622 useful statistics, but it serves to show many of the relevant 5623 behaviors. The following paragraphs describe a potential operational 5624 device and how it might use this LFB definition. 5626 Packets arriving without error from the physical interface come in on 5627 a Frame Relay DLCI on a laser channel. These two values are used by 5628 the LFB to look up the handling for the packet. If the handling 5629 indicates that the packet is LMI, then the output index is used to 5630 select an LFB port from the LMItoFE port group. The packet is sent 5631 as a full Frame Relay frame (without any bit or byte stuffing) on the 5632 selected port. The laser channel and DLCI are sent as meta-data, 5633 even though the DLCI is also still in the packet. 5635 Good packets that arrive and are not LMI and have a frame relay type 5636 indicator of IP are sent as IP packets on the port in the DatatoFE 5637 port group, using the same index field from the table based on the 5638 laser channel and DLCI. The channel and DLCI are attached as meta- 5639 data for other use (classifiers, for example.) 5641 The current definition does not specify what to do if the Frame Relay 5642 type information is not IP. 5644 Packets arriving on input ports arrive with the Laser Channel and 5645 Frame Relay DLCI as meta-data. As such, a single input port could 5646 have been used. With the structure that is defined (which parallels 5647 the output structure), the selection of channel and DLCI could be 5648 restricted by the arriving input port group (LMI vs. data) and port 5649 index. As an alternative LFB design, the structures could require a 5650 1-1 relationship between DLCI and LFB port, in which case no meta- 5651 data would be needed. This would however be quite complex and noisy. 5653 The intermediate level of structure here allows parallelism between 5654 input and output, without requiring excessive ports. 5656 8.1.1. Setting up a DLCI 5658 When a CE chooses to establish a DLCI on a specific laser channel, it 5659 sends a SET request directed to this LFB. The request might look 5660 like 5662 T = SET 5663 T = PATH-DATA 5664 Path: flags = none, length = 4, path = 2, channel, 4, entryIdx 5665 DataRaw: DLCI, Enabled(1), false, out-idx 5667 Which would establish the DLCI as enabled, with traffic going to a 5668 specific entry of the output port group DatatoFE. (The CE would 5669 ensure that output port is connected to the right place before 5670 issuing this request.) 5672 The response would confirm the creation of the specified entry. This 5673 table is structured to use separate internal indices and DLCIs. An 5674 alternative design could have used the DLCI as index, trading off 5675 complexities. 5677 One could also imagine that the FE has an LMI LFB. Such an LFB would 5678 be connected to the LMItoFE and LMIfromFE port groups. It would 5679 process LMI information. It might be the LFBs job to set up the 5680 frame relay circuits. The LMI LFB would have an alias entry that 5681 points to the Frame Relay circuits table it manages, so that it can 5682 manipulate those entities. 5684 8.1.2. Error Handling 5686 The LFB will receive invalid packets over the wire. Many of these 5687 will simply result in incrementing counters. The LFB designer might 5688 also specify some error rate measures. This puts more work on the 5689 FE, but allows for more meaningful alarms. 5691 There may be some error conditions that should cause parts of the 5692 packet to be sent to the CE. The error itself is not something that 5693 can cause an event in the LFB. There are two ways this can be 5694 handled. 5696 One way is to define a specific component to count the error, and a 5697 component in the LFB to hold the required portion of the packet. The 5698 component could be defined to hold the portion of the packet from the 5699 most recent error. One could then define an event that occurs 5700 whenever the error count changes, and declare that reporting the 5701 event includes the LFB field with the packet portion. For rare but 5702 extremely critical errors, this is an effective solution. It ensures 5703 reliable delivery of the notification. And it allows the CE to 5704 control if it wants the notification. 5706 Another approach is for the LFB to have a port that connects to a 5707 redirect sink. The LFB would attach the laser channel, the DLCI, and 5708 the error indication as meta-data, and ship the packet to the CE. 5710 Other aspects of error handling are discussed under events below. 5712 8.2. LFB Components 5714 This LFB is defined to have two top level components. One reflects 5715 the administrative state of the LFB. This allows the CE to disable 5716 the LFB completely. 5718 The other component is the table of information about the laser 5719 channels. It is a variable sized array. Each array entry contains 5720 an identifier for what laser frequency this entry is associated with, 5721 whether that frequency is operational, the power of the laser at that 5722 frequency, and a table of information about frame relay circuits on 5723 this frequency. There is no administrative status since a CE can 5724 disable an entry simply by removing it. (Frequency and laser power 5725 of a non-operational channel are not particularly useful. Knowledge 5726 about what frequencies can be supported would be a table in the 5727 capabilities section.) 5729 The Frame Relay circuit information contains the DLCI, the 5730 operational circuit status, whether this circuit is to be treated as 5731 carrying LMI information, and which port in the output port group of 5732 the LFB traffic is to be sent to. As mentioned above, the circuit 5733 index could, in some designs, be combined with the DLCI. 5735 8.3. Capabilities 5737 The capability information for this LFB includes whether the 5738 underlying interface is operational, how many frequencies are 5739 supported, and how many total circuits, across all channels, are 5740 permitted. The maximum number for a given laser channel can be 5741 determined from the properties of the FrameRelayCircuits table. A 5742 GET-PROP on path 2.channel.4 will give the CE the properties of that 5743 FrameRelayCircuits array which include the number of entries used, 5744 the first available entry, and the maximum number of entries 5745 permitted. 5747 8.4. Events 5749 This LFB is defined to be able to generate several events that the CE 5750 may be interested in. There are events to report changes in 5751 operational state of frequencies, and the creation and deletion of 5752 frequency entries. There is an event for changes in status of 5753 individual frame relay circuits. So an event notification of 5754 61.5.3.11 would indicate that there had been a circuit status change 5755 on subscript 11 of the circuit table in subscript 3 of the frequency 5756 table. The event report would include the new status of the circuit 5757 and the DLCI of the circuit. Arguably, the DLCI is redundant, since 5758 the CE presumably knows the DLCI based on the circuit index. It is 5759 included here to show including two pieces of information in an event 5760 report. 5762 As described above, the event declaration defines the event target, 5763 the event condition, and the event report content. The event 5764 properties indicate whether the CE is subscribed to the event, the 5765 specific threshold for the event, and any filter conditions for the 5766 event. 5768 Another event shown is a laser power problem. This event is 5769 generated whenever the laser falls below the specified threshold. 5770 Thus, a CE can register for the event of laser power loss on all 5771 circuits. It would do this by: 5773 T = SET-PROP 5774 Path-TLV: flags=0, length = 2, path = 61.4 5775 Path-TLV: flags = property-field, length = 1, path = 2 5776 Content = 1 (register) 5777 Path-TLV: flags = property-field, length = 1, path = 3 5778 Content = 15 (threshold) 5780 This would set the registration for the event on all entries in the 5781 table. It would also set the threshold for the event, causing 5782 reporting if the power falls below 15. (Presumably, the CE knows 5783 what the scale is for power, and has chosen 15 as a meaningful 5784 problem level.) 5786 If a laser oscillates in power near the 15 mark, one could get a lot 5787 of notifications. (If it flips back and forth between 14 and 15, 5788 each flip down will generate an event.) Suppose that the CE decides 5789 to suppress this oscillation somewhat on laser channel 5. It can do 5790 this by setting the hysteresis property on that event. The request 5791 would look like: 5793 T = SET-PROP 5794 Path-TLV: flags=0, length = 3, path = 61.4.5 5795 Path-TLV: flags = property-field, length = 1, path = 4 5796 Content = 2 (hysteresis) 5798 Setting the hysteresis to 2 suppress a lot of spurious notifications. 5799 When the level first falls below 10, a notification is generated. If 5800 the power level increases to 10 or 11, and then falls back below 10, 5801 an event will not be generated. The power has to recover to at least 5802 12 and fall back below 10 to generate another event. One common 5803 cause of this form of oscillation is when the actual value is right 5804 near the border. If it is really 9.5, tiny changes might flip it 5805 back and forth between 9 and 10. A hysteresis level of 1 will 5806 suppress this sort of condition. Many other events have oscillations 5807 that are somewhat wider, so larger hysteresis settings can be used 5808 with those. 5810 9. IANA Considerations 5812 The ForCES model creates the need for a unique XML namespace for 5813 ForCES library definition usage, and unique class names and numeric 5814 class identifiers. 5816 9.1. URN Namespace Registration 5818 IANA is requested to register a new XML namespace, as per the 5819 guidelines in RFC3688 [3]. 5821 URI: The URI for this namespace is 5822 urn:ietf:params:xml:ns:forces:lfbmodel:1.0 5824 Registrant Contact: IESG 5826 XML: none, this is an XML namespace 5828 9.2. LFB Class Names and LFB Class Identifiers 5830 In order to have well defined ForCES LFB Classes, and well defined 5831 identifiers for those classes, a registry of LFB Class names, 5832 corresponding class identifiers, and the document which defines the 5833 LFB Class is needed. The registry policy is simply first come first 5834 served(FCFS) with regard to LFB Class names. With regard to LFB 5835 Class identifiers, identifiers less than 65536 are reserved for 5836 assignment by IETF Standards Track RFCs. Identifiers above 65536, in 5837 the 32 bit class ID space, are available for assignment on a first 5838 come, first served basis. All Registry entries must be documented in 5839 a stable, publicly available form. 5841 Since this registry provides for FCFS allocation of a portion of the 5842 class identifier space, it is necessary to define rules for naming 5843 classes that are using that space. As these can be defined by 5844 anyone, the needed rule is to keep the FCFS class names from 5845 colliding with IETF defined class names. Therefore, all FCFS class 5846 names MUST start with the string "Ext-". 5848 Table 1 tabulates the above information. 5850 IANA is requested to create a register of ForCES LFB Class Names and 5851 the corresponding ForCES LFB Class Identifiers, with the location of 5852 the definition of the ForCES LFB Class, in accordance with the rules 5853 in the following table. 5855 +----------------+------------+---------------+---------------------+ 5856 | LFB Class Name | LFB Class | Place Defined | Description | 5857 | | Identifier | | | 5858 +----------------+------------+---------------+---------------------+ 5859 | Reserved | 0 | RFCxxxx | Reserved | 5860 | | | | -------- | 5861 | FE Object | 1 | RFCxxxx | Defines ForCES | 5862 | | | | Forwarding Element | 5863 | | | | information | 5864 | FE Protocol | 2 | [2] | Defines parameters | 5865 | Object | | | for the ForCES | 5866 | | | | protocol operation | 5867 | | | | -------- | 5868 | IETF defined | 3-65535 | Standards | Reserved for IETF | 5869 | LFBs | | Track RFCs | defined RFCs | 5870 | | | | -------- | 5871 | Forces LFB | >65535 | Any Publicly | First Come, First | 5872 | Class names | | Available | Served for any use | 5873 | beginning EXT- | | Document | | 5874 +----------------+------------+---------------+---------------------+ 5876 Table 1 5878 [Note to RFC Editor, RFCxxxx above is to be changed to the RFC number 5879 assigned to this document for publication.] 5881 10. Authors Emeritus 5883 The following are the authors who were instrumental in the creation 5884 of earlier releases of this document. 5886 Ellen Delganes, Intel Corp. 5887 Lily Yang, Intel Corp. 5888 Ram Gopal, Nokia Research Center 5889 Alan DeKok, Infoblox, Inc. 5890 Zsolt Haraszti, Clovis Solutions 5892 11. Acknowledgments 5894 Many of the colleagues in our companies and participants in the 5895 ForCES mailing list have provided invaluable input into this work. 5896 Particular thanks to Evangelos Haleplidis for help getting the XML 5897 right. 5899 12. Security Considerations 5901 The FE model describes the representation and organization of data 5902 sets and components in the FEs. The ForCES framework document [2] 5903 provides a comprehensive security analysis for the overall ForCES 5904 architecture. For example, the ForCES protocol entities must be 5905 authenticated per the ForCES requirements before they can access the 5906 information elements described in this document via ForCES. Access 5907 to the information contained in the FE model is accomplished via the 5908 ForCES protocol, which will be defined in separate documents, and 5909 thus the security issues will be addressed there. 5911 13. References 5913 13.1. Normative References 5915 [1] Bradner, S., "Key words for use in RFCs to Indicate Requirement 5916 Levels", BCP 14, RFC 2119, March 1997. 5918 [2] Doria, A., Haas, R., Hadi Salim, J., Khosravi, H., and W. Wang, 5919 "ForCES Protocol Specification", work in progress, draft-ietf - 5920 forces-protocol-11.txt, December 2007. 5922 [3] Mealling, M., "The IETF XML Registry", BCP 81, RFC 3688, 5923 January 2004. 5925 [4] Thompson, H., Beech, D., Maloney, M., and N. Mendelsohn, "XML 5926 Schema Part 1: Structures", W3C REC-xmlschema-1, 5927 http://www.w3.org/TR/ xmlschema-1/, May 2001. 5929 [5] Biron, P. and A. Malhotra, "XML Schema Part 2: Datatypes", 5930 W3C REC-xmlschema-2, http://www.w3.org/TR /xmlschema-2/, 5931 May 2001. 5933 13.2. Informative References 5935 [6] Khosravi, H. and T. Anderson, "Requirements for Separation of 5936 IP Control and Forwarding", RFC 3654, November 2003. 5938 [7] Yang, L., Dantu, R., Anderson, T., and R. Gopal, "Forwarding 5939 and Control Element Separation (ForCES) Framework", RFC 3746, 5940 April 2004. 5942 [8] Chan, K., Sahita, R., Hahn, S., and K. McCloghrie, 5943 "Differentiated Services Quality of Service Policy Information 5944 Base", RFC 3317, March 2003. 5946 [9] Sahita, R., Hahn, S., Chan, K., and K. McCloghrie, "Framework 5947 Policy Information Base", RFC 3318, March 2003. 5949 [10] Pras, A. and J. Schoenwaelder, "On the Difference between 5950 Information Models and Data Models", RFC 3444, January 2003. 5952 [11] Hollenbeck, S., Rose, M., and L. Masinter, "Guidelines for the 5953 Use of Extensible Markup Language (XML) within IETF Protocols", 5954 BCP 70, RFC 3470, January 2003. 5956 [12] Davis, M. and M. Suignard, "UNICODE Security Considerations", 5957 http://www.unicode.org/ reports/tr36/tr36-3.html, July 2005. 5959 Authors' Addresses 5961 Joel Halpern 5962 Self 5963 P.O. Box 6049 5964 Leesburg,, VA 20178 5966 Phone: +1 703 371 3043 5967 Email: jmh@joelhalpern.com 5969 Jamal Hadi Salim 5970 Znyx Networks 5971 Ottawa, Ontario 5972 Canada 5974 Email: hadi@znyx.com 5976 Full Copyright Statement 5978 Copyright (C) The IETF Trust (2008). 5980 This document is subject to the rights, licenses and restrictions 5981 contained in BCP 78, and except as set forth therein, the authors 5982 retain all their rights. 5984 This document and the information contained herein are provided on an 5985 "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS 5986 OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY, THE IETF TRUST AND 5987 THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS 5988 OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF 5989 THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED 5990 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 5992 Intellectual Property 5994 The IETF takes no position regarding the validity or scope of any 5995 Intellectual Property Rights or other rights that might be claimed to 5996 pertain to the implementation or use of the technology described in 5997 this document or the extent to which any license under such rights 5998 might or might not be available; nor does it represent that it has 5999 made any independent effort to identify any such rights. Information 6000 on the procedures with respect to rights in RFC documents can be 6001 found in BCP 78 and BCP 79. 6003 Copies of IPR disclosures made to the IETF Secretariat and any 6004 assurances of licenses to be made available, or the result of an 6005 attempt made to obtain a general license or permission for the use of 6006 such proprietary rights by implementers or users of this 6007 specification can be obtained from the IETF on-line IPR repository at 6008 http://www.ietf.org/ipr. 6010 The IETF invites any interested party to bring to its attention any 6011 copyrights, patents or patent applications, or other proprietary 6012 rights that may cover technology that may be required to implement 6013 this standard. Please address the information to the IETF at 6014 ietf-ipr@ietf.org.