draft-ietf-diffserv-mib-03.txt   draft-ietf-diffserv-mib-04.txt 
Internet Engineering Task Force F. Baker Internet Engineering Task Force F. Baker
Diffserv Working Group Cisco Systems Diffserv Working Group Cisco Systems
INTERNET-DRAFT K. Chan INTERNET-DRAFT K. Chan
Expires November 2000 Nortel Networks Expires January 2001 Nortel Networks
draft-ietf-diffserv-mib-03.txt A. Smith draft-ietf-diffserv-mib-04.txt A. Smith
Extreme Networks <editor>
Management Information Base for the Management Information Base for the
Differentiated Services Architecture Differentiated Services Architecture
Status of this Memo Status of this Memo
This document is an Internet-Draft and is in full conformance with all This document is an Internet-Draft and is in full conformance with all
provisions of Section 10 of RFC 2026. Internet-Drafts are working provisions of Section 10 of RFC 2026. Internet-Drafts are working
documents of the Internet Engineering Task Force (IETF), its areas, and documents of the Internet Engineering Task Force (IETF), its areas, and
its working groups. Note that other groups may also distribute working its working groups. Note that other groups may also distribute working
documents as Internet-Drafts. documents as Internet-Drafts.
skipping to change at page 1, line 40 skipping to change at page 1, line 41
diffserv@ietf.org. The charter for Differentiated Services may be found diffserv@ietf.org. The charter for Differentiated Services may be found
at http://www.ietf.org/html.charters/diffserv-charter.html at http://www.ietf.org/html.charters/diffserv-charter.html
Copyright (C) The Internet Society (2000). All Rights Reserved. Copyright (C) The Internet Society (2000). All Rights Reserved.
Distribution of this memo is unlimited. Distribution of this memo is unlimited.
Abstract Abstract
This memo describes a SMIv2 MIB for a device implementing the This memo describes a SMIv2 MIB for a device implementing the
Differentiated Services Architecture [DSARCH], described in detail by Differentiated Services Architecture [DSARCH], described in detail by
the Differentiated Services Router Conceptual Model [MODEL]. the Differentiated Services Router Informal Management Model [MODEL].
1. The SNMP Management Framework 1. The SNMP Management Framework
The SNMP Management Framework presently consists of five major The SNMP Management Framework presently consists of five major
components: components:
o An overall architecture, described in RFC 2571 [1]. o An overall architecture, described in RFC 2571 [1].
o Mechanisms for describing and naming objects and events for the o Mechanisms for describing and naming objects and events for the
purpose of management. The first version of this Structure of purpose of management. The first version of this Structure of
skipping to change at page 3, line 5 skipping to change at page 3, line 5
This memo specifies a MIB module that is compliant to the SMIv2. A MIB This memo specifies a MIB module that is compliant to the SMIv2. A MIB
conforming to the SMIv1 can be produced through the appropriate conforming to the SMIv1 can be produced through the appropriate
translations. The resulting translated MIB must be semantically translations. The resulting translated MIB must be semantically
equivalent, except where objects or events are omitted because no equivalent, except where objects or events are omitted because no
translation is possible (use of Counter64). Some machine-readable translation is possible (use of Counter64). Some machine-readable
information in SMIv2 will be converted into textual descriptions in information in SMIv2 will be converted into textual descriptions in
SMIv1 during the translation process. However, this loss of machine SMIv1 during the translation process. However, this loss of machine
readable information is not considered to change the semantics of the readable information is not considered to change the semantics of the
MIB. MIB.
2. Structure of this MIB 2. Introduction
This MIB is designed according to the Differentiated Services 2.1. Relationship to the Diffserv Informal Management Model
implementation conceptual model documented in [MODEL].
2.1. Overview This MIB is designed according to the Differentiated Services Informal
Management Model documented in [MODEL]. The model describes the way that
ingress and egress interfaces of an 'n'-port router are modelled. It
describes the configuration and management of a Diffserv interface in
terms of a Transmission Control Block (TCB) which contains, by
definition, zero or more classifiers, meters, actions, algorithmic
droppers, queues and schedulers. These elements are arranged according
to the QoS policy being expressed, always in that order. Traffic may be
classified; classified traffic may be metered; each stream of traffic
identified by a combination of classifiers and meters may have some set
of actions performed on it; it may have dropping algorithms applied and
it may ultimately be stored into a queue before being scheduled out to
its next destination, either onto a link or to another TCB. When the
treatment for a given packet must have any of those elements repeated in
a way that breaks the permitted sequence {classifier, meter, action,
algorithmic dropper, queue, scheduler}, this must be modelled by
cascading multiple TCBs.
The conceptual model [MODEL] discusses the way we model the ingress and The MIB represents this cascade by following the "Next" attributes of
egress interfaces of an 'n'-port router. In this MIB, we model these the various elements. They indicate what the next step in Diffserv
processing will be, whether it be a classifier, meter, action,
algorithmic dropper, queue, scheduler or a decision to now forward a
packet.
The MIB models the individual elements that make up the TCBs - it only
refers in passing to the higher-level concept of a TCB when it is
necessary to distinguish of which TCB, of several, a particular element
is a part. Literal TCBs are enumerated for Classifier elements: this is
necessary to distinguish different, but overlapping, classification
policies in different TCBs. However, TCBs are not enumerated for other
elements. When a TCB performs no classification the literal TCB of the
succeeding elements is not used in their instance (index) as there is no
need to distinguish them - each element is unique already.
2.2. Relationship to other MIBs and Policy Management
This MIB provides for direct reporting and manipulation of the most
detailed functional elements described by the Diffserv Informal
Management Model for management. These elements are instantiated in a
very detailed manner, typically indexed by interface, direction and
other indices. The concept of "interface" is as for the
InterfaceIndex/ifIndex of the IETF Interfaces MIB [IFMIB].
Other MIBs and data structure definitions for policy management
mechanisms other than SNMP/SMIv2 are likely to exist in the future for
the purposes of abstracting the model in other ways.
In particular, abstractions in the direction of less detailed
definitions of Diffserv functionality are likely e.g. some form of "Per-
Hop Behaviour"-based definition involving a template of detailed object
values which is applied to specific instances of objects in this MIB
semi-automatically.
Another possible direction of abstraction is one using a concept of
"roles" (often, but not always, applied to interfaces). In this case, it
may be possible to re-use the object definitions in this MIB but with
different indexing variables e.g. by mechanically replacing ifIndex by
some sort of "roleIndex". Work is ongoing in this area.
2.3. MIB Overview
In this MIB, we model the ingress and egress portions of a router
identically, making the distinction between them an index variable. identically, making the distinction between them an index variable.
Each interface then performs some or all of the following high-level Each interface then performs some or all of the following high-level
functions: functions:
o Classify each packet according to some set of rules o Classify each packet according to some set of rules
o Determine whether the data stream the packet is part of is within o Determine whether the data stream the packet is part of is within
or outside its rate or outside its rate
o Perform a set of resulting actions, possibly including counting the o Perform a set of resulting actions, possibly including counting the
skipping to change at page 4, line 5 skipping to change at page 5, line 14
Action Tables Action Tables
Absolute Drop, Mark and Count actions. The "multiplexer", Absolute Drop, Mark and Count actions. The "multiplexer",
"replicator" and "null" actions described in [MODEL] are "replicator" and "null" actions described in [MODEL] are
accomplished implicitly by means of the RowPointer structures of accomplished implicitly by means of the RowPointer structures of
the other elements. the other elements.
Queue, Scheduler and Algorithmic Dropper Tables Queue, Scheduler and Algorithmic Dropper Tables
Queue, Scheduler and Algorithmic Dropper Tables. Queue, Scheduler and Algorithmic Dropper Tables.
2.2. Classifiers 3. Structure of this MIB
3.1. Classifiers
The classifier and filter tables determine how traffic is sorted out. The classifier and filter tables determine how traffic is sorted out.
They identify separable classes of traffic, by reference to an They identify separable classes of traffic, by reference to an
appropriate filter, which may select anything from an individual micro- appropriate filter, which may select anything from an individual micro-
flow to aggregates identified by DSCP. flow to aggregates identified by DSCP.
The classification is used to send these separate streams to appropriate The classification is used to send these separate streams to appropriate
meters or action elements. For example, to indicate a multi-stage meter, Meter, Action, Queue, Scheduler and Algorithmic Dropper elements. For
sub-classes of traffic may be sent to different meter stages: e.g. in an example, to indicate a multi-stage meter, sub-classes of traffic may be
implementation of the Assured Forwarding (AF) PHB [AF-PHB], AF11 traffic sent to different meter stages: e.g. in an implementation of the Assured
might be sent to the first meter, AF12 traffic might be sent to the Forwarding (AF) PHB [AF-PHB], AF11 traffic might be sent to the first
second and AF13 traffic sent to the second meter stage's out-of-profile meter, AF12 traffic might be sent to the second and AF13 traffic sent to
action. the second meter stage's out-of-profile action.
2.2.1. Classifier Table 3.1.1. Classifier Table
The structure of the classifier table, as described in [MODEL], is a The structure of the classifier table, as described in [MODEL], is a
sequence of unambiguous tests. Within each stage in the sequence, it sequence of unambiguous tests. Within each stage in the sequence, it
must not be important in which order the tests are made. This is to must not be important in which order the tests are made. This is to
facilitate optimized implementations such as index trees. Order is facilitate optimized implementations such as index trees. Order is
present only to resolve ambiguity: for that reason the stage in the present only to resolve ambiguity: for that reason the stage in the
sequence is referred to here and in [MODEL] as the "precedence" of the sequence is referred to here and in [MODEL] as the "precedence" of the
classifier stage: stages with higher values of precedence are compared classifier stage: stages with higher values of precedence are compared
first; the order of tests for entries of the same precedence is first; the order of tests for entries of the same precedence is
unimportant. unimportant.
skipping to change at page 4, line 48 skipping to change at page 6, line 11
referenced via a RowPointer: this enables the use of any sort of filter referenced via a RowPointer: this enables the use of any sort of filter
table that one might wish to design, standard or proprietary. The filter table that one might wish to design, standard or proprietary. The filter
table may be, but does not need to be, defined in this MIB module. table may be, but does not need to be, defined in this MIB module.
The classifiers specified here are at the interface level i.e. they are The classifiers specified here are at the interface level i.e. they are
indexed by ifIndex: they may be derived from some more general policies indexed by ifIndex: they may be derived from some more general policies
e.g. something based on interface roles, but such discussion is outside e.g. something based on interface roles, but such discussion is outside
the scope of this document. See e.g. [POLTERM] section 4 for a the scope of this document. See e.g. [POLTERM] section 4 for a
discussion of Roles. discussion of Roles.
2.2.2. IP Six-Tuple Classifier Table 3.1.2. IP Six-Tuple Classifier Table
This MIB includes a definition for an IP Six-Tuple Classifier, used for This MIB includes a definition for an IP Six-Tuple Classifier, used for
IP traffic classification. Entries in this filter table are referenced IP traffic classification. Entries in this filter table are referenced
from the RowPointer diffServClassifierPattern attributes of classifier from the RowPointer diffServClassifierPattern attributes of classifier
table entries. table entries.
A Behavior Aggregate (BA) Classifier, acting only on DSCPs, is a simple A Behavior Aggregate (BA) Classifier, acting only on DSCPs, is a simple
form of the IP Six-Tuple Classifier. It is represented by having the form of the IP Six-Tuple Classifier. It is represented by having the
diffServSixTupleClfrDscp attribute set to the desired DSCP and all other diffServSixTupleClfrDscp attribute set to the desired DSCP and all other
classification attributes set to match-all, their default settings. The classification attributes set to match-all, their default settings. The
alternative approach of providing a specific definition in this MIB for alternative approach of providing a specific definition in this MIB for
a BA Classifier was discussed and rejected. a BA Classifier was discussed and rejected.
skipping to change at page 5, line 21 skipping to change at page 6, line 31
classification attributes set to match-all, their default settings. The classification attributes set to match-all, their default settings. The
alternative approach of providing a specific definition in this MIB for alternative approach of providing a specific definition in this MIB for
a BA Classifier was discussed and rejected. a BA Classifier was discussed and rejected.
Each entry in the IP Six-Tuple Classifier Table defines a single filter. Each entry in the IP Six-Tuple Classifier Table defines a single filter.
The textual convention of InetAddress [INETADDR] is used for both IPv4 The textual convention of InetAddress [INETADDR] is used for both IPv4
and IPv6 addressing. The use of IP Six-Tuple Classifiers is discussed and IPv6 addressing. The use of IP Six-Tuple Classifiers is discussed
in [DSARCH] and abstract examples of how they might be configured are in [DSARCH] and abstract examples of how they might be configured are
provided in [MODEL]. provided in [MODEL].
2.3. Meters 3.2. Meters
A meter, according to [MODEL] section 5, measures the rate at which A meter, according to [MODEL] section 5, measures the rate at which
packets making up a stream of traffic pass it, compares this rate to packets making up a stream of traffic pass it, compares this rate to
some set of thresholds and produces some number (two or more) of some set of thresholds and produces some number (two or more) of
potential results. A given packet is said to "conform" to the meter if, potential results. A given packet is said to "conform" to the meter if,
at the time that the packet is being looked at, the stream appears to be at the time that the packet is being looked at, the stream appears to be
within the meter's profile. MIB syntax makes it easiest to define this within the meter's profile. MIB syntax makes it easiest to define this
as a sequence of one or more cascaded pass/fail tests, modeled here as as a sequence of one or more cascaded pass/fail tests, modeled here as
if-then-else constructs. if-then-else constructs. It is important to understand that this way of
modelling does not imply anything about the implementation being
It is important to understand that this way of modelling does not imply "sequential": multi-rate/multi-profile meters e.g. those designed to
anything about the implementation being "sequential": multi-rate/multi- support [SRTCM] or [TRTCM], can still be modelled this way even if they,
profile meters e.g. those designed to support [SRTCM] or [TRTCM], can of necessity, share information between the stages: the stages are
still be modelled this way even if they, of necessity, share information introduced merely as a notational convenience in order to simplify the
between the stages: the stages are introduced merely as a notational MIB structure.
convenience in order to simplify the MIB structure.
2.3.1. Meter Table 3.2.1. Meter Table
The generic meter table is used as a base for all more specific forms of The generic meter table is used as a base for all more specific forms of
meter. The definition of the specific parameters of the meter to be meter. The definition of parameters specific to the type of meter used
used is referenced via a RowPointer: this enables the use of any sort of
specific meter table that one might wish to design, standard or
proprietary. The specific meter table may be, but does not need to be,
defined in this MIB module.
2.3.2. Token-Bucket Meter Table is referenced via a pointer to a table containing those specifics with
the instance within that table identified by the same indices as for the
base meter table. This enables the use of any sort of specific meter
table that one might wish to design, standard or proprietary. The
specific meter table may be, but does not need to be, defined in this
MIB module.
3.2.2. Token-Bucket Meter Table
This is included as an example of a common type of meter. Entries in This is included as an example of a common type of meter. Entries in
this table are referenced from the RowPointer diffServMeterSpecific this table are referenced from the RowPointer diffServMeterSpecific
attributes of meter table entries. The parameters are represented by a attributes of meter table entries. The parameters are represented by a
rate diffServTBMeterRate and a burst size diffServTBMeterBurstSize. rate diffServTBMeterRate and a burst size diffServTBMeterBurstSize.
2.4. Actions 3.3. Actions
Actions include "no action", "mark the traffic with a DSCP", "drop the Actions include "no action", "mark the traffic with a DSCP", "drop the
traffic" or "count it". Other tasks such as "shape the traffic" or "drop traffic" or "count it". Other tasks such as "shape the traffic" or "drop
based on some algorithm" are handled elsewhere as queueing mechanisms, based on some algorithm" are handled elsewhere as queueing mechanisms,
rather than actions, consistent with [MODEL]. The "multiplexer", rather than actions, consistent with [MODEL]. The "multiplexer",
"replicator" and "null" actions described in [MODEL] are accomplished "replicator" and "null" actions described in [MODEL] are accomplished
implicitly by means of the RowPointer structures of the other elements. implicitly by means of the RowPointer structures of the other elements.
This MIB uses the Action Table diffServActionTable to organize one This MIB uses the Action Table diffServActionTable to organize one
Action's relationship with the element(s) before and after it. It allows Action's relationship with the element(s) before and after it. It allows
Actions to be cascaded to enable multiple Actions be applied to a single Actions to be cascaded to enable multiple Actions be applied to a single
traffic stream by using each entry's diffServActionNext attribute. The traffic stream by using each entry's diffServActionNext attribute. The
last entry's diffServActionNext attribute may point to the next TCB diffServActionNext attribute of the last action entry in the chain
element, normally a Queueing element. points to the next element in the TCB, if any, e.g. a Queueing element.
It may also point at a next TCB.
The parameters needed for each Action element will depend on the type of The parameters needed for each Action element will depend on the type of
Action to be taken. Hence there are specific Action Tables for all the Action to be taken. Hence there are specific Action Tables for all the
different Action types. This flexibility allows additional Actions be different Action types. This flexibility allows additional Actions be
specified in future revisions of this MIB, or in other MIBs and also specified in future revisions of this MIB, or in other MIBs and also
allows for the use of proprietary Actions without impact on those allows for the use of proprietary Actions without impact on those
defined here. defined here.
2.4.1. DSCP Mark Action Table 3.3.1. DSCP Mark Action Table
This Action is applied to traffic in order to mark it with a Diffserv This Action is applied to traffic in order to mark it with a Diffserv
Codepoint (DSCP) value, specified in the diffServDscpMarkActTable. Codepoint (DSCP) value, specified in the diffServDscpMarkActTable.
Other marking actions might be specified elsewhere - these are outside Other marking actions might be specified elsewhere - these are outside
the scope of this MIB. the scope of this MIB.
2.4.2. Count Action Table 3.3.2. Count Action Table
Count Actions are used to count the traffic passing along a particular Count Actions are used to count the traffic passing along a particular
path through the model. If specified, they are likely to be placed path through the model. If specified, they are likely to be placed
first, before other types of Action. For example, when both a Count and first, before other types of Action. For example, when both a Count and
an Absolute Dropper Action are specified, the Count Action needs to an Absolute Dropper Action are specified, the Count Action needs to
count the traffic stream before any traffic gets dropped. Note that count the traffic stream before any traffic gets dropped. Note that
there are counters contained directly in Algorithmic Dropper elements to there are counters contained directly in Algorithmic Dropper elements to
indicate the amount of traffic dropped by those elements. indicate the amount of traffic dropped by those elements.
Counters are arranged in a single table but with separate conformance Counters are arranged in a single table but with separate conformance
statements for low-speed and high-speed interfaces, consistent with statements for low-speed and high-speed interfaces, consistent with
[IFMIB]. [IFMIB].
2.4.3. Absolute Drop Action 3.3.3. Absolute Drop Action
This action just silently discards all traffic presented to it, without This action just silently discards all traffic presented to it, without
counting it. This action has no additional parameters and so is counting it. This action has no additional parameters and so is
represented only as a diffServActionType of dropAlways without any represented only as a diffServActionSpecific pointing to
specific parameters (diffServActionSpecific value will be null). diffServAbsoluteDropAction without any specific parameters.
2.5. Queueing Elements 3.4. Queueing Elements
These include Algorithmic Droppers, Queues and Schedulers. These include Algorithmic Droppers, Queues and Schedulers which are all
inter-related in their use of queueing techniques.
2.5.1. Algorithmic Dropper Table 3.4.1. Algorithmic Dropper Table
Algorithmic Droppers have a close relationship with queueing: they are Algorithmic Droppers have a close relationship with queueing: they are
represented in this MIB by entries in an Algorithmic Dropper Table. represented in this MIB by entries in an Algorithmic Dropper Table.
Entries contain a "next" attribute which indicates to which queue they Entries contain a diffServAlgDropNext attribute which indicates to which
sink their traffic. They may also contain a pointer to specific detail queue they sink their traffic.
of the drop algorithm. This MIB only defines the detail for one drop
algorithm, Tail Drop; other algorithms are outside the scope of this MIB An Algorithmic Dropper is assumed to operate indiscriminately on all
but the general framework is intended to allow for their inclusion in packets that are presented at its input. If it is necessary to perform
other modules. additional classification on the stream then a separate TCB must be
introduced at this point: Classifier elements here can then distinguish
the different types of traffic on which dropping is to act and the
treatment for each type is described by a separate diffServAlgDropEntry.
Algorithmic Droppers may also contain a pointer to specific detail of
the drop algorithm. This MIB defines the detail for three drop
algorithms: Tail Drop, Head Drop and Random Drop; other algorithms are
outside the scope of this MIB modele but the general framework is
intended to allow for their inclusion via other MIB modules.
One generally-applicable parameter of a dropper is the specification of One generally-applicable parameter of a dropper is the specification of
a queue-depth threshold at which some drop action is to start. This is a queue-depth threshold at which some drop action is to start. This is
represented in this MIB, as a base attribute of the Algorithmic Dropper represented in this MIB, as a base attribute of the Algorithmic Dropper
entry, by pointing to the queue for which depth is to be compared and entry, by pointing to the queue for which depth is to be compared and
the threshold, in bytes, to compare against. the depth threshold to compare against.
<ed: is we need to represent a dropper as depending on multiple queues
then this single-queue pointer and threshold is not adequate: should we
leave them here or not? they will be useful for many, but not all,
dropper algorithms.>
o A Tail Dropper requires the specification of a maximum queue depth o A Tail Dropper requires the specification of a maximum queue depth
threshold: when the queue pointed at by diffServAlgDropQMeasure threshold: when the queue pointed at by diffServAlgDropQMeasure
reaches that depth threshold, diffServAlgDropQThresh, any new reaches that depth threshold, diffServAlgDropQThresh, any new
traffic arriving at the dropper is discarded. traffic arriving at the dropper is discarded. This algorithm uses
only parameters that are part of the diffServAlgDropEntry.
o Random Droppers require more detailed specification of the o A Head Dropper requires the specification of a maximum queue depth
characteristics of their drop functions. Representations of these threshold: when the queue pointed at by diffServAlgDropQMeasure
functions are outside the scope of this MIB although they should reaches that depth threshold, diffServAlgDropQThresh, traffic
use the available diffServAlgDropQMeasure and currently at the head of the queue is discarded. This algorithm
diffServAlgDropQThresh parameters where possible. uses only parameters that are part of the diffServAlgDropEntry.
<ed: should we keep this example (next 3 paragraphs) or not? It is not o Random Droppers are recommended as a way to control congestion, in
supported by the current MIB.> [QUEUEMGMT] and called for in the [AF-PHB]. Various implementations
As an example of a random dropper, RED-like droppers often have the exist, which agree on marking or dropping just enough traffic to
function described as a plot of drop probability (P) against communicate with TCP-like protocols about congestion avoidance, but
averaged queue length (Q). (Qmin,Pmin) defines the start of the differ markedly on their specific parameters. This MIB attempts to
characteristic plot. Normally Pmin=0, meaning with average queue offer a minimal set of controls for any random dropper, but expects
length below Qmin, there will be no drops. (Qmax,Pmax) defines a that vendors will augment the table with additional controls and
"knee" on the plot, after which point the drop probability become status in accordance with their implementation. This algorithm
more progressive (greater slope). (Qclip,1) defines the queue requires additional parameters on top of those in
length at which all packets will be dropped. Notice this is diffServAlgDropEntry: these are discussed below.
different from Tail Drop because this uses an averaged queue
length. It is possible for Qclip = Qmax.
The calculation of the averaged queue length may also have an 3.4.2. Random Dropper Table
important bearing on the behaviour of the dropper: parameters may
include the sampling interval and the weight of each sample. The
performance may be very sensitive to the values of these parameters
and a wide range of possible values may be required due to a wide
range of link speeds. There is ongoing research on this topic, see
e.g. [ACTQMGMT].
Deterministic Droppers can be viewed as a special case of Random One example of a random dropper is a RED-like dropper. An example of
the representation chosen in this MIB for this element is shown in
Figure 1.
Random droppers often have their drop probability function described as
a plot of drop probability (P) against averaged queue length (Q).
(Qmin,Pmin) then defines the start of the characteristic plot. Normally
Pmin=0, meaning with average queue length below Qmin, there will be no
drops. (Qmax,Pmax) defines a "knee" on the plot, after which point the
drop probability become more progressive (greater slope). (Qclip,1)
defines the queue length at which all packets will be dropped. Notice
this is different from Tail Drop because this uses an averaged queue
length. although it is possible for Qclip = Qmax. In the MIB module,
diffServRandomDropMinThreshBytes and diffServRandomDropMinThreshPkts
represent Qmin. diffServRandomDropMaxThreshBytes and
diffServRandomDropMaxThreshPkts represent Qmax.
+-------------+ +-----------+
--->| Next --------+-->| Next ---------> to Scheduler
| Thresh=100k | | | Min=none |
| Measure -------+ | Max=none |
| Type=random | | Pri=10 |
| Specif -------+ | Type=fifo |
+-------------+ | +-----------+
AlgDrop.3 | Queue.ifIndex.4
|
| +--------------+
+-->| Minthresh=10k|
| Maxthresh=80k|
| Weight=1/16 |
| ProbMax= 0.5 |
+--------------+
RandomDrop.3
Figure 1: Example Use of the RandomDropTable for Random Droppers
diffServRandomDropProbMax represents Pmax. This MIB does not represent
Pmin (assumed to be zero unless otherwise represented) or Qclip (assumed
to be Qmax unless otherwise represented).
Each random dropper specification is associated with a queue. This
allows multiple drop processes (of same or different types) be
associated with the same queue, as different PHB implementations may
require. This also allows for sequences of multiple droppers if
necessary.
The calculation of a smoothed queue length may also have an important
bearing on the behaviour of the dropper: parameters may include the
sampling interval and the weight of each sample. The performance may be
very sensitive to the values of these parameters and a wide range of
possible values may be required due to a wide range of link speeds. Most
algorithms include a sample weight, represented here by
diffServRandomDropInvWeight. Note however that there is ongoing research
on this topic, see e.g. [ACTQMGMT].
Additional parameters may be added in an enterprise MIB module, e.g. by
using AUGMENTS on this table, to handle aspects of random drop
algorithms that are not standardised here.
NOTE: Deterministic Droppers can be viewed as a special case of Random
Droppers with the drop probability restricted to 0 and 1. Hence Droppers with the drop probability restricted to 0 and 1. Hence
Deterministic Droppers might be described by a Random Dropper with Deterministic Droppers might be described by a Random Dropper with Pmin
Pmin = 0, Pmax = 1, Qmin = Qmax = Qclip, the averaged queue length
at which dropping occurs.
Each dropper specification is associated with a queue. This allows = 0, Pmax = 1, Qmin = Qmax = Qclip, the averaged queue length at which
multiple drop processes (of same or different types) be associated with dropping occurs.
the same queue, as different PHB implementations may require. This also
allows for sequences of multiple droppers if necessary.
2.5.2. Queues and Schedulers 3.4.3. Queues and Schedulers
The Queue Table models simple FIFO queues, as described in [MODEL] The Queue Table models simple FIFO queues, as described in [MODEL]
section 7.1.1. The Scheduler Table allows flexibility in constructing section 7.1.1. The Scheduler Table allows flexibility in constructing
both simple and somewhat more complex queueing hierarchies from those both simple and somewhat more complex queueing hierarchies from those
queues. Of course, since TCBs can be cascaded multiple times on an queues. Of course, since TCBs can be cascaded multiple times on an
interface, even more complex hierarchies can be constructed that way interface, even more complex hierarchies can be constructed that way
also. also.
The entries in the Queue Table have attributes which include a The entries in the Queue Table have attributes which include a
specification of the scheduler which services the queue. They are specification of the scheduler which services the queue. They are
skipping to change at page 9, line 46 skipping to change at page 12, line 19
reflected in the other. reflected in the other.
An input may also be capable of acting as a non-work-conserving [MODEL] An input may also be capable of acting as a non-work-conserving [MODEL]
traffic shaper: this is done by defining a Maximum Service Rate leaky- traffic shaper: this is done by defining a Maximum Service Rate leaky-
bucket profile in order to limit the scheduler bandwidth available to bucket profile in order to limit the scheduler bandwidth available to
that input. This is represented, similarly to the minimum rate, by a that input. This is represented, similarly to the minimum rate, by a
rate diffServQueueMaxRateAbs and a burst size diffServQueueMaxBurstSize. rate diffServQueueMaxRateAbs and a burst size diffServQueueMaxBurstSize.
The rate may, alternatively, be represented by a relative value, as a The rate may, alternatively, be represented by a relative value, as a
fraction of the interface's current line rate, diffServQueueMaxRateRel. fraction of the interface's current line rate, diffServQueueMaxRateRel.
2.5.3. Example of Algorithmic Droppers, Queues and Schedulers 3.4.4. Example of Algorithmic Droppers, Queues and Schedulers
As an example, the hypothetical queue/scheduler configuration shown in As an example, the hypothetical queue/scheduler configuration shown in
[MODEL] section 8.1 is shown in Table 1. [MODEL] section 8.1 is shown in Table 1.
Queues 1 and 3 are serviced for long enough to give them their promised
bandwidths and burst sizes, if they need them. Queue 2 is then serviced
up to its maximum limit profile. Only then does Queue 4 get an
opportunity to send its traffic. As an example of the use of the MIB
structures, Figure 2 shows how the example would be represented.
QId MinRate MaxRate Priority Scheduler QId MinRate MaxRate Priority Scheduler
--- ---------------- ---------------- -------- --------- --- ---------------- ---------------- -------- ---------
1 100kbps/20kbyte none/none 20 Scheduler.1 1 100kbps/20kbyte none/none 20 Scheduler.1
2 none/none 100kbps/100kbyte 40 Scheduler.1 2 none/none 100kbps/100kbyte 40 Scheduler.1
3 200kbps/20kbyte none/none 20 Scheduler.1 3 200kbps/20kbyte none/none 20 Scheduler.1
4 none/none none/none 10 Scheduler.1 4 none/none none/none 10 Scheduler.1
SchedId Type SchedId Type
------- ------------------ ------- ------------------
1 weightedRoundRobin 1 weightedRoundRobin
Table 1: Example Queue and Scheduler Parameters Table 1: Example Queue and Scheduler Parameters
Queues 1 and 3 are serviced for long enough to give them their promised
bandwidths and burst sizes, if they need them. Queue 2 is then serviced
up to its maximum limit profile. Only then does Queue 4 get an
opportunity to send its traffic. As an example of the use of the MIB
structures, Figure 1 shows how the example would be represented.
2.5.4. Example of extending this MIB
<ed: is it worth having this example here?>
One way to extend this MIB structure to accomodate a more complex
dropping algorithm might be to define a specific dropper table in
another MIB module, pointed at by diffServAlgDropSpecific, containing
its own parameters, as shown in figure 2. This algorithm might depend
for its operation e.g. on feedback of a queue's depth but pre-processed
by some type of smoothing function with its own parameters. The extended
table could still use some of the fields of the standard Algorithmic
Dropper Table, if relevant, although any divergent uses would have to be
well-documented in the extended MIB.
2.6. The use of RowPointer
RowPointer is a textual convention used to identify a conceptual row in
an SNMP Table by pointing to one of its objects. In this MIB, it is used
in two ways: to indicate indirection and to indicate succession.
When used for indirection, as in the diffServClassifierTable, the idea
is to allow other MIBs, including proprietary ones, to identify new and
arcane classifiers - MAC headers, IP4 and IP6 headers, BGP Communities
and all sorts of other things.
When used for succession, it answers the question "what happens next?".
Rather than presume that the next table must be as specified in the
+-----------+ +-----------+
----------------------->| Next -----+ ----------------------->| Next -----+
| Min=Profl4| | | Min=Profl4| |
| Max=none | | | Max=none | |
| Pri=20 | | | Pri=20 | |
| Type=fifo | | | Type=fifo | |
+-----------+ | +-----------+ |
Queue.ifIndex.1 | Queue.ifIndex.1 |
| |
+-----------+ +-----------+ | +-----------+ +-----------+ |
skipping to change at page 11, line 40 skipping to change at page 13, line 40
| |
+-----------+ +-----------+ | +-----------+ +-----------+ |
--->| Next ------+--->| Next -----+ --->| Next ------+--->| Next -----+
| Thresh=4k | | | Min=none | | Thresh=4k | | | Min=none |
| Measure -----+ | Max=none | | Measure -----+ | Max=none |
| Type=Tail | | Pri=10 | | Type=Tail | | Pri=10 |
| Spec=none | | Type=fifo | | Spec=none | | Type=fifo |
+-----------+ +-----------+ +-----------+ +-----------+
Dropper.3 Queue.ifIndex.4 Dropper.3 Queue.ifIndex.4
Figure 1: Example of the use of Queueing elements Figure 2: Example of the use of Queueing elements
+-----------+ +-----------+
--->| Next ------+--->| Next ---------> to Scheduler
| Thresh=X | | | Min=none |
| Measure -----+ | Max=none |
| Type=Ext | | Pri=10 |
| Spec -----+ | Type=fifo |
+-----------+ | +-----------+
Dropper.3 | Queue.ifIndex.4
|
| +-------------+
+--->|Smooth1=10 |
|Smooth2=2000 |
| <etc.> |
+-------------+
DropperExt.3
Figure 2: Example of extending the MIB for more complex droppers 4. Conventions used in this MIB
4.1. The use of RowPointer
RowPointer is a textual convention used to identify a conceptual row in
an SNMP Table by pointing to one of its objects. In this MIB, it is used
in two ways: to indicate indirection and to indicate succession.
When used for indirection as in the diffServClassifierTable, the idea is
to allow other MIBs, including proprietary ones, to define new and
arcane classifiers - MAC headers, IPv4 and IPv6 headers, BGP Communities
and all sorts of other things - whilst still utilising the structures of
this MIB. This is a form of class inheritance (in "object oriented"
language): it allows base object definitions ("classes") to be extended
in proprietary or standard ways, in the future, by other documents.
When used for succession, it answers the question "what happens next?".
Rather than presume that the next table must be as specified in the
conceptual model [MODEL] and providing its index, the RowPointer takes conceptual model [MODEL] and providing its index, the RowPointer takes
you to the MIB row representing that thing. In the diffServMeterTable, you to the MIB row representing that thing. In the diffServMeterTable,
for example, the diffServMeterFailNext RowPointer might take you to for example, the diffServMeterFailNext RowPointer might take you to
another meter, while the diffServMeterSucceedNext RowPointer would take another meter, while the diffServMeterSucceedNext RowPointer would take
you to an action. you to an action.
The RowPointer construct is used to build the TCBs described in [MODEL]: NOTE -- the RowPointer construct is used to build the TCBs
this MIB does not model TCBs directly - it operates at a lower level of described in [MODEL]: this MIB does not model TCBs directly - it
abstraction using only individual elements, connected in succession by operates at a lower level of abstraction using only individual
RowPointers. Therefore, the concept of TCBs enclosed in other more elements, connected in succession by RowPointers. Therefore, the
functional TCBs is not applicable to this MIB, although such a concept concept of TCBs enclosing individual functional datapath elements
may be employed by management tools that use this MIB. is not applicable to this MIB, although such a concept may be
employed by management tools that use this MIB.
3. Editorial information It is possible that a path through a device following a set of
RowPointers is indeterminate i.e. it ends in a dangling RowPointer (or
potentially does in the case of a Meter element) should be treated by
the agent as if it were operationally deactivated. For example, if an
Action element has a dangling diffServActionNext RowPointer that does
not point to an existent table entry (and is not zeroDotZero), then none
of the subsequent elements in that particular chain should have any
effect on the traffic proceeding down this chain and the Classification
or Meter element which lead to this Action element is not considered to
be active. Other parts of the device configuration remain in effect, of
course, but this rule simply removes all ambiguity from the operational
system.
4.2. Conceptual row creation and deletion
A number of conceptual tables defined in this MIB use as an index an
arbitrary integer value, unique across the scope of the agent. In order
to help with multi-manager row-creation problems, a mechanism must be
provided to allow a manager to obtain unique values for such an index
and to ensure that, when used, the manager knows whether it got what it
wanted or not.
Typically, such a table has an associated NextFree variable e.g.
diffServClassifierNextFree which provides a suitable value for the index
of the next row to be created e.g. diffServClassifierId. A special
value, 0, is used to indicate that no more entries can be created by the
agent. The table also has a columnar Status attribute with RowStatus
syntax [6].
If a manager attempts to create a conceptual row in the table (by a SET
operation that contains a varbind setting the Status to a value of
either createAndGo or createAndWait) and if the agent has sufficient
resources and has no other conceptual row with the same indices, the
agent will create the row and return success. If the agent has
insufficient resources or such a row is already existent then it returns
an error. A manager must be prepared to try again in such circumstances,
probably by re-reading the NextFree to obtain a new index value in case
a second manager had got in between the first manager's read of the
NextFree value and the first manager's row-creation attempt. The use of
RowStatus is covered in more detail in [6].
5. Editorial information
<this section will be removed before publication> <this section will be removed before publication>
3.1. Open Issues resolved in this draft 5.1. Open Issues resolved in previous drafts
(0) Terminology is more in line with [MODEL], [POLTERM] and [DSTERM]. (0) Terminology is more in line with [MODEL], [POLTERM] and [DSTERM].
Discarder -> "Algorithmic Dropper", "Monitor" -> "Counter" Discarder -> "Algorithmic Dropper", "Monitor" -> "Counter"
"Classifier element" -> "Filter" "Classifier element" -> "Filter"
(1) Cascaded token-buckets is not equivalent to multi-rate token- (1) Cascaded token-buckets is not equivalent to multi-rate token-
bucket: do we need to fix this by allowing a multi-rate TB in the bucket: do we need to fix this by allowing a multi-rate TB in the
MIB? Or, by defining cascaded buckets to mean "multi-rate". (assume MIB? Or, by defining cascaded buckets to mean "multi-rate". (assume
the latter - see text in 2.3) the latter - see text in 2.3)
skipping to change at page 14, line 38 skipping to change at page 17, line 12
statements sort out which ones must be implemented. This is statements sort out which ones must be implemented. This is
consistent with [IFMIB]. DONE. consistent with [IFMIB]. DONE.
(13) Droppers: we used to have a common "dropper" table that represented (13) Droppers: we used to have a common "dropper" table that represented
all of: dropAlways, randomDrop, tailDrop with just some parameters all of: dropAlways, randomDrop, tailDrop with just some parameters
valid for the simpler ones. A simpler representation is to define valid for the simpler ones. A simpler representation is to define
specific dropper tables for each type (e.g. a single OID to point specific dropper tables for each type (e.g. a single OID to point
at for dropAlways since it is always the last action in a chain) at for dropAlways since it is always the last action in a chain)
but this would mean a larger number of (simpler) MIB objects. but this would mean a larger number of (simpler) MIB objects.
CHANGES: dropAlways is still an Action but the others are moved to CHANGES: dropAlways is still an Action but the others are moved to
a diffServAlgDropTable. This table can handle tail/head drop. Other a diffServAlgDropTable. This table can handle tail/head/random drop
algorithms, specifically RED, are out of scope for now but can be - others by extension.
added using the framework defined here.
(14) Should TBMeterTable just AUGMENT the MeterTable, should it use same (14) Should TBMeterTable just AUGMENT the MeterTable, should it use same
indices or are separate structures linked by RowPointers indices or are separate structures linked by RowPointers
preferable? SAME INDICES - DONE. preferable? (same indices without RowPointer).
(15) Do we need to model multiple queues feeding back into a single (15) Do we need to model multiple queues feeding back into a single
dropper algorithm? (yes). If so, the current single-queue pointer dropper algorithm? (yes). If so, the current single-queue pointer
and threshold will not be adequate - should we leave them in? They and threshold will not be adequate - should we leave them in? They
will be useful for many, but not all, dropper algorithms. (yes) will be useful for many, but not all, dropper algorithms. (yes)
(17) We have concepts of "inbound" and "outbound" directions: but if we (17) We have concepts of "inbound" and "outbound" directions: but if we
have a series of multiple TCBs on a given interface for the same have a series of multiple TCBs on a given interface for the same
direction (allowed by the model) then we do not have a way to direction (allowed by the model) then we do not have a way to
indicate "this is the 1st one". Moreover, it is a somewhat indicate "this is the 1st one". Moreover, it is a somewhat
convoluted process to then find the 2nd, 3rd etc. ones - you would convoluted process to then find the 2nd, 3rd etc. ones - you would
have to follow the RowPointers to get there: should we explicitly have to follow the RowPointers to get there: should we explicitly
have an index to enable/help these lookup operations? Note: this is have an index to enable/help these lookup operations? Note: this is
not the same issue as needing a "precedence" for each filter entry not the same issue as needing a "precedence" for each filter entry
of a classifier (yes) - added another index to classifiers to of a classifier (yes - added another index to classifiers to
represent what "level" they operate at for a given represent what TCB they operate at for a given
interface/direction. interface/direction).
3.2. Still Open Issues 5.2. Open Issues resolved in this draft
(16) How should the creation of counter actions be under the control of (13) Droppers: slight change to previous resolution. MIB can now handle
manager or agent: should a diffServActionEntry and tail/head/random drop using diffServAlgDropTable and
diffServCountActEntry appear by magic (the device surely knows what diffServRandomDropTable.
counters it can and cannot maintain on a given interface)? (assume
no) If not, should diffServCountActEntry appear magically when a
diffServAction element is created which points at the
diffServCountActTable (then would be no need for
diffServCountActStatus)? (assume no)
(18) Should manager be allowed to create Queue elements or should agent (18) Should manager be allowed to create Queue elements or should agent
be in control of this? (the former) be in control of this? (the former)
(19) Should manager be allowed to create Scheduler elements or should (19) Should manager be allowed to create Scheduler elements or should
agent be in control of this? (the former) agent be in control of this? (the former)
(20) Related to (17) above, do we also need a "level" index for elements (20) Related to (17) above, do we also need a "TCB index" for elements
other than classifiers? (no) other than classifiers? (no)
(21) Do we need diffServAlgDropType of both "headDrop" and "tailDrop" or (21) Do we need diffServAlgDropType of both "headDrop" and "tailDrop" or
should we just represent the tail dropper by placing a dropper should we just represent the tail dropper by placing a dropper
after the queue instead of before the queue, as linked by the after the queue instead of before the queue, as linked by the
diffServQNext and diffServAlgDropNext RowPointers? (the former). diffServQNext and diffServAlgDropNext RowPointers? (the former -
dropper is always in front of the queue in this model).
(22) Do we need to support RED algorithms for algorithm parameter (22) Do we need to support RED algorithms for algorithm parameter
configuration and monitoring? If so, what variables are needed? configuration and monitoring? If so, what variables are needed?
(Added diffServRandomDropTable).
4. MIB Definition (24) diffServAlgDropQThreshold needs UNITS (Bytes).
(25) Dangling RowPointers: should we mandate that these are never
permitted? Or just define the behaviour if they do dangle? (We
define it such that elements that have dangling pointers, as well
as upstream elements that point to them, are considered "not
activated")
(26) Discontinuity times for MIB counters - is
ifCounterDiscontinuityTime adequate? (no: added
diffServCountActDiscontTime).
(27) How do we handle dropper algorithms that require additional
classification information in order to do their job? If a
Classifier is needed then create a new TCB for it at the point just
before the dropper: use ordinary Classifier elements in this TCB.
(28) Indexing of table entries and uniqueness hints: is TestAndIncr the
correct tool to use? (no: RowStatus is the right tool for ensuring
uniqueness; use a NextFree variable as a hint).
(32) Miscellaneous clarifications - thanks Bob.
5.3. Still Open Issues
(16) Should the creation of counter actions be under the control of
manager or agent: should a diffServActionEntry and
diffServCountActEntry appear by magic (does the agent know what
counters it can and cannot maintain on a given interface)? (no) If
no, should diffServCountActEntry appear magically when a
diffServAction element is created which points at the
diffServCountActTable (then would be no need for
diffServCountActStatus)? (no)
(23) Do daughter entries of derived table entries need to exist
independently of the parent? Examples are
diffServMeterEntry/diffServTBMeterEntry,
diffServActionEntry/diffServCountActEntry and
diffServAlgDropEntry/diffServRandomDropEntry (assume they must be
independent of the equivalent entry in diffServMeterTable which
points at the TB table - needs diffServTBMeterStatus: daughters
must be created explicitly by manager).
(30) Related to (17) - multi-manager creation of TCBs:
diffServClassifierId is unique across the agent, for all values of
diffServClassifierTcb but there is no "next free" variable to
report the next TCB to use. This can lead to a race condition when
2 managers are duelling to create entries with the same value of
diffServClassifierTcb. There are also legitimate reasons for
different managers to be "creating" the *same* TCB so a
conventional "next free" is not a good solution. Is this a rare
enough occurence given a suitable choice of diffServClassifierTcb
e.g. pseudo-random? (yes).
(31) When inheritance is needed and parent/daughter share indexing, the
parent often points to the daughter using a "Specific" attribute
e.g. diffServMeterSpecific, diffServActionSpecific,
diffServAlgDropSpecific. If this is a RowPointer and points to the
associated row in the daughter's table, there is redundant
information which gives scope for additional error cases. So,
wherever possible, should we remove this redundant information by
making the "Specific" attribute point only to the base of the
daughter table and make it an OBJECT IDENTIFIER? The con is that
this is an unusual use of MIB pointers (point at table base, not
individual entries).
6. MIB Definition
DIFF-SERV-MIB DEFINITIONS ::= BEGIN DIFF-SERV-MIB DEFINITIONS ::= BEGIN
IMPORTS IMPORTS
Unsigned32, Counter32, Counter64, OBJECT-TYPE, Unsigned32, Counter32, Counter64, OBJECT-TYPE,
MODULE-IDENTITY, OBJECT-IDENTITY, zeroDotZero, mib-2 MODULE-IDENTITY, OBJECT-IDENTITY, zeroDotZero, mib-2
FROM SNMPv2-SMI FROM SNMPv2-SMI
TEXTUAL-CONVENTION, RowStatus, RowPointer, TestAndIncr TEXTUAL-CONVENTION, RowStatus, RowPointer, TimeStamp
FROM SNMPv2-TC FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP MODULE-COMPLIANCE, OBJECT-GROUP
FROM SNMPv2-CONF FROM SNMPv2-CONF
ifIndex ifIndex
FROM IF-MIB FROM IF-MIB
InetAddressType, InetAddress InetAddressType, InetAddress
FROM INET-ADDRESS-MIB FROM INET-ADDRESS-MIB
BurstSize BurstSize
FROM INTEGRATED-SERVICES-MIB; FROM INTEGRATED-SERVICES-MIB;
diffServMib MODULE-IDENTITY diffServMib MODULE-IDENTITY
LAST-UPDATED "200005110000Z" LAST-UPDATED "200007130000Z"
ORGANIZATION "IETF Diffserv WG" ORGANIZATION "IETF Diffserv WG"
CONTACT-INFO CONTACT-INFO
" Brian Carpenter (co-chair of Diffserv WG) " Brian Carpenter (co-chair of Diffserv WG)
c/o iCAIR c/o iCAIR
1890 Maple Ave, #150 1890 Maple Ave, #150
Evanston, IL 60201, USA Evanston, IL 60201, USA
Phone: +1 847 467 7811 Phone: +1 847 467 7811
E-mail: brian@icair.org E-mail: brian@icair.org
Kathie Nichols (co-chair of Diffserv WG) Kathleen Nichols (co-chair of Diffserv WG)
Cisco Systems Packet Design
170 W. Tasman Drive E-mail: nichols@packetdesign.com
San Jose, CA 95134-1706, USA
Phone: +1 408 525 4857
E-mail: kmn@cisco.com
Fred Baker (author) Fred Baker (author)
Cisco Systems Cisco Systems
519 Lado Drive 519 Lado Drive
Santa Barbara, CA 93111, USA Santa Barbara, CA 93111, USA
E-mail: fred@cisco.com E-mail: fred@cisco.com
Kwok Ho Chan (author) Kwok Ho Chan (author)
Nortel Networks Nortel Networks
600 Technology Park Drive 600 Technology Park Drive
Billerica, MA 01821, USA Billerica, MA 01821, USA
E-mail: khchan@nortelnetworks.com E-mail: khchan@nortelnetworks.com
Andrew Smith (author) Andrew Smith (author)
Extreme Networks E-mail: ah_smith@pacbell.net"
3585 Monroe St.
Santa Clara, CA 95051, USA
E-mail: andrew@extremenetworks.com"
DESCRIPTION DESCRIPTION
"This MIB defines the objects necessary to manage a device that "This MIB defines the objects necessary to manage a device that
uses the Differentiated Services Architecture described in RFC uses the Differentiated Services Architecture described in RFC
2475 and the Conceptual Model for DiffServ Routers in draft-ietf- 2475 and the Informal Management Model for DiffServ Routers in
diffserv-model-03.txt." draft-ietf-diffserv-model-04.txt."
REVISION "200005110000Z" REVISION "200007130000Z"
DESCRIPTION DESCRIPTION
"Initial version, published as RFC xxxx." "Initial version, published as RFC xxxx."
::= { mib-2 12345 } -- anybody who uses this unassigned ::= { mib-2 12345 } -- anybody who uses this unassigned
-- number deserves the wrath of IANA -- number deserves the wrath of IANA
diffServObjects OBJECT IDENTIFIER ::= { diffServMib 1 } diffServObjects OBJECT IDENTIFIER ::= { diffServMib 1 }
diffServTables OBJECT IDENTIFIER ::= { diffServMib 2 } diffServTables OBJECT IDENTIFIER ::= { diffServMib 2 }
diffServMIBConformance OBJECT IDENTIFIER ::= { diffServMib 3 } diffServMIBConformance OBJECT IDENTIFIER ::= { diffServMib 3 }
-- These textual conventions have no effect on either the syntax -- These textual conventions have no effect on either the syntax
skipping to change at page 19, line 22 skipping to change at page 22, line 22
-- The Classifier Table allows us to enumerate the relationship -- The Classifier Table allows us to enumerate the relationship
-- between arbitrary classifiers and the subsequent downstream -- between arbitrary classifiers and the subsequent downstream
-- Diffserv elements. -- Diffserv elements.
diffServClassifierTable OBJECT-TYPE diffServClassifierTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServClassifierEntry SYNTAX SEQUENCE OF DiffServClassifierEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The classifier table defines the classifiers that a system "The classifier table defines the classifiers that are applied to
applies to incoming traffic. Specific classifiers are defined by traffic arriving at this interface in a particular direction.
RowPointers in the entries of this table which identify entries Specific classifiers are defined by RowPointers in the entries of
in filter tables of specific types, e.g. Multi-Field Classifiers this table which identify entries in filter tables of specific
(MFCs) for IP are defined in the diffServSixTupleClfrTable. Other types, e.g. Multi-Field Classifiers (MFCs) for IP are defined in
classifier types may be defined elsewhere." the diffServSixTupleClfrTable. Other classifier types may be
defined elsewhere."
REFERENCE REFERENCE
"[MODEL] section 4.1" "[MODEL] section 4.1"
::= { diffServTables 1 } ::= { diffServTables 1 }
diffServClassifierEntry OBJECT-TYPE diffServClassifierEntry OBJECT-TYPE
SYNTAX DiffServClassifierEntry SYNTAX DiffServClassifierEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the classifier table describes a single element of "An entry in the classifier table describes a single element of
the classifier." the classifier."
INDEX { ifIndex, diffServClassifierIfDirection, INDEX { ifIndex, diffServClassifierIfDirection,
diffServClassifierLevel, diffServClassifierId } diffServClassifierTcb, diffServClassifierId }
::= { diffServClassifierTable 1 } ::= { diffServClassifierTable 1 }
DiffServClassifierEntry ::= SEQUENCE { DiffServClassifierEntry ::= SEQUENCE {
diffServClassifierIfDirection IfDirection, diffServClassifierIfDirection IfDirection,
diffServClassifierLevel Unsigned32, diffServClassifierTcb Unsigned32,
diffServClassifierId INTEGER, diffServClassifierId Unsigned32,
diffServClassifierFilter RowPointer, diffServClassifierFilter RowPointer,
diffServClassifierNext RowPointer, diffServClassifierNext RowPointer,
diffServClassifierPrecedence Unsigned32, diffServClassifierPrecedence Unsigned32,
diffServClassifierStatus RowStatus diffServClassifierStatus RowStatus
} }
diffServClassifierIfDirection OBJECT-TYPE diffServClassifierIfDirection OBJECT-TYPE
SYNTAX IfDirection SYNTAX IfDirection
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the direction for this classifier entry on the "Specifies the direction for which this classifier entry applies
interface." on this interface."
::= { diffServClassifierEntry 1 } ::= { diffServClassifierEntry 1 }
diffServClassifierLevel OBJECT-TYPE diffServClassifierTcb OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the level of the TCB of which this classifier element "Specifies the TCB of which this classifier element is a part.
is a part. Lower numbers indicate an element that belongs to a Lower numbers indicate an element that belongs to a classifier
classifier that is part of a TCB that is applied to traffic that is part of a TCB that is, at least conceptually, applied to
before those with higher numbers." traffic before those with higher numbers - this is necessary to
resolve ambiguity in cases where different TCBs contain filters
that overlap with each other.
A manager wanting to create a new TCB should either first search
this table for existing entries and pick a value for this
variable that is not currently represented - some form of pseudo-
random choice is likely to minimise collisions. After successful
creation of a conceptual row using the chosen value, the manager
should check again that there are no other rows with this value
that have been created by a different manager that could,
potentially, interfere with the classifier elements that are
desired."
::= { diffServClassifierEntry 2 } ::= { diffServClassifierEntry 2 }
diffServClassifierId OBJECT-TYPE diffServClassifierId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"A classifier ID that enumerates the classifier elements. The set "A classifier ID that enumerates the classifier elements. The set
of such identifiers spans the whole agent - managers should of such identifiers spans the whole agent. Managers should obtain
obtain new values for row creation in this table by using new values for row creation in this table by reading
diffServClassifierUnique." diffServClassifierNextFree."
::= { diffServClassifierEntry 3 } ::= { diffServClassifierEntry 3 }
diffServClassifierFilter OBJECT-TYPE diffServClassifierFilter OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"A pointer to a valid entry in another table that describes the "A pointer to a valid entry in another table that describes the
applicable classification filter, e.g. an entry in applicable classification filter, e.g. an entry in
diffServSixTupleClfrTable. If the row pointed to does not exist, diffServSixTupleClfrTable. If the row pointed to does not exist,
skipping to change at page 21, line 12 skipping to change at page 24, line 25
DEFVAL { zeroDotZero } DEFVAL { zeroDotZero }
::= { diffServClassifierEntry 4 } ::= { diffServClassifierEntry 4 }
diffServClassifierNext OBJECT-TYPE diffServClassifierNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This selects the next datapath element to handle packets "This selects the next datapath element to handle packets
matching the filter pattern. For example, this can point to an matching the filter pattern. For example, this can point to an
entry in a meter or action table." entry in a meter, action, algorithmic dropper or queue table.
If the row pointed to does not exist, the classifier element is
ignored."
::= { diffServClassifierEntry 5 } ::= { diffServClassifierEntry 5 }
diffServClassifierPrecedence OBJECT-TYPE diffServClassifierPrecedence OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The relative precedence in which classifiers are applied: higher "The relative precedence in which classifiers are applied: higher
numbers represent classifiers with higher precedence. numbers represent classifiers with higher precedence.
Classifiers with the same precedence must be unambiguous i.e. Classifiers with the same precedence must be unambiguous i.e.
they must define non-overlapping patterns. Classifiers with they must define non-overlapping patterns, and are considered to
be applied simultaneously to the traffic stream. Classifiers with
different precedence may overlap in their filters: the classifier different precedence may overlap in their filters: the classifier
with the highest precedence that matches is taken. with the highest precedence that matches is taken.
On a given interface, there must be a complete classifier in On a given interface, there must be a complete classifier in
place at all times. This means that there must be always be one place at all times for the first TCB (lowest value of
or more filters that match every possible pattern that could be diffServClassifierTcb) in the ingress direction. This means that
presented in an inclming packet." 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 for subsequent TCBs in the ingress
direction, nor for any TCB in the egress direction."
DEFVAL { 0 } DEFVAL { 0 }
::= { diffServClassifierEntry 6 } ::= { diffServClassifierEntry 6 }
diffServClassifierStatus OBJECT-TYPE diffServClassifierStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of a classifier. Any writable variable may be modified deletion of a classifier. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServClassifierEntry 7 } ::= { diffServClassifierEntry 7 }
diffServClassifierUnique OBJECT-TYPE diffServClassifierNextFree OBJECT-TYPE
SYNTAX TestAndIncr SYNTAX Unsigned32
MAX-ACCESS read-write MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The diffServClassifierUnique object yields a unique new value "This object yields a value when read that is currently-unused
for diffServClassifierId when read and subsequently set. This for a diffServClassifierId instance. If a configuring system
value must be tested for uniqueness and can be used by a attempts to create a new row in the diffServClassifierTable using
configuring system to obtain a unique value for this value, that operation will fail if the value has, in the
diffServClassifierId for purposes of row creation in the meantime, been used to create another row that is currently
diffServClassifierTable." valid."
::= { diffServObjects 1 } ::= { diffServObjects 1 }
-- --
-- IP Six-Tuple Classification Table -- IP Six-Tuple Classification Table
-- --
-- Classification based on 6 different fields in the IP -- Classification based on 6 different fields in the IP
-- header. This is intended to be IP-version-independent. -- header. This is intended to be IP-version-independent.
-- --
diffServSixTupleClfrTable OBJECT-TYPE diffServSixTupleClfrTable OBJECT-TYPE
skipping to change at page 22, line 37 skipping to change at page 26, line 11
diffServSixTupleClfrEntry OBJECT-TYPE diffServSixTupleClfrEntry OBJECT-TYPE
SYNTAX DiffServSixTupleClfrEntry SYNTAX DiffServSixTupleClfrEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An IP Six-Tuple Classifier entry describes a single filter." "An IP Six-Tuple Classifier entry describes a single filter."
INDEX { diffServSixTupleClfrId } INDEX { diffServSixTupleClfrId }
::= { diffServSixTupleClfrTable 1 } ::= { diffServSixTupleClfrTable 1 }
DiffServSixTupleClfrEntry ::= SEQUENCE { DiffServSixTupleClfrEntry ::= SEQUENCE {
diffServSixTupleClfrId INTEGER, diffServSixTupleClfrId Unsigned32,
diffServSixTupleClfrDstAddrType InetAddressType, diffServSixTupleClfrDstAddrType InetAddressType,
diffServSixTupleClfrDstAddr InetAddress, diffServSixTupleClfrDstAddr InetAddress,
diffServSixTupleClfrDstAddrMask Unsigned32, diffServSixTupleClfrDstAddrMask Unsigned32,
diffServSixTupleClfrSrcAddrType InetAddressType, diffServSixTupleClfrSrcAddrType InetAddressType,
diffServSixTupleClfrSrcAddr InetAddress, diffServSixTupleClfrSrcAddr InetAddress,
diffServSixTupleClfrSrcAddrMask Unsigned32, diffServSixTupleClfrSrcAddrMask Unsigned32,
diffServSixTupleClfrDscp Dscp, diffServSixTupleClfrDscp Dscp,
diffServSixTupleClfrProtocol INTEGER, diffServSixTupleClfrProtocol INTEGER,
diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port, diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,
diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port, diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,
skipping to change at page 23, line 4 skipping to change at page 26, line 25
diffServSixTupleClfrSrcAddrType InetAddressType, diffServSixTupleClfrSrcAddrType InetAddressType,
diffServSixTupleClfrSrcAddr InetAddress, diffServSixTupleClfrSrcAddr InetAddress,
diffServSixTupleClfrSrcAddrMask Unsigned32, diffServSixTupleClfrSrcAddrMask Unsigned32,
diffServSixTupleClfrDscp Dscp, diffServSixTupleClfrDscp Dscp,
diffServSixTupleClfrProtocol INTEGER, diffServSixTupleClfrProtocol INTEGER,
diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port, diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,
diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port, diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,
diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port, diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port,
diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port, diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port,
diffServSixTupleClfrStatus RowStatus diffServSixTupleClfrStatus RowStatus
} }
diffServSixTupleClfrId OBJECT-TYPE diffServSixTupleClfrId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"A unique id for the filter. Filters may be shared by multiple "A unique identifier for the filter. Filters may be shared by
interfaces in the same system." multiple interfaces in the same system. Managers should obtain
new values for row creation in this table by reading
diffServSixTupleClfrNextFree."
::= { diffServSixTupleClfrEntry 1 } ::= { diffServSixTupleClfrEntry 1 }
diffServSixTupleClfrDstAddrType OBJECT-TYPE diffServSixTupleClfrDstAddrType OBJECT-TYPE
SYNTAX InetAddressType SYNTAX InetAddressType
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The type of IP destination address used by this classifier "The type of IP destination address used by this classifier
entry." entry."
::= { diffServSixTupleClfrEntry 2 } ::= { diffServSixTupleClfrEntry 2 }
skipping to change at page 23, line 36 skipping to change at page 27, line 11
SYNTAX InetAddress SYNTAX InetAddress
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The IP address to match against the packet's destination IP "The IP address to match against the packet's destination IP
address." address."
::= { diffServSixTupleClfrEntry 3 } ::= { diffServSixTupleClfrEntry 3 }
diffServSixTupleClfrDstAddrMask OBJECT-TYPE diffServSixTupleClfrDstAddrMask OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
UNITS "bits"
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The length of a mask for the matching of the destination IP "The length of a mask for the matching of the destination IP
address. Masks are constructed by setting bits in sequence from address. Masks are constructed by setting bits in sequence from
the most-significant bit downwards for the most-significant bit downwards for
diffServSixTupleClfrDstAddrMask bits length. All other bits in diffServSixTupleClfrDstAddrMask bits length. All other bits in
the mask, up to the number needed to fill the length of the the mask, up to the number needed to fill the length of the
address diffServSixTupleClfrDstAddr are cleared to zero. A zero address diffServSixTupleClfrDstAddr are cleared to zero. A zero
bit in the mask then means that the corresponding bit in the bit in the mask then means that the corresponding bit in the
skipping to change at page 24, line 21 skipping to change at page 27, line 45
SYNTAX InetAddress SYNTAX InetAddress
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The IP address to match against the source IP address of each "The IP address to match against the source IP address of each
packet." packet."
::= { diffServSixTupleClfrEntry 6 } ::= { diffServSixTupleClfrEntry 6 }
diffServSixTupleClfrSrcAddrMask OBJECT-TYPE diffServSixTupleClfrSrcAddrMask OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
UNITS "bits"
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The length of a mask for the matching of the source IP address. "The length of a mask for the matching of the source IP address.
Masks are constructed by setting bits in sequence from the most- Masks are constructed by setting bits in sequence from the most-
significant bit downwards for diffServSixTupleClfrSrcAddrMask significant bit downwards for diffServSixTupleClfrSrcAddrMask
bits length. All other bits in the mask, up to the number needed bits length. All other bits in the mask, up to the number needed
to fill the length of the address diffServSixTupleClfrSrcAddr are to fill the length of the address diffServSixTupleClfrSrcAddr are
cleared to zero. A zero bit in the mask then means that the cleared to zero. A zero bit in the mask then means that the
corresponding bit in the address always matches." corresponding bit in the address always matches."
skipping to change at page 26, line 15 skipping to change at page 29, line 40
diffServSixTupleClfrStatus OBJECT-TYPE diffServSixTupleClfrStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of a classifier. Any writable variable may be modified deletion of a classifier. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServSixTupleClfrEntry 14 } ::= { diffServSixTupleClfrEntry 14 }
diffServSixTupleClfrUnique OBJECT-TYPE diffServSixTupleClfrNextFree OBJECT-TYPE
SYNTAX TestAndIncr SYNTAX Unsigned32
MAX-ACCESS read-write MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The diffServSixTupleClfrUnique object yields a unique new "This object yields a value when read that is currently-unused
value for diffServSixTupleClfrId when read and subsequently for a diffServSixTupleClfrId instance.
set. This value must be tested for uniqueness and can If a configuring system attempts to create a new row
be used by a configuring system to obtain a in the diffServSixTupleClfrTable using this value, that operation
unique value for diffServSixTupleClfrId for purposes of will fail if the value has, in the meantime, been used
row creation in the diffServSixTupleClfrTable." to create another row that is currently valid."
::= { diffServObjects 2 } ::= { diffServObjects 2 }
-- --
-- Meters -- Meters
-- --
-- This MIB includes definitions for a generic Meter -- This MIB includes definitions for a generic Meter
-- Table as well as specific definitions for Token- -- Table as well as specific definitions for Token-
-- Bucket Meters, as one example of possible meters. -- Bucket Meters, as one example of possible meters.
-- --
diffServMeterTable OBJECT-TYPE diffServMeterTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServMeterEntry SYNTAX SEQUENCE OF DiffServMeterEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This table enumerates generic meters that a system may use to "This table enumerates generic meters that a system may use to
police a stream of classified traffic. The traffic stream to be police a stream of traffic. The traffic stream to be metered is
metered is determined by the classifier upstream of the meter determined by the element(s) upstream of the meter i.e. by the
i.e. by the object(s) that point to each entry in this table object(s) that point to each entry in this table. This may
using a RowPointer. This may include all traffic on an interface. include all traffic on an interface.
Specific meter details are to be found in diffServMeterSpecific." Specific meter details are to be found in diffServMeterSpecific."
REFERENCE REFERENCE
"[MODEL] section 5.1" "[MODEL] section 5.1"
::= { diffServTables 3 } ::= { diffServTables 3 }
diffServMeterEntry OBJECT-TYPE diffServMeterEntry OBJECT-TYPE
SYNTAX DiffServMeterEntry SYNTAX DiffServMeterEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the meter table describing a single meter." "An entry in the meter table describing a single meter."
INDEX { ifIndex, diffServMeterIfDirection, INDEX { ifIndex, diffServMeterIfDirection,
diffServMeterId } diffServMeterId }
::= { diffServMeterTable 1 } ::= { diffServMeterTable 1 }
DiffServMeterEntry ::= SEQUENCE { DiffServMeterEntry ::= SEQUENCE {
diffServMeterIfDirection IfDirection, diffServMeterIfDirection IfDirection,
diffServMeterId INTEGER, diffServMeterId Unsigned32,
diffServMeterSucceedNext RowPointer, diffServMeterSucceedNext RowPointer,
diffServMeterFailNext RowPointer, diffServMeterFailNext RowPointer,
diffServMeterSpecific OBJECT IDENTIFIER, diffServMeterSpecific OBJECT IDENTIFIER,
diffServMeterStatus RowStatus diffServMeterStatus RowStatus
} }
diffServMeterIfDirection OBJECT-TYPE diffServMeterIfDirection OBJECT-TYPE
SYNTAX IfDirection SYNTAX IfDirection
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the direction for this meter entry on the interface." "Specifies the direction for which this meter entry applies on
this interface."
::= { diffServMeterEntry 1 } ::= { diffServMeterEntry 1 }
diffServMeterId OBJECT-TYPE diffServMeterId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This identifies a meter entry." "This identifies a meter entry. Managers should obtain new values
for row creation in this table by reading diffServMeterNextFree."
::= { diffServMeterEntry 2 } ::= { diffServMeterEntry 2 }
diffServMeterSucceedNext OBJECT-TYPE diffServMeterSucceedNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"If the traffic does conform to the meter, this indicates the "If the traffic does conform to the meter, this indicates the
next datapath element to handle the traffic e.g. an Action or next datapath element to handle the traffic e.g. an Action or
another Meter datapath element. The value zeroDotZero in this another Meter datapath element.
variable indicates no further Diffserv treatment is performed on
this traffic by the current interface for this interface The value zeroDotZero in this variable indicates no further
direction." Diffserv treatment is performed on this traffic by the current
interface for this interface direction. If the row pointed to
does not exist, the meter element is considered inactive."
DEFVAL { zeroDotZero } DEFVAL { zeroDotZero }
::= { diffServMeterEntry 3 } ::= { diffServMeterEntry 3 }
diffServMeterFailNext OBJECT-TYPE diffServMeterFailNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"If the traffic does not conform to the meter, this indicates the "If the traffic does not conform to the meter, this indicates the
next datapath element to handle the traffic e.g. an Action or next datapath element to handle the traffic e.g. an Action or
Meter datapath element. The value zeroDotZero in this variable Meter datapath element.
indicates no further Diffserv treatment is performed on this
traffic by the current interface for this interface direction." The value zeroDotZero in this variable indicates no further
Diffserv treatment is performed on this traffic by the current
interface for this interface direction. If the row pointed to
does not exist, the meter element is considered inactive."
DEFVAL { zeroDotZero } DEFVAL { zeroDotZero }
::= { diffServMeterEntry 4 } ::= { diffServMeterEntry 4 }
diffServMeterSpecific OBJECT-TYPE diffServMeterSpecific OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This indicates the behaviour of the meter by pointing to an "This indicates the behaviour of the meter by pointing to a table
object containing detailed parameters. One example of a valid containing detailed parameters. Note that entries in that
object would be diffServTBMeterTable, whose entries are indexed specific table must be managed explicitly.
by the same variables as this table, for describing an instance
of a token-bucket meter." One example of a valid object would be diffServTBMeterTable,
whose entries are indexed by the same variables as this table,
for describing an instance of a token-bucket meter."
::= { diffServMeterEntry 5 } ::= { diffServMeterEntry 5 }
diffServMeterStatus OBJECT-TYPE diffServMeterStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of a meter. Any writable variable may be modified deletion of a meter. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServMeterEntry 6 } ::= { diffServMeterEntry 6 }
diffServMeterUnique OBJECT-TYPE diffServMeterNextFree OBJECT-TYPE
SYNTAX TestAndIncr SYNTAX Unsigned32
MAX-ACCESS read-write MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The diffServMeterUnique object yields a unique new value for "This object yields a value when read that is currently-unused
diffServMeterId when read and subsequently set. This value must for a diffServMeterId instance. If a configuring system attempts
be tested for uniqueness and can be used by a configuring system to create a new row in the diffServMeterTable using this value,
to obtain a unique value for diffServMeterId for purposes of row that operation will fail if the value has, in the meantime, been
creation in the diffServMeterTable." used to create another row that is currently valid."
::= { diffServObjects 3 } ::= { diffServObjects 3 }
-- --
-- Token-Bucket Meter Table -- Token-Bucket Meter Table
-- --
diffServTBMeterTable OBJECT-TYPE diffServTBMeterTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServTBMeterEntry SYNTAX SEQUENCE OF DiffServTBMeterEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This table enumerates specific token-bucket meters that a system "This table enumerates specific token-bucket meters that a system
may use to police a stream of traffic. Such meters are modelled may use to police a stream of traffic. Such meters are modelled
here as having a single rate and a burst size. here as having a single rate and a burst size.
Multiple meter elements may be logically cascaded if a multi-rate Multiple meter elements may be logically cascaded using their
token bucket is needed for a given Per-Hop Behavior. One example diffServMeterSucceedNext pointers if a multi-rate token bucket is
of such a PHB might be for an AF implementation. This is not needed. One example of this might be for an AF PHB
meant to imply that cascading of such elements is functionally implementation that used two-rate meters. Such cascading of
equivalent to a multi-rate meter, it is merely a convenience for meter elements of specific type of token-bucket indicates
this MIB representation. forwarding behaviour that is functionally equivalent to a multi-
rate meter: the sequential nature of the representation is merely
a notational convenience for this MIB.
Entries in this table share indexing with those in the base Entries in this table share indexing with a parent
diffServTBMeterTable: they appear in and are deleted from this diffServMeterEntry although they must be managed (e.g.
table whenever they " created/deleted) by explicit management action, independently of
the associated value of diffServMeterSpecific."
REFERENCE REFERENCE
"[MODEL] section 5.1.3" "[MODEL] section 5.1.3"
::= { diffServTables 4 } ::= { diffServTables 4 }
diffServTBMeterEntry OBJECT-TYPE diffServTBMeterEntry OBJECT-TYPE
SYNTAX DiffServTBMeterEntry SYNTAX DiffServTBMeterEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry that describes a single token-bucket meter, indexed by "An entry that describes a single token-bucket meter, indexed by
the same variables as a diffServMeterEntry." the same variables as a diffServMeterEntry."
INDEX { ifIndex, diffServMeterIfDirection, INDEX { ifIndex, diffServMeterIfDirection,
diffServMeterId } diffServMeterId }
::= { diffServTBMeterTable 1 } ::= { diffServTBMeterTable 1 }
DiffServTBMeterEntry ::= SEQUENCE { DiffServTBMeterEntry ::= SEQUENCE {
diffServTBMeterRate Unsigned32, diffServTBMeterRate Unsigned32,
diffServTBMeterBurstSize BurstSize, diffServTBMeterBurstSize BurstSize
diffServTBMeterStatus RowStatus diffServTBMeterStatus RowStatus
} }
diffServTBMeterRate OBJECT-TYPE diffServTBMeterRate OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
UNITS "kilobits per second" UNITS "kilobits per second"
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The token-bucket rate, in kilobits per second (kbps)." "The token-bucket rate, in kilobits per second (kbps)."
skipping to change at page 32, line 45 skipping to change at page 36, line 45
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the action table describing the actions applied to "An entry in the action table describing the actions applied to
traffic arriving at its input." traffic arriving at its input."
INDEX { ifIndex, diffServActionIfDirection, INDEX { ifIndex, diffServActionIfDirection,
diffServActionId } diffServActionId }
::= { diffServActionTable 1 } ::= { diffServActionTable 1 }
DiffServActionEntry ::= SEQUENCE { DiffServActionEntry ::= SEQUENCE {
diffServActionIfDirection IfDirection, diffServActionIfDirection IfDirection,
diffServActionId INTEGER, diffServActionId Unsigned32,
diffServActionNext RowPointer, diffServActionNext RowPointer,
diffServActionSpecific RowPointer, diffServActionSpecific OBJECT IDENTIFIER,
diffServActionStatus RowStatus diffServActionStatus RowStatus
} }
diffServActionIfDirection OBJECT-TYPE diffServActionIfDirection OBJECT-TYPE
SYNTAX IfDirection SYNTAX IfDirection
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the direction for this action entry on the interface." "Specifies the direction for which this action entry applies on
this interface."
::= { diffServActionEntry 1 } ::= { diffServActionEntry 1 }
diffServActionId OBJECT-TYPE diffServActionId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Action Id enumerates the Action entry." "This identifies the action entry. Managers should obtain new
values for row creation in this table by reading
diffServActionNextFree."
::= { diffServActionEntry 2 } ::= { diffServActionEntry 2 }
diffServActionNext OBJECT-TYPE diffServActionNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Next pointer indicates the next datapath element to handle "The Next pointer indicates the next datapath element to handle
the traffic. For example, a queue datapath element. The value the traffic. For example, a queue datapath element.
zeroDotZero in this variable indicates no further DiffServ
treatment is performed on this flow by the current interface for The value zeroDotZero in this variable indicates no further
this interface direction." DiffServ treatment is performed on this flow by the current
interface for this interface direction. If the row pointed to
does not exist, the action element is considered inactive."
DEFVAL { zeroDotZero } DEFVAL { zeroDotZero }
::= { diffServActionEntry 3 } ::= { diffServActionEntry 3 }
diffServActionSpecific OBJECT-TYPE diffServActionSpecific OBJECT-TYPE
SYNTAX RowPointer SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Pointer to a MIB table providing additional information for the "A pointer to an object instance providing additional information
type of action indicated by this action table entry. for the type of action indicated by this action table entry.
For the standard actions defined by this MIB module, this should For the standard actions defined by this MIB module, this should
point to an entry in one of the diffServDscpMarkActTable, point to one of the following: a diffServDscpMarkActEntry, a
diffServCountActTable tables or to the diffServAbsoluteDropAction diffServCountActEntry, the diffServAbsoluteDropAction OID. For
OID. For other actions, it may point to a table defined in some other actions, it may point to an object instance defined in some
other MIB." other MIB."
::= { diffServActionEntry 4 } ::= { diffServActionEntry 4 }
diffServActionStatus OBJECT-TYPE diffServActionStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation or
deletion of a meter. Any writable variable may be modified deletion of an action element. Any writable variable may be
whether the row is active or notInService." modified whether the row is active or notInService."
::= { diffServActionEntry 5 } ::= { diffServActionEntry 5 }
diffServActionUnique OBJECT-TYPE diffServActionNextFree OBJECT-TYPE
SYNTAX TestAndIncr SYNTAX Unsigned32
MAX-ACCESS read-write MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The diffServActionUnique object yields a unique new value for "This object yields a value when read that is currently-unused
diffServActionId when read and subsequently set. This value must for a diffServActionId instance. If a configuring system
be tested for uniqueness. This object allows a configuring attempts to create a new row in the diffServActionTable using
system to obtain a unique value for diffServActionId for purposes this value, that operation will fail if the value has, in the
of row creation." meantime, been used to create another row that is currently
valid."
::= { diffServObjects 4 } ::= { diffServObjects 4 }
-- DSCP Mark Action Table -- DSCP Mark Action Table
-- --
-- Rows of this table are pointed to by diffServAction to -- Rows of this table are pointed to by diffServAction to
-- provide detailed parameters specific to the DSCP -- provide detailed parameters specific to the DSCP
-- Mark action. -- Mark action.
diffServDscpMarkActTable OBJECT-TYPE diffServDscpMarkActTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServDscpMarkActEntry SYNTAX SEQUENCE OF DiffServDscpMarkActEntry
skipping to change at page 34, line 46 skipping to change at page 39, line 5
that points to diffServDscpMarkActTable." that points to diffServDscpMarkActTable."
REFERENCE REFERENCE
"[MODEL] section 6.1" "[MODEL] section 6.1"
::= { diffServTables 6 } ::= { diffServTables 6 }
diffServDscpMarkActEntry OBJECT-TYPE diffServDscpMarkActEntry OBJECT-TYPE
SYNTAX DiffServDscpMarkActEntry SYNTAX DiffServDscpMarkActEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the DSCP mark action table describes a single DSCP "An entry in the DSCP mark action table that describes a single
used for marking." DSCP used for marking."
INDEX { diffServDscpMarkActDscp } INDEX { diffServDscpMarkActDscp }
::= { diffServDscpMarkActTable 1 } ::= { diffServDscpMarkActTable 1 }
DiffServDscpMarkActEntry ::= SEQUENCE { DiffServDscpMarkActEntry ::= SEQUENCE {
diffServDscpMarkActDscp Dscp diffServDscpMarkActDscp Dscp
} }
diffServDscpMarkActDscp OBJECT-TYPE diffServDscpMarkActDscp OBJECT-TYPE
SYNTAX Dscp SYNTAX Dscp
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The DSCP that this Action uses for marking/remarking traffic. "The DSCP that this Action uses for marking/remarking traffic.
Note that it is quite possible that the only packets subject to Note that a DSCP value of -1 is not permitted in this table. It
this Action are already marked with this DSCP. is quite possible that the only packets subject to this Action
are already marked with this DSCP. Note also that Diffserv may
Diffserv may result in packet remarking both on ingress to a result in packet remarking both on ingress to a network and on
network and on egress and it is quite possible that ingress and egress from it and it is quite possible that ingress and egress
egress would occur in the same router." would occur in the same router."
::= { diffServDscpMarkActEntry 1 } ::= { diffServDscpMarkActEntry 1 }
-- --
-- Count Action Table -- Count Action Table
-- --
diffServCountActTable OBJECT-TYPE diffServCountActTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServCountActEntry SYNTAX SEQUENCE OF DiffServCountActEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
skipping to change at page 35, line 43 skipping to change at page 39, line 48
an action element." an action element."
REFERENCE REFERENCE
"[MODEL] section 6.5" "[MODEL] section 6.5"
::= { diffServTables 7 } ::= { diffServTables 7 }
diffServCountActEntry OBJECT-TYPE diffServCountActEntry OBJECT-TYPE
SYNTAX DiffServCountActEntry SYNTAX DiffServCountActEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the count action table describes a single set of "An entry in the count action table that describes a single set
traffic counters. This entry is indexed in the same way as a of traffic counters. Entries in this table share indexing with
diffServActionEntry. An entry should exist in this table for those in the base diffServActionTable although they must be
every diffServActionEntry that has a diffServActionSpecific managed (e.g. created/deleted) by explicit management action,
pointing to this table." independently of the associated value of diffServActionSpecific."
INDEX { ifIndex, diffServActionIfDirection, INDEX { ifIndex, diffServActionIfDirection,
diffServActionId } diffServActionId }
::= { diffServCountActTable 1 } ::= { diffServCountActTable 1 }
DiffServCountActEntry ::= SEQUENCE { DiffServCountActEntry ::= SEQUENCE {
diffServCountActOctets Counter32, diffServCountActOctets Counter32,
diffServCountActHCOctets Counter64, diffServCountActHCOctets Counter64,
diffServCountActPkts Counter32, diffServCountActPkts Counter32,
diffServCountActHCPkts Counter64, diffServCountActHCPkts Counter64,
diffServCountActDiscontTime TimeStamp,
diffServCountActStatus RowStatus diffServCountActStatus RowStatus
} }
diffServCountActOctets OBJECT-TYPE diffServCountActOctets OBJECT-TYPE
SYNTAX Counter32 SYNTAX Counter32
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The number of octets at the Action datapath element. On high "The number of octets at the Action datapath element. On high
speed devices, this object implements the least significant 32 speed devices, this object implements the least significant 32
bits of diffServcountActHCOctets. bits of diffServcountActHCOctets.
Discontinuities in the value of this counter can occur at re- Discontinuities in the value of this counter can occur at re-
initialization of the management system and at other times as initialization of the management system and at other times as
indicated by the value of ifCounterDiscontinuityTime appropriate indicated by the value of diffServCountActDiscontTime for this
to this interface." entry."
::= { diffServCountActEntry 1 } ::= { diffServCountActEntry 1 }
diffServCountActHCOctets OBJECT-TYPE diffServCountActHCOctets OBJECT-TYPE
SYNTAX Counter64 SYNTAX Counter64
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The number of octets at the Action datapath element. This "The number of octets at the Action datapath element. This
object should be used on high speed interfaces. object should be used on high speed interfaces.
Discontinuities in the value of this counter can occur at re- Discontinuities in the value of this counter can occur at re-
initialization of the management system and at other times as initialization of the management system and at other times as
indicated by the value of ifCounterDiscontinuityTime appropriate indicated by the value of diffServCountActDiscontTime for this
to this interface." entry."
::= { diffServCountActEntry 2 } ::= { diffServCountActEntry 2 }
diffServCountActPkts OBJECT-TYPE diffServCountActPkts OBJECT-TYPE
SYNTAX Counter32 SYNTAX Counter32
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The number of packets at the Action datapath element. On high "The number of packets at the Action datapath element. On high
speed devices, this object implements the least significant 32 speed devices, this object implements the least significant 32
bits of diffServcountActHCPkts. bits of diffServcountActHCPkts.
Discontinuities in the value of this counter can occur at re- Discontinuities in the value of this counter can occur at re-
initialization of the management system and at other times as initialization of the management system and at other times as
indicated by the value of ifCounterDiscontinuityTime appropriate indicated by the value of diffServCountActDiscontTime for this
to this interface." entry."
::= { diffServCountActEntry 3 } ::= { diffServCountActEntry 3 }
diffServCountActHCPkts OBJECT-TYPE diffServCountActHCPkts OBJECT-TYPE
SYNTAX Counter64 SYNTAX Counter64
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The number of packets at the Action datapath element. This "The number of packets at the Action datapath element. This
object should be used on high speed interfaces. object should be used on high speed interfaces.
Discontinuities in the value of this counter can occur at re- Discontinuities in the value of this counter can occur at re-
initialization of the management system and at other times as initialization of the management system and at other times as
indicated by the value of ifCounterDiscontinuityTime appropriate indicated by the value of diffServCountActDiscontTime for this
to this interface." entry."
::= { diffServCountActEntry 4 } ::= { diffServCountActEntry 4 }
diffServCountActDiscontTime OBJECT-TYPE
SYNTAX TimeStamp
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of sysUpTime on the most recent occasion at which any
one or more of this entry's counters suffered a discontinuity. If
no such discontinuities have occurred since the last re-
initialization of the local management subsystem, then this
object contains a zero value."
::= { diffServCountActEntry 5 }
diffServCountActStatus OBJECT-TYPE diffServCountActStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of this entry. Any writable variable may be modified deletion of this entry. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServCountActEntry 5 } ::= { diffServCountActEntry 6 }
diffServAbsoluteDropAction OBJECT-IDENTITY diffServAbsoluteDropAction OBJECT-IDENTITY
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This object identifier may be used as the value of a "This object identifier may be used as the value of a
diffServActionSpecific pointer in order to indicate that all diffServActionSpecific pointer in order to indicate that all
packets following this path are to be dropped unconditionally at packets following this path are to be dropped unconditionally at
this point. It is likely, but not required, that this action will this point. It is likely, but not required, that this action will
be preceded by a counter action." be preceded by a counter action."
::= { diffServObjects 6 } ::= { diffServObjects 6 }
-- --
-- Algorithmic Drop Table -- Algorithmic Drop Table
-- --
diffServAlgDropTable OBJECT-TYPE diffServAlgDropTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServAlgDropEntry SYNTAX SEQUENCE OF DiffServAlgDropEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The algorithmic drop table contains entries describing a process "The algorithmic drop table contains entries describing an
that drops packets according to some algorithm." element that drops packets according to some algorithm."
REFERENCE REFERENCE
"[MODEL] section 7.1.3" "[MODEL] section 7.1.3"
::= { diffServTables 8 } ::= { diffServTables 8 }
diffServAlgDropEntry OBJECT-TYPE diffServAlgDropEntry OBJECT-TYPE
SYNTAX DiffServAlgDropEntry SYNTAX DiffServAlgDropEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry describes a process that drops packets according to "An entry describes a process that drops packets according to
some algorithm. Algorithms described here include: tailDrop(2), some algorithm. Further details of the algorithm type are to be
headDrop(3) and other(1). found in diffServAlgDropType and may be pointed to by
diffServAlgDropSpecific."
Specifically, Random Drop algorithms are not directly represented
in this MIB but can be indicated by an entry in this table with
diffServAlgDropType of other(1) and extensions, pointed to by
diffServAlgDropSpecific, in some other MIB module that parallels
entries in this table e.g. by using the same index attribute(s)."
INDEX { ifIndex, diffServAlgDropIfDirection, INDEX { ifIndex, diffServAlgDropIfDirection,
diffServAlgDropId } diffServAlgDropId }
::= { diffServAlgDropTable 1 } ::= { diffServAlgDropTable 1 }
DiffServAlgDropEntry ::= SEQUENCE { DiffServAlgDropEntry ::= SEQUENCE {
diffServAlgDropIfDirection IfDirection, diffServAlgDropIfDirection IfDirection,
diffServAlgDropId INTEGER, diffServAlgDropId Unsigned32,
diffServAlgDropType INTEGER, diffServAlgDropType INTEGER,
diffServAlgDropNext RowPointer, diffServAlgDropNext RowPointer,
diffServAlgDropQMeasure RowPointer, diffServAlgDropQMeasure RowPointer,
diffServAlgDropQThreshold Unsigned32, diffServAlgDropQThreshold Unsigned32,
diffServAlgDropSpecific OBJECT IDENTIFIER, diffServAlgDropSpecific OBJECT IDENTIFIER,
diffServAlgDropOctets Counter32, diffServAlgDropOctets Counter32,
diffServAlgDropHCOctets Counter64, diffServAlgDropHCOctets Counter64,
diffServAlgDropPkts Counter32, diffServAlgDropPkts Counter32,
diffServAlgDropHCPkts Counter64, diffServAlgDropHCPkts Counter64,
diffServAlgDropStatus RowStatus diffServAlgDropStatus RowStatus
} }
diffServAlgDropIfDirection OBJECT-TYPE diffServAlgDropIfDirection OBJECT-TYPE
SYNTAX IfDirection SYNTAX IfDirection
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the direction for this algorithmic dropper entry on "Specifies the direction for which this algorithmic dropper entry
the interface." applies on this interface."
::= { diffServAlgDropEntry 1 } ::= { diffServAlgDropEntry 1 }
diffServAlgDropId OBJECT-TYPE diffServAlgDropId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Drop Action Id enumerates the Drop Action entry." "This identifies the drop action entry. Managers should obtain
new values for row creation in this table by reading
diffServAlgDropNextFree."
::= { diffServAlgDropEntry 2 } ::= { diffServAlgDropEntry 2 }
diffServAlgDropType OBJECT-TYPE diffServAlgDropType OBJECT-TYPE
SYNTAX INTEGER { other(1), tailDrop(2), headDrop(3) } SYNTAX INTEGER { other(1), tailDrop(2),
headDrop(3), randomDrop(4) }
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The type of algorithm used by this dropper. A value of "The type of algorithm used by this dropper. A value of
tailDrop(2) or headDrop(3) represents an algorithm that is tailDrop(2) or headDrop(3) represents an algorithm that is
completely specified by this MIB. A value of other(1) requires completely specified by this MIB. A value of other(1) requires
further specification in some other MIB module. further specification in some other MIB module.
The tailDrop(2) algorithm is described as follows: The tailDrop(2) algorithm is described as follows:
diffServAlgDropQThreshold represents the depth of the queue diffServAlgDropQThreshold represents the depth of the queue
diffServAlgDropQMeasure at which all newly arriving packets will diffServAlgDropQMeasure at which all newly arriving packets will
be dropped. be dropped.
The headDrop(3) algorithm is described as follows: if a packet The headDrop(3) algorithm is described as follows: if a packet
arrives when the current depth of the queue arrives when the current depth of the queue
diffServAlgDropQMeasure is at diffServAlgDropQThreshold, the diffServAlgDropQMeasure is at diffServAlgDropQThreshold, packets
packet currently at the head of the queue is dropped and the new currently at the head of the queue are dropped to make room for
packet is enqueued at the tail of the queue." 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, an associated diffServRandomDropEntry is indicated by
pointing diffServAlgDropSpecific at the diffServRandomDropTable.
The relevant entry in that table is selected by the common
indexing of the two tables. For this algorithm,
diffServAlgQThreshold is understood to be the absolute maximum
size of the queue and additional parameters are described in
diffServRandomDropTable."
::= { diffServAlgDropEntry 3 } ::= { diffServAlgDropEntry 3 }
diffServAlgDropNext OBJECT-TYPE diffServAlgDropNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Next pointer indicates the next datapath element to handle "The Next pointer indicates the next datapath element to handle
the traffic e.g. a queue datapath element. The value zeroDotZero the traffic e.g. a queue datapath element.
in this variable indicates no further DiffServ treatment is
performed on this flow by the current interface for this The value zeroDotZero in this variable indicates no further
interface direction." DiffServ treatment is performed on this flow by the current
interface for this interface direction. If the row pointed to
does not exist, the algorithmic dropper element is considered
inactive."
::= { diffServAlgDropEntry 4 } ::= { diffServAlgDropEntry 4 }
diffServAlgDropQMeasure OBJECT-TYPE diffServAlgDropQMeasure OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Points to an entry in the diffServQueueTable to indicate the "Points to an entry in the diffServQueueTable to indicate the
queue that a drop algorithm is to monitor when deciding whether queue that a drop algorithm is to monitor when deciding whether
to drop a packet." to drop a packet. If the row pointed to does not exist, the
algorithmic dropper element is considered inactive."
::= { diffServAlgDropEntry 5 } ::= { diffServAlgDropEntry 5 }
diffServAlgDropQThreshold OBJECT-TYPE diffServAlgDropQThreshold OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
UNITS "Bytes"
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"A threshold on the depth of the queue being measured at which a "A threshold on the depth in bytes of the queue being measured at
trigger is generated to the dropping algorithm. which a trigger is generated to the dropping algorithm.
For the tailDrop(2) or headDrop(3) algorithms, this represents For the tailDrop(2) or headDrop(3) algorithms, this represents
the depth of the queue diffServAlgDropQMeasure at which the drop the depth of the queue diffServAlgDropQMeasure at which the drop
action will take place. Other algorithms will need to define action will take place. Other algorithms will need to define
their own semantics for this threshold." their own semantics for this threshold."
::= { diffServAlgDropEntry 6 } ::= { diffServAlgDropEntry 6 }
diffServAlgDropSpecific OBJECT-TYPE diffServAlgDropSpecific OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Points to a table (not an entry in the table) defined elsewhere "Points to a table (not an entry in the table) defined elsewhere
that provides further detail regarding a drop algorithm described that provides further detail regarding a drop algorithm. Entries
as diffServAlgDropType other(1). entries in such a table are to in such a table are indexed by the same variables as this
be indexed by the same variables as this diffServAlgDropEntry. diffServAlgDropEntry but note that those entries must be managed
independently of those in this table.
For algorithms specified fully in this MIB module, this should Entries with diffServAlgDropType equal to other(1) may have this
take the value zeroDotzero." point to a table defined in another MIB module. Entries with
diffServAlgDropType equal to randomDrop(4) must have this point
to diffServRandomDropTable.
For all other algorithms, this should take the value
zeroDotzero."
::= { diffServAlgDropEntry 7 } ::= { diffServAlgDropEntry 7 }
diffServAlgDropOctets OBJECT-TYPE diffServAlgDropOctets OBJECT-TYPE
SYNTAX Counter32 SYNTAX Counter32
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The number of octets that have been dropped by this drop "The number of octets that have been dropped by this drop
process. On high speed devices, this object implements the least process. On high speed devices, this object implements the least
significant 32 bits of diffServAlgDropHCOctets. significant 32 bits of diffServAlgDropHCOctets.
skipping to change at page 42, line 21 skipping to change at page 47, line 42
diffServAlgDropStatus OBJECT-TYPE diffServAlgDropStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of this entry. Any writable variable may be modified deletion of this entry. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServAlgDropEntry 12 } ::= { diffServAlgDropEntry 12 }
diffServAlgDropNextFree OBJECT-TYPE
diffServAlgDropUnique OBJECT-TYPE SYNTAX Unsigned32
SYNTAX TestAndIncr MAX-ACCESS read-only
MAX-ACCESS read-write
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"This object yields a unique new "This object yields a value when read that is currently-unused
value for diffServAlgDropId when read and subsequently for a diffServAlgDropId instance. If a configuring system
set. This value must be tested for uniqueness and can attempts to create a new row in the diffServAlgDropTable using
be used by a configuring system to obtain a this value, that operation will fail if the value has, in the
unique value for diffServAlgDropId for purposes of meantime, been used to create another row that is currently
row creation in the diffServAlgDropTable." valid."
::= { diffServObjects 7 } ::= { diffServObjects 7 }
diffServRandomDropTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServRandomDropEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The random drop table augments the algorithmic drop table. It
contains entries describing a process that drops packets
randomly. This table is intended to be pointed to by the
associated diffServAlgDropSpecific in such cases."
REFERENCE
"[MODEL] section 7.1.3"
::= { diffServTables 9 }
diffServRandomDropEntry OBJECT-TYPE
SYNTAX DiffServRandomDropEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An entry describes a process that drops packets according to a
random algorithm. Entries in this table share indexing with a
parent diffServAlgDropEntry although they must be managed (e.g.
created/deleted) by explicit management action, independently of
the associated value of diffServAlgDropSpecific."
INDEX { ifIndex, diffServAlgDropIfDirection,
diffServAlgDropId }
::= { diffServRandomDropTable 1 }
DiffServRandomDropEntry ::= SEQUENCE {
diffServRandomDropMinThreshBytes Unsigned32,
diffServRandomDropMinThreshPkts Unsigned32,
diffServRandomDropMaxThreshBytes Unsigned32,
diffServRandomDropMaxThreshPkts Unsigned32,
diffServRandomDropInvWeight Unsigned32,
diffServRandomDropProbMax Unsigned32,
diffServRandomDropStatus RowStatus
}
diffServRandomDropMinThreshBytes OBJECT-TYPE
SYNTAX Unsigned32
UNITS "bytes"
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The average queue depth in bytes, beyond which traffic has a
non-zero probability of being dropped. Changes in this variable
may or may not be reflected in the reported value of
diffServRandomDropMinThreshPkts."
::= { diffServRandomDropEntry 1 }
diffServRandomDropMinThreshPkts OBJECT-TYPE
SYNTAX Unsigned32
UNITS "packets"
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The average queue depth in packets, beyond which traffic has a
non-zero probability of being dropped. Changes in this variable
may or may not be reflected in the reported value of
diffServRandomDropMinThreshBytes."
::= { diffServRandomDropEntry 2 }
diffServRandomDropMaxThreshBytes OBJECT-TYPE
SYNTAX Unsigned32
UNITS "bytes"
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The average queue depth beyond which traffic has a probability
indicated by diffServRandomDropInvMaxProb of being dropped or
marked. Note that this differs from the physical queue limit,
which is stored in diffServAlgDropQThreshold. Changes in this
variable may or may not be reflected in the reported value of
diffServRandomDropMaxThreshPkts."
::= { diffServRandomDropEntry 3 }
diffServRandomDropMaxThreshPkts OBJECT-TYPE
SYNTAX Unsigned32
UNITS "packets"
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The average queue depth beyond which traffic has a probability
indicated by diffServRandomDropInvMaxProb of being dropped or
marked. Note that this differs from the physical queue limit,
which is stored in diffServAlgDropQThreshold. Changes in this
variable may or may not be reflected in the reported value of
diffServRandomDropMaxThreshBytes."
::= { diffServRandomDropEntry 4 }
diffServRandomDropInvWeight OBJECT-TYPE
SYNTAX Unsigned32
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The weighting of past history in affecting the calculation of
the current queue average. The moving average of the queue depth
uses the inverse of this value as the factor for the new queue
depth, and one minus that inverse as the factor for the
historical average.
Implementations may choose to limit the acceptable set of values
to a specified set, such as powers of 2."
::= { diffServRandomDropEntry 5 }
diffServRandomDropProbMax OBJECT-TYPE
SYNTAX Unsigned32
MAX-ACCESS read-create
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."
::= { diffServRandomDropEntry 6 }
diffServRandomDropStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or
deletion of this entry. Any writable variable may be modified
whether the row is active or notInService."
::= { diffServRandomDropEntry 7 }
-- --
-- Queue Table -- Queue Table
-- --
diffServQTable OBJECT-TYPE diffServQTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServQEntry SYNTAX SEQUENCE OF DiffServQEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Queue Table enumerates the individual queues on an "The Queue Table enumerates the individual queues on an
interface." interface."
::= { diffServTables 9 } ::= { diffServTables 10 }
diffServQEntry OBJECT-TYPE diffServQEntry OBJECT-TYPE
SYNTAX DiffServQEntry SYNTAX DiffServQEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the Queue Table describes a single queue in one "An entry in the Queue Table describes a single queue in one
direction on an interface." direction on an interface."
INDEX { ifIndex, diffServQIfDirection, diffServQId } INDEX { ifIndex, diffServQIfDirection, diffServQId }
::= { diffServQTable 1 } ::= { diffServQTable 1 }
DiffServQEntry ::= SEQUENCE { DiffServQEntry ::= SEQUENCE {
diffServQIfDirection IfDirection, diffServQIfDirection IfDirection,
diffServQId INTEGER, diffServQId Unsigned32,
diffServQNext RowPointer, diffServQNext RowPointer,
diffServQPriority Unsigned32, diffServQPriority Unsigned32,
diffServQMinRateAbs Unsigned32, diffServQMinRateAbs Unsigned32,
diffServQMinRateRel Unsigned32, diffServQMinRateRel Unsigned32,
diffServQMaxRateAbs Unsigned32, diffServQMaxRateAbs Unsigned32,
diffServQMaxRateRel Unsigned32, diffServQMaxRateRel Unsigned32,
diffServQStatus RowStatus diffServQStatus RowStatus
} }
diffServQIfDirection OBJECT-TYPE diffServQIfDirection OBJECT-TYPE
SYNTAX IfDirection SYNTAX IfDirection
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the direction for this queue entry on the interface." "Specifies the direction for which this queue entry applies on
this interface."
::= { diffServQEntry 1 } ::= { diffServQEntry 1 }
diffServQId OBJECT-TYPE diffServQId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Queue Id enumerates the Queue entry." "The Queue Id enumerates the Queue entry. Managers should obtain
new values for row creation in this table by reading
diffServQNextFree."
::= { diffServQEntry 2 } ::= { diffServQEntry 2 }
diffServQNext OBJECT-TYPE diffServQNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Next pointer indicates the next datapath element to handle "The Next pointer indicates the next datapath element to handle
the traffic e.g. a scheduler datapath element." the traffic e.g. a scheduler datapath element. If the row
pointed to does not exist, the queue element is considered
inactive."
::= { diffServQEntry 3 } ::= { diffServQEntry 3 }
diffServQPriority OBJECT-TYPE diffServQPriority OBJECT-TYPE
SYNTAX Unsigned32 SYNTAX Unsigned32
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The priority of this queue, to be used as a parameter to the "The priority of this queue, to be used as a parameter to the
next scheduler element downstream from this one." next scheduler element downstream from this one."
::= { diffServQEntry 4 } ::= { diffServQEntry 4 }
skipping to change at page 46, line 47 skipping to change at page 54, line 51
diffServQStatus OBJECT-TYPE diffServQStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of a queue. Any writable variable may be modified deletion of a queue. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServQEntry 9 } ::= { diffServQEntry 9 }
diffServQUnique OBJECT-TYPE diffServQNextFree OBJECT-TYPE
SYNTAX TestAndIncr SYNTAX Unsigned32
MAX-ACCESS read-write MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The diffServQUnique object yields a unique new value for "This object yields a value when read that is currently-unused
diffServQId when read and subsequently set. This value must be for a diffServQId instance. If a configuring system attempts to
tested for uniqueness and can be used by a configuring system to create a new row in the diffServQTable using this value, that
obtain a unique value for diffServQId for purposes of row operation will fail if the value has, in the meantime, been used
creation in the diffServQTable." to create another row that is currently valid."
::= { diffServObjects 8 } ::= { diffServObjects 8 }
-- --
-- Scheduler Table -- Scheduler Table
-- --
-- The Scheduler Table is used for representing packet schedulers: -- The Scheduler Table is used for representing packet schedulers:
-- it provides flexibility for multiple scheduling algorithms, each -- it provides flexibility for multiple scheduling algorithms, each
-- servicing multiple queues, to be used on the same logical/physical -- servicing multiple queues, to be used on the same logical/physical
-- interface. -- interface.
diffServSchedulerTable OBJECT-TYPE diffServSchedulerTable OBJECT-TYPE
SYNTAX SEQUENCE OF DiffServSchedulerEntry SYNTAX SEQUENCE OF DiffServSchedulerEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Scheduler Table enumerates packet schedulers. Multiple "The Scheduler Table enumerates packet schedulers. Multiple
scheduling algorithms can be used on a given interface, with each scheduling algorithms can be used on a given interface, with each
algorithm described by one diffServSchedulerEntry." algorithm described by one diffServSchedulerEntry."
REFERENCE REFERENCE
"[MODEL] section 7.1.2" "[MODEL] section 7.1.2"
::= { diffServTables 10 } ::= { diffServTables 11 }
diffServSchedulerEntry OBJECT-TYPE diffServSchedulerEntry OBJECT-TYPE
SYNTAX DiffServSchedulerEntry SYNTAX DiffServSchedulerEntry
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"An entry in the Scheduler Table describing a single instance of "An entry in the Scheduler Table describing a single instance of
a scheduling algorithm." a scheduling algorithm."
INDEX { ifIndex, diffServSchedulerIfDirection, INDEX { ifIndex, diffServSchedulerIfDirection,
diffServSchedulerId } diffServSchedulerId }
::= { diffServSchedulerTable 1 } ::= { diffServSchedulerTable 1 }
DiffServSchedulerEntry ::= SEQUENCE { DiffServSchedulerEntry ::= SEQUENCE {
diffServSchedulerIfDirection IfDirection, diffServSchedulerIfDirection IfDirection,
diffServSchedulerId INTEGER, diffServSchedulerId Unsigned32,
diffServSchedulerMethod INTEGER, diffServSchedulerMethod INTEGER,
diffServSchedulerNext RowPointer, diffServSchedulerNext RowPointer,
diffServSchedulerStatus RowStatus diffServSchedulerStatus RowStatus
} }
diffServSchedulerIfDirection OBJECT-TYPE diffServSchedulerIfDirection OBJECT-TYPE
SYNTAX IfDirection SYNTAX IfDirection
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Specifies the direction for this scheduler entry on the "Specifies the direction for which this scheduler entry applies
interface." on this interface."
::= { diffServSchedulerEntry 1 } ::= { diffServSchedulerEntry 1 }
diffServSchedulerId OBJECT-TYPE diffServSchedulerId OBJECT-TYPE
SYNTAX INTEGER (0..2147483647) SYNTAX Unsigned32
MAX-ACCESS not-accessible MAX-ACCESS not-accessible
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Scheduler Id enumerates the Scheduler entry." "This identifies the scheduler entry. Managers should obtain new
values for row creation in this table by reading
diffServSchedulerNextFree."
::= { diffServSchedulerEntry 2 } ::= { diffServSchedulerEntry 2 }
diffServSchedulerMethod OBJECT-TYPE diffServSchedulerMethod OBJECT-TYPE
SYNTAX INTEGER { SYNTAX INTEGER {
other(1), -- not listed here other(1), -- not listed here
priorityq(2), -- Priority Queueing priorityq(2), -- Priority Queueing
wrr(3) -- Weighed Round Robin wrr(3) -- Weighed Round Robin
} }
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
skipping to change at page 49, line 4 skipping to change at page 57, line 11
REFERENCE REFERENCE
"[MODEL] section 7.1.2" "[MODEL] section 7.1.2"
::= { diffServSchedulerEntry 3 } ::= { diffServSchedulerEntry 3 }
diffServSchedulerNext OBJECT-TYPE diffServSchedulerNext OBJECT-TYPE
SYNTAX RowPointer SYNTAX RowPointer
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"Selects the next data path component, which can be another "Selects the next data path component, which can be another
Scheduler or other TC elements. One usage of multiple serial scheduler or other TC elements. One usage of multiple scheduler
Schedulers is for Class Base Queueing (CBQ). elements in series is for Class Base Queueing (CBQ).
The value zeroDotZero in this variable indicates no further The value zeroDotZero in this variable indicates no further
DiffServ treatment is performed on this flow by the current DiffServ treatment is performed on this flow by the current
interface for this interface direction. For example, for an interface for this interface direction. For example, for an
inbound interface the value zeroDotZero indicates that the packet inbound interface the value zeroDotZero indicates that the packet
flow has now completed inbound DiffServ treatment and should be flow has now completed inbound DiffServ treatment and should be
forwarded on to the appropriate outbound interface." forwarded on to the appropriate outbound interface. If the row
pointed to does not exist, the scheduler element is considered
inactive."
DEFVAL { zeroDotZero } DEFVAL { zeroDotZero }
::= { diffServSchedulerEntry 4 } ::= { diffServSchedulerEntry 4 }
diffServSchedulerStatus OBJECT-TYPE diffServSchedulerStatus OBJECT-TYPE
SYNTAX RowStatus SYNTAX RowStatus
MAX-ACCESS read-create MAX-ACCESS read-create
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The RowStatus variable controls the activation, deactivation, or "The RowStatus variable controls the activation, deactivation, or
deletion of a queue. Any writable variable may be modified deletion of a queue. Any writable variable may be modified
whether the row is active or notInService." whether the row is active or notInService."
::= { diffServSchedulerEntry 5 } ::= { diffServSchedulerEntry 5 }
diffServSchedulerUnique OBJECT-TYPE diffServSchedulerNextFree OBJECT-TYPE
SYNTAX TestAndIncr SYNTAX Unsigned32
MAX-ACCESS read-write MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The diffServSchedulerUnique object yields a unique new value for "This object yields a value when read that is currently-unused
diffServSchedulerId when read and subsequently set. This value for a diffServSchedulerId instance. If a configuring system
must be tested for uniqueness and can be used by a configuring attempts to create a new row in the diffServSchedulerTable using
system to obtain a unique value for diffServSchedulerId for this value, that operation will fail if the value has, in the
purposes of row creation in the diffServSchedulerTable." meantime, been used to create another row that is currently
valid."
::= { diffServObjects 9 } ::= { diffServObjects 9 }
-- --
-- MIB Compliance statements. -- MIB Compliance statements.
-- --
diffServMIBCompliances OBJECT IDENTIFIER ::= { diffServMIBConformance 1 } diffServMIBCompliances OBJECT IDENTIFIER ::= { diffServMIBConformance 1 }
diffServMIBGroups OBJECT IDENTIFIER ::= { diffServMIBConformance 2 } diffServMIBGroups OBJECT IDENTIFIER ::= { diffServMIBConformance 2 }
diffServMIBCompliance MODULE-COMPLIANCE diffServMIBCompliance MODULE-COMPLIANCE
skipping to change at page 51, line 23 skipping to change at page 59, line 23
GROUP diffServMIBTokenBucketMeterGroup GROUP diffServMIBTokenBucketMeterGroup
DESCRIPTION DESCRIPTION
"This group is mandatory for devices that implement token-bucket "This group is mandatory for devices that implement token-bucket
metering functions." metering functions."
GROUP diffServMIBDscpMarkActionGroup GROUP diffServMIBDscpMarkActionGroup
DESCRIPTION DESCRIPTION
"This group is mandatory for devices that implement DSCP-Marking "This group is mandatory for devices that implement DSCP-Marking
functions." functions."
GROUP diffServMIBRandomDropGroup
DESCRIPTION
"This group is mandatory for devices that implement Random Drop
functions."
GROUP diffServMIBStaticGroup GROUP diffServMIBStaticGroup
DESCRIPTION DESCRIPTION
"This group is mandatory for devices that allow creation of rows "This group is mandatory for devices that allow creation of rows
in any of the writable tables of this MIB." in any of the writable tables of this MIB."
OBJECT diffServClassifierFilter OBJECT diffServClassifierFilter
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
skipping to change at page 54, line 46 skipping to change at page 63, line 4
OBJECT diffServAlgDropQMeasure OBJECT diffServAlgDropQMeasure
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
OBJECT diffServAlgDropQThreshold OBJECT diffServAlgDropQThreshold
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
OBJECT diffServAlgDropSpecific OBJECT diffServAlgDropSpecific
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
OBJECT diffServAlgDropStatus OBJECT diffServAlgDropStatus
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
OBJECT diffServRandomDropMinThreshBytes
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServRandomDropMaxThreshPkts
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServRandomDropMinThreshBytes
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServRandomDropMaxThreshPkts
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServRandomDropInvWeight
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServRandomDropProbMax
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServRandomDropStatus
MIN-ACCESS read-only
DESCRIPTION
"Write access is not required."
OBJECT diffServQNext OBJECT diffServQNext
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
OBJECT diffServQPriority OBJECT diffServQPriority
MIN-ACCESS read-only MIN-ACCESS read-only
DESCRIPTION DESCRIPTION
"Write access is not required." "Write access is not required."
skipping to change at page 57, line 47 skipping to change at page 66, line 47
diffServMeterSpecific, diffServMeterStatus diffServMeterSpecific, diffServMeterStatus
} }
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Meter Group defines the objects used in describing a generic "The Meter Group defines the objects used in describing a generic
meter element." meter element."
::= { diffServMIBGroups 3 } ::= { diffServMIBGroups 3 }
diffServMIBTokenBucketMeterGroup OBJECT-GROUP diffServMIBTokenBucketMeterGroup OBJECT-GROUP
OBJECTS { OBJECTS {
diffServTBMeterRate, diffServTBMeterBurstSize, diffServTBMeterRate, diffServTBMeterBurstSize
diffServTBMeterStatus diffServTBMeterStatus
} }
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Token-Bucket Meter Group defines the objects used in "The Token-Bucket Meter Group defines the objects used in
describing a single-rate token bucket meter element." describing a single-rate token bucket meter element."
::= { diffServMIBGroups 4 } ::= { diffServMIBGroups 4 }
diffServMIBActionGroup OBJECT-GROUP diffServMIBActionGroup OBJECT-GROUP
OBJECTS { OBJECTS {
skipping to change at page 59, line 39 skipping to change at page 68, line 39
diffServAlgDropType, diffServAlgDropNext, diffServAlgDropType, diffServAlgDropNext,
diffServAlgDropQMeasure, diffServAlgDropQThreshold, diffServAlgDropQMeasure, diffServAlgDropQThreshold,
diffServAlgDropSpecific, diffServAlgDropStatus diffServAlgDropSpecific, diffServAlgDropStatus
} }
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Algorithmic Drop Group contains the objects that describe "The Algorithmic Drop Group contains the objects that describe
algorithmic dropper operation and configuration." algorithmic dropper operation and configuration."
::= { diffServMIBGroups 10 } ::= { diffServMIBGroups 10 }
diffServMIBRandomDropGroup OBJECT-GROUP
OBJECTS {
diffServRandomDropMinThreshBytes,
diffServRandomDropMinThreshPkts,
diffServRandomDropMaxThreshBytes,
diffServRandomDropMaxThreshPkts,
diffServRandomDropInvWeight, diffServRandomDropProbMax
diffServRandomDropStatus
}
STATUS current
DESCRIPTION
"The Random Drop Group augments the Algorithmic Drop Group for
random dropper operation and configuration."
::= { diffServMIBGroups 11 }
diffServMIBQueueGroup OBJECT-GROUP diffServMIBQueueGroup OBJECT-GROUP
OBJECTS { OBJECTS {
diffServQPriority, diffServQNext, diffServQMinRateAbs, diffServQPriority, diffServQNext, diffServQMinRateAbs,
diffServQMinRateRel, diffServQMaxRateAbs, diffServQMinRateRel, diffServQMaxRateAbs,
diffServQMaxRateRel, diffServQStatus diffServQMaxRateRel, diffServQStatus
} }
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Queue Group contains the objects that describe an "The Queue Group contains the objects that describe an
interface's queues." interface's queues."
::= { diffServMIBGroups 11 } ::= { diffServMIBGroups 12 }
diffServMIBSchedulerGroup OBJECT-GROUP diffServMIBSchedulerGroup OBJECT-GROUP
OBJECTS { OBJECTS {
diffServSchedulerMethod, diffServSchedulerNext, diffServSchedulerMethod, diffServSchedulerNext,
diffServSchedulerStatus diffServSchedulerStatus
} }
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Scheduler Group contains the objects that describe packet "The Scheduler Group contains the objects that describe packet
schedulers on interfaces." schedulers on interfaces."
::= { diffServMIBGroups 12 } ::= { diffServMIBGroups 13 }
diffServMIBStaticGroup OBJECT-GROUP diffServMIBStaticGroup OBJECT-GROUP
OBJECTS { OBJECTS {
diffServClassifierUnique, diffServSixTupleClfrUnique, diffServClassifierNextFree, diffServSixTupleClfrNextFree,
diffServMeterUnique, diffServActionUnique, diffServMeterNextFree, diffServActionNextFree,
diffServAlgDropUnique, diffServQUnique, diffServSchedulerUnique diffServAlgDropNextFree, diffServQNextFree, diffServSchedulerNextFree
} }
STATUS current STATUS current
DESCRIPTION DESCRIPTION
"The Static Group contains scalar objects used in creating unique "The Static Group contains readable scalar objects used in
enumerations for classifiers, meters, actions and queues. These creating unique identifiers for classifiers, meters, actions and
are required whenever row creation operations on such tables are queues. These are required whenever row creation operations on
supported." such tables are supported."
::= { diffServMIBGroups 13 } ::= { diffServMIBGroups 14 }
END END
5. Acknowledgments 7. Acknowledgments
This MIB builds on all the work that has gone into the conceptual model This MIB builds on all the work that has gone into the Informal
for diffserv routers. It has been developed with the active involvement Management Model for Diffserv routers. It has been developed with the
of many people, but most notably Yoram Bernet, Steve Blake, Brian active involvement of many people, but most notably Yoram Bernet, Steve
Carpenter, Dave Durham, Jeremy Greene, Roch Guerin, Scott Hahn, Keith Blake, Brian Carpenter, Dave Durham, Jeremy Greene, Dan Grossman, Roch
McCloghrie, Kathleen Nichols, Ping Pan and Bert Wijnen. Guerin, Scott Hahn, Keith McCloghrie, Bob Moore, Kathleen Nichols, Ping
Pan, Nabil Seddigh and Bert Wijnen.
6. Security Considerations 8. Security Considerations
It is clear that this MIB is potentially useful for configuration, and It is clear that this MIB is potentially useful for configuration, and
anything that can be configured can be misconfigured, with potentially anything that can be configured can be misconfigured, with potentially
disastrous effect. disastrous effect.
At this writing, no security holes have been identified beyond those At this writing, no security holes have been identified beyond those
that SNMP Security is itself intended to address. These relate primarily that SNMP Security is itself intended to address. These relate primarily
to controlled access to sensitive information and the ability to to controlled access to sensitive information and the ability to
configure a device - or which might result from operator error, which is configure a device - or which might result from operator error, which is
beyond the scope of any security architecture. beyond the scope of any security architecture.
skipping to change at page 62, line 15 skipping to change at page 71, line 15
It is recommended that the implementers consider the security features It is recommended that the implementers consider the security features
as provided by the SNMPv3 framework. Specifically, the use of the User- as provided by the SNMPv3 framework. Specifically, the use of the User-
based Security Model [12] and the View-based Access Control Model [15] based Security Model [12] and the View-based Access Control Model [15]
is recommended. is recommended.
It is then a customer/user responsibility to ensure that the SNMP entity It is then a customer/user responsibility to ensure that the SNMP entity
giving access to an instance of this MIB, is properly configured to give giving access to an instance of this MIB, is properly configured to give
access to the objects only to those principals (users) that have access to the objects only to those principals (users) that have
legitimate rights to indeed GET or SET (change/create/delete) them. legitimate rights to indeed GET or SET (change/create/delete) them.
7. References 9. References
[1] Harrington, D., Presuhn, R., and B. Wijnen, "An Architecture for [1] Harrington, D., Presuhn, R., and B. Wijnen, "An Architecture for
Describing SNMP Management Frameworks", RFC 2571, Cabletron Describing SNMP Management Frameworks", RFC 2571, Cabletron
Systems, Inc., BMC Software, Inc., IBM T. J. Watson Research, April Systems, Inc., BMC Software, Inc., IBM T. J. Watson Research, April
1999 1999
[2] Rose, M., and K. McCloghrie, "Structure and Identification of [2] Rose, M., and K. McCloghrie, "Structure and Identification of
Management Information for TCP/IP-based Internets", RFC 1155, STD Management Information for TCP/IP-based Internets", RFC 1155, STD
[3] Rose, M., and K. McCloghrie, "Concise MIB Definitions", RFC 1212, [3] Rose, M., and K. McCloghrie, "Concise MIB Definitions", RFC 1212,
skipping to change at page 64, line 20 skipping to change at page 73, line 20
S. Blake, D. Black, M. Carlson, E. Davies, Z. Wang, W. Weiss, "An S. Blake, D. Black, M. Carlson, E. Davies, Z. Wang, W. Weiss, "An
Architecture for Differentiated Service", RFC 2475, December 1998. Architecture for Differentiated Service", RFC 2475, December 1998.
[DSFIELD] [DSFIELD]
K. Nichols, S. Blake, F. Baker, D. Black, "Definition of the K. Nichols, S. Blake, F. Baker, D. Black, "Definition of the
Differentiated Services Field (DS Field) in the IPv4 and IPv6 Differentiated Services Field (DS Field) in the IPv4 and IPv6
Headers", RFC 2474, December 1998. Headers", RFC 2474, December 1998.
[DSPIB] [DSPIB]
M. Fine, K. McCloghrie, J. Seligson, K. Chan, S. Hahn, A. Smith, M. Fine, K. McCloghrie, J. Seligson, K. Chan, S. Hahn, A. Smith,
"Differentiated Services Policy Information Base", March 2000, "Differentiated Services Policy Information Base", Internet Draft
draft-ietf-diffserv-pib-00.txt
[DSTERMS] [DSTERMS]
D. Grossman, "New Terminology for Diffserv", Internet Draft <draft- D. Grossman, "New Terminology for Diffserv", Internet Draft <draft-
ietf-diffserv-new-terms-02.txt>, November 1999. ietf-diffserv-new-terms-02.txt>, November 1999.
[EF-PHB] [EF-PHB]
V. Jacobson, K. Nichols, K. Poduri, "An Expedited Forwarding PHB." V. Jacobson, K. Nichols, K. Poduri, "An Expedited Forwarding PHB."
RFC 2598, June 1999. RFC 2598, June 1999.
[IFMIB] [IFMIB]
K. McCloghrie, F. Kastenholz, "The Interfaces Group MIB using K. McCloghrie, F. Kastenholz, "The Interfaces Group MIB using
SMIv2", RFC 2233, November 1997. SMIv2", RFC 2233, November 1997.
[INETADDRESS] [INETADDRESS]
Daniele, M., Haberman, B., Routhier, S., Schoenwaelder, J., Daniele, M., Haberman, B., Routhier, S., Schoenwaelder, J.,
"Textual Conventions for Internet Network Addresses.", Internet "Textual Conventions for Internet Network Addresses.", RFC 2851,
Draft <draft-ops-endpoint-mib-08.txt>, April 2000. June 2000.
[INTSERVMIB] [INTSERVMIB]
F. Baker, J. Krawczyk, A. Sastry, "Integrated Services Management F. Baker, J. Krawczyk, A. Sastry, "Integrated Services Management
Information Base using SMIv2", RFC 2213, September 1997. Information Base using SMIv2", RFC 2213, September 1997.
[MODEL] [MODEL]
Y. Bernet, S. Blake, A. Smith, D. Grossman, "A Conceptual Model for Y. Bernet, S. Blake, A. Smith, D. Grossman, "An Informal Management
Diffserv Routers", Internet Draft <draft-ietf-diffserv- Model for Diffserv Routers", Internet Draft <draft-ietf-diffserv-
model-03.txt>, May 2000. model-04.txt>, July 2000.
[POLTERM] [POLTERM]
F. Reichmeyer, D. Grossman, J. Strassner, M. Condell, "A Common F. Reichmeyer, D. Grossman, J. Strassner, M. Condell, "A Common
Terminology for Policy Management", Internet Draft <draft- Terminology for Policy Management", Internet Draft <draft-
8. Authors' Addresses [QUEUEMGMT]
B. Braden et al., "Recommendations on Queue Management and
Congestion Avoidance in the Internet", RFC 2309, April 1998.
[RED93]
"Random Early Detection", 1993.
10. Authors' Addresses
Fred Baker Fred Baker
Cisco Systems Cisco Systems
519 Lado Drive 519 Lado Drive
Santa Barbara, California 93111 Santa Barbara, California 93111
fred@cisco.com fred@cisco.com
Kwok Ho Chan Kwok Ho Chan
Nortel Networks Nortel Networks
600 Technology Park Drive 600 Technology Park Drive
Billerica, MA 01821 Billerica, MA 01821
khchan@nortelnetworks.com khchan@nortelnetworks.com
Andrew Smith Andrew Smith
Extreme Networks ah_smith@pacbell.net
3585 Monroe Street
Santa Clara, CA 95051
USA
andrew@extremenetworks.com
Table of Contents Table of Contents
1 The SNMP Management Framework ................................... 2 1 The SNMP Management Framework ................................... 2
2 Structure of this MIB ........................................... 3 2 Introduction .................................................... 3
2.1 Overview ...................................................... 3 2.1 Relationship to the Diffserv Informal Management Model ........ 3
2.2 Classifiers ................................................... 4 2.2 Relationship to other MIBs and Policy Management .............. 3
2.2.1 Classifier Table ............................................ 4 2.3 MIB Overview .................................................. 4
2.2.2 IP Six-Tuple Classifier Table ............................... 4 3 Structure of this MIB ........................................... 5
2.3 Meters ........................................................ 5 3.1 Classifiers ................................................... 5
2.3.1 Meter Table ................................................. 5 3.1.1 Classifier Table ............................................ 5
2.3.2 Token-Bucket Meter Table .................................... 5 3.1.2 IP Six-Tuple Classifier Table ............................... 6
2.4 Actions ....................................................... 6 3.2 Meters ........................................................ 6
2.4.1 DSCP Mark Action Table ...................................... 6 3.2.1 Meter Table ................................................. 6
2.4.2 Count Action Table .......................................... 6 3.2.2 Token-Bucket Meter Table .................................... 7
2.4.3 Absolute Drop Action ........................................ 7 3.3 Actions ....................................................... 7
2.5 Queueing Elements ............................................. 7 3.3.1 DSCP Mark Action Table ...................................... 7
2.5.1 Algorithmic Dropper Table ................................... 7 3.3.2 Count Action Table .......................................... 8
2.5.2 Queues and Schedulers ....................................... 8
2.5.3 Example of Algorithmic Droppers, Queues and Schedulers ...... 9
2.5.4 Example of extending this MIB ............................... 10
2.6 The use of RowPointer ......................................... 10 3.3.3 Absolute Drop Action ........................................ 8
3 Editorial information ........................................... 13 3.4 Queueing Elements ............................................. 8
3.1 Open Issues resolved in this draft ............................ 13 3.4.1 Algorithmic Dropper Table ................................... 8
3.2 Still Open Issues ............................................. 15 3.4.2 Random Dropper Table ........................................ 9
4 MIB Definition .................................................. 16 3.4.3 Queues and Schedulers ....................................... 11
5 Acknowledgments ................................................. 61 3.4.4 Example of Algorithmic Droppers, Queues and Schedulers ...... 12
6 Security Considerations ......................................... 61 4 Conventions used in this MIB .................................... 13
7 References ...................................................... 62 4.1 The use of RowPointer ......................................... 13
8 Authors' Addresses .............................................. 65 4.2 Conceptual row creation and deletion .......................... 14
5 Editorial information ........................................... 15
5.1 Open Issues resolved in previous drafts ....................... 15
5.2 Open Issues resolved in this draft ............................ 17
5.3 Still Open Issues ............................................. 18
6 MIB Definition .................................................. 19
7 Acknowledgments ................................................. 70
8 Security Considerations ......................................... 70
9 References ...................................................... 71
10 Authors' Addresses ............................................. 74
9. Full Copyright 11. Full Copyright
Copyright (C) The Internet Society (2000). All Rights Reserved. Copyright (C) The Internet Society (2000). All Rights Reserved.
This document and translations of it may be copied and furnished to This document and translations of it may be copied and furnished to
others, and derivative works that comment on or otherwise explain it others, and derivative works that comment on or otherwise explain it
or assist in its implmentation may be prepared, copied, published and or assist in its implmentation may be prepared, copied, published and
distributed, in whole or in part, without restriction of any kind, distributed, in whole or in part, without restriction of any kind,
provided that the above copyright notice and this paragraph are provided that the above copyright notice and this paragraph are
included on all such copies and derivative works. However, this included on all such copies and derivative works. However, this
document itself may not be modified in any way, such as by removing document itself may not be modified in any way, such as by removing
 End of changes. 173 change blocks. 
454 lines changed or deleted 916 lines changed or added

This html diff was produced by rfcdiff 1.34. The latest version is available from http://tools.ietf.org/tools/rfcdiff/