RFC 3317
Differentiated Services Quality of Service Policy Information Base
Differentiated Services Quality of Service Policy Information Base 🎀
Okay bestie, here's the title block tea ☕. This is from the Network Working Group (March 2003). The authors are K. Chan (Nortel Networks), R. Sahita and S. Hahn (both Intel), and K. McCloghrie (Cisco Systems). It's Informational 🌸, which means it's info for the Internet community and it does not specify an Internet standard. The title block doesn't list anything it obsoletes or updates, so no drama there 💅.
Status of this Memo
This memo gives information to the Internet community. It isn't an Internet standard of any kind 🧚. Distribution of this memo is unlimited ✨.
Copyright Notice
Copyright (C) The Internet Society (2003). All Rights Reserved 💜.
Abstract
Okay so this doc describes a Policy Information Base (PIB) for a device that implements the Differentiated Services Architecture 🦋. The provisioning classes in here give you policy control over the resources that implement DiffServ, and they can team up with other provisioning classes (the non-DiffServ ones defined in other PIBs) to get a fully policy-controlled mapping from service requirements to device resource capability and usage. It's giving full-course planning energy 🔥.
Table of Contents
Conventions used in this document...................................3
1. Glossary.........................................................3
2. Introduction.....................................................3
3. Relationship to the DiffServ Informal Management Model...........3
3.1. PIB Overview.................................................4
4. Structure of the PIB.............................................6
4.1. General Conventions..........................................6
4.2. DiffServ Data Paths..........................................7
4.2.1. Data Path PRC............................................7
4.3. Classifiers..................................................8
4.3.1. Classifier PRC...........................................9
4.3.2. Classifier Element PRC...................................9
4.4. Meters.......................................................9
4.4.1. Meter PRC...............................................10
4.4.2. Token-Bucket Parameter PRC..............................10
4.5. Actions.....................................................10
4.5.1. DSCP Mark Action PRC....................................11
4.6. Queueing Elements...........................................11
4.6.1. Algorithmic Dropper PRC.................................11
4.6.2. Random Dropper PRC......................................12
4.6.3. Queues and Schedulers...................................14
4.7. Specifying Device Capabilities..............................16
5. PIB Usage Example...............................................17
5.1. Data Path Example...........................................17
5.2. Classifier and Classifier Element Example...................18
5.3. Meter Example...............................................21
5.4. Action Example..............................................21
5.5. Dropper Examples............................................22
5.5.1. Tail Dropper Example....................................22
5.5.2. Single Queue Random Dropper Example.....................23
5.5.3. Multiple Queue Random Dropper Example...................23
5.6. Queue and Scheduler Example...............................26
6. Summary of the DiffServ PIB.....................................27
7. PIB Operational Overview........................................28
8. PIB Definition..................................................29
9. Acknowledgments.................................................90
10. Security Considerations........................................90
11. Intellectual Property Considerations...........................91
12. IANA Considerations............................................91
13. Normative References...........................................92
14. Authors' Addresses.............................................95
15. Full Copyright Statement.......................................96Conventions used in this document
Bestie, the BCP 14 key words in this doc are "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL", and they get read the way [RFC2119] explains 📖.
1. Glossary ✨
Here's the glossary, no cap, every term matters 🫶.
PRC Provisioning Class. A type of policy data. See [POLTERM].
PRI Provisioning Instance. An instance of a PRC. See [POLTERM].
PIB Policy Information Base. The database of policy information.
See [POLTERM].
PDP Policy Decision Point. See [RAP-FRAMEWORK].
PEP Policy Enforcement Point. See [RAP-FRAMEWORK].
PRID Provisioning Instance Identifier. Uniquely identifies an
instance of a PRC.2. Introduction 🦋
Okay so [SPPI] lays out a structure for specifying policy information, which can then get sent to a network device so it can configure policy there 💖. The model behind it is a set of well-defined provisioning classes, plus instances of those classes living in a virtual information store called the Policy Information Base (PIB). Literally iconic architecture 👑.
This doc defines a set of provisioning classes made just for setting up QoS Policy for Differentiated Services [DSARCH] 🌈.
One way to provision policy is the COPS protocol [COPS], along with its provisioning extensions [COPS-PR] 🍓. COPS supports multiple clients, and each one can provision policy for its own policy domain, like QoS. The PRCs in this DiffServ QoS PIB are meant for the COPS-PR diffServ client type. They also sit alongside any other PIBs that might get defined for the diffServ client type later, plus the PRCs from the Framework PIB [FR-PIB] 🫶.
3. Relationship to the DiffServ Informal Management Model 💅
This PIB is designed around the Differentiated Services Informal Management Model in [MODEL] 🧚. The model describes how the ingress and egress interfaces of an 'n'-port router are modeled. It handles configuring and managing a DiffServ interface using a Traffic Conditioning Block (TCB), which holds zero or more classifiers, meters, actions, algorithmic droppers, queues and schedulers. These elements get arranged based on the QoS policy being expressed, and they're always in that order 🔥.
So here's the flow, bestie: traffic can get classified, and classified traffic can get metered. Each stream identified by a combo of classifiers and meters can have some set of actions performed on it. It can have dropping algorithms applied, and it might end up stored in a queue before getting scheduled out to its next destination, either onto a link or into another TCB 💖. When the treatment for a packet has to repeat any of those elements in a way that breaks the permitted sequence {classifier, meter, action, algorithmic dropper, queue, scheduler}, that has to be modeled by cascading multiple TCBs 🌸.
The PIB shows this cascade by following the "Next" attributes of the various elements ✨. Those attributes say what the next step in DiffServ processing is, whether that's a classifier, meter, action, algorithmic dropper, queue, scheduler, or a decision to forward the packet 🦋.
The PIB models the individual elements that make up the TCBs. The higher-level TCB concept isn't required for parameterizing or linking the individual elements, so the PIB doesn't use it. TCBs only show up in the text, to relate the PIB back to [MODEL] 🎀. Knowing which TCB a given element belongs to isn't needed to instrument a device for DiffServ functionality, but it's useful conceptually 🧠. Because the PIB skips the TCB concept, any grouping of elements can build TCBs using the rules in [MODEL], and that keeps changes to this PIB small if the rules in [MODEL] ever change 💜.
Last but not least, the PIB uses the notion of a Data Path to show the DiffServ processing a packet may go through 👑. A Data Path is distinguished by its Role Combination, Capability Set, and the Direction of the flow the packet belongs to. A Data Path Table Entry points to the first of possibly several elements that will apply DiffServ treatment to the packet ✨.
3.1. PIB Overview 💖
okay so this PIB is built around two big questions: which sequential DiffServ treatments get applied to a packet, and how do you parameterize those treatments? 💅 These two parts of the configuration stay separate the whole way through the design, and each one has its own tables and data definitions. ✨
The PIB also includes tables that describe the capabilities and limitations of the device, using a general extensible framework. 🧚 These tables get reported to the PDP so it can configure the functional elements the device can actually realize. It's giving "know your device before you ask it to do things" 🫶
This capabilities and limitations exchange lets a single device or multiple devices support lots of different variations of a functional datapath element. Diverse methods of providing a general functional datapath element, bestie! 🌈
In this PIB, the ingress and egress portions of a router are configured independently but in the same manner. The difference is an attribute in a table describing the start of the data path. 🦋 Each interface performs some or all of the following high-level functions:
- Classify each packet according to some set of rules.
- Determine whether the data stream the packet is part of is within or outside its metering parameters.
- Perform a set of resulting actions, such as counting and marking the traffic with a Differentiated Services Code Point (DSCP) as defined in [DSFIELD].
- Apply the appropriate drop policy, either simple or complex algorithmic drop functionality.
- Enqueue the traffic for output in the appropriate queue, whose scheduler may shape the traffic or simply forward it with some minimum rate or maximum latency.
So the PIB contains these elements: 🍓
- Data Path Table: This describes the starting point of DiffServ data paths within a single DiffServ device. This class describes interface role combination and interface direction specific data paths.
- Classifier Tables: A general extensible framework for specifying a group of filters.
- Meter Tables: A general extensible framework and one example of a parameterization table, the TBParam table, applicable for Simple Token Bucket Meter, Average Rate Meter, Single Rate Three Color Meter, Two Rate Three Color Meter, and Sliding Window Three Color Meter.
- Action Tables: A general extensible framework and example of parameterization tables for Mark action. The "multiplexer" and "null" actions described in [MODEL] are accomplished implicitly by means of the Prid structures of the other elements. 🙈
- Algorithmic Dropper Tables: A general extensible framework for describing the dropper functional datapath element. This includes the absolute dropper and other queue measurement dependent algorithmic droppers.
- Queue and Scheduler Tables: A general extensible framework for parameterizing queuing and scheduler systems. Notice Shaper is considered as a type of scheduler and is included here.
- Capabilities Tables: A general extensible framework for defining the capabilities and limitations of the elements listed above. The capability tables allow intelligent configuration of the elements by a PDP. 👑
4. Structure of the PIB ✨
4.1. General Conventions 🎀
okay so the PIB is made of PRCs that represent functional elements in the data path (like classifiers, meters, and actions), plus classes that specify the parameters for a certain type of functional element (like a Token Bucket meter or a Mark action). 💜 Parameters are typically specified in a separate PRC so that multiple policies can reuse the same parameter classes. ♻️
Functional element PRCs use the Prid TC (defined in [SPPI]) to indicate indirection. A Prid is an object identifier that specifies an instance of a PRC in another table. 🔗 A Prid points to a parameter PRC that applies to a functional element, such as which filter a classifier element should use. A Prid is also used to specify an instance of a functional element PRC that describes what treatment should be applied next to a packet in the data path.
Note that using Prids to specify parameter PRCs lets the same functional element PRC be extended with a number of different types of parameter PRC's. Plus, using Prids to indicate the next functional datapath element lets the elements be ordered in any way. Literally so flexible. 🤸♀️
4.2. DiffServ Data Paths 🌸
This part of the PIB provides instrumentation for connecting the DiffServ Functional Elements within a single DiffServ device. For discussions on the valid sequencing and grouping of DiffServ Functional Elements, please refer to [MODEL]. 📖 Given some basic information (like the interface capability, role combination, and direction), the first DiffServ Functional Element is determined. Subsequent DiffServ Functional Elements are provided by the "Next" pointer attribute of each entry of data path tables. A description of how this "Next" pointer is used in each table is provided in their respective DESCRIPTION clauses.
4.2.1. Data Path PRC 🦋
The Data Path PRC provides the DiffServ treatment starting points for all packets of this DiffServ device. Each instance of this PRC specifies the interface capability, role combination, and direction for the packet flow. There should be at most two entries for each instance (interface type, role combination, interface capability), one for ingress and one for egress. 🚦
Each instance provides the first DiffServ Functional Element that each packet should experience at a specific interface (identified by the roles assigned to the interface) traveling in a specific relative direction. Notice this class is interface specific, with the use of interface type capability set and RoleCombination.
To indicate explicitly that there are no DiffServ treatments for a particular interface type capability set, role combination, and direction, an instance of the Data Path PRC can be created with zeroDotZero in the dsDataPathStart attribute. This situation can also be indicated implicitly by not supplying an instance of a Data Path PRC for that particular interface type capability set, role combination, and direction. The explicit/implicit selection is up to the implementation. ⚖️
This means that the PEP should perform normal IP device processing whenzeroDotZerois used in thedsDataPathStartattribute, or when the entry does not exist. Normal IP device processing will depend on the device; for example, this can be forwarding the packet.
Based on implementation experience of network devices where data path functional elements are implemented in separate physical processors or application specific integrated circuits, separated by switch fabric, it seems that more complex notions of data path are required within the network device to correlate the different physically separate data path functional elements. 🧩 For example, ingress processing may have determined a specific ingress flow that gets aggregated with other ingress flows at an egress data path functional element. Some of the information determined at the ingress data path functional element may need to be used by the egress data path functional element.
In numerous implementations, such information has been carried by adding it to the frame/memory block used to carry the flow within the network device. Some implementers have called such information a "preamble" or a "frame descriptor". Different implementations use different formats for such information. 🤓
Initially, one may think such information has implementation details within the network device that does not need to be exposed outside of the network device. But from the Policy Control point of view, such information will be very useful in determining network resource usage feedback from the network device to the policy server. This is accomplished by using the Internal Label Marker and Filter PRCs defined in [FR-PIB]. 💅
4.3. Classifiers 🔍
The classifier and classifier element tables determine how traffic is sorted out. They identify separable classes of traffic by reference to appropriate filters, which may select anything from an individual micro-flow to aggregates identified by DSCP. 🧁
The classification is used to send these separate streams to appropriate Meter, Action, Algorithmic Dropper, Queue, and Scheduler elements. For example, to indicate a multi-stage meter, sub-classes of traffic may be sent to different meter stages. In an implementation of the Assured Forwarding (AF) PHB [AF-PHB], AF11 traffic might be sent to the first meter, AF12 traffic might be sent to the second, and AF13 traffic sent to the second meter stage's out-of-profile action. 🌷
The concept of a classifier is the same as described in [MODEL]. The structure of the classifier and classifier element tables is the same as the classifier described in [MODEL]. Classifier elements have an associated precedence order solely for the purpose of resolving ambiguity between overlapping filters. A filter with higher values of precedence is compared first; the order of tests for entries of the same precedence is unimportant. 🧮
A datapath may consist of more than one classifier. There may be an overlap of filter specification between filters of different classifiers. The first classifier functional datapath element encountered, as determined by the sequencing of DiffServ functional datapath elements, will be used first. 🥇
An important form of classifier is "everything else": the final stage of the classifier, i.e., the one with the lowest precedence, must be "complete", since the result of an incomplete classifier is not necessarily deterministic. See [MODEL] section 4.1.2 for details. 🫠
When a classifier PRC is instantiated at the PEP, it should always have at least one classifier element table entry: the "everything else" classifier element, with its filter matching all IP packets. This "everything else" classifier element should be created by the PDP as part of the classifier setup. The PDP has full control of all classifier PRIs instantiated at the PEP. 👑
The definition of the actual filter used by the classifier is referenced via a Prid. This enables the use of any sort of filter table one might wish to design, standard or proprietary. No filters are defined in this PIB. However, standard filters for IP packets are defined in the Framework PIB [FR-PIB]. 🦋
4.3.1. Classifier PRC 🌈
Classifiers, used in various ingress and egress interfaces, are organized by the instances of the Classifier PRC. A data path entry points to a classifier entry. A classifier entry identifies a list of classifier elements. A classifier element effectively includes the filter entry and points to a "next" classifier entry or some other data path functional element. 🧃
4.3.2. Classifier Element PRC 💖
Classifier elements point to the filters which identify various classes of traffic. The separation between the "classifier element" and the "filter" allows us to use many different kinds of filters with the same essential semantics of "an identified set of traffic". ✨ The traffic matching the filter corresponding to a classifier element is given to the "next" data path functional element identified in the classifier element.
An example of a filter that may be pointed to by a Classifier Element PRI is the frwkIpFilter PRC, defined in [FR-PIB]. 🫶
4.4. Meters ✨
okay so a meter is basically the bouncer 💅 it watches how fast packets in a stream are showing up, checks that rate against a few thresholds, and then gives back at least two possible results. a packet "conforms" to the meter if, right when it's being looked at, the stream seems to be inside the meter's profile 🎀 the PIB makes this easiest to describe as a chain of one or more pass/fail checks, written as if-then-else. but bestie, this doesn't mean the real thing runs one step after another 🙈 multi-rate and multi-profile meters (like the ones built for [SRTCM], [TRTCM], or [TSWTCM]) can still be modeled this way, even when the stages share info under the hood. the stages are just a notational convenience so the PIB structure stays simple 🧚
4.4.1. Meter PRC
the generic meter PRC is the base for every more specific kind of meter 🦋 the details that depend on the meter type are reached through a pointer to an instance of a PRC that holds those specifics. this means you can use any meter table you dream up, standard or proprietary ✨ this PIB module defines one specific meter table, and other meter tables can be defined in other PIB modules 💜
4.4.2. Token-Bucket Parameter PRC
this one is here as an example of a super common meter type 🍓 entries in this class get referenced from the dsMeterSpecific attributes of meter PRC instances. the parameters are a rate (dsTBParamRate), a burst size (dsTBParamBurstSize), and an interval (dsTBparamInterval). the dsTBParamType attribute tells you what kind of meter is being parameterized, and that decides how the rate, burst, and rate interval get used 🌈 more meter parameterization classes can be defined in other PIBs whenever they're needed.
4.5. Actions
actions are things like "no action", "mark the traffic with a DSCP", or "specific action" 🌸 stuff like "shape the traffic" or "drop based on some algorithm" is handled by other functional datapath elements instead, not by actions. the "multiplexer", "replicator", and "null" actions from [MODEL] happen implicitly through different combos of the other elements 🫶
this PIB uses the Action PRC dsActionTable to organize one action's relationship with the element(s) before and after it 💖 actions can be cascaded so that multiple actions get applied to one traffic stream, using each entry's dsActionNext attribute. the dsActionNext attribute of the last action entry in the chain points to the next element in the TCB, if there is one, like a Queueing element 👑 it can also point at a next TCB.
the parameters for an Action element depend on what kind of action it is, so the PIB allows for specific Action Tables for the different action types ✨ that means extra actions can be specified in other PIBs, and proprietary actions can exist without messing with the ones defined here 🦋
packet dropping can be thought of as an Action element 🙈 but it's actually handled by the Algorithmic Dropper datapath functional element.
4.5.1. DSCP Mark Action PRC
this Action gets applied to traffic to mark it with a DiffServ Codepoint (DSCP) value, which is specified in the dsDscpMarkActTable 💅
4.6. Queueing Elements
these include Algorithmic Droppers, Queues, and Schedulers 🎀 they're all super interrelated because they all use queueing techniques. iconic teamwork 👯
4.6.1. Algorithmic Dropper PRC
Algorithmic Droppers are represented in this PIB by instances of the Algorithmic Dropper PRC 💖 an Algorithmic Dropper is assumed to operate indiscriminately on all packets presented at its input, so any traffic separation should be done by the classifiers and meters before it 🫶
the Algorithmic Dropper includes lots of types, from the super simple always dropper to the more complex random dropper 🌈 which type you've got is indicated by the dsAlgDropType attribute.
Algorithmic Droppers are closely tied to queuing 🍓 each Algorithmic Dropper Table entry has a dsAlgDropQMeasure attribute, which says whose queue's state affects the dropper's calculation. each entry also has a dsAlgDropNext attribute that says which queue the dropper sinks its traffic into.
Algorithmic Droppers can also point to a specific detail of the drop algorithm through dsAlgDropSpecific. this PIB defines the details for three drop algorithms: Tail Drop, Head Drop, and Random Drop 🦋 other algorithms are outside the scope of this PIB module, but the general framework is meant to let them be included through other PIB modules ✨
one general parameter every dropper has is a queue-depth threshold where some drop action starts 🔥 in this PIB it's a base attribute, dsAlgDropQThreshold, on the Algorithmic Dropper entry. the dsAlgDropQMeasure attribute specifies which queue's depth dsAlgDropQThreshold gets compared against.
- An Always Dropper drops every packet presented to it 💀 this type doesn't need any other parameter.
- A Tail Dropper needs a maximum queue depth threshold: when the queue pointed at by
dsAlgDropQMeasurereaches that depth threshold,dsAlgDropQThreshold, any new traffic arriving at the dropper gets discarded 🌸 this algorithm only uses parameters that are part of thedsAlgDropEntry. - A Head Dropper also needs a maximum queue depth threshold: when the queue pointed at by
dsAlgDropQMeasurereaches that depth threshold,dsAlgDropQThreshold, the traffic currently at the head of the queue gets discarded 🍓 this algorithm only uses parameters that are part of thedsAlgDropEntry. - Random Droppers are recommended as a way to control congestion in [QUEUEMGMT] and are called for in the [AF-PHB] ✨ there are lots of implementations that agree on marking or dropping just enough traffic to talk to TCP-like protocols about congestion avoidance, but they really differ on their specific parameters 💅 this PIB tries to offer a minimal set of controls for any random dropper, but it expects vendors to add more controls and status that match their implementation 🎀 this algorithm needs extra parameters on top of those in
dsAlgDropEntry, which get discussed below.
a Dropper Type of other is provided for implementing dropper types that aren't defined here 👑 when the Dropper Type is other, its full specification has to come from another PRC referenced by dsAlgDropSpecific. there's also a Dropper Type of Multiple Queue Random Dropper 🌈 please reference section 5.5.3 of this document for more details on that one.
4.6.2. Random Dropper PRC
a RED-like dropper is one example of a random dropper 🦋 here's how this PIB represents that element, shown in Figure 1 🫶
random droppers often describe their drop probability as a plot of drop probability (P) against averaged queue length (Q) 📈 (Qmin, Pmin) defines where the characteristic plot starts. normally Pmin=0, which means that with an average queue length below Qmin, there are no drops 🌸 (Qmax, Pmax) defines a "knee" on the plot, after which the drop probability gets more progressive (greater slope) 💖 (Qclip, 1) is the queue length where all packets get dropped 😭 this is different from Tail Drop, because it uses an averaged queue length. although it is possible for Qclip = Qmax.
in the PIB module, dsRandomDropMinThreshBytes and dsRandomDropMinThreshPkts represent Qmin 🍓 dsRandomDropMaxThreshBytes and dsRandomDropMaxThreshPkts represent Qmax. dsAlgDropQThreshold represents Qclip. dsRandomDropProbMax represents Pmax. this PIB does not represent Pmin (it's assumed to be zero unless otherwise represented) ✨
also, since message memory is finite, queues generally have some upper bound above which they can't store any more traffic 🫶 normally this number is equal to Qclip, specified by dsAlgDropQThreshold.
each random dropper specification is associated with a queue 🎀 this lets multiple drop processes (of the same or different types) be associated with the same queue, as different PHB implementations may require 🧚 it also allows for sequences of multiple droppers if necessary 💜
+-----------------+ +-------+
|AlgDrop | |Queue |
--->| Next ---------+-+----------------->| Next -+-->
| QMeasure -------+-+ | ... |
| QThreshold | +-------+
| Type=randomDrop | +----------------+
| Specific -------+-->|RandomDrop |
+-----------------+ | MinThreshBytes |
| MaxThreshBytes |
| ProbMax |
| Weight |
| SamplingRate |
+----------------+
Figure 1: Example Use of the RandomDropTable for Random Droppersthe calculation of a smoothed queue length can also have a big impact on how the dropper behaves 🌈 parameters may include the sampling interval or rate, and the weight of each sample 🔥 performance can be super sensitive to these values, and a wide range of values may be needed because link speeds vary a lot 😭 most algorithms include a sample weight, which is represented here by dsRandomDropWeight. the readability of dsRandomDropSamplingRate is important, because the info the Sampling Rate gives you is essential for configuring dsRandomDropWeight 💅 having the Sampling Rate be configurable is also helpful, since as line speed goes up, you need queue sampling to happen less often than packet arrival 🦋 but heads up, there's ongoing research on this topic, see e.g., [ACTQMGMT] and [AQMROUTER] 👀
extra parameters can be added in an enterprise PIB module, e.g., by using AUGMENTS on this class, to handle aspects of random drop algorithms that aren't standardized here 🎀
NOTE: Deterministic Droppers can be viewed as a special case of Random Droppers with the drop probability restricted to 0 and 1. Hence Deterministic Droppers might be described by a Random Dropper with Pmin = 0, Pmax = 1, Qmin = Qmax = Qclip, the averaged queue length at which dropping occurs. 🧚
4.6.3. Queues and Schedulers 🧚
okay bestie, so the Queue PRC is basically your classic FIFO line 🎀 (see [MODEL] section 7.1.1). The Scheduler PRC is where it gets fun ✨, because you can stack those queues into simple or kinda complex queueing hierarchies. And since TCBs can be cascaded multiple times on an interface, you can build even more intense hierarchies on top of that, literally obsessed 💅.
Queue PRC instances are pointed at by the "next" attributes of the upstream elements e.g., dsMeterSucceedNext. Multiple upstream elements are allowed to send their traffic to the same Queue PRI 🫶. For example, the Assured Forwarding PHB suggests that all traffic marked AF11, AF12, or AF13 be placed in the same queue after metering, without reordering. This would be represented by having the dsMeterSucceedNext of each upstream meter point at the same Queue PRI 🌸.
NOTE: Queue and Scheduler PRIs are for data path description; they both use Scheduler Parameterization Table entries for diffserv treatment parameterization. 💜
A Queue Table entry specifies the scheduler it wants service from by use of its Next pointer 🍓.
Each Scheduler Table entry represents the algorithm in use for servicing the one or more queues that feed it. [MODEL] section 7.1.2 describes a scheduler with multiple inputs. This is represented in the PIB by having the scheduling parameters be associated with each input, so sets of Queues can be grouped together as inputs to the same Scheduler 🦋. This class serves to represent the example scheduler described in the [MODEL]. Other, more complex representations might be created outside of this PIB 🌈.
Both the Queue PRC and the Scheduler PRC use instances of the Scheduler Parameterization PRC to specify diffserv treatment parameterization. Scheduler Parameter PRC instances are used to parameterize each input that feeds into a scheduler. The inputs can be a mixture of Queue PRI's and Scheduler PRI's. Scheduler Parameter PRI's can be used or reused by one or more Queue and/or Scheduler Table entries 🎀.
For representing a Strict Priority scheduler, each scheduler input is assigned a priority with respect to all the other inputs feeding the same scheduler, with default values for the other parameters. A higher-priority input which contains traffic that is not being delayed for shaping will be serviced before a lower-priority input 👑.
For Weighted Scheduling methods, e.g., WFQ and WRR, the "weight" of a given scheduler input is represented with a Minimum Service Rate leaky-bucket profile. That profile provides a guaranteed minimum bandwidth to that input, if required ⭐. This is represented by a rate dsMinRateAbsolute. The classical weight is the ratio between that rate and the interface speed, or perhaps the ratio between that rate and the sum of the configured rates for classes. Alternatively, the rate may be represented by a relative value, as a fraction of the interface's current line rate, dsMinRateRelative. This helps in cases where line rates are variable or where a higher-level policy might be expressed in terms of fractions of network resources 🧚. The two rate parameters are inter-related, and changes in one may be reflected in the other 🔥.
For weighted scheduling methods, one can say loosely that WRR focuses on meeting bandwidth sharing, without concern for relative delay amongst the queues. WFQ, on the other hand, control both queue service order and amount of traffic serviced, providing meeting bandwidth sharing and relative delay ordering amongst the queues 💅.
A queue or scheduled set of queues (which is an input to a scheduler) may also be capable of acting as a non-work-conserving [MODEL] traffic shaper. This is done by defining a Maximum Service Rate leaky-bucket profile in order to limit the scheduler bandwidth available to that input. This is represented by a rate dsMaxRateAbsolute. The classical weight is the ratio between that rate and the interface speed, or perhaps the ratio between that rate and the sum of the configured rates for classes. Alternatively, the rate may be represented by a relative value, as a fraction of the interface's current line rate, dsMaxRateRelative 🦋.
There was discussion in the working group about alternative modeling approaches, such as defining a shaping action or a shaping element. We did not take this approach, because shaping is in fact something a scheduler does to its inputs. (We model it as a queue with a maximum rate, or a scheduler whose output has a maximum rate.) We felt it was simpler and more elegant to simply describe it in that context 🙈. Additionally, multi-rate shaper [SHAPER] can be represented by the use of multiple dsMaxRateTable entries 🌸.
Other types of priority and weighted scheduling methods can be defined using existing parameters in dsMinRateEntry.
NOTE: dsSchedulerMethod uses AutonomousType syntax, with the different types of scheduling methods defined as OBJECT-IDENTITY. Future scheduling methods may be defined in other PIBs. This requires an OBJECT-IDENTITY definition, a description of how the existing objects are reused (if they are), and any new objects they require 💜.
NOTE: Hierarchical schedulers can be parameterized using this PIB by having Scheduler Table entries feeds into Scheduler Table entry 🧚.
4.7. Specifying Device Capabilities ✨
The DiffServ PIB uses the Base PRC classes frwkPrcSupportTable and frwkCompLimitsTable, defined in [FR-PIB], to specify which PRCs are supported by a PEP and to specify any limitations on that support 🎀. The PIB also uses the capability PRCs frwkCapabilitySetTable and frwkIfRoleComboTable, defined in [FR-PIB], to specify the device's capability sets, interface types, and role combinations 💖.
Each instance of the capability PRC frwkCapabilitySetTable contains an OID that points to an instance of a PRC that describes some capability of that interface type. The DiffServ PIB defines several of these capability PRCs, which assist the PDP with the configuration of DiffServ functional elements that can be implemented by the device 🦋. Each of these capability PRCs contains a direction attribute that specifies the direction for which the capability applies. This attribute is defined in a base capability PRC, which is extended by each specific capability PRC 🌈.
Classification capabilities, which specify the information elements the device can use to classify traffic, are reported using the dsIfClassificationCaps PRC. Metering capabilities, which indicate what the device can do with out-of-profile packets, are specified using the dsIfMeteringCaps PRC. Scheduling capabilities, such as the number of inputs supported, are reported using the dsIfSchedulingCaps PRC. Algorithmic drop capabilities, such as the types of algorithms supported, are reported using the dsIfAlgDropCaps PRC. Queue capabilities, such as the maximum number of queues, are reported using the dsIfQueueCaps PRC. Maximum Rate capabilities, such as the maximum number of max rate Levels, are reported using the dsIfMaxRateCaps PRC 🍓.
Two PRCs are defined to allow specification of the element linkage capabilities of the PEP. The dsIfElmDepthCaps PRC indicates the maximum number of functional datapath elements that can be linked consecutively in a datapath. The dsIfElmLinkCaps PRC indicates which functional datapath elements may follow a specific type of element in a datapath 🔥.
The capability reporting classes in the DiffServ and Framework PIB are meant to allow the PEP to indicate some general guidelines about what the device can do. They are intended to be an aid to the PDP when it constructs policy for the PEP 🫶. These classes do not necessarily allow the PEP to indicate every possible configuration that it can or cannot support. If a PEP receives a policy that it cannot implement, it must notify the PDP with a failure report 😭. Currently, the [COPS-PR] error handling mechanism, as specified in [COPS-PR] sections 4.4, 4.5, and 4.6, completely handles all known error cases of this PIB. Hence, no additional methods or PRCs need to be specified here 👑.
5. PIB Usage Example 🌸
This section provides some examples of how the different table entries of this PIB may be used together for a DiffServ Device. The usage of each individual attribute is defined within the PIB module itself 💖. For the figures, all the PIB table entry and attribute names are assumed to have "ds" as their first common initial part of the name, with the table entry name assumed to be their second common initial part of the name. 0.0 is being used to mean zeroDotZero. And for Scheduler Method, = X means "using the OID of diffServSchedulerX" 🧚.
5.1. Data Path Example 🎀
Each entry of the DataPath table is used for a specific interface type handling a flow in a specific direction, for a specific functional role-combination. For our example, we just define one such entry 🦋.
+---------------------+
|DataPath |
| CapSetName ="IfCap1"|
| Roles = "A+B" |
| IfDirection=Ingress | +---------+
| Start --------------+--->|Clfr |
+---------------------+ | Id=Dept |
+---------+
Figure 2: DataPath Usage ExampleIn Figure 2, we are using IfCap1 to indicate an interface type with capability set 1 handling ingress flow for functional roles of "A+B" 💅. We are using the classifier for departments to lead us into the Classifier Example below 🌈.
5.2. Classifier and Classifier Element Example ✨
okay so we want to show how a multilevel classifier gets built with the classifier tables this PIB gives us 🦋 heads up, we're not going deep on the filters bc this PIB doesn't define them 🙈 Picking up from the Data Path example in 5.1, let's say we want this classification to do flow separation by department and application type 💅
if (Dept1) then take Dept1-action
{
if (Appl1) then take Dept1-Appl1-action.
if (Appl2) then take Dept1-Appl2-action.
if (Appl3) then take Dept1-Appl3-action.
}
if (Dept2) then take Dept2-action
{
if (Appl1) then take Dept2-Appl1-action.
if (Appl2) then take Dept2-Appl2-action.
if (Appl3) then take Dept2-Appl3-action.
}
if (Dept3) then take Dept3-action
{
if (Appl1) then take Dept3-Appl1-action.
if (Appl2) then take Dept3-Appl2-action.
if (Appl3) then take Dept3-Appl3-action.
}That logic becomes PIB table entries with two levels of classification 🌸 The first level is for department:
+---------+
|Clfr |
| Id=Dept |
+---------+
+-------------+ +-----------+
|ClfrElement | +-->|Clfr |
| Id=Dept1 | | | Id=D1Appl |
| ClfrId=Dept | | +-----------+
| Preced=NA | |
| Next -------+--+ +------------+
| Specific ---+----->|Filter Dept1|
+-------------+ +------------+
+-------------+ +-----------+
|ClfrElement | +-->|Clfr |
| Id=Dept2 | | | Id=D2Appl |
| ClfrId=Dept | | +-----------+
| Preced=NA | |
| Next -------+--+ +------------+
| Specific ---+----->|Filter Dept2|
+-------------+ +------------+
+-------------+ +-----------+
|ClfrElement | +-->|Clfr |
| Id=Dept3 | | | Id=D3Appl |
| ClfrId=Dept | | +-----------+
| Preced=NA | |
| Next -------+--+ +------------+
| Specific ---+----->|Filter Dept3|
+-------------+ +------------+And the second level is for application 🧚
+-----------+
|Clfr |
| Id=D1Appl |
+-----------+
+---------------+ +--------------+
|ClfrElement | +----------------->|Meter |
| Id=D1Appl1 | | | Id=D1A1Rate1 |
| ClfrId=D1Appl | | | SucceedNext -+--->...
| Preced=NA | | | FailNext ----+--->...
| Next ---------+--+ +------------+ | Specific ----+--->...
| Specific -----+---->|Filter Appl1| +--------------+
+---------------+ +------------+
+---------------+ +--------------+
|ClfrElement | +----------------->|Meter |
| Id=D1Appl2 | | | Id=D1A2Rate1 |
| ClfrId=D1Appl | | | SucceedNext -+--->...
| Preced=NA | | | FailNext ----+--->...
| Next ---------+--+ +------------+ | Specific ----+--->...
| Specific -----+---->|Filter Appl2| +--------------+
+---------------+ +------------+
+---------------+ +--------------+
|ClfrElement | +----------------->|Meter |
| Id=D1Appl3 | | | Id=D1A3Rate1 |
| ClfrId=D1Appl | | | SucceedNext -+--->...
| Preced=NA | | | FailNext ----+--->...
| Next ---------+--+ +------------+ | Specific ----+--->...
| Specific -----+---->|Filter Appl3| +--------------+
+---------------+ +------------+Figure 3: Classifier Usage Example
The application classifiers for departments 2 and 3 look basically the same as the one for department 1 above 💖 Also, the Filters for Appl1, Appl2, and Appl3 can be reused across the application classifiers, which is so efficient, I'm obsessed 😭
This example assumes the next differentiated services functional datapath element is Meter, so next up is the Meter Example section 🎀
5.3. Meter Example
A single rate simple Meter is easy to picture, so we're doing a Two Rate Three Color [TRTCM] example instead 🌈 It uses two Meter table entries and two TBParam table entries.
+--------------+ +---------+ +--------------+ +----------+
|Meter | +->|Action | +->| Meter | +->|Action |
| Id=D1A1Rate1 | | | Id=Green| | | Id=D1A1Rate2 | | | Id=Yellow|
| SucceedNext -+-+ +---------+ | | SucceedNext -+-+ +----------+
| FailNext ----+-----------------+ | FailNext ----+--+ +-------+
| Specific -+ | | Specific -+ | +->|Action |
+-----------+--+ +-----------+--+ | Id=Red|
| | +-------+
| +------------+ | +------------+
+->|TBParam | +->|TBParam |
| Type=TRTCM | | Type=TRTCM |
| Rate | | Rate |
| BurstSize | | BurstSize |
| Interval | | Interval |
+------------+ +------------+Figure 4: Meter Usage Example
For [TRTCM], the first level TBParam entry is used for the Committed Information Rate and Committed Burst Size Token Bucket, and the second level TBParam entry is used for the Peak Information Rate and Peak Burst Size Token Bucket 🍓
The other meters for this example depend on the service class each classified flow uses, but they're built pretty much like the one here. The TBParam table entries can be shared by multiple Meter table entries, which is a big vibe 🫶
In this example, the differentiated services functional datapath element after Meter is Action, which we get into in the next section ✨
5.4. Action Example
Typically, Mark Action gets used, so we'll keep going with the "Action, Id=Green" branch off the Meter example 💅
Remember, this is the D1A1Rate1 SucceedNext branch, which means the flow belongs to Department 1 Application 1 and is within the committed rate and burst size limits for this flow 👑 We want to Mark this flow with a specific DSCP and also with a device internal label 🦋
+-----------+ +-----------+ +--->AlgDropAF11
|Action | +----------------->|Action | |
| Next -----+--+ +------------+ | Next -----+--+ +-------------+
| Specific -+---->|DscpMarkAct | | Specific -+--->|ILabelMarker |
+-----------+ | Dscp=AF11 | +-----------+ | ILabel=D1A1 |
+------------+ +-------------+Figure 5: Action Usage Example
This example uses the frwkILabelMarker PRC defined in [FR-PIB] 🌸 It shows the device internal label identifying the micro flow that feeds into the aggregated AF flow. That device internal label may be used for flow accounting purposes and/or other data path treatments, so it's a whole multitasker 🙌
5.5. Dropper Examples
These Dropper examples pick up from the Action example above for the AF11 flow 💜 We're giving three different dropper setups, going from simple to complex. Some queuing structures show up in the examples below, but they're only there to show how the droppers relate to queuing, so they aren't complete. Queuing examples come in later sections 🧚
5.5.1. Tail Dropper Example
The Tail Dropper is one of the simplest ones 🍓 For this example, we just want to drop the part of the flow that goes over the queue's buffering capacity, which is 2 Mbytes.
+--------------------+ +------+
|AlgDrop | +->|Q AF1 |
| Id=AF11 | | +------+
| Type=tailDrop | |
| Next --------------+-+--+
| QMeasure ----------+-+
| QThreshold=2Mbytes |
| Specific=0.0 |
+--------------------+Figure 6: Tail Dropper Usage Example
5.5.2. Single Queue Random Dropper Example
This is where Random Dropper comes in, and it introduces the usage of dsRandomDropEntry, as shown in the example below 🌈
+-----------------+ +------+
|AlgDrop | +->|Q AF1 |
| Id=AF11 | | +------+
| Type=randomDrop | |
| Next -----------+-+--+
| QMeasure -------+-+
| QThreshold | +----------------+
| Specific -------+-->|RandomDrop |
+-----------------+ | MinThreshBytes |
| MinThreshPkts |
| MaxThreshBytes |
| MaxThreshPkts |
| ProbMax |
| Weight |
| SamplingRate |
+----------------+Figure 7: Single Queue Random Dropper Usage Example
Notice that for Random Dropper, dsAlgDropQThreshold holds the maximum average queue length, Qclip, for the queue being measured as indicated by dsAlgDropQMeasure. The rest of the Random Dropper parameters are specified by dsRandomDropEntry, which is referenced by dsAlgDropSpecific 🔥 In this example, both dsAlgDropNext and dsAlgDropQMeasure reference the same queue. That's the simple case, but dsAlgDropQMeasure may reference another queue for a PEP implementation that supports this feature 💖
5.5.3. Multiple Queue Random Dropper Example ✨
okay so when a device has to measure multiple queues to decide how a drop algorithm behaves, bestie, the PRCs already in this PIB are enough for the simple case 💅 this example shows exactly that 🦋
+-------------+ +------+
|AlgDrop | +----------------+-------------------+->|Q_AF1 |
| Id=AF11 | | | | +------+
| Type=mQDrop | | | |
| Next -------+-+ +------------+ | +------------+ |
| QMeasure ---+-->|MQAlgDrop | | +->|MQAlgDrop | |
| QThreshold | | Id=AF11A | | | | Id=AF11B | |
| Specific | | Type | | | | Type | |
+-------------+ | Next ------+-+ | | Next ------+-+
| ExceedNext +---+ | ExceedNext | +------+
| QMeasure --+-+ | QMeasure --+-->|Q_AF2 |
| QThreshold | | | QThreshold | +------+
| Specific + | | | Specific + |
+----------+-+ | +----------+-+
| | +---+
+------+ | +------+ |
| +->|Q_AF1 | |
| +------+ |
| |
| +----------------+ | +----------------+
+->|RandomDrop | +->|RandomDrop |
| MinThreshBytes | | MinThreshBytes |
| MinThreshPkts | | MinThreshPkts |
| MaxThreshBytes | | MaxThreshBytes |
| MaxThreshPkts | | MaxThreshPkts |
| ProbMax | | ProbMax |
| Weight | | Weight |
| SamplingRate | | SamplingRate |
+----------------+ +----------------+Figure 8: Multiple Queue Random Dropper Usage Example 🌸
So here's the setup 🎀 we've got two queues, Q_AF1 and Q_AF2, that share the same buffer resources. The goal is to make sure that shared buffer is big enough to handle the AF11 traffic, and we also want to measure both queues to figure out the drop algorithm for the AF11 traffic going into Q_AF1. Also, notice that mQDrop is the value used for dsAlgDropType in dsAlgDropEntry to say "this is the Multiple Queue Dropping Algorithm" 🔥
The shared common buffer is represented by dsAlgDropEntry, and its attributes work like this:
dsAlgDropTypesays which algorithm is in use, which ismQDrop.dsAlgDropNextpoints to the next functional data path element that handles the flow when no drop happens.dsAlgDropQMeasureis the anchor for the list ofdsMQAlgDropEntry, with one entry for each queue being measured.dsAlgDropQThresholdgives the size of the shared buffer pool.dsAlgDropSpecificcan reference instances of extra PRCs (not defined in this PIB) if more parameters are needed to describe the shared buffer resource.
Next up, there are two dsMQAlgDropEntrys after that, one for each queue being measured 💖 their attributes go like this:
dsMQAlgDropTypesays which algorithm is used. In this example, bothdsMQAlgDropTypevalues userandomDrop.dsMQAlgDropQMeasuresays which queue is being measured.dsMQAlgDropNextpoints to the next functional data path element that handles the flow when no drop happens.dsMQAlgDropExceedNextpoints to the next queue'sdsMQAlgDropEntry. The last queue useszeroDotZeroto show that it's the end of the line 🧚dsMQAlgDropQMeasure(yes, again, it's used to say which queue is being measured). In this example,Q_AF1andQ_AF2are the two queues.dsAlgDropQThresholdis used the same way as in the single queue Random Dropper.dsAlgDropSpecificreferences the PRID that describes the dropper parameters, just like its normal usage. In this example, bothdsAlgDropSpecifics referencedsRandomDropEntrys.
Notice how the anchoring dsAlgDropEntry and both dsMQAlgDropEntrys all have their Next attribute pointing at Q_AF1 👑 that means:
- If the packet doesn't need to be checked against an individual queue's drop processing because the common shared buffer has plenty of room, then the packet goes to
Q_AF1. - If the packet isn't dropped because of the current
Q_AF1conditions, then it goes toQ_AF1. - If the packet isn't dropped because of the current
Q_AF2conditions, then it also goes toQ_AF1.
This example also uses two dsRandomDropEntrys, one for each of the two queues it measures. Their attribute usage is the same as in the single queue random dropper 🌈
More complicated result combinations are possible too. You can do that by defining a new PRC and referencing it from dsAlgDropSpecific on the anchoring dsAlgDropEntry. A simpler setup also works when one single set of drop parameters is used for every queue being measured, and that can be referenced from the anchoring dsAlgDropSpecific as well. Neither of these is defined in this PIB, so they're just mentioned here 🫶
5.6. Queue and Scheduler Example
okay this is the queue and scheduler example, and it picks up right where the dropper example left off 🍓 it focuses on the queue and scheduler DiffServ datapath functional elements. Also, heads up: a shaper is built out of a queue and a scheduler using the MaxRate parameters 🔥
+------------+ +-----------------+
---->|Q | +->|Scheduler |
| Id=EF | | | Id=DiffServ |
| Next ------+------------------------+ | Next=0.0 |
| MinRate ---+--+ | | Method=Priority |
| MaxRate -+ | | +----------+ | | MinRate=0.0 |
+----------+-+ +-->|MinRate | | | MaxRate=0.0 |
| | Priority | | +-----------------+
+----------+ | Absolute | |
| | Relative | |
| +-----------+ +----------+ |
+->|MaxRate | |
| Level | |
| Absolute | |
| Relative | |
| Threshold | |
+-----------+ +-------------+
|
+----------+ +------------+ |
---->|Q | +-->|Scheduler | |
| Id=AF1 | | | Id=AF | |
| Next ----+--------------------+ | Next ------+--+
| MinRate -+-+ | | Method=WRR |
| MaxRate | | +----------+ | | MinRate -+ |
+----------+ +->|MinRate | | | MaxRate | |
| Priority | | +----------+-+
| Absolute | | |
| Relative | | +----------+
+----------+ | |
+----------+ | | +------------+
---->|Q | | +->|MinRate |
| Id=AF2 | | | Priority |
| Next ----+--------------------+ | Absolute |
| MinRate -+-+ | | Relative |
| MaxRate | | +----------+ | +------------+
+----------+ +->|MinRate | |
| Priority | |
| Absolute | |
| Relative | |
+----------+ |
+----------+ |
---->|Q | |
| Id=AF3 | |
| Next ----+--------------------+
| MinRate -+-+
| MaxRate | | +----------+
+----------+ +->|MinRate |
| Priority |
| Absolute |
| Relative |
+----------+Figure 9: Queue and Scheduler Usage Example 💅
This example shows the queuing setup for EF, AF1, AF2, and AF3 traffic 🦋 we assume that AF11, AF12, and AF13 traffic feeds into Queue AF1. Same deal for AF2x and AF3x traffic 🌸
The AF1, AF2, and AF3 Queues get serviced by the AF Scheduler using a Weighed Round Robin method. The AF Scheduler services each queue feeding into it based on that queue's minimum rate parameters 💖
The AF and EF traffic gets serviced by the DiffServ Scheduler using a Strict Priority method. The DiffServ Scheduler services each of its inputs based on their priority parameter ✨
Here's the tea: there's an upper bound on how much EF traffic the DiffServ Scheduler services, and that's done with maximum rate parameters 🔥 The DiffServ Scheduler uses both the maximum rate and the priority parameters when it services the EF Queue.
The DiffServ Scheduler is the last DiffServ datapath functional element in this datapath, so it uses zeroDotZero in its Next attribute 🧚
6. Summary of the DiffServ PIB 👑
okay so the DiffServ PIB is made of one module 🎀 that module has the base PRCs for setting DiffServ policy (queues, classifiers, meters, and so on), and it also has capability PRCs that let a PEP tell the PDP about its device characteristics 💜 This module has two groups, and we'll summarize both right here.
DiffServ Capabilities Group
This group is all about PRCs that tell the PDP what kinds of interfaces the PEP supports in terms of their DiffServ capabilities 🦋 It also covers the PRCs the PDP can install to configure those interfaces (queues, scheduling parameters, buffer sizes, etc.) so the desired policy takes effect. It describes capabilities by interface type and takes configuration by interface type and role combinations [FR-PIB]. It does not deal with individual interfaces on the device 🌈
DiffServ Policy Group
This group holds the configurations of the functional elements that make up the DiffServ policy applied to an interface, along with the specific parameters that describe those elements 💖 It includes classifiers, meters, actions, droppers, queues, and schedulers. It also includes the PRC that ties the datapath elements to role combinations ✨
7. PIB Operational Overview ✨
okay so this section is the big-picture tour of how DiffServ QoS policy gets configured, bestie 💅
first, the PEP and PDP have to set up their communication, and [COPS-PR] is one example of how that happens 🫶. once they're talking, the PEP tells the PDP which PIB Provisioning classes (PRCs), interface types, and interface type capabilities it supports. it's giving organized 🎀
the PRCs the PEP supports get reported in the PRC Support Table, frwkPrcSupportTable, which is defined in the framework PIB [FR-PIB]. each instance of that table is one PRC the PEP understands and the PDP can send class instances for as part of the policy information 💜
the capabilities of the interface types the PEP supports live in the capability set table, frwkCapabilitySetTable 🦋. each row (or instance of this class) has a pointer to an instance of a PRC that describes the interface type's capabilities. those capability objects might be in the dsIfClassifierCapsTable, the dsIfMeteringCapsTable, the dsIfSchedulerCapsTable, the dsIfElmDepthCapsTable, the dsIfElmLinkCapsTable, or in a table defined in another PIB. so many places, but it all connects ✨
once the PDP knows what the PEP can do, it hands over the administrative domain and interface-type-specific policy information. the PDP is basically planning the outfit around what the PEP can actually wear 👑
last thing: instances of the dsDataPathTable are used to specify the first element in the set of functional elements applied to an interface type. each instance applies to an interface type defined by its roles and direction (ingress or egress) 🌸
8. PIB Definition 🎀
Here's the actual PIB module, verbatim, because the details matter and I'm not about to paraphrase a MIB 🙈
DIFFSERV-PIB PIB-DEFINITIONS ::= BEGIN
IMPORTS
Unsigned32, MODULE-IDENTITY, MODULE-COMPLIANCE,
OBJECT-TYPE, OBJECT-GROUP, pib
FROM COPS-PR-SPPI
InstanceId, Prid, TagId, TagReferenceId
FROM COPS-PR-SPPI-TC
zeroDotZero
FROM SNMPv2-SMI
AutonomousType
FROM SNMPv2-TC
SnmpAdminString
FROM SNMP-FRAMEWORK-MIB
RoleCombination, PrcIdentifierOid, PrcIdentifierOidOrZero,
AttrIdentifier
FROM FRAMEWORK-TC-PIB
Dscp
FROM DIFFSERV-DSCP-TC
IfDirection
FROM DIFFSERV-MIB
BurstSize
FROM INTEGRATED-SERVICES-MIB;
dsPolicyPib MODULE-IDENTITY
SUBJECT-CATEGORIES { diffServ (2) } -- DiffServ QoS COPS Client Type
LAST-UPDATED "200302180000Z" -- 18 Feb 2003
ORGANIZATION "IETF DIFFSERV WG"
CONTACT-INFO "
Keith McCloghrie
Cisco Systems, Inc.
170 West Tasman Drive,
San Jose, CA 95134-1706 USA
Phone: +1 408 526 5260
Email: kzm@cisco.com
John Seligson
Nortel Networks, Inc.
4401 Great America Parkway
Santa Clara, CA 95054 USA
Phone: +1 408 495 2992
Email: jseligso@nortelnetworks.com
Kwok Ho Chan
Nortel Networks, Inc.
600 Technology Park Drive
Billerica, MA 01821 USA
Phone: +1 978 288 8175
Email: khchan@nortelnetworks.com
Differentiated Services Working Group:
diffserv@ietf.org"
DESCRIPTION
"The PIB module containing a set of provisioning classes
that describe quality of service (QoS) policies for
DiffServ. It includes general classes that may be extended
by other PIB specifications as well as a set of PIB
classes related to IP processing.
Copyright (C) The Internet Society (2003). This version of
this PIB module is part of RFC 3317; see the RFC itself for
full legal notices."
REVISION "200302180000Z" -- 18 Feb 2003
DESCRIPTION
"Initial version, published as RFC 3317."
::= { pib 4 }
dsCapabilityClasses OBJECT IDENTIFIER ::= { dsPolicyPib 1 }
dsPolicyClasses OBJECT IDENTIFIER ::= { dsPolicyPib 2 }
dsPolicyPibConformance OBJECT IDENTIFIER ::= { dsPolicyPib 3 }
--
-- Interface Type Capabilities Group
--
--
-- Interface Type Capability Tables
--
-- The Interface type capability tables define capabilities that may
-- be associated with interfaces of a specific type.
-- This PIB defines capability tables for DiffServ Functionalities.
--
--
-- The Base Capability Table
--
dsBaseIfCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsBaseIfCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"The Base Interface Type Capability class. This class
represents a generic capability supported by a device in the
ingress, egress, or both directions."
::= { dsCapabilityClasses 1 }
dsBaseIfCapsEntry OBJECT-TYPE
SYNTAX DsBaseIfCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the dsBaseIfCaps class."
PIB-INDEX { dsBaseIfCapsPrid }
::= { dsBaseIfCapsTable 1 }
DsBaseIfCapsEntry ::= SEQUENCE {
dsBaseIfCapsPrid InstanceId,
dsBaseIfCapsDirection INTEGER
}
dsBaseIfCapsPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsBaseIfCapsEntry 1 }
dsBaseIfCapsDirection OBJECT-TYPE
SYNTAX INTEGER {
inbound(1),
outbound(2),
inAndOut(3)
}
STATUS current
DESCRIPTION
"This object specifies the direction(s) for which the
capability applies. A value of 'inbound(1)' means the
capability applies only to the ingress direction. A value of
'outbound(2)' means the capability applies only to the egress
direction. A value of 'inAndOut(3)' means the capability
applies to both directions."
::= { dsBaseIfCapsEntry 2 }
--
-- The Classification Capability Table
--
dsIfClassificationCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfClassificationCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the classification capabilities of
a Capability Set."
::= { dsCapabilityClasses 2 }
dsIfClassificationCapsEntry OBJECT-TYPE
SYNTAX DsIfClassificationCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the classification
capabilities of a Capability Set."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfClassificationCapsSpec }
::= { dsIfClassificationCapsTable 1 }
DsIfClassificationCapsEntry ::= SEQUENCE {
dsIfClassificationCapsSpec BITS
}
dsIfClassificationCapsSpec OBJECT-TYPE
SYNTAX BITS {
ipSrcAddrClassification(0),
-- indicates the ability to classify based on
-- IP source addresses
ipDstAddrClassification(1),
-- indicates the ability to classify based on
-- IP destination addresses
ipProtoClassification(2),
-- indicates the ability to classify based on
-- IP protocol numbers
ipDscpClassification(3),
-- indicates the ability to classify based on
-- IP DSCP
ipL4Classification(4),
-- indicates the ability to classify based on
-- IP layer 4 port numbers for UDP and TCP
ipV6FlowID(5)
-- indicates the ability to classify based on
-- IPv6 FlowIDs.
}
STATUS current
DESCRIPTION
"Bit set of supported classification capabilities. In
addition to these capabilities, other PIBs may define other
capabilities that can then be specified in addition to the
ones specified here (or instead of the ones specified here if
none of these are specified)."
::= { dsIfClassificationCapsEntry 1 }
--
-- Metering Capabilities
--
dsIfMeteringCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfMeteringCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the metering capabilities of a
Capability Set."
::= { dsCapabilityClasses 3 }
dsIfMeteringCapsEntry OBJECT-TYPE
SYNTAX DsIfMeteringCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the metering
capabilities of a Capability Set."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfMeteringCapsSpec }
::= { dsIfMeteringCapsTable 1 }
DsIfMeteringCapsEntry ::= SEQUENCE {
dsIfMeteringCapsSpec BITS
}
dsIfMeteringCapsSpec OBJECT-TYPE
SYNTAX BITS {
zeroNotUsed(0),
simpleTokenBucket(1),
avgRate(2),
srTCMBlind(3),
srTCMAware(4),
trTCMBlind(5),
trTCMAware(6),
tswTCM(7)
}
STATUS current
DESCRIPTION
"Bit set of supported metering capabilities. As with
classification capabilities, these metering capabilities may
be augmented by capabilities specified in other PRCs (in other
PIBs)."
::= { dsIfMeteringCapsEntry 1 }
--
-- Algorithmic Dropper Capabilities
--
dsIfAlgDropCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfAlgDropCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the algorithmic dropper
capabilities of a Capability Set.
This capability table indicates the types of algorithmic
drop supported by a Capability Set for a specific flow
direction.
Additional capabilities affecting the drop functionalities
are determined based on queue capabilities associated with
specific instance of a dropper, hence not specified by
this class."
::= { dsCapabilityClasses 4 }
dsIfAlgDropCapsEntry OBJECT-TYPE
SYNTAX DsIfAlgDropCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the algorithmic dropper
capabilities of a Capability Set."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfAlgDropCapsType,
dsIfAlgDropCapsMQCount }
::= { dsIfAlgDropCapsTable 1 }
DsIfAlgDropCapsEntry ::= SEQUENCE {
dsIfAlgDropCapsType BITS,
dsIfAlgDropCapsMQCount Unsigned32
}okay bestie, the dropper stuff is giving main character energy 🎀 This first bit is all about which drop algorithms a queue dropper can use, and how many queues the MQ one is allowed to measure ✨
dsIfAlgDropCapsType OBJECT-TYPE
SYNTAX BITS {
zeroNotUsed(0),
oneNotUsed(1),
tailDrop(2),
headDrop(3),
randomDrop(4),
alwaysDrop(5),
mQDrop(6) }
STATUS current
DESCRIPTION
"The type of algorithm that droppers associated with queues
may use.
The tailDrop(2) algorithm means that packets are dropped from
the tail of the queue when the associated queue's MaxQueueSize
is exceeded. The headDrop(3) algorithm means that packets are
dropped from the head of the queue when the associated queue's
MaxQueueSize is exceeded. The randomDrop(4) algorithm means
that an algorithm is executed which may randomly
drop the packet, or drop other packet(s) from the queue
in its place. The specifics of the algorithm may be
proprietary. However, parameters would be specified in the
dsRandomDropTable. The alwaysDrop(5) will drop every packet
presented to it. The mQDrop(6) algorithm will drop packets
based on measurement from multiple queues."
::= { dsIfAlgDropCapsEntry 1 }
dsIfAlgDropCapsMQCount OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
STATUS current
DESCRIPTION
"Indicates the number of queues measured for the drop
algorithm.
This attribute is ignored when alwaysDrop(5) algorithm is
used. This attribute contains the value of 1 for all drop
algorithm types except for mQDrop(6), where this attribute
is used to indicate the maximum number of dsMQAlgDropEntry
that can be chained together."
::= { dsIfAlgDropCapsEntry 2 }
--
-- Queue Capabilities
--
dsIfQueueCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfQueueCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the queueing capabilities of a
Capability Set."
::= { dsCapabilityClasses 5 }
dsIfQueueCapsEntry OBJECT-TYPE
SYNTAX DsIfQueueCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the queue
capabilities of a Capability Set."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfQueueCapsMinQueueSize,
dsIfQueueCapsMaxQueueSize,
dsIfQueueCapsTotalQueueSize }
::= { dsIfQueueCapsTable 1 }
DsIfQueueCapsEntry ::= SEQUENCE {
dsIfQueueCapsMinQueueSize Unsigned32,
dsIfQueueCapsMaxQueueSize Unsigned32,
dsIfQueueCapsTotalQueueSize Unsigned32
}
dsIfQueueCapsMinQueueSize OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
UNITS "Bytes"
STATUS current
DESCRIPTION
"Some interfaces may allow the size of a queue to be
configured. This attribute specifies the minimum size that
can be configured for a queue, specified in bytes.
dsIfQueueCapsMinQueueSize must be less than or equals to
dsIfQueueCapsMaxQueueSize when both are specified.
A zero value indicates not specified."
::= { dsIfQueueCapsEntry 1 }
dsIfQueueCapsMaxQueueSize OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
UNITS "Bytes"
STATUS current
DESCRIPTION
"Some interfaces may allow the size of a queue to be
configured. This attribute specifies the maximum size that
can be configured for a queue, specified in bytes.
dsIfQueueCapsMinQueueSize must be less than or equals to
dsIfQueueCapsMaxQueueSize when both are specified.
A zero value indicates not specified."
::= { dsIfQueueCapsEntry 2 }
dsIfQueueCapsTotalQueueSize OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
UNITS "Bytes"
STATUS current
DESCRIPTION
"Some interfaces may have a limited buffer space to be
shared amongst all queues of that interface while also
allowing the size of each queue to be configurable. To
prevent the situation where the PDP configures the sizes of
the queues in excess of the total buffer available to the
interface, the PEP can report the total buffer space in
bytes available with this capability.
A zero value indicates not specified."
::= { dsIfQueueCapsEntry 3 }
--
-- Scheduler Capabilities
--
dsIfSchedulerCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfSchedulerCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the scheduler capabilities of a
Capability Set."
::= { dsCapabilityClasses 6 }
dsIfSchedulerCapsEntry OBJECT-TYPE
SYNTAX DsIfSchedulerCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the scheduler
capabilities of a Capability Set."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfSchedulerCapsServiceDisc,
dsIfSchedulerCapsMaxInputs }
::= { dsIfSchedulerCapsTable 1 }
DsIfSchedulerCapsEntry ::= SEQUENCE {
dsIfSchedulerCapsServiceDisc AutonomousType,
dsIfSchedulerCapsMaxInputs Unsigned32,
dsIfSchedulerCapsMinMaxRate INTEGER
}
dsIfSchedulerCapsServiceDisc OBJECT-TYPE
SYNTAX AutonomousType
STATUS current
DESCRIPTION
"The scheduling discipline for which the set of capabilities
specified in this object apply. Object identifiers for several
general purpose and well-known scheduling disciplines are
shared with and defined in the DiffServ MIB.
These include diffServSchedulerPriority,
diffServSchedulerWRR, diffServSchedulerWFQ."
::= { dsIfSchedulerCapsEntry 1 }
dsIfSchedulerCapsMaxInputs OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
STATUS current
DESCRIPTION
"The maximum number of queues and/or schedulers that can
feed into a scheduler indicated by this capability entry.
A value of zero means there is no maximum."
::= { dsIfSchedulerCapsEntry 2 }
dsIfSchedulerCapsMinMaxRate OBJECT-TYPE
SYNTAX INTEGER {
minRate(1),
maxRate(2),
minAndMaxRates(3)
}
STATUS current
DESCRIPTION
"Scheduler capability indicating ability to handle inputs
with minimum rate, maximum rate, or both."
::= { dsIfSchedulerCapsEntry 3 }
--
-- Maximum Rate Capabilities
--
dsIfMaxRateCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfMaxRateCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the maximum rate capabilities of a
Capability Set."
::= { dsCapabilityClasses 7 }
dsIfMaxRateCapsEntry OBJECT-TYPE
SYNTAX DsIfMaxRateCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the maximum rate
capabilities of a Capability Set."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfMaxRateCapsMaxLevels }
::= { dsIfMaxRateCapsTable 1 }
DsIfMaxRateCapsEntry ::= SEQUENCE {
dsIfMaxRateCapsMaxLevels Unsigned32
}
dsIfMaxRateCapsMaxLevels OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
STATUS current
DESCRIPTION
"The maximum number of levels a maximum rate specification
may have for this Capability Set and flow direction."
::= { dsIfMaxRateCapsEntry 1 }
--
-- DataPath Element Linkage Capabilities
--
--
-- DataPath Element Cascade Depth
--
dsIfElmDepthCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfElmDepthCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies the number of elements of the same
type that can be cascaded together in a datapath."
::= { dsCapabilityClasses 8 }
dsIfElmDepthCapsEntry OBJECT-TYPE
SYNTAX DsIfElmDepthCapsEntry
STATUS current
DESCRIPTION
"An instance of this class describes the cascade depth
for a particular functional datapath element PRC. A
functional datapath element not represented in this
class can be assumed to have no specific maximum
depth."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfElmDepthCapsPrc }
::= { dsIfElmDepthCapsTable 1 }
DsIfElmDepthCapsEntry ::= SEQUENCE {
dsIfElmDepthCapsPrc PrcIdentifierOid,
dsIfElmDepthCapsCascadeMax Unsigned32
}
dsIfElmDepthCapsPrc OBJECT-TYPE
SYNTAX PrcIdentifierOid
STATUS current
DESCRIPTION
"The object identifier of a PRC that represents a functional
datapath element. This may be one of: dsClfrElementEntry,
dsMeterEntry, dsActionEntry, dsAlgDropEntry, dsQEntry, or
dsSchedulerEntry.
There may not be more than one instance of this class with
the same value of dsIfElmDepthCapsPrc and same value of
dsBaseIfCapsDirection. Must not contain the value of
zeroDotZero."
::= { dsIfElmDepthCapsEntry 1 }
dsIfElmDepthCapsCascadeMax OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
STATUS current
DESCRIPTION
"The maximum number of elements of type dsIfElmDepthCapsPrc
that can be linked consecutively in a data path. A value of
zero indicates there is no specific maximum."
::= { dsIfElmDepthCapsEntry 2 }
--
-- DataPath Element Linkage Types
--
dsIfElmLinkCapsTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsIfElmLinkCapsEntry
PIB-ACCESS notify
STATUS current
DESCRIPTION
"This class specifies what types of datapath functional
elements may be used as the next downstream element for
a specific type of functional element."
::= { dsCapabilityClasses 9 }
dsIfElmLinkCapsEntry OBJECT-TYPE
SYNTAX DsIfElmLinkCapsEntry
STATUS current
DESCRIPTION
"An instance of this class specifies a PRC that may
be used as the next functional element after a specific
type of element in a data path."
EXTENDS { dsBaseIfCapsEntry }
UNIQUENESS { dsBaseIfCapsDirection,
dsIfElmLinkCapsPrc,
dsIfElmLinkCapsAttr,
dsIfElmLinkCapsNextPrc }
::= { dsIfElmLinkCapsTable 1 }
DsIfElmLinkCapsEntry ::= SEQUENCE {
dsIfElmLinkCapsPrc PrcIdentifierOid,
dsIfElmLinkCapsAttr AttrIdentifier,
dsIfElmLinkCapsNextPrc PrcIdentifierOidOrZero
}
dsIfElmLinkCapsPrc OBJECT-TYPE
SYNTAX PrcIdentifierOid
STATUS current
DESCRIPTION
" The object identifier of a PRC that represents a functional
datapath element. This may be one of: dsClfrElementEntry,
dsMeterEntry, dsActionEntry, dsAlgDropEntry, dsQEntry, or
dsSchedulerEntry.
This must not have the value zeroDotZero."
::= { dsIfElmLinkCapsEntry 1 }
dsIfElmLinkCapsAttr OBJECT-TYPE
SYNTAX AttrIdentifier
STATUS current
DESCRIPTION
"The value represents the attribute in the PRC
indicated by dsIfElmLinkCapsPrc that is used to
specify the next functional element in the datapath."
::= { dsIfElmLinkCapsEntry 2 }okay so this next bit is where the linkage stuff gets really specific, and the example is honestly so clean 🎀✨
dsIfElmLinkCapsNextPrc OBJECT-TYPE
SYNTAX PrcIdentifierOidOrZero
STATUS current
DESCRIPTION
"The value is the OID of a PRC table entry from which
instances can be referenced by the attribute indicated
by dsIfElmLinkCapsPrc and dsIfElmLinkAttr.
For example, suppose a meter's success output can be an
action or another meter, and the fail output can only be
an action. This can be expressed as follows:
Prid Prc Attr NextPrc
1 dsMeterEntry dsMeterSucceedNext dsActionEntry
2 dsMeterEntry dsMeterSucceedNext dsMeterEntry
3 dsMeterEntry dsMeterFailNext dsActionEntry.
zeroDotZero is a valid value for this attribute to
specify that the PRC specified in dsIfElmLinkCapsPrc
is the last functional data path element."
::= { dsIfElmLinkCapsEntry 3 }ngl the meter example is giving clear 💅 the success output can point to an action OR another meter, but the fail output is only ever an action 🙈 and zeroDotZero is the "ok we're done here, this is the last element" 🫶
--
-- Policy Classes
--
--
-- Data Path Table
--
dsDataPathTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsDataPathEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The data path table indicates the start of
functional data paths in this device.
The Data Path Table enumerates the Differentiated
Services Functional Data Paths within this device.
Each entry specifies the first functional datapath
element to process data flow for each specific datapath.
Each datapath is defined by the interface set's capability
set name, role combination, and direction. This class can
therefore have up to two entries for each interface set,
ingress and egress."
::= { dsPolicyClasses 1 }
dsDataPathEntry OBJECT-TYPE
SYNTAX DsDataPathEntry
STATUS current
DESCRIPTION
"Each entry in this class indicates the start of a single
functional data path, defined by its capability set name,
role combination and traffic direction. The first
functional datapath element to handle traffic for each
data path is defined by the dsDataPathStart attribute
of each table entry.
Notice for each entry:
1. dsDataPathCapSetName must reference an existing capability
set name in frwkCapabilitySetTable [FR-PIB].
2. dsDataPathRoles must reference existing Role Combination
in frwkIfRoleComboTable [FR-PIB].
3. dsDataPathStart must reference an existing entry in a
functional data path element table.
If any one or more of these three requirements is not
satisfied, the dsDataPathEntry will not be installed."
PIB-INDEX { dsDataPathPrid }
UNIQUENESS { dsDataPathCapSetName,
dsDataPathRoles,
dsDataPathIfDirection }
::= { dsDataPathTable 1 }
DsDataPathEntry ::= SEQUENCE {
dsDataPathPrid InstanceId,
dsDataPathCapSetName SnmpAdminString,
dsDataPathRoles RoleCombination,
dsDataPathIfDirection IfDirection,
dsDataPathStart Prid
}
dsDataPathPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsDataPathEntry 1 }
dsDataPathCapSetName OBJECT-TYPE
SYNTAX SnmpAdminString
STATUS current
DESCRIPTION
"The capability set associated with this data path entry.
The capability set name specified by this attribute
must exist in the frwkCapabilitySetTable [FR-PIB]
prior to association with an instance of this class."
::= { dsDataPathEntry 2 }
dsDataPathRoles OBJECT-TYPE
SYNTAX RoleCombination
STATUS current
DESCRIPTION
"The interfaces to which this data path entry applies,
specified in terms of roles. There must exist an entry
in the frwkIfRoleComboTable [FR-PIB] specifying
this role combination, together with the capability
set specified by dsDataPathCapSetName, prior to
association with an instance of this class."
::= { dsDataPathEntry 3 }
dsDataPathIfDirection OBJECT-TYPE
SYNTAX IfDirection
STATUS current
DESCRIPTION
"Specifies the direction for which this data path
entry applies."
::= { dsDataPathEntry 4 }
dsDataPathStart OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This selects the first functional datapath element
to handle traffic for this data path. This
Prid should point to an instance of one of:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
dsQEntry
The PRI pointed to must exist prior to the installation of
this datapath start element."
::= { dsDataPathEntry 5 }the data path table is basically the front door 🚪 each entry says where traffic first lands for a given capability set name, role combo, and direction ✨ up to two entries per interface set (ingress and egress), and if any of the three checks fail, the entry just doesn't get installed 💀
--
-- Classifiers
--
-- Classifier allows multiple classifier elements, of same or
-- different types, to be used together.
-- A classifier must completely classify all packets presented to
-- it. This means all traffic handled by a classifier must match
-- at least one classifier element within the classifier,
-- with the classifier element parameters specified by a filter.
-- It is the PDP's responsibility to create a _catch all_ classifier
-- element and filter that matches all packet. This _catch all_
-- classifier element should have the lowest Precedence value.
--
-- If there is ambiguity between classifier elements of different
-- classifier, classifier linkage order indicates their precedence;
-- the first classifier in the link is applied to the traffic first.
--
-- Each entry in the classifier table represents a classifier, with
-- classifier element table handling the fan-out functionality of a
-- classifier, and filter table defining the classification
-- patterns.
--
--
-- Classifier Table
--
dsClfrTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsClfrEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"This table enumerates all the DiffServ classifier functional
data path elements of this device. The actual classification
definitions are detailed in dsClfrElementTable entries
belonging to each classifier. Each classifier is referenced
by its classifier elements using its classifier ID.
An entry in this table, referenced by an upstream functional
data path element or a datapath table entry, is the entry
point to the classifier functional data path element.
The dsClfrId of each entry is used to organize all
classifier elements belonging to the same classifier."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 4.1"
::= { dsPolicyClasses 2 }
dsClfrEntry OBJECT-TYPE
SYNTAX DsClfrEntry
STATUS current
DESCRIPTION
"An entry in the classifier table describes a single
classifier. Each classifier element belonging to this
classifier must have its dsClfrElementClfrId attribute equal
to dsClfrId."
PIB-INDEX { dsClfrPrid }
UNIQUENESS { dsClfrId }
::= { dsClfrTable 1 }
DsClfrEntry ::= SEQUENCE {
dsClfrPrid InstanceId,
dsClfrId TagReferenceId
}
dsClfrPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsClfrEntry 1 }
dsClfrId OBJECT-TYPE
SYNTAX TagReferenceId
PIB-TAG { dsClfrElementClfrId }
STATUS current
DESCRIPTION
"Identifies a Classifier. A Classifier must be
complete, this means all traffic handled by a
Classifier must match at least one Classifier
Element within the Classifier."
::= { dsClfrEntry 2 }okay the classifier section is where it gets a little dramatic 🌸 a classifier has to be complete, so all the traffic it gets has to match at least one element, and the _catch all_ element is the one the PDP is responsible for making, with the lowest precedence value 🧚
--
-- Classifier Element Table
--
dsClfrElementTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsClfrElementEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"Entries in the classifier element table serves as
the anchor for each classification pattern, defined
in filter table entries. Each classifier element
table entry also specifies the subsequent downstream
diffserv functional datapath element when the
classification pattern is satisfied. Hence
the classifier element table enumerates the relationship
between classification patterns and subsequent downstream
diffserv functional data path elements, describing one
branch of the fan-out characteristic of a classifier
indicated in [Model].
Classification parameters are defined by entries of filter
tables pointed to by dsClfrElementSpecific. There can be
filter tables of different types, and they can be inter-mixed
and used within a classifier. An example of a filter table is
the frwkIpFilterTable [FR-PIB], for IP Multi-Field
Classifiers (MFCs).
If there is ambiguity between classifier elements of the same
classifier, then dsClfrElementPrecedence needs to be used."
::= { dsPolicyClasses 3 }
dsClfrElementEntry OBJECT-TYPE
SYNTAX DsClfrElementEntry
STATUS current
DESCRIPTION
"An entry in the classifier element table describes a
single element of the classifier."
PIB-INDEX { dsClfrElementPrid }
UNIQUENESS { dsClfrElementClfrId,
dsClfrElementPrecedence,
dsClfrElementSpecific }
::= { dsClfrElementTable 1 }
DsClfrElementEntry ::= SEQUENCE {
dsClfrElementPrid InstanceId,
dsClfrElementClfrId TagId,
dsClfrElementPrecedence Unsigned32,
dsClfrElementNext Prid,
dsClfrElementSpecific Prid
}
dsClfrElementPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsClfrElementEntry 1 }
dsClfrElementClfrId OBJECT-TYPE
SYNTAX TagId
STATUS current
DESCRIPTION
"A classifier is composed of one or more classifier
elements. Each classifier element belonging to
the same classifier uses the same classifier ID.
Hence, A classifier Id identifies which classifier
this classifier element is a part of. This must be
the value of dsClfrId attribute for an existing
instance of dsClfrEntry."
::= { dsClfrElementEntry 2 }
dsClfrElementPrecedence OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
STATUS current
DESCRIPTION
"The relative order in which classifier elements are
applied: higher numbers represent classifier elements
with higher precedence. Classifier elements with the
same precedence must be unambiguous i.e., they must
define non-overlapping patterns, and are considered to
be applied simultaneously to the traffic stream.
Classifier elements with different precedence may
overlap in their filters: the classifier element with
the highest precedence that matches is taken.
On a given interface, there must be a complete
classifier in place at all times in the ingress
direction. This means that there will always be one
or more filters that match every possible pattern
that could be presented in an incoming packet.
There is no such requirement in the egress direction."
::= { dsClfrElementEntry 3 }the precedence rules are where things get spicy 🌶️ higher numbers win when filters overlap, but equal precedence has to be non-overlapping, and ingress has to always be fully covered 👀 egress doesn't have that same rule 🫶
okay so we're picking up right where the classifier element stuff left off 💅 the next pointer and the meter tables are where the datapath really comes together 🦋
dsClfrElementNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This attribute provides one branch of the fan-out
functionality of a classifier described in Diffserv
Model section 4.1.
This selects the next diffserv functional datapath
element to handle traffic for this data path.
A value of zeroDotZero marks the end of DiffServ processing
for this data path. Any other value must point to a
valid (pre-existing) instance of one of:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
dsQEntry."
DEFVAL { zeroDotZero }
::= { dsClfrElementEntry 4 }
dsClfrElementSpecific OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"A pointer to a valid entry in another table that
describes the applicable classification filter, e.g.,
an entry in frwkIpFilterTable (Framework PIB).
The PRI pointed to must exist prior to the installation of
this classifier element.
The value zeroDotZero is interpreted to match any-
thing not matched by another classifier element - only one
such entry may exist for each classifier."
::= { dsClfrElementEntry 5 }
--
-- Meters
--
-- This PIB supports a variety of Meters. It includes a
-- specific definition for Meters whose parameter set can
-- be modeled using Token Bucket parameters.
-- Other metering parameter sets can be defined by other PIBs.
--
-- Multiple meter elements may be logically cascaded
-- using their dsMeterSucceedNext and dsMeterFailNext pointers if
-- required.
-- One example of this might be for an AF PHB implementation
-- that uses multiple level conformance meters.
--
-- Cascading of individual meter elements in the PIB is intended
-- to be functionally equivalent to multiple level conformance
-- determination of a packet. The sequential nature of the
-- representation is merely a notational convenience for this PIB.
--
-- srTCM meters (RFC 2697) can be specified using two sets of
-- dsMeterEntry and dsTBParamEntry. First set specifies the
-- Committed Information Rate and Committed Burst Size
-- token-bucket. Second set specifies the Excess Burst
-- Size token-bucket.
--
-- trTCM meters (RFC 2698) can be specified using two sets of
-- dsMeterEntry and dsTBParamEntry. First set specifies the
-- Committed Information Rate and Committed Burst Size
-- token-bucket. Second set specifies the Peak Information
-- Rate and Peak Burst Size token-bucket.
--
-- tswTCM meters (RFC 2859) can be specified using two sets of
-- dsMeterEntry and dsTBParamEntry. First set specifies the
-- Committed Target Rate token-bucket. Second set specifies the
-- Peak Target Rate token-bucket. dsTBParamInterval in each
-- token bucket reflects the Average Interval.
dsMeterTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsMeterEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"This class enumerates specific meters that a system
may use to police a stream of traffic. The traffic
stream to be metered is determined by the element(s)
upstream of the meter i.e., by the object(s) that
point to each entry in this class. This may include
all traffic on an interface.
Specific meter details are to be found in table entry
referenced by dsMeterSpecific."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 5"
::= { dsPolicyClasses 4 }
dsMeterEntry OBJECT-TYPE
SYNTAX DsMeterEntry
STATUS current
DESCRIPTION
"An entry in the meter table describes a single
conformance level of a meter."
PIB-INDEX { dsMeterPrid }
UNIQUENESS { dsMeterSucceedNext,
dsMeterFailNext,
dsMeterSpecific }
::= { dsMeterTable 1 }
DsMeterEntry ::= SEQUENCE {
dsMeterPrid InstanceId,
dsMeterSucceedNext Prid,
dsMeterFailNext Prid,
dsMeterSpecific Prid
}
dsMeterPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsMeterEntry 1 }
dsMeterSucceedNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"If the traffic does conform, this selects the next
diffserv functional datapath element to handle
traffic for this data path.
The value zeroDotZero in this variable indicates no
further DiffServ treatment is performed on traffic of
this datapath. Any other value must point to a valid
(pre-existing) instance of one of:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
dsQEntry."
DEFVAL { zeroDotZero }
::= { dsMeterEntry 2 }
dsMeterFailNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"If the traffic does not conform, this selects the
next diffserv functional datapath element to handle
traffic for this data path.
The value zeroDotZero in this variable indicates no
further DiffServ treatment is performed on traffic of
this datapath. Any other value must point to a valid
(pre-existing) instance of one of:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
dsQEntry."
DEFVAL { zeroDotZero }
::= { dsMeterEntry 3 }
dsMeterSpecific OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This indicates the behaviour of the meter by point-
ing to an entry containing detailed parameters. Note
that entries in that specific table must be managed
explicitly.
For example, dsMeterSpecific may point to an
entry in dsTBMeterTable, which contains an
instance of a single set of Token Bucket parameters.
The PRI pointed to must exist prior to installing this
Meter datapath element."
::= { dsMeterEntry 4 }
--
-- Token-Bucket Parameter Table
--
-- Each entry in the Token Bucket Parameter Table parameterizes
-- a single token bucket. Multiple token buckets can be
-- used together to parameterize multiple levels of
-- conformance.
--
-- Note that an entry in the Token Bucket Parameter Table can
-- be shared, pointed to, by multiple dsMeterTable entries.
--
dsTBParamTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsTBParamEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"This table enumerates token-bucket meter parameter sets
that a system may use to police a stream of traffic.
Such parameter sets are modelled here as each having a single
rate and a single burst size. Multiple entries are used
when multiple rates/burst sizes are needed."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 5.1"
::= { dsPolicyClasses 5 }
dsTBParamEntry OBJECT-TYPE
SYNTAX DsTBParamEntry
STATUS current
DESCRIPTION
"An entry that describes a single token-bucket
parameter set."
PIB-INDEX { dsTBParamPrid }
UNIQUENESS { dsTBParamType,
dsTBParamRate,
dsTBParamBurstSize,
dsTBParamInterval }
::= { dsTBParamTable 1 }
DsTBParamEntry ::= SEQUENCE {
dsTBParamPrid InstanceId,
dsTBParamType AutonomousType,
dsTBParamRate Unsigned32,
dsTBParamBurstSize BurstSize,
dsTBParamInterval Unsigned32
}
dsTBParamPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsTBParamEntry 1 }
dsTBParamType OBJECT-TYPE
SYNTAX AutonomousType
STATUS current
DESCRIPTION
"The Metering algorithm associated with the
Token-Bucket parameters. zeroDotZero indicates this
is unknown.
Standard values for generic algorithms are as follows:
diffServTBParamSimpleTokenBucket, diffServTBParamAvgRate,
diffServTBParamSrTCMBlind, diffServTBParamSrTCMAware,
diffServTBParamTrTCMBlind, diffServTBParamTrTCMAware,
diffServTBParamTswTCM
These are specified in the DiffServ MIB."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 5.1"
::= { dsTBParamEntry 2 }
dsTBParamRate OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "kilobits per second"
STATUS current
DESCRIPTION
"The token-bucket rate, in kilobits per second
(kbps). This attribute is used for:
1. CIR in RFC 2697 for srTCM
2. CIR and PIR in RFC 2698 for trTCM
3. CTR and PTR in RFC 2859 for TSWTCM
4. AverageRate in RFC 3290, section 5.1.1"
::= { dsTBParamEntry 3 }
dsTBParamBurstSize OBJECT-TYPE
SYNTAX BurstSize
UNITS "Bytes"
STATUS current
DESCRIPTION
"The maximum number of bytes in a single transmission
burst. This attribute is used for:
1. CBS and EBS in RFC 2697 for srTCM
2. CBS and PBS in RFC 2698 for trTCM
3. Burst Size in RFC 3290, section 5."
::= { dsTBParamEntry 4 }
dsTBParamInterval OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "microseconds"
STATUS current
DESCRIPTION
"The time interval used with the token bucket. For:
1. Average Rate Meter, RFC 3290, section 5.1.1,
-Delta.
2. Simple Token Bucket Meter, RFC 3290, section
5.1.3, - time interval t.
3. RFC 2859 TSWTCM, - AVG_INTERVAL.
4. RFC 2697 srTCM, RFC 2698 trTCM, - token
bucket update time interval."
::= { dsTBParamEntry 5 }
--
-- Actions
--
--
-- The Action Table allows enumeration of the different
-- types of actions to be applied to a traffic flow.
--
dsActionTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsActionEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The Action Table enumerates actions that can be per-
formed to a stream of traffic. Multiple actions can
be concatenated.
Specific actions are indicated by dsAction-
Specific which points to an entry of a specific
action type parameterizing the action in detail."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 6."
::= { dsPolicyClasses 6 }
dsActionEntry OBJECT-TYPE
SYNTAX DsActionEntry
STATUS current
DESCRIPTION
"Each entry in the action table allows description of
one specific action to be applied to traffic."
PIB-INDEX { dsActionPrid }
UNIQUENESS { dsActionNext,
dsActionSpecific }
::= { dsActionTable 1 }
DsActionEntry ::= SEQUENCE {
dsActionPrid InstanceId,
dsActionNext Prid,
dsActionSpecific Prid
}
dsActionPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsActionEntry 1 }okay bestie, we're picking up right where the action table left off 💖✨
dsActionNext is the pointer that says where the packet goes after this action. 🦋
dsActionNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This selects the next diffserv functional datapath
element to handle traffic for this data path.
The value zeroDotZero in this variable indicates no
further DiffServ treatment is performed on traffic of
this datapath. Any other value must point to a valid
(pre-existing) instance of one of:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
dsQEntry."
DEFVAL { zeroDotZero }
::= { dsActionEntry 2 }
dsActionSpecific OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"A pointer to an object instance providing additional
information for the type of action indicated by this
action table entry.
For the standard actions defined by this PIB module,
this should point to an instance of dsDscpMarkActEntry.
For other actions, it may point to an instance of a
PRC defined in some other PIB.
The PRI pointed to must exist prior to installing this
action datapath entry."
::= { dsActionEntry 3 }ooh, now the DSCP Mark Action Table, which is giving main character energy 💅🎀
-- DSCP Mark Action Table
--
-- Rows of this class are pointed to by dsActionSpecific
-- to provide detailed parameters specific to the DSCP
-- Mark action.
-- This class should at most contain one entry for each supported
-- DSCP value. These entries should be reused by different
-- dsActionEntry in same or different data paths.
--
dsDscpMarkActTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsDscpMarkActEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"This class enumerates specific DSCPs used for marking or
remarking the DSCP field of IP packets. The entries of this
table may be referenced by a dsActionSpecific attribute."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 6.1"
::= { dsPolicyClasses 7 }
dsDscpMarkActEntry OBJECT-TYPE
SYNTAX DsDscpMarkActEntry
STATUS current
DESCRIPTION
"An entry in the DSCP mark action table that describes a
single DSCP used for marking."
PIB-INDEX { dsDscpMarkActPrid }
UNIQUENESS { dsDscpMarkActDscp }
::= { dsDscpMarkActTable 1 }
DsDscpMarkActEntry ::= SEQUENCE {
dsDscpMarkActPrid InstanceId,
dsDscpMarkActDscp Dscp
}
dsDscpMarkActPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsDscpMarkActEntry 1 }
dsDscpMarkActDscp OBJECT-TYPE
SYNTAX Dscp
STATUS current
DESCRIPTION
"The DSCP that this Action uses for marking/remarking
traffic. Note that a DSCP value of -1 is not permit-
ted in this class. It is quite possible that the
only packets subject to this Action are already
marked with this DSCP. Note also that DiffServ may
result in packet remarking both on ingress to a net-
work and on egress from it and it is quite possible
that ingress and egress would occur in the same
router."
::= { dsDscpMarkActEntry 2 }next up: the Algorithmic Drop Table 🌸 it's the entry point for the dropper, and it gets a little spicy with the mQDrop stuff 🔥
--
-- Algorithmic Drop Table
--
-- Algorithmic Drop Table is the entry point for the Algorithmic
-- Dropper functional data path element.
-- For a simple algorithmic dropper, a single algorithmic drop entry
-- will be sufficient to parameterize the dropper.
-- For more complex algorithmic dropper, the dsAlgDropSpecific
-- attribute can be used to reference an entry in a parameter table,
-- e.g., dsRandomDropTable for random dropper.
-- For yet more complex dropper, for example, dropper that measures
-- multiple queues, each queue with its own algorithm, can use a
-- dsAlgDropTable entry as the entry point for Algorithmic Dropper
-- functional data path element, leaving the dropper parameters
-- for each queue be specified by entries of dsMQAlgDropTable.
-- In such usage, the anchoring dsAlgDropEntry's dsAlgDropType
-- should be mQDrop, and its dsAlgDropQMeasure should reference
-- the subsequent dsMQAlgDropEntry's, its dsAlgDropSpecific
-- should be used to reference parameters applicable to all the
-- queues being measured.
-- The subsequent dsMQAlgDropEntry's will provide the parameters,
-- one for each queue being measured. The dsMQAlgDropEntry's are
-- chained using their dsMQAlgDropNext attributes.
--
dsAlgDropTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsAlgDropEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The algorithmic drop table contains entries describ-
ing a functional data path element that drops
packets according to some algorithm."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 7.1.3"
::= { dsPolicyClasses 8 }
dsAlgDropEntry OBJECT-TYPE
SYNTAX DsAlgDropEntry
STATUS current
DESCRIPTION
"An entry describes a process that drops packets
according to some algorithm. Further details of the
algorithm type are to be found in dsAlgDropType
and with more detail parameter entry pointed to by
dsAlgDropSpecific when necessary."
PIB-INDEX { dsAlgDropPrid }
UNIQUENESS { dsAlgDropType,
dsAlgDropNext,
dsAlgDropQMeasure,
dsAlgDropQThreshold,
dsAlgDropSpecific }
::= { dsAlgDropTable 1 }
DsAlgDropEntry ::= SEQUENCE {
dsAlgDropPrid InstanceId,
dsAlgDropType INTEGER,
dsAlgDropNext Prid,
dsAlgDropQMeasure Prid,
dsAlgDropQThreshold Unsigned32,
dsAlgDropSpecific Prid
}
dsAlgDropPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsAlgDropEntry 1 }
dsAlgDropType OBJECT-TYPE
SYNTAX INTEGER {
other(1),
tailDrop(2),
headDrop(3),
randomDrop(4),
alwaysDrop(5),
mQDrop(6)
}
STATUS current
DESCRIPTION
"The type of algorithm used by this dropper. A value
of tailDrop(2), headDrop(3), or alwaysDrop(5) represents
an algorithm that is completely specified by this PIB.
A value of other(1) indicates that the specifics of
the drop algorithm are specified in some other PIB
module, and that the dsAlgDropSpecific attribute
points to an instance of a PRC in that PIB that
specifies the information necessary to implement the
algorithm.
The tailDrop(2) algorithm is described as follows:
dsAlgDropQThreshold represents the depth of the
queue, pointed to by dsAlgDropQMeasure, at
which all newly arriving packets will be dropped.
The headDrop(3) algorithm is described as follows: if
a packet arrives when the current depth of the queue,
pointed to by dsAlgDropQMeasure, is at
dsAlgDropQThreshold, packets currently at the head of
the queue are dropped to make room for the new packet
to be enqueued at the tail of the queue.
The randomDrop(4) algorithm is described as follows:
on packet arrival, an algorithm is executed which may
randomly drop the packet, or drop other packet(s)
from the queue in its place. The specifics of the
algorithm may be proprietary. For this algorithm,
dsAlgDropSpecific points to a dsRandomDropEntry
that describes the algorithm. For this
algorithm, dsAlgQThreshold is understood to be
the absolute maximum size of the queue and additional
parameters are described in dsRandomDropTable.
The alwaysDrop(5) algorithm always drops packets. In
this case, the other configuration values in this Entry
are not meaningful; The queue is not used, therefore,
dsAlgDropNext, dsAlgDropQMeasure, and
dsAlgDropSpecific should be all set to zeroDotZero.
The mQDrop(6) algorithm measures multiple queues for
the drop algorithm. The queues measured are represented
by having dsAlgDropQMeasure referencing a dsMQAlgDropEntry.
Each of the chained dsMQAlgDropEntry is used to describe
the drop algorithm for one of the measured queues."
::= { dsAlgDropEntry 2 }
dsAlgDropNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This selects the next diffserv functional datapath
element to handle traffic for this data path.
The value zeroDotZero in this attribute indicates no
further DiffServ treatment is performed on traffic of
this datapath. Any other value must point to a valid
(pre-existing) instance of one of:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
dsQEntry.
When dsAlgDropType is alwaysDrop(5), this attribute is
Ignored."
DEFVAL { zeroDotZero }
::= { dsAlgDropEntry 3 }
dsAlgDropQMeasure OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"Points to a PRI to indicate the queues that a drop algorithm
is to monitor when deciding whether to drop a packet.
For alwaysDrop(5), this attribute should be zeroDotZero.
For tailDrop(2), headDrop(3), randomDrop(4), this should
point to an entry in the dsQTable.
For mQDrop(6), this should point to a dsMQAlgDropEntry that
Describe one of the queues being measured for multiple
queue dropper.
The PRI pointed to must exist prior to installing
this dropper element."
::= { dsAlgDropEntry 4 }
dsAlgDropQThreshold OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "Bytes"
STATUS current
DESCRIPTION
"A threshold on the depth in bytes of the queue being
measured at which a trigger is generated to the drop-
ping algorithm, unless dsAlgDropType is alwaysDrop(5)
where this attribute is ignored.
For the tailDrop(2) or headDrop(3) algorithms, this
represents the depth of the queue, pointed to by
dsAlgDropQMeasure, at which the drop action
will take place. Other algorithms will need to define
their own semantics for this threshold."
::= { dsAlgDropEntry 5 }
dsAlgDropSpecific OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"Points to a table entry that provides further detail
regarding a drop algorithm. The PRI pointed to
must exist prior to installing this dropper element.
Entries with dsAlgDropType equal to other(1) must
have this point to an instance of a PRC defined
in another PIB module.
Entries with dsAlgDropType equal to random-
Drop(4) must have this point to an entry in
dsRandomDropTable.
Entries with dsAlgDropType equal to mQDrop(6) can use this
attribute to reference parameters that is used by all the
queues of the multiple queues being measured.
For all other algorithms, this should take the value
zeroDotZero."
::= { dsAlgDropEntry 6 }and last bit for this part: the Multiple Queue Algorithmic Drop Table is starting to set up 🧚💜
--
-- Multiple Queue Algorithmic Drop Table
--
-- Entries of this table should be referenced by dsAlgDropQMeasure
-- when dsAlgDropType is mQDrop(6) for droppers measuring multiple
-- queues for its drop algorithm.
-- Each entry of the table is used to describe the drop algorithm
-- for a single queue within the multiple queues being measured.
--
-- Entries of this table, dsMQAlgDropEntry, is extended from
-- dsAlgDropEntry, with usage of corresponding parameters the sameokay so picking right back up where the multi-queue dropper left off 💅
-- except:
-- dsAlgDropNext is used to point to the next diffserv
-- functional data path element when the packet is not dropped.
-- dsMQAlgDropExceedNext is used to point to the next
-- dsMQAlgDropEntry for chaining together the multiple
-- dsMQAlgDropEntry's for the multiple queues being measured.
--
dsMQAlgDropTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsMQAlgDropEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The multiple queue algorithmic drop table contains entries
describing each queue being measured for the multiple queue
algorithmic dropper."
::= { dsPolicyClasses 9 }
dsMQAlgDropEntry OBJECT-TYPE
SYNTAX DsMQAlgDropEntry
STATUS current
DESCRIPTION
"An entry describes a process that drops packets
according to some algorithm. Each entry is used for
each of the multiple queues being measured. Each entry
extends the basic dsAlgDropEntry with adding of a
dsMQAlgDropExceedNext attribute.
Further details of the algorithm type are to be found in
dsAlgDropType and with more detail parameter entry pointed
to by dsMQAlgDropSpecific when necessary."
EXTENDS { dsAlgDropEntry }
UNIQUENESS { dsMQAlgDropExceedNext }
::= { dsMQAlgDropTable 1 }
DsMQAlgDropEntry ::= SEQUENCE {
dsMQAlgDropExceedNext Prid
}
dsMQAlgDropExceedNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"Used for linking of multiple dsMQAlgDropEntry for mQDrop.
A value of zeroDotZero indicates this is the last of a
chain of dsMQAlgDropEntry."
DEFVAL { zeroDotZero }
::= { dsMQAlgDropEntry 1 }Random Drop Table 🎀
--
-- Random Drop Table
--
dsRandomDropTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsRandomDropEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The random drop table contains entries describing a
process that drops packets randomly. Entries in this
table is intended to be pointed to by dsAlgDropSpecific
when dsAlgDropType is randomDrop(4)."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 7.1.3"
::= { dsPolicyClasses 10 }
dsRandomDropEntry OBJECT-TYPE
SYNTAX DsRandomDropEntry
STATUS current
DESCRIPTION
"An entry describes a process that drops packets
according to a random algorithm."
PIB-INDEX { dsRandomDropPrid }
UNIQUENESS { dsRandomDropMinThreshBytes,
dsRandomDropMinThreshPkts,
dsRandomDropMaxThreshBytes,
dsRandomDropMaxThreshPkts,
dsRandomDropProbMax,
dsRandomDropWeight,
dsRandomDropSamplingRate
}
::= { dsRandomDropTable 1 }
DsRandomDropEntry ::= SEQUENCE {
dsRandomDropPrid InstanceId,
dsRandomDropMinThreshBytes Unsigned32,
dsRandomDropMinThreshPkts Unsigned32,
dsRandomDropMaxThreshBytes Unsigned32,
dsRandomDropMaxThreshPkts Unsigned32,
dsRandomDropProbMax Unsigned32,
dsRandomDropWeight Unsigned32,
dsRandomDropSamplingRate Unsigned32
}
dsRandomDropPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsRandomDropEntry 1 }
dsRandomDropMinThreshBytes OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "bytes"
STATUS current
DESCRIPTION
"The average queue depth in bytes, beyond which traffic has a
non-zero probability of being dropped."
::= { dsRandomDropEntry 2 }
dsRandomDropMinThreshPkts OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "packets"
STATUS current
DESCRIPTION
"The average queue depth in packets, beyond which traffic has
a non-zero probability of being dropped."
::= { dsRandomDropEntry 3 }
dsRandomDropMaxThreshBytes OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "bytes"
STATUS current
DESCRIPTION
"The average queue depth beyond which traffic has a
probability indicated by dsRandomDropProbMax of being dropped
or marked. Note that this differs from the physical queue
limit, which is stored in dsAlgDropQThreshold."
::= { dsRandomDropEntry 4 }
dsRandomDropMaxThreshPkts OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "packets"
STATUS current
DESCRIPTION
"The average queue depth beyond which traffic has a
probability indicated by dsRandomDropProbMax of being dropped
or marked. Note that this differs from the physical queue
limit, which is stored in dsAlgDropQThreshold."
::= { dsRandomDropEntry 5 }
dsRandomDropProbMax OBJECT-TYPE
SYNTAX Unsigned32 (0..1000)
STATUS current
DESCRIPTION
"The worst case random drop probability, expressed in drops
per thousand packets.
For example, if every packet may be dropped in the worst case
(100%), this has the value 1000. Alternatively, if in the
worst case one percent (1%) of traffic may be dropped, it has
the value 10."
::= { dsRandomDropEntry 6 }
dsRandomDropWeight OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
STATUS current
DESCRIPTION
"The weighting of past history in affecting the Exponentially
Weighted Moving Average function which calculates the current
average queue depth. The equation uses
dsRandomDropWeight/MaxValue as the coefficient for the new
sample in the equation, and
(MaxValue - dsRandomDropWeight)/MaxValue as the coefficient
of the old value, where, MaxValue is determined via capability
reported by the PEP.
Implementations may further limit the values of
dsRandomDropWeight via the capability tables."
::= { dsRandomDropEntry 7 }
dsRandomDropSamplingRate OBJECT-TYPE
SYNTAX Unsigned32 (0..1000000)
STATUS current
DESCRIPTION
"The number of times per second the queue is sampled for queue
average calculation. A value of zero means the queue is
sampled approximately each time a packet is enqueued (or
dequeued)."
::= { dsRandomDropEntry 8 }Queue Table 🧚
--
-- Queue Table
--
--
-- An entry of dsQTable represents a FIFO queue diffserv
-- functional data path element as described in [MODEL] section
-- 7.1.1.
-- Notice the specification of scheduling parameters for a queue
-- as part of the input to a scheduler functional data path
-- element as described in [MODEL] section 7.1.2. This allows
-- building of hierarchical queuing/scheduling.
-- A queue therefore is parameterized by:
-- 1. Which scheduler will service this queue, dsQNext.
-- 2. How the scheduler will service this queue, with respect
-- to all the other queues the same scheduler needs to service,
-- dsQMinRate and dsQMaxRate.
--
-- Notice one or more upstream diffserv functional data path element
-- may share, point to, a dsQTable entry as described in [MODEL]
-- section 7.1.1.
--
dsQTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsQEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The Queue Table enumerates the queues."
::= { dsPolicyClasses 11 }
dsQEntry OBJECT-TYPE
SYNTAX DsQEntry
STATUS current
DESCRIPTION
"An entry in the Queue Table describes a single queue
as a functional data path element."
PIB-INDEX { dsQPrid }
UNIQUENESS { dsQNext,
dsQMinRate,
dsQMaxRate }
::= { dsQTable 1 }
DsQEntry ::= SEQUENCE {
dsQPrid InstanceId,
dsQNext Prid,
dsQMinRate Prid,
dsQMaxRate Prid
}
dsQPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsQEntry 1 }
dsQNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This selects the next diffserv scheduler. This must point
to a dsSchedulerEntry.
A value of zeroDotZero in this attribute indicates an
incomplete dsQEntry instance. In such a case, the entry
has no operational effect, since it has no parameters to
give it meaning."
::= { dsQEntry 2 }
dsQMinRate OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This Prid indicates the entry in dsMinRateTable
the scheduler, pointed to by dsQNext, should use to service
this queue.
If this value is zeroDotZero
then minimum rate and priority is unspecified.
If this value is not zeroDotZero then the instance pointed to
must exist prior to installing this entry."
::= { dsQEntry 3 }
dsQMaxRate OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This Prid indicates the entry in dsMaxRateTable
the scheduler, pointed to by dsQNext, should use to service
this queue.
If this value is zeroDotZero, then the maximum rate is the
line speed of the interface.
If this value is not zeroDotZero, then the instance pointed
to must exist prior to installing this entry."
::= { dsQEntry 4 }Scheduler Table 🦋
--
-- Scheduler Table
--
--
-- The Scheduler Table is used for representing packet schedulers:
-- it provides flexibility for multiple scheduling algorithms, each
-- servicing multiple queues, to be used on the same
-- logical/physical interface of a data path.
--
-- Notice the servicing parameters the scheduler uses is
-- specified by each of its upstream functional data path elements,
-- queues or schedulers of this PIB.
-- The coordination and coherency between the servicing parameters
-- of the scheduler's upstream functional data path elements must
-- be maintained for the scheduler to function correctly.
--
-- The dsSchedulerMinRate and dsSchedulerMaxRate attributes are
-- used for specifying the servicing parameters for output of a
-- scheduler when its downstream functional data path element
-- is another scheduler.
-- This is used for building hierarchical queue/scheduler.
--
-- More discussion of the scheduler functional data path element
-- is in [MODEL] section 7.1.2.
--
dsSchedulerTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsSchedulerEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The Scheduler Table enumerates packet schedulers.
Multiple scheduling algorithms can be used on a given
datapath, with each algorithm described by one
dsSchedulerEntry."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 7.1.2"
::= { dsPolicyClasses 12 }
dsSchedulerEntry OBJECT-TYPE
SYNTAX DsSchedulerEntry
STATUS current
DESCRIPTION
"An entry in the Scheduler Table describing a single
instance of a scheduling algorithm."
PIB-INDEX { dsSchedulerPrid }
UNIQUENESS { dsSchedulerNext,
dsSchedulerMethod,
dsSchedulerMinRate,
dsSchedulerMaxRate }
::= { dsSchedulerTable 1 }
DsSchedulerEntry ::= SEQUENCE {
dsSchedulerPrid InstanceId,
dsSchedulerNext Prid,
dsSchedulerMethod AutonomousType,
dsSchedulerMinRate Prid,
dsSchedulerMaxRate Prid
}
dsSchedulerPrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsSchedulerEntry 1 }Okay so this bit is all about where the traffic goes next 🦋 dsSchedulerNext is the pointer that says which functional datapath element picks up the traffic after this scheduler. Normally it's zeroDotZero, which means no further DiffServ treatment happens on this datapath. That's the default for the last element in the chain 💅
dsSchedulerNext OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This selects the next diffserv functional datapath
element to handle traffic for this data path.
This attribute normally have a value of zeroDotZero to
indicate no further DiffServ treatment is performed on
traffic of this datapath. The use of zeroDotZero is the
normal usage for the last functional datapath element.
Any value other than zeroDotZero must point to a valid
(pre-existing) instance of one of:
dsSchedulerEntry
dsQEntry,
or:
dsClfrEntry
dsMeterEntry
dsActionEntry
dsAlgDropEntry
This points to another dsSchedulerEntry
for implementation of multiple scheduler methods for
the same data path, and for implementation of
hierarchical schedulers."
DEFVAL { zeroDotZero }
::= { dsSchedulerEntry 2 }Next up is dsSchedulerMethod, which is the scheduling algorithm this scheduler uses 🎀 The standard generic values are listed right there, and they're defined in the DiffServ MIB. Other PIBs can add more, and zeroDotZero means "we don't know" 🤷♀️
dsSchedulerMethod OBJECT-TYPE
SYNTAX AutonomousType
STATUS current
DESCRIPTION
"The scheduling algorithm used by this Scheduler.
Standard values for generic algorithms:
diffServSchedulerPriority,
diffServSchedulerWRR,
diffServSchedulerWFQ
are specified in the DiffServ MIB.
Additional values may be further specified in other PIBs.
A value of zeroDotZero indicates this is unknown."
REFERENCE
"An Informal Management Model for Diffserv Routers,
RFC 3290, section 7.1.2"
::= { dsSchedulerEntry 3 }Then come the min and max rate pointers for the scheduler itself. Both of them only matter when there's more than one level of scheduler, so if you've only got one level, they're basically sitting there doing nothing 🌸 zeroDotZero means no minimum or maximum rate is imposed.
dsSchedulerMinRate OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This Prid indicates the entry in dsMinRateTable
which indicates the priority or minimum output rate from this
scheduler. This attribute is used only when there is more
than one level of scheduler.
When it has the value zeroDotZero, it indicates that no
Minimum rate or priority is imposed."
DEFVAL { zeroDotZero }
::= { dsSchedulerEntry 4 }
dsSchedulerMaxRate OBJECT-TYPE
SYNTAX Prid
STATUS current
DESCRIPTION
"This Prid indicates the entry in dsMaxRateTable
which indicates the maximum output rate from this scheduler.
When more than one maximum rate applies (e.g., a multi-rate
shaper is used), it points to the first of the rate entries.
This attribute is only used when there is more than one level
of scheduler.
When it has the value zeroDotZero, it indicates that no
Maximum rate is imposed."
DEFVAL { zeroDotZero }
::= { dsSchedulerEntry 5 }Now for the Minimum Rate Parameters Table ✨ The idea is that the scheduling settings get their own table, separate from the queue and scheduler entries. That way they can be reused, and both queues and schedulers can point at the same entry. That's what makes hierarchical scheduling possible 💜 The comment block below explains the rest, including the difference between the priority/absolute/relative attributes and how work-conserving scheduling behaves.
--
-- Minimum Rate Parameters Table
--
-- The parameters used by a scheduler for its inputs or outputs are
-- maintained separately from the Queue or Scheduler table entries
-- for reusability reasons and so that they may be used by both
-- queues and schedulers. This follows the approach for separation
-- of data path elements from parameterization that is used
-- throughout this PIB.
-- Use of these Minimum Rate Parameter Table entries by Queues and
-- Schedulers allows the modeling of hierarchical scheduling
-- systems.
--
-- Specifically, a Scheduler has one or more inputs and one output.
-- Any queue feeding a scheduler, or any scheduler which feeds a
-- second scheduler, might specify a minimum transfer rate by
-- pointing to a Minimum Rate Parameter Table entry.
--
-- The dsMinRatePriority/Absolute/Relative attributes are used as
-- parameters to the work-conserving portion of a scheduler:
-- "work-conserving" implies that the scheduler can continue to emit
-- data as long as there is data available at its input(s). This
-- has the effect of guaranteeing a certain priority relative to
-- other scheduler inputs and/or a certain minimum proportion of the
-- available output bandwidth. Properly configured, this means a
-- certain minimum rate, which may be exceeded should traffic be
-- available should there be spare bandwidth after all other classes
-- have had opportunities to consume their own minimum rates.
--
dsMinRateTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsMinRateEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The Minimum Rate Table enumerates individual
sets of scheduling parameter that can be used/reused
by Queues and Schedulers."
::= { dsPolicyClasses 13 }
dsMinRateEntry OBJECT-TYPE
SYNTAX DsMinRateEntry
STATUS current
DESCRIPTION
"An entry in the Minimum Rate Table describes
a single set of scheduling parameter for use by
queues and schedulers."
PIB-INDEX { dsMinRatePrid }
UNIQUENESS { dsMinRatePriority,
dsMinRateAbsolute,
dsMinRateRelative }
::= { dsMinRateTable 1 }
DsMinRateEntry ::= SEQUENCE {
dsMinRatePrid InstanceId,
dsMinRatePriority Unsigned32,
dsMinRateAbsolute Unsigned32,
dsMinRateRelative Unsigned32
}
dsMinRatePrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsMinRateEntry 1 }
dsMinRatePriority OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
STATUS current
DESCRIPTION
"The priority of this input to the associated scheduler,
relative to the scheduler's other inputs. Higher Priority
value indicates the associated queue/scheduler will get
service first before others with lower Priority values."
::= { dsMinRateEntry 2 }Next is dsMinRateAbsolute, which is the minimum absolute rate in kilobits per second 🍓 If it's zero there's effectively no guarantee. The description also couples it to dsMinRateRelative, so changing one changes the other. It includes the conversion equations too, so you can do the maths between the two. Keep the original spelling of ifHIghSpeed in mind when you read it, because that's exactly how it's written 🙈
dsMinRateAbsolute OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "kilobits per second"
STATUS current
DESCRIPTION
"The minimum absolute rate, in kilobits/sec, that a downstream
scheduler element should allocate to this queue. If the value
is zero, then there is effectively no minimum rate guarantee.
If the value is non-zero, the scheduler will assure the
servicing of this queue to at least this rate.
Note that this attribute's value is coupled to that
of dsMinRateRelative: changes to one will affect the value
of the other.
[IFMIB] defines ifSpeed as Gauge32 in units of bits per
second, and ifHighSpeed as Gauge32 in units of 1,000,000 bits
per second.
This yields the following equations:
RateRelative = [ (RateAbsolute * 1000) / ifSpeed ] * 1,000
Where, 1000 is for converting kbps used by RateAbsolute to bps
used by ifSpeed, 1,000 is for 'in units of 1/1,000 of 1' for
RateRelative.
or, if appropriate:
RateRelative =
{ [ (RateAbsolute * 1000) / 1,000,000 ] / ifHIghSpeed } *
1,000
Where, 1000 and 1,000,000 is for converting kbps used by
RateAbsolute to 1 million bps used by ifHighSpeed, 1,000 is
for 'in units of 1/1,000 of 1' for RateRelative."
REFERENCE
"ifSpeed, ifHighSpeed from the IF-MIB, RFC 2863."
::= { dsMinRateEntry 3 }And dsMinRateRelative is the same deal, just expressed as a fraction of the interface's maximum rate, in units of 1/1,000 of 1 👑 It's coupled to the absolute one too, with the same equations and the same reference to the IF-MIB.
dsMinRateRelative OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
STATUS current
DESCRIPTION
"The minimum rate that a downstream scheduler element
should allocate to this queue, relative to the max-
imum rate of the interface as reported by ifSpeed or
ifHighSpeed, in units of 1/1,000 of 1. If the value
is zero, then there is effectively no minimum rate
guarantee. If the value is non-zero, the scheduler
will assure the servicing of this queue to at least
this rate.
Note that this attribute's value is coupled to that
of dsMinRateAbsolute: changes to one will
affect the value of the other.
[IFMIB] defines ifSpeed as Gauge32 in units of bits per
second, and ifHighSpeed as Gauge32 in units of 1,000,000 bits
per second.
This yields the following equations:
RateRelative = [ (RateAbsolute * 1000) / ifSpeed ] * 1,000
Where, 1000 is for converting kbps used by RateAbsolute to bps
used by ifSpeed, 1,000 is for 'in units of 1/1,000 of 1' for
RateRelative.
or, if appropriate:
RateRelative =
{ [ (RateAbsolute * 1000) / 1,000,000 ] / ifHIghSpeed } *
1,000
Where, 1000 and 1,000,000 is for converting kbps used by
RateAbsolute to 1 million bps used by ifHighSpeed, 1,000 is
for 'in units of 1/1,000 of 1' for RateRelative."
REFERENCE
"ifSpeed, ifHighSpeed from the IF-MIB, RFC 2863."
::= { dsMinRateEntry 4 }Last up for this part is the Maximum Rate Parameters Table 🌈 It works the same way as the minimum one, just for the non-work-conserving side of a scheduler. Multi-rate shapers, like a Dual Leaky Bucket, use several entries that share the same dsMaxRateId but have different dsMaxRateLevel values. The comment block explains the details, including the bit about shaping that's covered in the Informal Differentiated Services Model.
--
-- Maximum Rate Parameters Table
--
-- The parameters used by a scheduler for its inputs or outputs are
-- maintained separately from the Queue or Scheduler table entries
-- for reusability reasons and so that they may be used by both
-- queues and schedulers. This follows the approach for separation
-- of data path elements from parameterization that is used
-- throughout this PIB.
--
-- Use of these Maximum Rate Parameter Table entries by Queues and
-- Schedulers allows the modeling of hierarchical scheduling
-- systems.
--
-- Specifically, a Scheduler has one or more inputs and one output.
-- Any queue feeding a scheduler, or any scheduler which feeds a
-- second scheduler, might specify a maximum transfer rate by
-- pointing to a Maximum Rate Parameter Table entry. Multi-rate
-- shapers, such as a Dual Leaky Bucket algorithm, specify their
-- rates using multiple Maximum Rate Parameter Entries with the same
-- dsMaxRateId but different dsMaxRateLevels.
--
-- The dsMaxRateLevel/Absolute/Relative attributes are used as
-- parameters to the non-work-conserving portion of a scheduler:
-- non-work-conserving implies that the scheduler may sometimes not
-- emit a packet, even if there is data available at its input(s).
-- This has the effect of limiting the servicing of the
-- queue/scheduler input or output, in effect performing shaping of
-- the packet stream passing through the queue/scheduler, as
-- described in the Informal Differentiated Services Model
-- section 7.2.
--
dsMaxRateTable OBJECT-TYPE
SYNTAX SEQUENCE OF DsMaxRateEntry
PIB-ACCESS install
STATUS current
DESCRIPTION
"The Maximum Rate Table enumerates individual
sets of scheduling parameter that can be used/reused
by Queues and Schedulers."
::= { dsPolicyClasses 14 }
dsMaxRateEntry OBJECT-TYPE
SYNTAX DsMaxRateEntry
STATUS current
DESCRIPTION
"An entry in the Maximum Rate Table describes
a single set of scheduling parameter for use by
queues and schedulers."
PIB-INDEX { dsMaxRatePrid }
UNIQUENESS { dsMaxRateId,
dsMaxRateLevel,
dsMaxRateAbsolute,
dsMaxRateRelative,
dsMaxRateThreshold }
::= { dsMaxRateTable 1 }
DsMaxRateEntry ::= SEQUENCE {
dsMaxRatePrid InstanceId,
dsMaxRateId Unsigned32,
dsMaxRateLevel Unsigned32,
dsMaxRateAbsolute Unsigned32,
dsMaxRateRelative Unsigned32,
dsMaxRateThreshold BurstSize
}
dsMaxRatePrid OBJECT-TYPE
SYNTAX InstanceId
STATUS current
DESCRIPTION
"An arbitrary integer index that uniquely identifies an
instance of the class."
::= { dsMaxRateEntry 1 }okay bestie, the rate knobs are next and they're giving main character energy 💖 Here's the MIB stuff, verbatim so the rules stay exact 🎀
dsMaxRateId OBJECT-TYPE
SYNTAX Unsigned32 (0..4294967295)
STATUS current
DESCRIPTION
"An identifier used together with dsMaxRateLevel for
representing a multi-rate shaper. This attribute is used for
associating all the rate attributes of a multi-rate shaper.
Each dsMaxRateEntry of a multi-rate shaper must have the same
value in this attribute. The different rates of a multi-rate
shaper is identified using dsMaxRateLevel.
This attribute uses the value of zero to indicate this
attribute is not used, for single rate shaper."
DEFVAL { 0 }
::= { dsMaxRateEntry 2 }
dsMaxRateLevel OBJECT-TYPE
SYNTAX Unsigned32 (1..32)
STATUS current
DESCRIPTION
"An index that indicates which level of a multi-rate shaper is
being given its parameters. A multi-rate shaper has some
number of rate levels. Frame Relay's dual rate specification
refers to a 'committed' and an 'excess' rate; ATM's dual rate
specification refers to a 'mean' and a 'peak' rate. This table
is generalized to support an arbitrary number of rates. The
committed or mean rate is level 1, the peak rate (if any) is
the highest level rate configured, and if there are other
rates they are distributed in monotonically increasing order
between them.
When the entry is used for a single rate shaper, this
attribute contains a value of one."
DEFVAL { 1 }
::= { dsMaxRateEntry 3 }
dsMaxRateAbsolute OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
UNITS "kilobits per second"
STATUS current
DESCRIPTION
"The maximum rate in kilobits/sec that a downstream
scheduler element should allocate to this queue. If
the value is zero, then there is effectively no max-
imum rate limit and that the scheduler should attempt
to be work-conserving for this queue. If the value
is non-zero, the scheduler will limit the servicing
of this queue to, at most, this rate in a non-work-
conserving manner.
Note that this attribute's value is coupled to that
of dsMaxRateRelative: changes to one will
affect the value of the other.
[IFMIB] defines ifSpeed as Gauge32 in units of bits per
second, and ifHighSpeed as Gauge32 in units of 1,000,000 bits
per second.
This yields the following equations:
RateRelative = [ (RateAbsolute * 1000) / ifSpeed ] * 1,000
Where, 1000 is for converting kbps used by RateAbsolute to bps
used by ifSpeed, 1,000 is for 'in units of 1/1,000 of 1'
for RateRelative.
or, if appropriate:
RateRelative =
{ [ (RateAbsolute * 1000) / 1,000,000 ] / ifHIghSpeed } *
1,000
Where, 1000 and 1,000,000 is for converting kbps used by
RateAbsolute to 1 million bps used by ifHighSpeed, 1,000 is
for 'in units of 1/1,000 of 1' for RateRelative."
::= { dsMaxRateEntry 4 }
dsMaxRateRelative OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
STATUS current
DESCRIPTION
"The maximum rate that a downstream scheduler element
should allocate to this queue, relative to the max-
imum rate of the interface as reported by ifSpeed or
ifHighSpeed, in units of 1/1,000 of 1. If the value
is zero, then there is effectively no maximum rate
limit and the scheduler should attempt to be work-
conserving for this queue. If the value is non-zero,
the scheduler will limit the servicing of this queue
to, at most, this rate in a non-work-conserving
manner.
Note that this attribute's value is coupled to that
of dsMaxRateAbsolute: changes to one will
affect the value of the other.
[IFMIB] defines ifSpeed as Gauge32 in units of bits per
second, and ifHighSpeed as Gauge32 in units of 1,000,000 bits
per second.
This yields the following equations:
RateRelative = [ (RateAbsolute * 1000) / ifSpeed ] * 1,000
Where, 1000 is for converting kbps used by RateAbsolute to bps
used by ifSpeed, 1,000 is for 'in units of 1/1,000 of 1' for
RateRelative.
or, if appropriate:
RateRelative =
{ [ (RateAbsolute * 1000) / 1,000,000 ] / ifHIghSpeed } *
1,000
Where, 1000 and 1,000,000 is for converting kbps used by
RateAbsolute to 1 million bps used by ifHighSpeed, 1,000 is
for 'in units of 1/1,000 of 1' for RateRelative."
REFERENCE
"ifSpeed, ifHighSpeed from the IF-MIB, RFC 2863."
::= { dsMaxRateEntry 5 }
dsMaxRateThreshold OBJECT-TYPE
SYNTAX BurstSize
UNITS "Bytes"
STATUS current
DESCRIPTION
"The number of bytes of queue depth at which the rate of a
multi-rate scheduler will increase to the next output rate. In
the last PRI for such a shaper, this threshold is
ignored and by convention is zero."
REFERENCE
"Adaptive Rate Shaper, RFC 2963"
::= { dsMaxRateEntry 6 }
--
-- Conformance Section
--
dsPolicyPibCompliances
OBJECT IDENTIFIER ::= { dsPolicyPibConformance 1 }
dsPolicyPibGroups
OBJECT IDENTIFIER ::= { dsPolicyPibConformance 2 }the conformance bits are next, so the cute stuff isn't over yet 🦋
okay bestie, the compliance checklist is here and it is SO detailed 💅 the MANDATORY-GROUPS lists are literally the must-haves, and the PIB-MIN-ACCESS lines say which objects can be left alone 🫶
dsPolicyPibCompliance MODULE-COMPLIANCE
STATUS current
DESCRIPTION
"Describes the requirements for conformance to the
QoS Policy PIB."
MODULE FRAMEWORK-PIB
MANDATORY-GROUPS {
frwkPrcSupportGroup,
frwkPibIncarnationGroup,
frwkDeviceIdGroup,
frwkCompLimitsGroup,
frwkCapabilitySetGroup,
frwkRoleComboGroup,
frwkIfRoleComboGroup,
frwkBaseFilterGroup,
frwkIpFilterGroup }
OBJECT frwkPibIncarnationLongevity
PIB-MIN-ACCESS notify
DESCRIPTION
"Install support is required if policy expiration is to
be supported."
OBJECT frwkPibIncarnationTtl
PIB-MIN-ACCESS notify
DESCRIPTION
"Install support is required if policy expiration is to
be supported."
MODULE DIFFSERV-PIB -- this module
MANDATORY-GROUPS {
dsPibBaseIfCapsGroup,
dsPibIfClassificationCapsGroup,
dsPibIfAlgDropCapsGroup,
dsPibIfQueueCapsGroup,
dsPibIfSchedulerCapsGroup,
dsPibIfMaxRateCapsGroup,
dsPibIfElmDepthCapsGroup,
dsPibIfElmLinkCapsGroup,
dsPibDataPathGroup,
dsPibClfrGroup,
dsPibClfrElementGroup,
dsPibActionGroup,
dsPibAlgDropGroup,
dsPibQGroup,
dsPibSchedulerGroup,
dsPibMinRateGroup,
dsPibMaxRateGroup }
GROUP dsPibIfMeteringCapsGroup
DESCRIPTION
"This group is mandatory for devices that implement
metering functions."
GROUP dsPibMeterGroup
DESCRIPTION
"This group is mandatory for devices that implement
metering functions."
GROUP dsPibTBParamGroup
DESCRIPTION
"This group is mandatory for devices that implement
token-bucket metering functions."
GROUP dsPibDscpMarkActGroup
DESCRIPTION
"This group is mandatory for devices that implement
DSCP-Marking functions."
GROUP dsPibMQAlgDropGroup
DESCRIPTION
"This group is mandatory for devices that implement
Multiple Queue Measured Algorithmic Drop functions."
GROUP dsPibRandomDropGroup
DESCRIPTION
"This group is mandatory for devices that implement
Random Drop functions."
OBJECT dsClfrId
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsClfrElementClfrId
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsClfrElementPrecedence
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsClfrElementNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsClfrElementSpecific
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMeterSucceedNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMeterFailNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMeterSpecific
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsTBParamType
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsTBParamRate
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsTBParamBurstSize
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsTBParamInterval
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsActionNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsActionSpecific
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsAlgDropType
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsAlgDropNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsAlgDropQMeasure
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsAlgDropQThreshold
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsAlgDropSpecific
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropMinThreshBytes
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropMinThreshPkts
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropMaxThreshBytes
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropMaxThreshPkts
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropProbMax
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropWeight
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsRandomDropSamplingRate
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsQNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsQMinRate
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsQMaxRate
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsSchedulerNext
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsSchedulerMethod
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsSchedulerMinRate
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsSchedulerMaxRate
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMinRatePriority
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMinRateAbsolute
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMinRateRelative
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMaxRateId
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMaxRateLevel
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMaxRateAbsolute
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMaxRateRelative
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
OBJECT dsMaxRateThreshold
PIB-MIN-ACCESS not-accessible
DESCRIPTION
"Install support is not required."
::= { dsPolicyPibCompliances 1 }
dsPibBaseIfCapsGroup OBJECT-GROUP
OBJECTS {
dsBaseIfCapsPrid, dsBaseIfCapsDirection
}
STATUS current
DESCRIPTION
"The Base Interface Capability Group defines the PIB
Objects that describe the base for interface capabilities."
::= { dsPolicyPibGroups 1 }
dsPibIfClassificationCapsGroup OBJECT-GROUP
OBJECTS {
dsIfClassificationCapsSpec
}
STATUS current
DESCRIPTION
"The Classification Capability Group defines the PIB
Objects that describe the classification capabilities."
::= { dsPolicyPibGroups 2 }
dsPibIfMeteringCapsGroup OBJECT-GROUP
OBJECTS {
dsIfMeteringCapsSpec
}
STATUS current
DESCRIPTION
"The Metering Capability Group defines the PIB
Objects that describe the metering capabilities."
::= { dsPolicyPibGroups 3 }
dsPibIfAlgDropCapsGroup OBJECT-GROUP
OBJECTS {
dsIfAlgDropCapsType, dsIfAlgDropCapsMQCount
}
STATUS current
DESCRIPTION
"The Algorithmic Dropper Capability Group defines the
PIB Objects that describe the algorithmic dropper
capabilities."
::= { dsPolicyPibGroups 4 }
dsPibIfQueueCapsGroup OBJECT-GROUP
OBJECTS {
dsIfQueueCapsMinQueueSize, dsIfQueueCapsMaxQueueSize,
dsIfQueueCapsTotalQueueSize
}
STATUS current
DESCRIPTION
"The Queueing Capability Group defines the PIB
Objects that describe the queueing capabilities."
::= { dsPolicyPibGroups 5 }
dsPibIfSchedulerCapsGroup OBJECT-GROUP
OBJECTS {
dsIfSchedulerCapsServiceDisc, dsIfSchedulerCapsMaxInputs,
dsIfSchedulerCapsMinMaxRate
}
STATUS current
DESCRIPTION
"The Scheduler Capability Group defines the PIB
Objects that describe the scheduler capabilities."
::= { dsPolicyPibGroups 6 }
dsPibIfMaxRateCapsGroup OBJECT-GROUP
OBJECTS {
dsIfMaxRateCapsMaxLevels
}
STATUS current
DESCRIPTION
"The Max Rate Capability Group defines the PIB
Objects that describe the max rate capabilities."
::= { dsPolicyPibGroups 7 }
dsPibIfElmDepthCapsGroup OBJECT-GROUP
OBJECTS {
dsIfElmDepthCapsPrc, dsIfElmDepthCapsCascadeMax
}
STATUS current
DESCRIPTION
"The DataPath Element Depth Capability Group defines the PIB
Objects that describe the datapath element depth
capabilities."
::= { dsPolicyPibGroups 8 }
dsPibIfElmLinkCapsGroup OBJECT-GROUP
OBJECTS {
dsIfElmLinkCapsPrc, dsIfElmLinkCapsAttr,
dsIfElmLinkCapsNextPrc
}
STATUS current
DESCRIPTION
"The DataPath Element Linkage Capability Group defines the
PIB Objects that describe the datapath element linkage
capabilities."
::= { dsPolicyPibGroups 9 }
dsPibDataPathGroup OBJECT-GROUP
OBJECTS {
dsDataPathPrid, dsDataPathCapSetName,
dsDataPathRoles, dsDataPathIfDirection,
dsDataPathStart
}
STATUS current
DESCRIPTION
"The Data Path Group defines the PIB Objects that
describe a data path."
::= { dsPolicyPibGroups 10 }
dsPibClfrGroup OBJECT-GROUP
OBJECTS {
dsClfrPrid, dsClfrId
}
STATUS current
DESCRIPTION
"The Classifier Group defines the PIB Objects that
describe a generic classifier."
::= { dsPolicyPibGroups 11 }
dsPibClfrElementGroup OBJECT-GROUP
OBJECTS {
dsClfrElementPrid, dsClfrElementClfrId,
dsClfrElementPrecedence, dsClfrElementNext,
dsClfrElementSpecific
}
STATUS current
DESCRIPTION
"The Classifier Group defines the PIB Objects that
describe a generic classifier."
::= { dsPolicyPibGroups 12 }
dsPibMeterGroup OBJECT-GROUP
OBJECTS {
dsMeterPrid, dsMeterSucceedNext,
dsMeterFailNext, dsMeterSpecific
}
STATUS current
DESCRIPTION
"The Meter Group defines the objects used in describ-
ing a generic meter element."
::= { dsPolicyPibGroups 13 }
dsPibTBParamGroup OBJECT-GROUP
OBJECTS {
dsTBParamPrid, dsTBParamType, dsTBParamRate,
dsTBParamBurstSize, dsTBParamInterval
}
STATUS current
DESCRIPTION
"The Token-Bucket Parameter Group defines the objects
used in describing a single-rate token bucket meter
element."
::= { dsPolicyPibGroups 14 }that's the whole vibe for this chunk 🧚 the groups are basically little labelled boxes of objects, each with its own number ✨
dsPibActionGroup OBJECT-GROUP
OBJECTS {
dsActionPrid, dsActionNext, dsActionSpecific
}
STATUS current
DESCRIPTION
"The Action Group defines the objects used in
describing a generic action element."
::= { dsPolicyPibGroups 15 }
dsPibDscpMarkActGroup OBJECT-GROUP
OBJECTS {
dsDscpMarkActPrid, dsDscpMarkActDscp
}
STATUS current
DESCRIPTION
"The DSCP Mark Action Group defines the objects used
in describing a DSCP Marking Action element."
::= { dsPolicyPibGroups 16 }
dsPibAlgDropGroup OBJECT-GROUP
OBJECTS {
dsAlgDropPrid, dsAlgDropType, dsAlgDropNext,
dsAlgDropQMeasure, dsAlgDropQThreshold,
dsAlgDropSpecific
}
STATUS current
DESCRIPTION
"The Algorithmic Drop Group contains the objects that
describe algorithmic dropper operation and configura-
tion."
::= { dsPolicyPibGroups 17 }
dsPibMQAlgDropGroup OBJECT-GROUP
OBJECTS {
dsMQAlgDropExceedNext
}
STATUS current
DESCRIPTION
"The Multiple Queue Measured Algorithmic Drop Group
contains the objects that describe multiple queue
measured algorithmic dropper operation and configuration."
::= { dsPolicyPibGroups 18 }
dsPibRandomDropGroup OBJECT-GROUP
OBJECTS {
dsRandomDropPrid,
dsRandomDropMinThreshBytes,
dsRandomDropMinThreshPkts,
dsRandomDropMaxThreshBytes,
dsRandomDropMaxThreshPkts,
dsRandomDropProbMax,
dsRandomDropWeight,
dsRandomDropSamplingRate
}
STATUS current
DESCRIPTION
"The Random Drop Group augments the Algorithmic Drop Group
for random dropper operation and configuration."
::= { dsPolicyPibGroups 19 }
dsPibQGroup OBJECT-GROUP
OBJECTS {
dsQPrid, dsQNext, dsQMinRate, dsQMaxRate
}
STATUS current
DESCRIPTION
"The Queue Group contains the objects that describe
an interface type's queues."
::= { dsPolicyPibGroups 20 }
dsPibSchedulerGroup OBJECT-GROUP
OBJECTS {
dsSchedulerPrid, dsSchedulerNext, dsSchedulerMethod,
dsSchedulerMinRate, dsSchedulerMaxRate
}
STATUS current
DESCRIPTION
"The Scheduler Group contains the objects that
describe packet schedulers on interface types."
::= { dsPolicyPibGroups 21 }
dsPibMinRateGroup OBJECT-GROUP
OBJECTS {
dsMinRatePrid, dsMinRatePriority,
dsMinRateAbsolute, dsMinRateRelative
}
STATUS current
DESCRIPTION
"The Minimum Rate Group contains the objects
that describe packet schedulers' parameters on interface
types."
::= { dsPolicyPibGroups 22 }
dsPibMaxRateGroup OBJECT-GROUP
OBJECTS {
dsMaxRatePrid, dsMaxRateId, dsMaxRateLevel,
dsMaxRateAbsolute, dsMaxRateRelative,
dsMaxRateThreshold
}
STATUS current
DESCRIPTION
"The Maximum Rate Group contains the objects
that describe packet schedulers' parameters on interface
types."
::= { dsPolicyPibGroups 23 }
END9. Acknowledgments ✨
Okay, big thank-you time 🫶 Early versions of this spec were also co-authored by Michael Fine, John Seligson, Carol Bell, Andrew Smith, and Francis Reichmeyer. 💜
This PIB builds on all the work that went into the Informal Management Model for DiffServ Routers and the Management Information Base for the Differentiated Services Architecture. 🌈
It was developed with lots of active involvement from so many people, but most notably Diana Rawlins, Martin Bokaemper, Walter Weiss, and Bert Wijnen. The squad really showed up 👑
10. Security Considerations 🔐
Okay, this part is serious, bestie, so listen up 🙈 The information in a PIB, when it's carried by the COPS protocol [COPS-PR], can be sensitive, and because its whole job is provisioning a PEP, only authorized communication is allowed to happen. No strangers in the group chat 💀
Now, this PIB doesn't have any PRCs that are sensitive all on their own, like passwords or monetary amounts. BUT there are a bunch of PRCs in here that could be sensitive from a business point of view, since they might show a customer's service contract or the filters a service provider picks to apply to a customer's traffic. These PRCs have a PIB-ACCESS clause of install:
dsDataPathTable, dsClfrTable, dsClfrElementTable, dsMeterTable,
dsTBParamTable, dsActionTable, dsDscpMarkActTable, dsAlgDropTable,
dsMQAlgDropTable, dsRandomDropTable, dsQTable, dsSchedulerTable,
dsMinRateTable, dsMaxRateTable🚨 Messing with the PRCs above (changing them on purpose) can mess up the DiffServ behavior of the device being provisioned. Not a vibe!
🚨 Getting into the PRCs above without permission exposes policy info about how the device is set up. Private stuff, periodt 🔒
This PIB also contains PRCs with a PIB-ACCESS clause of notify:
dsBaseIfCapsTAble, dsIfClassificationCapsTable,
dsIfMeteringCapsTable, dsIfAlgDropCapsTable, dsIfQueueCapsTable,
dsIfSchedulerCapsTable, dsIfMaxRateCapsTable, dsIfElmDepthCapsTable,
dsIfElmLinkCapsTableAccessing those PRCs without permission exposes information about the device being provisioned, so keep those eyes closed 👀🚫
And the protection for all this? The use of IPSEC between PDP and PEP, as described in [COPS], provides the necessary protection. Lowkey the security glow-up we needed 💅✨
11. Intellectual Property Considerations 💡
The IETF has been notified of intellectual property rights claimed in regard to some or all of the specification in this document. For more info, check out the online list of claimed rights 📜
12. IANA Considerations 🦋
So this document describes the dsPolicyPib Policy Information Base (PIB) modules for standardization under the "pib" branch registered with IANA. IANA has assigned PIB number (4) under the "pib" branch. Yay, number four! 🎀
[SPPI] PIB SUBJECT-CATEGORIES are mapped to COPS Client Types. IANA Considerations for SUBJECT-CATEGORIES follow the same requirements as specified in the [COPS] IANA Considerations for COPS Client Types. The DiffServ QoS PIB defines a new COPS Client Type in the Standards space, and IANA has assigned the COPS client type diffServ (2) as described in [COPS] IANA Considerations. IANA also updated the registry for COPS Client Types as a result, which you can find at http://www.iana.org/assignments/cops-parameters 🌸
13. Normative References 📚
- [COPS] Boyle, J., Cohen, R., Durham, D., Herzog, S., Rajan, R. and A. Sastry, "The COPS (Common Open Policy Service) Protocol", RFC 2748, January 2000.
- [COPS-PR] Chan, K., Durham, D., Gai, S., Herzog, S., McCloghrie, K., Reichmeyer, F., Seligson, J., Smith, A. and R. Yavatkar, "COPS Usage for Policy Provisioning", RFC 3084, March 2001.
- [SPPI] McCloghrie, K., Fine, M., Seligson, J., Chan, K., Hahn, S., Sahita, R., Smith, A. and F. Reichmeyer, "Structure of Policy Provisioning Information", RFC 3159, August 2001.
- [DSARCH] Carlson, M., Weiss, W., Blake, S., Wang, Z., Black, D. and E. Davies, "An Architecture for Differentiated Services", RFC 2475, December 1998.
- [DSFIELD] Nichols, K., Blake, S., Baker, F. and D. Black, "Definition of the Differentiated Services Field (DS Field) in the IPv4 and IPv6 Headers", RFC 2474, December 1998.
- [FR-PIB] Fine, M., McCloghrie, K., Seligson, J., Chan, K., Hahn, S., Sahita, R., Smith, A. and F. Reichmeyer, "Framework Policy Information Base", RFC 3318, March 2003.
- [RAP-FRAMEWORK] Yavatkar, R. and D. Pendarakis, "A Framework for Policy-based Admission Control", RFC 2753, January 2000.
- [SNMP-SMI] McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M. and S. Waldbusser, "Structure of Management Information Version 2 (SMIv2)", STD 58, RFC 2578, April 1999.
- [MODEL] Bernet, Y., Blake, S., Grossman, D. and A. Smith, "An Informal Management Model for Diffserv Routers", RFC 3290, May 2002.
- [IFMIB] McCloghrie, K. and F. Kastenholz, "The Interfaces Group MIB", RFC 2863, June 2000.
- [DS-MIB] Baker, F., Chan, K. and A. Smith, "Management Information Base for the Differentiated Services Architecture", RFC 3289, May 2002.
- [ACTQMGMT] Firoiu, V. and M. Borden, "A Study of Active Queue Management for Congestion Control", March 2000, In IEEE Infocom 2000,
http://www.ieee-infocom.org/2000/papers/405.pdf - [AQMROUTER] Misra, V., Gong, W. and D. Towsley, "Fluid-based analysis of a network of AQM routers supporting TCP flows with an application to RED", In SIGCOMM 2000,
http://www.acm.org/sigcomm/sigcomm2000/conf/paper/sigcomm2000-4-3.ps.gz - [AF-PHB] Heinanen, J., Baker, F., Weiss, W. and J. Wroclawski, "Assured Forwarding PHB Group", RFC 2597, June 1999.
- [EF-PHB] Jacobson, V., Nichols, K. and K. Poduri, "An Expedited Forwarding PHB", RFC 2598, June 1999.
- [INTSERVMIB] Baker, F., Krawczyk, J. and A. Sastry, "Integrated Services Management Information Base using SMIv2", RFC 2213, September 1997.
- [QUEUEMGMT] Braden, B., Clark, D., Crowcroft, J., Davie, B., Deering, S., Estrin, D., Floyd, S., Jacobson, V., Minshall, G., Partridge, C., Peterson, L., Ramakrishnan, K., Shenker, S., Wroclawski, J. and L. Zhang, "Recommendations on Queue Management and Congestion Avoidance in the Internet", RFC 2309, April 1998.
- [SRTCM] Heinanen, J. and R. Guerin, "A Single Rate Three Color Marker", RFC 2697, September 1999.
- [TRTCM] Heinanen, J. and R. Guerin, "A Two Rate Three Color Marker", RFC 2698, September 1999.
- [TSWTCM] Fang, W., Seddigh, N. and B. Nandy, "A Time Sliding Window Three Colour Marker", RFC 2859, June 2000.
- [RFC2026] Bradner, S., "The Internet Standards Process -- Revision 3", BCP 9, RFC 2026, October 1996.
- [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
- [RFC2579] McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M. and S. Waldbusser, "Textual Conventions for SMIv2", STD 58, RFC 2579, April 1999.
- [SHAPER] Bonaventure, O. and S. De Cnodder, "A Rate Adaptive Shaper for Differentiated Services", RFC 2963, October 2000.
- [POLTERM] Westerinen, A., Schnizlein, J., Strassner, J., Scherling, M., Quinn, B., Herzog, S., Huynh, A., Carlson, M., Perry, J. and S. Waldbusser, "Terminology for Policy-Based Management", RFC 3198, November 2001.
14. Authors' Addresses 💌
okay bestie, here are the four legends who wrote this 🫶 each one has their own little address card
Kwok Ho Chan
Nortel Networks, Inc.
600 Technology Park Drive
Billerica, MA 01821 USA
Phone: +1 978 288 8175
EMail: khchan@nortelnetworks.comRavi Sahita
Intel Labs.
2111 NE 25th Avenue
Hillsboro, OR 97124 USA
Phone: +1 503 712 1554
EMail: ravi.sahita@intel.comScott Hahn
Intel
2111 NE 25th Avenue
Hillsboro, OR 97124 USA
Phone: +1 503 264 8231
EMail: scott.hahn@intel.comKeith McCloghrie
Cisco Systems, Inc.
170 West Tasman Drive
San Jose, CA 95134-1706 USA
Phone: +1 408 526 5260
EMail: kzm@cisco.com15. Full Copyright Statement ©
Copyright (C) The Internet Society (2003). All Rights Reserved. 🔒✨
okay so the Internet Society owns the copyright here, and honestly the sharing rules are pretty generous 💖 anyone can copy this doc and pass it around, and they can write derivative works that comment on it, explain it, or help people implement it, and they can publish and distribute all of that however they like, in whole or in part, no restrictions of any kind. the one catch is that the copyright notice and this paragraph have to stay on every single copy and derivative work 🎀 the doc itself is a different story: you can't modify it in any way, which means no removing the copyright notice and no removing references to the Internet Society or other Internet organizations. the exceptions are when you're developing Internet standards (then you have to follow the copyright procedures in the Internet Standards process) or when you're translating it into a language that isn't English 🌍
the permissions above are perpetual 🦋 the Internet Society, its successors, and its assigns can't take them back
the document and the info in it are provided "AS IS", and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 💀
Acknowledgement 🙏
Funding for the RFC Editor function is currently provided by the Internet Society. 🌸
📦 where this page comes from
- ietf: rfc3317 2003-03
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms