Internet Engineering Task Force                                 F. Baker  |
Diffserv Working Group                                     Cisco Systems
INTERNET-DRAFT                                                   K. Chan
Expires May August 2001                                      Nortel Networks
draft-ietf-diffserv-mib-06.txt  |
draft-ietf-diffserv-mib-07.txt                                  A. Smith  |
                                                        Allegro Networks
                                                           November 2000
                                                           February 2001  |
                  Management Information Base for the
                  Differentiated Services Architecture

Status of this Memo                                                       |

This document is an Internet-Draft and is in full conformance with all
provisions of Section 10 of RFC 2026. Internet-Drafts are working
documents of the Internet Engineering Task Force (IETF), its areas, and
its working groups. Note that other groups may also distribute working
documents as Internet-Drafts.

Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet Drafts as reference material
or to cite them other than as "work in progress."

The list of current Internet-Drafts can be accessed at
http://www.ietf.org/ietf/1id-abstracts.txt.  The list of Internet-Draft
Shadow Directories can be accessed at http://www.ietf.org/shadow.html.

This document is a product of the IETF's Differentiated Services Working
Group. Comments should be addressed to WG's mailing list at
diffserv@ietf.org. The charter for Differentiated Services may be found
at http://www.ietf.org/html.charters/diffserv-charter.html

Copyright (C) The Internet Society (2000). All Rights Reserved.
Distribution of this memo is unlimited.

Abstract

This memo describes a SMIv2 MIB for a device implementing the
Differentiated Services Architecture [DSARCH], described in detail by     |
the Differentiated Services Router Informal Management Model for Diffserv Routers [MODEL].

1.  The SNMP Management Framework

The SNMP Management Framework presently consists of five major
components:

    o   An overall architecture, described in RFC 2571 [1].

    o   Mechanisms for describing and naming objects and events for the
        purpose of management. The first version of this Structure of
        Management Information (SMI) is called SMIv1 and described in
        RFC 1155 [2], RFC 1212 [3] and RFC 1215 [4]. The second version,
        called SMIv2, is described in RFC 2578 [5], RFC 2579 [6] and RFC
        2580 [7].

    o   Message protocols for transferring management information. The
        first version of the SNMP message protocol is called SNMPv1 and
        described in RFC 1157 [8]. A second version of the SNMP message
        protocol, which is not an Internet standards track protocol, is
        called SNMPv2c and described in RFC 1901 [9] and RFC 1906 [10].
        The third version of the message protocol is called SNMPv3 and
        described in RFC 1906 [10], RFC 2572 [11] and RFC 2574 [12].

    o   Protocol operations for accessing management information. The
        first set of protocol operations and associated PDU formats is
        described in RFC 1157 [8]. A second set of protocol operations
        and associated PDU formats is described in RFC 1905 [13].

    o   A set of fundamental applications described in RFC 2573 [14] and
        the view-based access control mechanism described in RFC 2575
        [15].

A more detailed introduction to the current SNMP Management Framework
can be found in RFC 2570 [16].

Managed objects are accessed via a virtual information store, termed the
Management Information Base or MIB. Objects in the MIB are defined using
the mechanisms defined in the SMI.

This memo specifies a MIB module that is compliant to the SMIv2. A MIB
conforming to the SMIv1 can be produced through the appropriate
translations. The resulting translated MIB must be semantically
equivalent, except where objects or events are omitted because no
translation is possible (use of Counter64). Some machine-readable
information in SMIv2 will be converted into textual descriptions in
SMIv1 during the translation process. However, this loss of machine

readable information is not considered to change the semantics of the
MIB.

2.  Introduction                                                          |

2.1.  Relationship to the Diffserv Informal Management Model for Diffserv          |
Router

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. modeled. It  |
describes the configuration and management of a Diffserv interface in     |
terms of a one or more Traffic Conditioning Block (TCB) which contains, (TCB), each containing,   |
arranged in the specified order, 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 modeled by cascading multiple TCBs.       |

The MIB represents this cascade by following the "Next" attributes of
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.  The
higher level concept of a TCB is not required in the parameterization or
in the linking together of the individual elements, hence it is not used
in the MIB itself and is only mentioned in the text for relating the MIB  |
with the [MODEL].  The actual distinguishing of which TCB a specific
element is a part of is not needed for the instructmentation instrumentation of a device    |
to support the functionalities functionality of DiffServ, Diffserv, but it is useful for            |
conceptual reasons.  By not including using the TCB notion in its parameters, concept, this MIB allow allows any    |
grouping of elements to construct TCBs, TCBs using the rules
indicated defined by         |
[MODEL]: that document should be consulted for the [MODEL]. allowed combinations   |
of elements that make up a TCB.  This will minimize changes to this MIB
if rules in [MODEL] changes.

The notion of a Data Path is used in this MIB to indicate the DiffServ Diffserv    |
processing a packet may experience.  This Data Path is distinguished      |
based on the Interface and the Direction of the flow the packet is part   |
of.  A Data Path Table Entry indicates the first of possibly multiple     |
elements that will apply DiffServ Diffserv treatment to the packet.

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. [MODEL].  These elements are    |
designed with their parameterization tables separated from their data
path linkage tables, allowing reuse of each table as much as possible.    |
The data path linkage in this MIB is coupled with an interface thru through    |
the use of the diffServDataPathTable.  The concept of "interface" is as for the   |
defined by 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 Behavior"-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, especially
the parameterization tables.  The Data Path table will help in the reuse
of the data path linkage tables by having the interface specific
information centralized, allowing easier mechanical replacement of
ifIndex by some sort of "roleIndex".  Work is ongoing in this area.

2.3.  MIB Overview

This MIB is structured based on the need to describe the sequential
DiffServ       |
Diffserv treatments being applied to a packet, and the parameterization
of these treatments.  These two requirements are kept separate thru out            |
throughout the design of this MIB, and are full-filled fulfilled using separate       |
tables and data definitions.

In this MIB, we model the ingress and egress portions of a DiffServ Diffserv       |
network device identically, making the distinction between them an index
variable. Each interface then performs some or all of the following
high-level functions:

o    Classify each packet according to some set of rules

o    Determine whether the packet's data stream  is conforming or not
     conforming to its permitted rates

o    Perform a set of resulting actions, possibly including counting the
     traffic, application of an appropriate drop policy and marking of
     the traffic with a Differentiated Services Code Point (DSCP) as
     defined in [DSFIELD].

o    Enqueue the traffic for output in the appropriate queue, whose
     scheduler may shape the traffic or simply forward it with some
     minimum rate or maximum latency.

The MIB therefore contains the following elements:

Data Path Table
     A general extensible framework for describing
     This is the starting point of
     DiffServ datapaths Diffserv data paths within a single DiffServ    |
     Diffserv device.  Data paths defined by this table are interface
     and interface direction specific.

Classifier and Filter Tables
     A general extensible framework and one example of a
     parameterization table - filter table     |
     (an IP Six-Tuple Multi-Field Classification Table).

Meter Tables
     A general extensible framework and one example of a
     parameterization table - TBMeter table, applicable for Simple Token
     Bucket Meter, Average Rate Meter, Single Rate Three Color Meter,
     Two Rate Three Color Meter, and Sliding Window Three Color Meter.

Action Tables
     A general extensible framework and examples of parameterization
     tables for Absolute Drop, Mark and Count actions.  The
     "multiplexer", "replicator"               |
     "multiplexer" and "null" actions described in [MODEL] are
     accomplished implicitly by means of the RowPointer structures of
     the other elements.

Queue, Scheduler and Algorithmic Dropper Tables
     A general extensible framework for parameterizing queuing and
     scheduler systems.  The queue measurement dependent algorithmic
     droppers are also described here.

3.  Structure of this MIB

This MIB is structured with separate tables for purpose of DiffServ Diffserv data  |
path description and DiffServ Diffserv treatment parameterization of the DiffServ Diffserv  |
device.  The data path description and/or the treatment parameterization  |
tables can each be reuse reused independently, allowing the flexibility to      |
maintain a common data construct for DiffServ Diffserv device configuration and    |
provisioning, independent of the configuration/provisioning configuration method used.  The          |
definitions in this MIB are intented intended to be reused reusable by the DiffServ
PIB and SNMPCONF working group's DiffServ Policy MIB. other future       |

standards.  The treatment parameters can also be reused by other IP
based technologies.  For example, IP packet filtering parameters most     |
likely can be reused by other IP based technologies. technologies that rely on packet   |
classification.                                                           |

3.1.  DiffServ  Diffserv Data Paths

This part of the MIB provide provides instrumentation for connecting the DiffServ          |
Diffserv Functional Data path Elements within a single DiffServ Diffserv device.   |
Please refer to the [MODEL] for discussions on the valid sequencing and   |
grouping of
DiffServ Diffserv Functional Data path Elements.  Given some basic
information, e.g. ifIndex and interface direction, the first DiffServ Diffserv     |
Functional Data path Element applied to a given packet on a given         |
interface is determined.  Subsequent DiffServ Diffserv Functional Elements are
provided by the "Next" pointer attribute of each entry of data path
tables.  Description of how this "Next" pointer is used in each table is
provided in their respective DESCRIPTION clause.

The data path can be redefined to allow a different level of control
other than interface level control currently defined in this MIB.  There
is on-going work in this area, most notably the development of Policy
Information Base in DiffServ and RAP working groups, and DiffServ Policy
MIB in SNMPCONF working group.

3.1.1.  Data Path Table

Entries                          *

3.1.1.  Data Path Table

Entries in the Data Path Table provide the DiffServ Diffserv treatment starting    |
points for all packets of DiffServ Diffserv interfaces on this device.  Notice
not  Not all    |
interfaces on this device need to be DiffServ Diffserv interfaces, hence not all   |
entries in the ifTable need to have corresponding entries in the Data
Path Table.  Each entry in this table is indexed by ifIndex and the
direction of the packet flow.  There should be at most two entries for
each interface, one for ingress and one for egress.  Each entry provides  |
the first DiffServ Diffserv Functional Data path Element each packet at a          |
specific interface traveling a specific relative direction should
experience.
Notice  NOTE: this table is interface specific, with the use of      |
ifIndex.  As
indicated in section 2.2, with some modification/extension of the Data
Path Table, most of the tables and their entries are reusable by other
Policy Management mechanisms. For indication of none existence of
DiffServ Treatments, entries can  Entries may be created with zeroDotZero in the
diffServDataPathStart attribute to indicate this explicitly. that there are no further     |
diffserv elements in that data path.  For example, a classifier that      |
should never match anything but is present to debug or detect traffic     |
might use this, although one could argue that it should transit to a      |
dropper.  The none
existence non-existence of DiffServ Treatment can also be any Diffserv treatment on an               |
interface/direction is indicated implicitly by not having the no corresponding    |
entry at all. The explicit/implicit selection is up to the
implementation. in this table.  This means allow allowing normal IP device processing     |
when zeroDotZero is used in the diffServDataPathStart attribute, or when
the entry does not exist.  Normal IP device processing will depend on
the device, for example, this can be forwarding the packet.

3.2.  Classifiers

The classifier, classifier element, and filter tables determine how
traffic is sorted out. They identify separable classes of traffic, by
reference to an appropriate filter, which may select anything from an

individual micro-flow to aggregates identified by DSCP.

The classification is used to send these separate streams to appropriate
Meter, Action, Algorithmic Dropper, Queue, Scheduler and Algorithmic Dropper Scheduler elements. For    |
example, to indicate a multi-stage meter, sub-classes of traffic may be sent to different meter stages:    |
e.g. in an implementation of the Assured Forwarding (AF) PHB [AF-PHB],    |
AF11 traffic might be sent to the first meter, AF12 traffic might be
sent to the second and AF13 traffic sent to the second meter stage's
out-of-profile action.

The concept of a classifier is the same as described in [MODEL].  The
structure of the classifier and classifier element tables, is the same
as the classifier described in [MODEL].  Within each classifier, it must
not be important in which order the tests filters are made. applied. This is to       |
facilitate optimized implementations such as index trees. Order Precedence is
present   |
used only to resolve ambiguity, by use of "order" here and
"precedence" as described in [MODEL].  Filter with     |
higher values of order precedence are compared first; the order of tests for    |
entries of the same order precedence is unimportant.

A datapath data path may consist of more than one classifier.  There may be        |
overlap of filter specification between filters of different
classifiers.  The first classifier functional datapath data path element           |
encountered, as determined by the sequencing of diffserv functional
datapath data  |
path elements, will be used first.

An important form of classification is "everything else": the final
stage of the classifier i.e. the one with the lowest order, must be
"complete" since the result of an incomplete classifier is not
necessarily deterministic - see [MODEL] section 4.1.2.

The definition of the actual filter to be used by the classifier is
referenced via a StaticRowPointer: this enables the use of any sort of
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.

The classifiers specified here are at the interface level, they may be
derived from some more general policies 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 discussion of Roles.

3.2.1.  Classifier Table

Classifiers

Classifiers, used in various ingress and egress interfaces, are           |
organized by entries of the Classifier Table.  With each
entry corresponds to classifier table. Each classifier will isolate a single Classifier.  It is number  |
of classes of traffic, identified by various kinds of filters. To         |
enumerate this, we define the entries in classifier table, the
Classifier Table that get linked from classifier element    |
table, and the upstream diffserv functional
datapath element, i.e. an entry in diffServDataPathTable. filter table.  A data path
may consist entry points to a classifier    |
entry.  A classifier entry identifies a list of more than one Classifier, the order classifier elements.  A   |
classifier element effectively includes the classification
processes aplies filter entry, and points to the traffic is the same as the order the   |
a "next" classifier
table entries entry or other data path functional element.  There   |
are linked potentially many types of filters, only one of which is specified in the data path.

3.2.2.  |
this MIB Module.

3.2.1.  Classifier Element Table

While

The classifier table, therefore, identifies the Classifier Table entries handles classifiers that are      |
used in various interfaces. It organizes the input side list of classifier elements  |
that identify the
Classifier, the various classes.

3.2.2.  Classifier Element Table enumerates each branch

Classifier elements point to the filters which identify various classes   |
of traffic. The separation between the
fan-out "classifier element" and the       |
"filter" allows us to use many different kinds of a Classifier, associating each fan-out branch filters with a Filter
for discriminating the traffic for that branch. Each Classifier Element
table entry is part same   |
essential semantics of "an identified set of traffic". The traffic        |
matching the filter corresponding to a Classifier, indicated by
diffServClfrElementClfrId. classifier element is given to     |
the "next" data path functional element identified in the classifier      |
element.

3.2.3.  Filter Table - IP Six-Tuple Classifier Table

This MIB includes one Filter Table, a definition for an IP Six-Tuple
Classifier, used for IP traffic classification. Entries in this filter
table are referenced from the StaticRowPointer
diffServClfrElementSpecific attributes of classifier element table
entries.

For example, 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 diffServSixTupleClfrDscp attribute set to the desired DSCP
and all other classification attributes set to match-all, their default
settings.

Each entry in the IP Six-Tuple Classifier Table defines a single filter.
The textual convention of InetAddress [INETADDR] is used for both IPv4
and IPv6 addressing.  The use of IP Six-Tuple Classifiers is discussed
in [DSARCH] and abstract examples of how they might be configured are
provided in [MODEL].

3.3.  Meters

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
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,
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
as a sequence of one or more cascaded pass/fail tests, modeled here as
if-then-else constructs. It is important to understand that this way of
modelling   |

modeling does not imply anything about the implementation being           |
"sequential":  multi-rate/multi-profile meters e.g. those designed to
support [SRTCM], [TRTCM], or [TSWTCM] can still be modelled modeled this way even  |
if they, of necessity, share information between the stages: the stages
are introduced merely as a notational convenience in order to simplify
the MIB structure.

3.3.1.  Meter Table

The generic meter table is used as a base for all more specific forms of
meter.  The definition of parameters specific to the type of meter used
is referenced via a pointer to a table containing those specifics.  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.3.2.  Token-Bucket Meter Table

This is included as an example of a common type of meter.  Entries in
this table are referenced from the StaticRowPointer
diffServMeterSpecific attributes of meter table entries.  The parameters
are represented by a rate diffServTBMeterRate, a burst size
diffServTBMeterBurstSize, and an interval diffServTBMeterInterval.  How
these parameters are used depends on the type of meter being
parameterized, this is provided by the diffServTBMeterType attribute.
Additional meter parameterization tables can be defined in other MIBs
when necessary.

3.4.  Actions

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  |
based on some algorithm" are handled elsewhere as queueing queuing mechanisms,
rather than actions, consistent with [MODEL].  The "multiplexer",
"replicator" and "null" actions described in [MODEL] are accomplished
implicitly by means of the RowPointer structures of the other elements.

This MIB uses the Action Table diffServActionTable to organize one
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
traffic stream by using each entry's diffServActionNext attribute.  The
diffServActionNext attribute of the last action entry in the chain
points to the next element in the TCB, if any, e.g.  a Queueing Queuing element.   |
It may also point at a next TCB.

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

different Action types.  This flexibility allows additional Actions be
specified in future revisions of this MIB, or in other MIBs and also
allows for the use of proprietary Actions without impact on those
defined here.

3.4.1.  DSCP Mark Action Table

This Action is applied to traffic in order to mark it with a Diffserv
Codepoint (DSCP) value, specified in the diffServDscpMarkActTable. Other
marking actions might be specified elsewhere - these are outside the
scope of this MIB.

3.4.2.  Count Action Table

Count Actions are used to count the traffic passing along a particular
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
an Absolute Dropper Action are specified, the Count Action needs to
count the traffic stream before any traffic gets dropped.  Note that
there are counters contained directly in Algorithmic Dropper elements to
indicate the amount of traffic dropped by those elements.

Notice counter support is implementation specific.  Where within a data
path and for what purpose a counter exists can be different between
implementations.  It is advisable to have at least one counter within a
data path and have different counts derived from DiffServ counters and
counters

Since count actions are defined in this way, they are inherently          |
optional.  However, the management information necessary to demonstrate   |
SLA compliance or non-compliance is not available from any other MIBs. source.  |
Therefore, practically, count actions may be expected to be included in   |
each set of actions that a network manager configures.

Counters are arranged in a single table but with separate conformance
statements for low-speed and high-speed interfaces, consistent with
[IFMIB].

3.4.3.  Absolute Drop Action

This action just silently discards all traffic presented to it, without
counting it. This action has no additional parameters and so is
represented only within diffServActionType without its specific table.    |

3.5.  Queueing  Queuing Elements

These include Algorithmic Droppers, Queues and Schedulers which are all
inter-related in their use of queueing queuing techniques.                         |

3.5.1.  Algorithmic Dropper Table

Algorithmic Droppers have a close relationship with queueing: they are represented in this MIB by entries in an         |
Algorithmic Dropper Table.
Entries contain a diffServAlgDropNext attribute which indicates to which
queue they sink their traffic.  An Algorithmic Dropper is assumed to operate  |

indiscriminately on all packets that are presented at its input. If it is necessary to perform
additional classification on the stream then a separate TCB must input, all      |
traffic separation should be
introduced at this point: Classifier elements here can then distinguish done by classifiers and meters preceding     |
it.

Algorithmic Droppers have a close relationship with queuing, each         |
Algorithmic Dropper Table entry contains a diffServAlgDropQMeasure        |
attribute, indicating which queue's state affects the different types calculation of traffic on the  |
Algorithmic Dropper.  Each entry also contains a diffServAlgDropNext      |
attribute which dropping is indicates to act and which queue the
treatment for each type is described by a separate diffServAlgDropEntry. Algorithmic Dropper sinks    |
its traffic.

Algorithmic Droppers may also contain a pointer to specific detail of     |
the drop algorithm, diffServAlgDropSpecific. 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 module 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
a queue-depth threshold at which some drop action is to start. This is    |
represented in this MIB, as a base attribute, diffServAlgDropQThreshold,  |
of the Algorithmic Dropper entry.  The queue for attribute,                         |
diffServAlgDropQMeasure, specifies which queue's depth                    |
diffServAlgDropQThreshold is to be
compared and the depth threshold to compare against, is specified with
diffServAlgDropQMeasure. against.

o    A Tail Dropper requires the specification of a maximum queue depth
     threshold: when the queue pointed at by diffServAlgDropQMeasure
     reaches that depth threshold, diffServAlgDropQThresh, any new
     traffic arriving at the dropper is discarded. This algorithm uses
     only parameters that are part of the diffServAlgDropEntry.

o    A Head Dropper requires the specification of a maximum queue depth
     threshold: when the queue pointed at by diffServAlgDropQMeasure
     reaches that depth threshold, diffServAlgDropQThresh, traffic
     currently at the head of the queue is discarded. This algorithm
     uses only parameters that are part of the diffServAlgDropEntry.

o    Random Droppers are recommended as a way to control congestion, in
     [QUEUEMGMT] and called for in the [AF-PHB]. Various implementations
     exist, which agree on marking or dropping just enough traffic to
     communicate with TCP-like protocols about congestion avoidance, but
     differ markedly on their specific parameters. This MIB attempts to
     offer a minimal set of controls for any random dropper, but expects
     that vendors will augment the table with additional controls and     |
     status in accordance with their implementation.  This algorithm      |
     requires additional parameters on top of those in                    |
     diffServAlgDropEntry: these are discussed below.

3.5.2.  Random Dropper Table

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  Although it is possible for Qclip = Qmax.                        |

In the MIB module, diffServRandomDropMinThreshBytes and
diffServRandomDropMinThreshPkts represent Qmin.
diffServRandomDropMaxThreshBytes and diffServRandomDropMaxThreshPkts
represent Qmax.  diffServAlgDropQThreshold represents Qclip.              |
diffServRandomDropInvProbMax represents Pmax. Pmax (inverse).  This MIB does    |
not represent Pmin (assumed to be zero unless otherwise represented) or
Qclip (assumed to be Qmax unless otherwise represented).

      +-------------+      +-----------+
  --->| Next   -----+--+-->| Next    --+------> to Scheduler
      | Thresh=100k     |
In addition, since message memory is finite, queues generally have some   |
upper bound above which they are incapable of storing additional          | Min=none  |
      | Measure ----+--+   | Max=none  |
      | Type=random |      | Pri=10    |
      | Specific ---+--+   | Type=fifo |
      +-------------+  |   +-----------+
        AlgDrop.3      |  Queue.4
                       |
                       |   +--------------+
                       +-->| Minthresh=10k|
                           | Maxthresh=80k|
                           | Weight=1/16  |
                           | ProbMax= 0.5
traffic.  Normally this number is equal to Qclip, specified by            |
                           +--------------+
                            RandomDrop.3

  Figure 1: Example Use of the RandomDropTable for Random Droppers
diffServeAlgDropQThreshold.

Each random dropper specification is associated with a queue. This
allows multiple drop processes (of same or different types) to be         |
associated with the same queue, as different PHB implementations may
require.  This also allows for sequences of multiple droppers if

      AlgDrop                                   Queue                     |
      +-----------------+                       +-------+                 |
  --->| Next   ---------+--+------------------->| Next -+--> ...          |
      | QMeasure -------+--+                    | ...   |                 |
      | QThreshold      |     RandomDrop        +-------+                 |
      | Type=randomDrop |     +----------------+                          |
      | Specific -------+---->| MinThreshBytes |                          |
      +-----------------+     | MaxThreshBytes |                          |
                              | InvProbMax     |                          |
                              | InvWeight      |                          |
                              | SamplingRate   |                          |
                              +----------------+                          |

  Figure 1: Example Use of the RandomDropTable for Random Droppers        *

necessary.

The calculation of a smoothed queue length may also have an important     |
bearing on the behaviour behavior of the dropper: parameters may include the        |
sampling rate interval or rate, 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.  The availability of
diffServRandomDropSamplingRate as readable is important, the information
provided by Sampling Rate is essential to the configuration of
diffServRandomDropInvWeight.  Having Sampling Rate be configurable is
also helpful, as line speed increases, the ability to have queue
sampling be less frequent than packet arrival is needed.  Note however
that there is ongoing research on this topic, see e.g. [ACTQMGMT] and
[AQMROUTER].

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 standardized here.

NOTE: Deterministic Droppers can be viewed as a special case of Random
Droppers with the drop probability restricted to 0 and 1. Hence
Deterministic Droppers might be described by a Random Dropper with Pmin
= 0, Pmax = 1, Qmin = Qmax = Qclip, the averaged queue length at which
dropping occurs.

3.5.3.  Queues and Schedulers

The Queue Table models simple FIFO queues, as described in [MODEL]
section 7.1.1.  The Scheduler Table allows flexibility in constructing
both simple and somewhat more complex queueing queuing hierarchies from those      |
queues.  Of course, since TCBs can be cascaded multiple times on an
interface, even more complex hierarchies can be constructed that way
also.

Queue Table entries are pointed at by the "next" attributes of the
upstream elements e.g. diffServMeterSucceedNext.  Note that multiple
upstream elements may direct their traffic to the same Queue Table
entry. For example, the Assured Forwarding PHB suggests that all traffic
marked AF11, AF12 or AF13 be placed in the same queue, after metering,
without reordering. This would be represented by having the
diffServMeterSucceedNext of each upstream meter point at the same entry
in the Queue Table.

Notice

NOTE: Queue Table and Scheduler Table entries are for data path           |
description, they both uses Scheduler Parameterization Table entries for

diffserv treatment parameterization.

Queue Table entries specify the scheduler it wants service from by use
of its Next pointer.

Each Scheduler Table entry represents the algorithm in use for servicing
the one or more queues that feed it. The [MODEL] section 7.1.2 describes
a scheduler with multiple inputs: this is represented in the MIB by
having the scheduling parameters be associated with each input.  In this
way, sets of Queues can be grouped together as inputs to the same
Scheduler.  This table serves to represent the example scheduler
described in the [MODEL].   More complex queuing and scheduling
structures are possible using the tables defined in this MIB.  When
necessary, more complex constructs may be created outside of this MIB.

Scheduler Parameter Table entries are used to parameterized parameterize each input     |
that feeds into a scheduler.  The inputs can be a mixture of Queue Table
and Scheduler Table entries.  Scheduler Parameter Table entries can be
used/reused by one or more Queue and/or Scheduler Table entries.

For representing a Strict Priority scheduler, each scheduler input is
assigned a priority with respect to all the other inputs feeding the
same scheduler, with default values for the other parameters.  A          |
higher-priority input which contains traffic that is not being delayed    |
for shaping will be serviced first over before a lower-priority
input, assuming that all guarantees have already been met. input.

For weighted scheduling method Weighted Queuing methods e.g. WFQ, WRR, the "weight" of a given       |
scheduler input is represented with a Minimum Service Rate leaky-bucket   |
profile which provides guaranteed bandwidth to that input, if required.   |
This is represented, as were token-bucket meters, by a rate               |
diffServSchdParamMinRateAbs and a burst size diffServSchdParamBurstSize.                              |
diffServSchdParamMinBurstSize.  The rate may, alternatively, be           |
represented by a relative value, as a fraction of the interface's         |
current line rate, diffServSchdParamMinRateRel to assist in cases where   |
line rates are variable or where a higher-level policy might be           |
expressed in terms of fractions of network resources.  The two rate       |
parameters are inter-
related inter-related and changes in one may be reflected in the   |
other.

For weighted scheduling methods, one can say loosely, that WRR focuses
on meeting bandwidth sharing, without concern for relative delay amongst
the queues; where WFQ control both queue service order and amount of
traffic serviced, providing meeting bandwidth sharing and relative delay
ordering amongst the queues.

An

A queue or scheduled set of queues (which is an input to a scheduler)     |
may also be capable of acting as a non-work-conserving [MODEL] traffic

shaper: this is done by defining a Maximum Service Rate leaky-
bucket leaky-bucket
profile in order to limit the scheduler bandwidth available to that
input. This is represented, similarly to the minimum rate, by a rate      |
diffServSchdParamMaxRateAbs and a burst size
diffServSchdParamBurstSize.                              |
diffServSchdParamMaxBurstSize.  The rate may, alternatively, be
represented by a relative value, as a fraction of the interface's
current line rate, diffServSchdParamMaxRateRel.  There was discussion in  |
the working group about alternative modeling approaches, such as          |
defining a shaping action or a shaping element. We did not take this      |
approach because shaping is in fact something a scheduler does to its     |
inputs, and we felt it was simpler and more elegant to simply describe    |
it in that context.

Other types of priority and weighted scheduling methods can be defined    |
using existing parameters in diffServSchdParamEntry.  Notice  NOTE:
diffServSchedulerMethod uses OBJECT IDENTIFIER syntax, with the
different types of scheduling methods defined as OBJECT-IDENTITY.  When
new         |
Future scheduling methods need to may be defined, and no new scheduling
parameters are needed, just need to add a new OBJECT-IDENTITY definition defined in some other MIB, with description MIBs.  This require an  |
OBJECT-IDENTITY definition, a description of how the existing scheduling
parameters will be used by the new scheduling method.  If the existing
scheduling parameters objects     |
are not sufficient, reused, if they are, and any new scheduling parameter
tables can be defined in some other MIB.

Notice objects they require.

NOTE: hierarchical schedulers can be parameterized using this MIB by      |
having Scheduler Table entries feeds into Scheduler Table entry.          |

4.  MIB Usage Example

This section provides some examples on how the different table entries    |
of this MIB may be used together for a DiffServ Diffserv Device, with the usage
of each individual attribute be defined within the MIB module itself.
For the figures, all the MIB table entry and attribute names assumes to
have "diffServ" as their first common initial part of name, with the
table entry name assumed to be their second common initial part of name.
"0.0" is being used to mean zeroDotZero.  And for Scheduler Method "= X"
means "using the OID of diffServSchedulerX".

4.1.  Model's Example

As an example, when this MIB's structures are used for the hypothetical
configuration in [MODEL] section 8.1, the result is shown in Figure 2,
3, and 4.  The parameterization table entries' values are not specified
in detail here, they can be obtained from [MODEL] section 8.1.  This
example has been explained in sufficient detail in [MODEL] section 8.1,
please use that as a reference.            *

+---------------------+                +------------------------> Q_EF
|DataPath             |                |
| ifIndex=1           |                |       +--------------+
| IfDirection=Ingress |    +------+    |  +--->|Action        |
| Start --------------+--->|Clfr  |    |  |    | Id=EF2       |
+---------------------+    | Id=1 |    |  |    | Next=0.0     |
                           +------+    |  |    | Specific=0.0 |
                                       |  |    | Type=AbsDrop |
                                       |  |    +--------------+
                                       |  |
                                       |  +-------------------+
                                       |                      |
  +------------+      +--------------+ |     +-----------+    |
  |ClfrElement |  +-->|Meter         | |  +->|Action     |    |
  | Id=EF      |  |   | Id=EF        | |  |  | Id=EF1    |    |
  | ClfrId=1   |  |   | SucceedNext -+-+  |  | Next -----+----+
  | Order=NA   |  |   | FailNext ----+----+  | Specific -+--+
  | Next ------+--+   | Specific -+  |       | Type=Spcf |  |
  | Specific --+-+    +-----------+--+       +-----------+  |
  +------------+ |                |                         |
                 |                |                 +-------+
                 |                |                 |
                 |   +--------+   |   +---------+   |  +--------------+
                 +-->|FilterEF|   +-->|TBMeterEF|   +->|CountActEFDrop|
                     +--------+       +---------+      +--------------+

  +------------+      +----------+      +--------------+
  |ClfrElement |  +-->|Action    |  +-->|AlgDrop       |
  | Id=AF11    |  |   | Id=AF11  |  |   | Id=AF11      |
  | ClfrId=1   |  |   | Next ----+--+   | Type=tailDrop|
  | Order=NA   |  |   | Specific +-+    | Next --------+--+-> Q_AF11 Q_AF1       |
  | Next ------+--+   | Type=Spcf| |    | QMeasure ----+--+
  | Specific --+-+    +----------+ |    | QThreshold   |
  +------------+ |                 |    | Specific=0.0 |
                 |                 |    +--------------+
                 |                 |
                 |  +----------+   |  +------------+
                 +->|FilterAF11|   +->|CountActAF11|
                    +----------+      +------------+

      Figure 2: Example from Model Section 8.1 part 1
  +------------+      +--------------+      +-------------+
  |ClfrElement |  +-->|Meter         |  +-->|Action       |
  | Id=AF21    |  |   | Id=AF21      |  |   | Id=AF21S    |
  | ClfrId=1   |  |   | SucceedNext -+--+   | Next -------+----> Q_AF21 Q_AF2    |
  | Order=NA   |  |   | FailNext +   |      | Specific -+ |
  | Next ------+--+   | Specific --+ |      | Type=Spcf | |
  | Specific --+-+    +----------+-+-+      +-----------+-+
  +------------+ |               | |                    |
                 |               | |                +---+
                 |               | |                |
                 |  +----------+ | |  +-----------+ |  +-------------+
                 +->|FilterAF21| | +->|TBMeterAF21| +->|CountActAF21S|
                    +----------+ |    +-----------+    +-------------+
                                 |
                  +--------------+
            +--------------------+                                        |
            |                                                             |
            |   +-----------+      +-----------+                          |
            +-->|Action     |  +-->|Action     |                          |
                | Id=AF21F1 |  |   | Id=AF21F2 |                          |
                | Next -----+--+   | Next -----+------> Q_BE Q_AF2             |
                | Specific -+-+    | Specific -+-+                        |
                | Type=Spcf | |    | Type=Spcf | |                        |
                +-----------+ |    +-----------+ |                        |
                              |                  |  +-------------+                        |
                              |  +-------------+ |  +---------------+     |
                              +->|CountActAF21F| +->|DscpMarkActBE|
                                       +-------------+ +->|DscpMarkActAF22|     |
                                 +-------------+    +---------------+     |

  +------------+
  |ClfrElement |  +-----------------------------------------> Q_BE
  | Id=WildCard|  |
  | ClfrId=1   |  |
  | Order=NA   |  |
  | Next ------+--+    +--------------+
  | Specific --+------>|FilterMatchAll|
  +------------+       +--------------+

      Figure 3: Example from Model Section 8.1 part 2
        +-------------+
Q_EF--->|Q            |
        | Id=EF    +--+--------------------------+
        | Next ----+  |   +-----------+          |
        | SchdParam --+-->|SchdParamEF|          |
        +-------------+   +-----------+          |
                                                 |
        +-------------+      +----------------+                          |  +----------------+
Q_AF11->|Q    |   +->|Scheduler
Q_AF1-->|Q            |                          +->|Scheduler       |    | Id=AF11     |   |  | Id=AF11Shaper
        | Id=AF1   +--+--------------------------+  | Id=Diffserv    | Id=DiffServ    |
        | Next -------+---+ ----+  | Next ----------+--+   +------------+         | Next=0.0  | Next=0.0       | SchdParam --+-+    | Method=Shaping
        | SchdParam --+-->|SchdParamAF1|         |  | Method=Priority|
        +-------------+ |    | SchdParam -+    |
        +-------------+   +------------+         |  | SchdParam=0.0  |    |    +------------+---+
                                                 |  +----------------+
        +---------------+                 |    |
        |                    +------------+      |
        |  +--------------+  |  +-------------+  |
        +->|SchdParamAF11S|  +->|SchdParamAF11|  |
           +--------------+
        +-------------+                          |
Q_AF2-->|Q            |
        +-------------+                          |
Q_AF21->|Q                          |                        |
        | Id=AF21 Id=AF2   +--+--------------------------+                        |
        | Next ----+  |   +-------------+   +------------+         |                        |
        | SchdParam --+-->|SchdParamAF21| --+-->|SchdParamAF2|         |                        |
        +-------------+   +-------------+   +------------+         |                        |
                                                 |
        +-------------+                          |
Q_BE--->|Q            |                          |
        | Id=BE    +--+--------------------------+
        | Next ----+  |   +-----------+
        | SchdParam --+-->|SchdParamBE|
        +-------------+   +-----------+

      Figure 4: Example from Model Section 8.1 part 3

4.2.  Additional Data Path Example

4.2.1.  Data Path and Classifier Example Discussion

The example in Figure 5 shows a single DataPathTable diffServDataPathTable entry        |
feeding into a single Classifier entry, with three ClfrElement Classifier Element     |
and Filter Table entry pairs belonging to this Classifier 1.  Notice the
three Filters used here must completely classify all the traffic
presented to this data path.

Another level of classification can be defined that follows the Action    |
functional DataPath elements in Figure 5.  This multi-level
classification allow the construction of traffic separations and          |
specific actions at each level, like:
  if (dept1) then take dept1-action
  {

+---------------------+
|DataPath             |
| ifIndex=1           |
| IfDirection=Ingress |    +------+
| Start --------------+--->|Clfr  |
+---------------------+    | Id=1 |
                           +------+

  +------------+      +--------------+      +-----------+
  |ClfrElement |  +-->|Meter         |  +-->|Action     |
  | Id=101     |  |   | Id=101       |  |   | Id=101    |
  | ClfrId=1   |  |   | SucceedNext -+--+   | Next -----+---->...
  | Order=NA   |  |   | FailNext ----+->... | Specific -+-+
  | Next ------+--+   | Specific -+  |      | Type=Spcf | |
  | Specific --+-+    +-----------+--+      +-----------+ |
  +------------+ |                |               +-------+
                 |   +-------+    |   +--------+  |   +---------+
                 +-->|Filter1|    +-->|TBMeter1|  +-->|CountAct1|
                     +-------+        +--------+      +---------+

  +------------+      +--------------+      +-----------+
  |ClfrElement |  +-->|Meter         |  +-->|Action     |
  | Id=102     |  |   | Id=102       |  |   | Id=102    |
  | ClfrId=1   |  |   | SucceedNext -+--+   | Next -----+---->...
  | Order=NA   |  |   | FailNext ----+->... | Specific -+-+
  | Next ------+--+   | Specific -+  |      | Type=Spcf | |
  | Specific --+-+    +-----------+--+      +-----------+ |
  +------------+ |                |               +-------+
                 |   +-------+    |   +--------+  |   +---------+
                 +-->|Filter2|    +-->|TBMeter2|  +-->|CountAct2|
                     +-------+        +--------+      +---------+

  +------------+      +--------------+      +-----------+
  |ClfrElement |  +-->|Meter         |  +-->|Action     |
  | Id=103     |  |   | Id=103       |  |   | Id=103    |
  | ClfrId=1   |  |   | SucceedNext -+--+   | Next -----+---->...
  | Order=NA   |  |   | FailNext ----+->... | Specific -+-+
  | Next ------+--+   | Specific -+  |      | Type=Spcf | |
  | Specific --+-+    +-----------+--+      +-----------+ |
  +------------+ |                |               +-------+
                 |   +-------+    |   +--------+  |   +---------+
                 +-->|Filter3|    +-->|TBMeter3|  +-->|CountAct3|
                     +-------+        +--------+      +---------+

      Figure 5: Additional Data Path Example Part 1
     +-------------+                          +-----------------+     +----------------+         |
---->|Q            |                       +->|Scheduler        |  +->|Scheduler         |
     | Id=EF       |                       |  | Id=DiffServ Id=Diffserv     |         |
     | Id=Shaping     |
     | Next -------+---+  | Next -----------+--+ -------+-----------------------+  | Next=0.0        |         |
     | SchdParam -+|                       |  | Method=Priority |         | Method=Shaping |
     +------------++                       |  | SchdParam -+ SchdParam=0.0   |         | SchdParam=0.0
                  |                        |  +-----------------+         |  +------------+----+     +----------------+
     +------------+                        |                              |
     |                                     |  +------------+                              |
     |  +-----------+                      |                              |
     +->|SchdParamEF|                      |                              |  +----------------+
        +-----------+                      +---------------------+        |  +->|SchdParamShaping|
                       |     +----------------+
                       |
                       +-----------------------------------------+
                                                                 |
    +----------------+       +-------------+                     |
--->|AlgDrop         |    +->|Q            |                     |
    | Id=AF11        |    |  | Id=AF1X Id=AF1      |    +-------------+  |        |
    | Type=randomDrop|    |  | Next -------+--->|Scheduler    |  |
    | Next ----------+-+--+  | SchdParam -+|    | Id=AF       |  |
    | QMeasure ------+-+  |  +------------++    | Next -------+--+
    | QThreshold     |    |               |     | Method=WFQ  |
    | Specific -+    |    |  +------------+     | SchdParam --+--+
    +-----------+----+    |  |                  +-------------+  |
                |         |  |  +-------------+  +------------+                   |        |
    +-----------+         |  +->|SchdParamAF1X|  +->|SchdParamAF1|  +----------------+        |
    |  +--------------+   |     +-------------+     +------------+  |                         |
    +->|RandomDropAF11|   |                     |  +-----------+
       +--------------+   |                     +->|SchdParamAF|
                          |                        +-----------+
    +----------------+    |
--->|AlgDrop         |    |
    | Id=AF12        |    |
    | Type=randomDrop|    |
    | Next ----------+-+--+
    | QMeasure ------+-+
    | QThreshold     |
    | Specific -+    |
    +-----------+----+
                |
    +-----------+
    |  +--------------+
    +->|RandomDropAF12|
       +--------------+

      Figure 6: Additional Data Path Example Part 2

Another level of classification can be defined that follows the Action
functional datapath elements in Figure 5.  This second level of
classifiers and their subsequent functional datapath elements would be
considered as in another TCB.

This multi-level classification allow the construction of traffic
seperations like:

    if (dept1) (appl1) then take dept1-action
  {
    if (appl1) then take dept1-appl1-action. dept1-appl1-action.
    if (appl2) then take dept1-appl2-action.

    if (appl3) then take dept1-appl3-action.
  }
  if (dept2) then take dept2-action
  {
    if (appl1) then take dept2-appl1-action.
    if (appl2) then take dept2-appl2-action.
    if (appl3) then take dept2-appl3-action.
  }
  if (dept3) then take dept3-action
  {
    if (appl1) then take dept3-appl1-action.
    if (appl2) then take dept3-appl2-action.
    if (appl3) then take dept3-appl3-action.
  }

Minimumly,

Minimally, the filters for appl1, appl2, appl3 may be reused for the      |
above setup.

4.2.2.  Meter and Action Example Discussion

A simple Meter that can be parameterized by a single TBMeter entry is     |
shown here.  For Metering types that require mutliple multiple TBMeter entries
for parameterization, a second level Meter and TBMeter table entries may
be used.  For example, for trTCM, [TRTCM], with the first level TBMeter entry    |
used for Peak Information Token Bucket, the first level SucceedNext
points to the second level Meter entry, with second level TBMeter entry
used for Committed Information Token Bucket.

Notice the CountAct Action is shown in Figure 5.  This is purposely done  |
to indicate indicates that all datapaths DataPath should have at least one CountAct Action.
Other actions can be pointed to by the Next pointer of the CountAct
action, like DscpMarkAct action.

4.2.3.  Queue and Scheduler Example Discussion

Example in Figure 6 shows three classified input traffic streams, EF,
AF11, and AF12, feeding into their respective queue and algorithmic
droppers.  After their respective dropping process, the AF traffic
streams feed into the same queue, QAF1X.

A Scheduler, AF, is shown in Figure 6, as the sink for AF1X queue
traffic, servicing AF1X queue with scheduling parameters indicated by
SchdParamAF1X.  This scheduler is used to service traffic from AF1X,
AF2X, AF3X queues using weighted fair queueing queuing method.  The AF2X and AF3X  |
queues are not shown in Figure 6, they can be very much like AF1X queue

setup.

Another traffic stream, EF, is handled by the EF queue.  Scheduler
DiffServ        |
Diffserv services output of EF queue using SchdParamEF, and output of AF
scheduler using SchdParamAF, with Priority Queue scheduling method.

Notice all the diffserv traffic may go out on a link with traffic
shaping.  The traffic shaping can be parameterize using the Shaping
Scheduler in Figure 6.  For shaping, the diffServSchdParamMaxRate
attributes should be used.  The Shaping Scheduler is indicated as the
last diffserv functional element of this data path by using its Next
pointer with value of zeroDotZero.

5.  Conventions used in this MIB

5.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
to indicate succession, for pointing to data path linkage table entries.

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 you to the
MIB row representing that thing. In the diffServMeterTable, for example,
the diffServMeterFailNext RowPointer might take you to another meter,
while the diffServMeterSucceedNext RowPointer would take you to an
action.

     NOTE -- the RowPointer construct is used to build the TCBs
     described in [MODEL]: this MIB does not model TCBs directly - it
     operates at a lower level of abstraction using only individual
     elements, connected in succession by RowPointers. Therefore, the     |
     concept of TCBs enclosing individual functional datapath DataPath elements    |
     is not applicable to this MIB, although such a concept may be
     employed by management tools that use this MIB.

It is possible that a path through a device following a set of
RowPointers is indeterminate i.e. it ends in a dangling RowPointer.
Guidance is provided in the MIB module's DESCRIPTION-clause for each of
the linkage attribute.  In general, for both zeroDotZero and dangling
RowPointer, it is assumed the data path ends and the traffic should be
given to the none-diffserv part of the device.  Any variation from this
usage is indicated by the attribute affected.

5.2.  The use of StaticRowPointer

StaticRowPointer, like 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 to indicate parameterization, for
pointing to parameterization table entries.

For indirection as in the diffServClfrElementTable, the idea is to allow
other MIBs, including proprietary ones, to define new and arcane filters
- MAC headers, IPv4 and IPv6 headers, BGP Communities and all sorts of    |
other things - whilst still utilising utilizing 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.

StaticRowPointer also clearly indicate the identified conceptual row's
content does not change, hence they can be simultaneously used, pointed
to, by more than one data path linkage table entries.  The
identification of StaticRowPointer allows higher level policy mechanisms
to take advantage of this characteristic.

5.3.  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.
diffServClfrNextFree which provides a suitable value for the index of
the next row to be created e.g. diffServClfrId. A special value, 0, is
used to indicate that no more entries can be created configured 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].

6.  Extending this MIB

With the structures of this MIB divided into data path linkage tables
and parameterization tables, and with the use of RowPointer and
StaticRowPointer, new data path linkage and parameterization tables can
be defined in other MIB modules, and used with tables defined in this
MIB.  This MIB does not limit on the type of entries its RowPointer
attributes can point to, hence new functional data path elements can be
defined in other MIBs and integrated with functional data path elements
of this MIB.  For example, new Action functional data path element can
be defined for Traffic Engineering and be integrated with DiffServ Diffserv        |
functional data path elements, possibly used within the same data path
sharing the same classifiers and meters.

It is more likely that new parameterization tables will be created in
other MIBs as new methods or proprietary methods get deployed for
existing diffserv functional data path elements.  For example, different
kinds of filters can be defined by using new filter parameterization
tables.  New scheduling methods can be deployed by defining new
scheduling method OIDs and new scheduling parameter tables.

Notice both new data path linkage tables and parameterization tables can
be added without needing to change this MIB document or affect existing
tables and their usage.

7.  MIB Definition

DIFF-SERV-MIB                                                        |

DIFFSERV-DSCP-TC DEFINITIONS ::= BEGIN                                    |
                                                                          |
    IMPORTS
    Integer32, Unsigned32, Counter32, Counter64, MODULE-IDENTITY, OBJECT-TYPE, OBJECT-IDENTITY,
    zeroDotZero, mib-2                                     |
         FROM SNMPv2-SMI
    TEXTUAL-CONVENTION, RowStatus, RowPointer, TimeStamp
         FROM SNMPv2-TC
    MODULE-COMPLIANCE, OBJECT-GROUP
         FROM SNMPv2-CONF
    ifIndex
        FROM IF-MIB
    InetAddressType, InetAddress
        FROM INET-ADDRESS-MIB
    BurstSize                                                  |
    TEXTUAL-CONVENTION                                                    |
         FROM INTEGRATED-SERVICES-MIB;

diffServMib SNMPv2-TC;                                                  |
                                                                          |
                                                                          |
diffServDSCPTC MODULE-IDENTITY                                            |
    LAST-UPDATED "200011190000Z" "200101080000Z"                                          |
    ORGANIZATION "IETF Diffserv WG"                                       |
    CONTACT-INFO                                                          |
       "       Fred Baker                                                 |
               Cisco Systems                                              |
               519 Lado Drive                                             |
               Santa Barbara, CA 93111, USA                               |
               E-mail: fred@cisco.com                                     |
                                                                          |
                                                                          |
               Kwok Ho Chan                                               |
               Nortel Networks                                            |
               600 Technology Park Drive                                  |
               Billerica, MA 01821, USA                                   |
               E-mail: khchan@nortelnetworks.com                          |
                                                                          |
                                                                          |
               Andrew Smith                                               |
               Allegro Networks                                           |
               6399 San Ignacio Ave                                       |
               San Jose, CA 95119, USA                                    |
               E-mail: andrew@allegronetworks.com"                        |
    DESCRIPTION
       "This MIB defines the objects necessary to  manage  a
       device  that  uses the Differentiated Services Archi-
       tecture  described                                                           |
       "The Textual Conventions defined in  RFC  2475  and this module should be used     |
       whenever the  Informal
       Management  Model for DiffServ Routers Diffserv Code Point is used in draft-ietf-
       diffserv-model-05.txt." a MIB."                |
    REVISION "200011190000Z" "200101080000Z"                                              |
    DESCRIPTION                                                           |
       "Initial version, published as RFC xxxx."                          |
    ::= { mib-2 12345 12344 }  -- anybody who uses this unassigned
                         -- number deserves the wrath of to be assigned by IANA

diffServMIBObjects     OBJECT IDENTIFIER ::= { diffServMib 1 }
diffServMIBConformance OBJECT IDENTIFIER                        |
                                                                          |
                                                                          |
Dscp ::= { diffServMib 2 }

-- These textual conventions have no effect on either the syntax
-- nor the semantics of any managed object.  Objects defined
-- using this convention are always encoded by means of the
-- rules TEXTUAL-CONVENTION                                               |
    DISPLAY-HINT "d"                                                      |
    STATUS   current                                                      |
    DESCRIPTION                                                           |
       "The IP header Diffserv Code-Point that define their primitive type.

Dscp may be used for            |
       discriminating or marking a traffic stream."                       |
    REFERENCE                                                             |
        "RFC 2474, RFC 2780"                                              |
    SYNTAX   Integer32 (0..63)                                            |
                                                                          |
                                                                          |
DscpOrAny ::= TEXTUAL-CONVENTION                                          |
    DISPLAY-HINT "d"                                                      |
    STATUS   current                                                      |
    DESCRIPTION                                                           |
       "The IP header Diffserv Code-Point that may be used for            |
       discriminating or marking a traffic stream. The value -1  ( 4294967295 for Integer32 ) is used   |
       to indicate a wildcard i.e. any value."
    SYNTAX   Integer32 (4294967295                            | 0..63)

SixTupleClfrL4Port ::= TEXTUAL-CONVENTION
    DISPLAY-HINT "d"
    STATUS   current
    DESCRIPTION
       "A value indicating a Layer-4 protocol port number."
    REFERENCE                                                             |
        "RFC 2474, RFC 2780"                                              |
    SYNTAX   Unsigned32 (0..65535)

IfDirection   Integer32 (-1 | 0..63)                                       |

END                                                                       |

SNMP-ROWPOINTER-TC-MIB DEFINITIONS ::= BEGIN                              |

    IMPORTS                                                               |
    MODULE-IDENTITY, mib-2                                                |
         FROM SNMPv2-SMI                                                  |
    TEXTUAL-CONVENTION
    STATUS current                                                    |
         FROM SNMPv2-TC;                                                  |
                                                                          |
                                                                          |
snmpRowPointerTCMIB MODULE-IDENTITY                                       |
    LAST-UPDATED "200012150000Z"                                          |
    ORGANIZATION "IETF Diffserv WG"                                       |
    CONTACT-INFO                                                          |
       "       Bob Moore                                                  |
               IBM Corporation, BRQA/502                                  |
               PO Box 12195                                               |
               Research Triangle Park, NC 27709, USA                      |
               Phone: +1 919 254 4436                                     |
               E-Mail: remoore@us.ibm.com                                 |
                                                                          |
                                                                          |
               Kwok Ho Chan                                               |
               Nortel Networks                                            |
               600 Technology Park Drive                                  |
               Billerica, MA 01821, USA                                   |
               E-Mail: khchan@nortelnetworks.com"                         |
    DESCRIPTION
       "Specifies a direction of data travel  on  an  inter-
       face.  'inbound' traffic is operated on during recep-
       tion from the interface, while 'outbound' traffic  is
       operated on prior to transmission on the interface."
    SYNTAX  INTEGER {
                inbound(1),     -- ingress interface
                outbound(2)     -- egress interface
            }

-- The following                                                           |
       "This MIB module defines textual convention, StaticRowPointer,
-- is similiar conventions similar to the        |
       RowPointer textual convention,
-- but embody with additional semantics to indicate whether
-- a single instance of the target object can be pointed
-- to by more than one parent objects.
-- This textual convention allows a clearer definition
-- of parameterization table entries, sementics."         |
    REVISION "200012150000Z"                                              |
    DESCRIPTION                                                           |
       "Initial version, published as compared to
-- datapath linking table entries. RFC xxxx."                          |
    ::= { mib-2 12343 }  -- Objects pointed to by StaticRowPointers, parameterization
-- table entries, can be reused by one or more data path
-- functional elements in one or more TCBs, belonging to one
-- or more data paths.
-- This textual convention also allow easier reuse of
-- data definitions in this MIB assigned by higher level configuration
-- and provisioning mechanisms. IANA                        |

                                                                          |
StaticRowPointer ::= TEXTUAL-CONVENTION                                   |
    STATUS current                                                        |
    DESCRIPTION                                                           |
       "Like a RowPointer, this textual convention represents a pointer   |
       to a conceptual row. The value is the name of the instance of the  |
       first accessible columnar object in the conceptual row.            |

       The additional semantics of this textual convention, relative to   |
       RowPointer, are related to the object the pointer is pointing to.  |
       The pointed-to object may have more than one parent object         |
       pointing to it, indicating the pointed-to object can be shared by  |
       one or more parent objects.

       This textual convention allows a clearer definition of             |
       parameterization table entries, as compared to datapath linking    |
       table entries. Objects pointed to by StaticRowPointers,            |
       parameterization table entries, can be reused by one or more data  |
       path functional elements, belonging to one or more data paths.

       This textual convention also allow easier reuse of data            |
       definitions in this MIB by higher level configuration and          |
       provisioning mechanisms.

       This additional semantics facilitates the creation of
       instance-specific instance-    |
       specific objects by cloning, used by higher level                  |
       configuration/provisioning mechanisms. The objects being cloned    |
       may either be special ones that express configuration information  |
       at the
       implementation-specific mechanism-specific level, or simply instance-
       specific instance-specific ones  |
       that already exist at the time the cloning is done.  When an       |
       object with the syntax Sta-
       ticRowPointer StaticRowPointer is cloned, the             |
       StaticRowPointer in the newly cloned object is set to point to     |
       the same con-
       ceptual conceptual row that the StaticRowPointer in the  cloned-
       from object pointed to. The cloning operations may be
       accomplished cloned-   |
       from object pointed to. The cloning operations may be              |
       accomplished either with the script-based technique defined by     |
       SNMP Configuration, or by ordinary SNMP Get and Set operations,    |
       or other mechanisms.                                               |

       Support of this additional semantics and cloning functionality is  |
       not required for conformance to this MIB. When the additional      |
       semantics is not supported, this textual convention behaves        |
       identically to the RowPointer textual convention."                 |
    SYNTAX  OBJECT IDENTIFIER                                             |
                                                                          |
END                                                                       |

DIFFSERV-MIB DEFINITIONS ::= BEGIN                                        |

                                                                          |
    IMPORTS                                                               |
    Unsigned32, Counter32, Counter64,                                     |
    MODULE-IDENTITY, OBJECT-TYPE, OBJECT-IDENTITY,                        |
    zeroDotZero, mib-2                                                    |
         FROM SNMPv2-SMI                                                  |
    TEXTUAL-CONVENTION, RowStatus, RowPointer, TimeStamp                  |
         FROM SNMPv2-TC                                                   |
    MODULE-COMPLIANCE, OBJECT-GROUP                                       |
         FROM SNMPv2-CONF                                                 |
    ifIndex                                                               |
        FROM IF-MIB                                                       |
    InetAddressType, InetAddress                                          |
        FROM INET-ADDRESS-MIB                                             |
    BurstSize                                                             |
        FROM INTEGRATED-SERVICES-MIB;                                     |
    Dscp, DscpOrAny                                                       |
        FROM DIFFSERV-DSCP-TC;                                            |
    StaticRowPointer                                                      |
        FROM SNMP-ROWPOINTER-TC-MIB;                                      |

                                                                          |
diffServMib MODULE-IDENTITY                                               |
    LAST-UPDATED "200012150000Z"                                          |
    ORGANIZATION "IETF Diffserv WG"                                       |
    CONTACT-INFO                                                          |
       "       Fred Baker                                                 |
               Cisco Systems                                              |
               519 Lado Drive                                             |
               Santa Barbara, CA 93111, USA                               |
               E-mail: fred@cisco.com                                     |
                                                                          |
                                                                          |
               Kwok Ho Chan                                               |
               Nortel Networks                                            |
               600 Technology Park Drive                                  |
               Billerica, MA 01821, USA                                   |
               E-mail: khchan@nortelnetworks.com                          |
                                                                          |
                                                                          |
               Andrew Smith                                               |
               Allegro Networks                                           |
               6399 San Ignacio Ave                                       |
               San Jose, CA 95119, USA                                    |
               E-mail: andrew@allegronetworks.com"                        |
    DESCRIPTION                                                           |
       "This MIB defines the objects necessary to manage a device that    |
       uses the Differentiated Services Architecture described in RFC     |
       2475 and the Informal Management Model for Diffserv Routers in     |
       draft-ietf-diffserv-model-05.txt."                                 |
    REVISION "200012150000Z"                                              |
    DESCRIPTION                                                           |
       "Initial version, published as RFC xxxx."                          |
    ::= { mib-2 12345 }  -- anybody who uses this unassigned              |
                         -- number deserves the wrath of IANA             |
                                                                          |
                                                                          |
diffServMIBObjects     OBJECT IDENTIFIER ::= { diffServMib 1 }            |
diffServMIBConformance OBJECT IDENTIFIER ::= { diffServMib 2 }            |
                                                                          |
                                                                          |
                                                                          |
-- These textual conventions have no effect on either with the  script-based  technique syntax          |
-- nor the semantics of any managed object.  Objects defined              |
-- using this convention are always encoded by  SNMP  Configuration, or by ordinary SNMP
       Get and Set operations, or other mechanisms.

       Support means of  this  additional  semantics  and  cloning
       functionality the               |
-- rules that define their primitive type.                                |
                                                                          |
                                                                          |
SixTupleClfrL4Port ::= TEXTUAL-CONVENTION                                 |
    DISPLAY-HINT "d"                                                      |
    STATUS   current                                                      |
    DESCRIPTION                                                           |
       "A value indicating a Layer-4 protocol port number."               |
    SYNTAX   Unsigned32 (0..65535)                                        |
                                                                          |
                                                                          |
IfDirection ::= TEXTUAL-CONVENTION                                        |
    STATUS current                                                        |
    DESCRIPTION                                                           |
       "Specifies a direction of data travel on an interface. 'inbound'   |
       traffic is not required for conformance to this
       MIB.  When operated on during reception from the additional semantics interface, while  |
       'outbound' traffic is not supported,
       this  textual  convention  behaves identically operated on prior to transmission on the
       RowPointer textual convention."     |
       interface."                                                        |
    SYNTAX  OBJECT IDENTIFIER  INTEGER {                                                     |
                inbound(1),     -- ingress interface                      |
                outbound(2)     -- egress interface                       |
            }                                                             |
                                                                          |
                                                                          |
--                                                                        |
-- Data Path                                                              |
--

diffServDataPath       OBJECT IDENTIFIER ::= { diffServMIBObjects 1 }     |
                                                                          |
--                                                                        |
-- Data Path Table                                                        |
--                                                                        |
-- The Data Path Table enumerates the Differentiated Services             |
-- Data Paths within this device.  Each entry in this table               |
-- is indexed by ifIndex and ifDirection.  Each entry provides            |
-- the first diffserv functional datapath element to process data         |
-- flow for each specific datapath.  This table should have at most       |
-- two entries for each DiffServ capable interface on this device;        |
-- ingress and egress.                                                    |
--                                                                        |
-- Notice all diffserv functional datapath elements linked together       |
-- using their individual next pointers and anchored by an entry          |
-- of the diffServDataPathTable must belong to the same datapath.         |
-- The use of next pointer to point to diffserv functional datapath       |
-- element of a different datapath is not allowed.                        |
--
                                                                          |
                                                                          |
diffServDataPathTable OBJECT-TYPE                                         |
    SYNTAX       SEQUENCE OF DiffServDataPathEntry                        |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The data path table defines the data paths in this device. Each   |
       data path is defined by the interface and traffic direction. The   |
       first diffserv functional datapath element to handle traffic for   |
       this data path is defined by a RowPointer, diffServDataPathStart,  |
       in the entries of this table."                                     |
    ::= { diffServDataPath 1 }                                            |
                                                                          |
                                                                          |
diffServDataPathEntry OBJECT-TYPE                                         |
    SYNTAX       DiffServDataPathEntry                                    |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "An entry in the data path table describes a single diffserv       |
       datapath in this device."                                          |
    INDEX { ifIndex, diffServDataPathIfDirection }                        |
    ::= { diffServDataPathTable 1 }                                       |
                                                                          |
                                                                          |
DiffServDataPathEntry ::= SEQUENCE  {                                     |
    diffServDataPathIfDirection    IfDirection,                           |
    diffServDataPathStart          RowPointer,                            |
    diffServDataPathStatus         RowStatus                              |
}                                                                         |
                                                                          |
                                                                          |
diffServDataPathIfDirection OBJECT-TYPE                                   |
    SYNTAX       IfDirection                                              |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "Specifies the direction for which this data path entry applies    |
       on this interface."                                                |
    ::= { diffServDataPathEntry 1 }                                       |
                                                                          |
                                                                          |
diffServDataPathStart OBJECT-TYPE                                         |
    SYNTAX       RowPointer                                               |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "This selects the first diffserv functional datapath element to    |
       handle traffic for this data path. This RowPointer should point    |
       to an instance of one of:                                          |
         diffServClfrEntry                                                |
         diffServMeterEntry                                               |
         diffServActionEntry                                              |
         diffServAlgDropEntry                                             |
         diffServQEntry                                                   |

       A value of zeroDotZero in this attribute indicates no further      |
       Diffserv treatment is performed on traffic of this datapath. The   |
       use of zeroDotZero is the normal usage for the last functional     |
       datapath element of the current data path.                         |

       If the row pointed to does not exist, the treatment is as if this  |
       attribute contains a value of zero-
       DotZero." zeroDotZero."                        |
    ::= { diffServDataPathEntry 2 }                                       |
                                                                          |
                                                                          |

diffServDataPathStatus OBJECT-TYPE                                        |
    SYNTAX       RowStatus                                                |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The RowStatus variable controls the activation, deactivation, or  |
       deletion of a row/entry. Any writ-
       able writable variable may be modified     |
       whether the row is active or notInService."                        |
    ::= { diffServDataPathEntry 3 }                                       |
                                                                          |
                                                                          |
--
-- Classifiers                                                            |
--                                                                        |
                                                                          |
diffServClassifier     OBJECT IDENTIFIER ::= { diffServMIBObjects 2 }     |
                                                                          |
--                                                                        |
-- Classifier Table                                                       |
--                                                                        |
-- Classifier allows multiple classifier elements, of same or different   |
-- types, to be used together.                                            |
-- A classifier must completely classify all packets presented to it,     |
-- this means all traffic handled by a classifier must match              |
-- at least one classifier element within the classifier,                 |
-- with the classifier element parameters specified by a filter.          |
--                                                                        |
-- If there is ambiguity between classifier elements of different         |
-- classifier, the precedence is indicated by the order the classifiers   |
-- are linked, the first classifier in the link is applied to the         |
-- traffic first.                                                         |
--                                                                        |
                                                                          |
                                                                          |
diffServClfrNextFree OBJECT-TYPE                                          |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   read-only                                                |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "This object yields a value when read that is currently unused     |
       for a diffServClfrId instance. If a configuring system attempts    |
       to create a new row in the diffServClfrTable using this value,     |
       that opera-
       tion operation will fail if the value has, in the meantime, been   |
       used to create another row that is currently valid."               |
    ::= { diffServClassifier 1 }                                          |
                                                                          |
                                                                          |

diffServClfrTable OBJECT-TYPE                                             |
    SYNTAX       SEQUENCE OF DiffServClfrEntry                            |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "This table enumerates all the diffserv classifier functional      |
       datapath elements of this device.  The actual classification       |
       definitions are defined in diffServClfrElementTable entries        |
       belonging to each classifier."                                     |
    REFERENCE                                                             |
        "[MODEL] section 4.1"                                             |
    ::= { diffServClassifier 2 }                                          |
                                                                          |
                                                                          |
diffServClfrEntry OBJECT-TYPE                                             |
    SYNTAX       DiffServClfrEntry                                        |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "An entry in the classifier table describes a single classifier.   |
       All classifier elements belonging to the same classifier uses the  |
       classifier's diffServClfrId in thier diffServClfrElementClfrId     |
       attribute."                                                        |
    INDEX { diffServClfrId }                                              |
    ::= { diffServClfrTable 1 }                                           |
                                                                          |
                                                                          |
DiffServClfrEntry ::= SEQUENCE  {                                         |
    diffServClfrId              Unsigned32,                               |
    diffServClfrStatus          RowStatus                                 |
}                                                                         |
                                                                          |
                                                                          |
diffServClfrId OBJECT-TYPE                                                |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "An index that enumerates the classifier entries. The set of such  |
       identifiers spans the whole agent. Managers should obtain new      |
       values for row creation in this table by reading                   |
       diffServClfrNextFree."                                             |
    ::= { diffServClfrEntry 1 }                                           |
                                                                          |
                                                                          |
diffServClfrStatus OBJECT-TYPE                                            |
    SYNTAX       RowStatus                                                |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The RowStatus variable controls the activation, deactivation, or  |
       deletion of a classifier. Any writ-
       able writable variable may be modified    |
       whether the row is active or notInService."                        |
    ::= { diffServClfrEntry 2 }                                           |
                                                                          |
                                                                          |
--                                                                        |
-- Classifier Element Table                                               |
--                                                                        |
-- Entries in the classifier element table serves as                      |
-- the anchor for each classification pattern, defined                    |
-- in filter table entries.  Each classifier element                      |
-- table entry also specifies the subsequent downstream                   |
-- diffserv functional datapath element when the                          |
-- classification pattern is satisfied.                                   |
-- Each entry in the classifier element table describes                   |
-- one branch of the fan-out characteristic of a classifier               |
-- indicated in [MODEL] section 4.1.  A classifier is madeup              |
-- of one or more classifier elements.                                    |
--                                                                        |
                                                                          |
                                                                          |
diffServClfrElementNextFree OBJECT-TYPE                                   |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   read-only                                                |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "This  object  yields  a  value  when  read  that  is currently    |
       unused for a diffServClfrElementId instance. If a configuring      |
       system attempts to create a new row in the                         |
       diffServClfrElementTable using this value, that opera- tion will   |
       fail if the value  has,  in  the  meantime, been  used  to         |
       create  another row that is currently valid."                      |
    ::= { diffServClassifier 3 }                                          |
                                                                          |
                                                                          |
diffServClfrElementTable OBJECT-TYPE                                      |
    SYNTAX       SEQUENCE OF DiffServClfrElementEntry                     |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The classifier element table enumerates the  rela-
       tionship relationship between  |
       classification patterns and subse-
       quent subsequent downstream diffserv         |
       functional datapath  ele-
       ments. elements. Classification parameters are        |
       defined by entries of filter tables pointed to by                  |
       diffServClfrElementSpecific. There can be filter tables of         |
       different types, and they can be  inter-
       mixed inter-mixed and used within a     |
       classifier. An example of a filter table defined in this MIB is  diffServSixTu-
       pleClfrTable,    |
       diffServSixTupleClfrTable, for IP Multi-Field Classifiers (MFCs).  |
       Filter tables for other filter types may be defined elsewhere."    |
    REFERENCE                                                             |
        "[MODEL] section 4.1"                                             |
    ::= { diffServClassifier 4 }                                          |
                                                                          |
                                                                          |
diffServClfrElementEntry OBJECT-TYPE                                      |
    SYNTAX       DiffServClfrElementEntry                                 |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "An entry in the classifier element table describes a single       |
       element of the classifier."                                        |
    INDEX { diffServClfrElementClfrId, diffServClfrElementId }            |
    ::= { diffServClfrElementTable 1 }                                    |
                                                                          |
                                                                          |
DiffServClfrElementEntry ::= SEQUENCE  {                                  |
    diffServClfrElementId          Unsigned32,                            |
    diffServClfrElementClfrId      Unsigned32,
    diffServClfrElementOrder                            |
    diffServClfrElementPrecedence  Unsigned32,                            |
    diffServClfrElementNext        RowPointer,                            |
    diffServClfrElementSpecific    StaticRowPointer,                      |
    diffServClfrElementPkts        Counter32,                             |
    diffServClfrElementHCPkts      Counter64,                             |
    diffServClfrElementStatus      RowStatus                              |
}                                                                         |
                                                                          |
                                                                          |
diffServClfrElementId OBJECT-TYPE                                         |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "An index that enumerates the Classifier Element entries. The set  |
       of such identifiers spans the whole agent. Managers should obtain  |
       new values for row creation in this table by reading               |
       diffServClfrElementNextFree."                                      |
    ::= { diffServClfrElementEntry 1 }                                    |
                                                                          |
                                                                          |
diffServClfrElementClfrId OBJECT-TYPE                                     |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   not-accessible                                           |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "A classifier Id identifies which classifier this classifier       |
       element is a part of.  This needs to be the value of               |
       diffServClfrId attribute for an existing row in                    |
       diffServClfrTable."                                                |
    ::= { diffServClfrElementEntry 2 }

diffServClfrElementOrder                                    |
                                                                          |
                                                                          |
diffServClfrElementPrecedence OBJECT-TYPE                                 |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The relative order in which classifier elements are applied:      |
       higher  numbers  represent classifier ele-
       ment element with higher          |
       precedence.  Classifier elements with the same order  must  be     |
       unambiguous  i.e. they must define non-overlapping patterns, and   |
       are   con-
       sidered  considered  to  be applied  simultaneously  to the traffic    |
       stream. Clas- sifier elements with different order  may  overlap   |
       in their  filters:  the classif-
       ier classifier element with the highest order  |
       that matches is taken.                                             |

       On a given interface, there must be a complete  clas- sifier  in   |
       place  at  all  times in   the ingress direction.  This means      |
       that there will always be one or more filters that match every     |
       possible pat- tern  that  could be presented in an incoming        |
       packet. There is no such requirement in the egress direc-
       tion." direction."     |
    DEFVAL { 0 }                                                          |
    ::= { diffServClfrElementEntry 3 }                                    |
                                                                          |
                                                                          |
diffServClfrElementNext OBJECT-TYPE                                       |
    SYNTAX       RowPointer                                               |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "This attribute provides one branch of the fan-out functionality   |
       of a classifier described in [MODEL] section 4.1.                  |

       This selects the next diffserv functional datapath element to      |
       handle traffic for this data path. This RowPointer should point    |
       to an instance of one of:                                          |
         diffServClfrEntry                                                |
         diffServMeterEntry                                               |
         diffServActionEntry                                              |
         diffServAlgDropEntry                                             |
         diffServQEntry                                                   |

       A value of zeroDotZero in this attribute indicates no further      |
       Diffserv treatment is performed on traffic of this datapath. The   |
       use of zeroDotZero is the normal usage for the last functional     |
       datapath element of the current data path.                         |

       If the row pointed to does not exist, the treatment is as if this  |
       attribute contains a value of zero-
       DotZero." zeroDotZero."                        |
    ::= { diffServClfrElementEntry 4 }                                    |
                                                                          |
                                                                          |
diffServClfrElementSpecific OBJECT-TYPE                                   |
    SYNTAX       StaticRowPointer                                         |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "A pointer to a valid entry  in  another  table, filter table,     |
       that describes  the applicable classif-
       ication classification parameters, e.g. an  |
       entry in  diffServSixTu-
       pleClfrTable. diffServSixTupleClfrTable.                                |

       If the row pointed to does not exist, the  classifier
       element is ignored.

       The classifier element is    |
       ignored.                                                           |

       The value zeroDotZero is interpreted to match anything not         |
       matched by another classifier element - only one such entry may    |
       exist for each classifier."                                        |
    DEFVAL { zeroDotZero }                                                |
    ::= { diffServClfrElementEntry 5 }                                    |
                                                                          |
                                                                          |
diffServClfrElementPkts OBJECT-TYPE                                       |
    SYNTAX       Counter32                                                |
    MAX-ACCESS   read-only                                                |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The number of packets that have passed throught this process. On  |
       high speed devices, this object implements the least significant   |
       32 bits of diffServClfrElementHCPkts.                              |

       Discontinuities in the value of this counter can occur at re-      |
       initialization of the management system and at other times as      |
       indicated by the value of ifCounterDiscontinuityTime appropriate   |
       to this interface."                                                |
    ::= { diffServClfrElementEntry 6 }                                    |
                                                                          |
                                                                          |
diffServClfrElementHCPkts OBJECT-TYPE                                     |
    SYNTAX       Counter64                                                |
    MAX-ACCESS   read-only                                                |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The number of packets that have been dropped by this drop         |
       process. This object should be used on high speed interfaces.      |

       Discontinuities in the value of this counter can occur at re-      |
       initialization of the management system and at other times as      |
       indicated by the value  zeroDotZero  is  interpreted of ifCounterDiscontinuityTime appropriate   |
       to   match
       anything  not matched by another classifier element -
       only one such entry may exist for each classifier."
    DEFVAL { zeroDotZero } this interface."                                                |
    ::= { diffServClfrElementEntry 5 7 }                                    |
                                                                          |
                                                                          |
diffServClfrElementStatus OBJECT-TYPE                                     |
    SYNTAX       RowStatus                                                |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "The  RowStatus  variable  controls  the  activation,              |
       deactivation,  or deletion of a classifier element. Any writ-      |
       able variable may be  modified  whether  the  row  is active or    |
       notInService."                                                     |
    ::= { diffServClfrElementEntry 6 8 }                                    |
                                                                          |
                                                                          |
--                                                                        |
-- IP Six-Tuple Classification Table                                      |
--                                                                        |
-- Classification based on 6 different fields in the IP                   |
-- header. This is intended to be IP-version-independent.                 |
-- Filters, entries in this table, may be shared, pointed to,             |
-- by multiple diffServClfrElementEntry, of same or different             |
-- datapaths in the same system.                                          |
--                                                                        |
                                                                          |
                                                                          |
diffServSixTupleClfrNextFree OBJECT-TYPE                                  |
    SYNTAX       Unsigned32                                               |
    MAX-ACCESS   read-only                                                |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "This object yields a value when read that is currently unused     |
       for a diffServSixTupleClfrId instance.                             |
       If a configuring system attempts to create a new row               |
       in the diffServSixTupleClfrTable using this value, that operation  |
       will fail if the value has, in the meantime, been used             |
       to create another row that is currently valid."                    |
    ::= { diffServClassifier 5 }                                          |
                                                                          |
                                                                          |
diffServSixTupleClfrTable OBJECT-TYPE                                     |
    SYNTAX   SEQUENCE OF DiffServSixTupleClfrEntry                        |
    MAX-ACCESS   not-accessible                                           |
    STATUS   current                                                      |
    DESCRIPTION                                                           |
       "A table of IP Six-Tuple Classifier filter entries that a system   |
       may use to identify IP traffic."                                   |
    REFERENCE                                                             |
        "[MODEL] section 4.2.2"                                           |
    ::= { diffServClassifier 6 }                                          |
                                                                          |
                                                                          |
diffServSixTupleClfrEntry OBJECT-TYPE                                     |
    SYNTAX       DiffServSixTupleClfrEntry                                |
    MAX-ACCESS   not-accessible                                           |
    STATUS   current                                                      |
    DESCRIPTION                                                           |
       "An IP Six-Tuple Classifier entry describes a single filter."      |
    INDEX { diffServSixTupleClfrId }                                      |
    ::= { diffServSixTupleClfrTable 1 }                                   |
                                                                          |
                                                                          |
DiffServSixTupleClfrEntry ::= SEQUENCE {                                  |
    diffServSixTupleClfrId           Unsigned32,                          |
    diffServSixTupleClfrDstAddrType  InetAddressType,                     |
    diffServSixTupleClfrDstAddr      InetAddress,                         |
    diffServSixTupleClfrDstAddrMask  Unsigned32,                          |
    diffServSixTupleClfrSrcAddrType  InetAddressType,                     |
    diffServSixTupleClfrSrcAddr      InetAddress,                         |
    diffServSixTupleClfrSrcAddrMask  Unsigned32,                          |
    diffServSixTupleClfrDscp         Dscp,         DscpOrAny,                           |
    diffServSixTupleClfrProtocol     Unsigned32,                          |
    diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,                  |
    diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,                  |
    diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port,                  |
    diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port,                  |
    diffServSixTupleClfrStatus       RowStatus                            |
}                                                                         |
                                                                          |
                                                                          |

diffServSixTupleClfrId OBJECT-TYPE                                        |
    SYNTAX         Unsigned32                                             |
    MAX-ACCESS     not-accessible                                         |
    STATUS     current                                                    |
    DESCRIPTION                                                           |
       "An index that enumerates the Six Tuple Classifier filter          |
       entries.  The set of such identifiers spans the whole agent.       |
       Managers should obtain new values for row creation in this table   |
       by reading diffServSixTupleClfrNextFree."                          |
    ::= { diffServSixTupleClfrEntry 1 }                                   |
                                                                          |
                                                                          |
diffServSixTupleClfrDstAddrType OBJECT-TYPE                               |
    SYNTAX         InetAddressType                                        |
    MAX-ACCESS     read-create                                            |
    STATUS         current                                                |
    DESCRIPTION                                                           |
       "The type of IP destination address used by this classifier        |
       entry."                                                            |
    ::= { diffServSixTupleClfrEntry 2 }                                   |
                                                                          |
                                                                          |
diffServSixTupleClfrDstAddr OBJECT-TYPE
    SYNTAX         InetAddress
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The IP address to match against the packet's  desti-
       nation destination IP
       address."
    ::= { diffServSixTupleClfrEntry 3 }

diffServSixTupleClfrDstAddrMask OBJECT-TYPE
    SYNTAX         Unsigned32
    UNITS          "bits"
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The length of a mask for the matching of the  desti-
       nation destination IP
       address.  Masks are constructed by setting bits in sequence from
       the most-significant bit  down-
       wards downwards for
       diffServSixTupleClfrDstAddrMask bits length. All other bits in
       the mask, up to the number needed to fill the length of the
       address diffServSix-
       TupleClfrDstAddr diffServSixTupleClfrDstAddr are cleared to zero.  A zero
       bit in the mask then means that the corresponding bit in the
       address always matches."
    DEFVAL         {0}
    ::= { diffServSixTupleClfrEntry 4 }

diffServSixTupleClfrSrcAddrType OBJECT-TYPE
    SYNTAX         InetAddressType
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The type of IP source address used by this  classif-
       ier classifier entry."
    ::= { diffServSixTupleClfrEntry 5 }

diffServSixTupleClfrSrcAddr OBJECT-TYPE
    SYNTAX         InetAddress
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The IP address to match against the source IP address of each
       packet."
    ::= { diffServSixTupleClfrEntry 6 }

diffServSixTupleClfrSrcAddrMask OBJECT-TYPE
    SYNTAX         Unsigned32
    UNITS          "bits"
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The length of a mask for the matching of the source IP address.
       Masks are constructed by setting bits in sequence from the most-significant most-
       significant bit downwards for diffServSixTupleClfrSrcAddrMask
       bits length. All other bits in the mask, up to the number needed
       to fill the length of the address  diffServSixTu-
       pleClfrSrcAddr diffServSixTupleClfrSrcAddr are
       cleared to zero.  A zero bit in the mask then means that the
       corresponding bit in the address always matches."
    DEFVAL         {0}
    ::= { diffServSixTupleClfrEntry 7 }

diffServSixTupleClfrDscp OBJECT-TYPE
    SYNTAX         Dscp         DscpOrAny                                              |
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The value that the DSCP in the packet must have to match this
       entry. A value of -1 indicates that a specific DSCP value has not
       been defined and thus all DSCP values are considered a match."
    DEFVAL         {-1}
    ::= { diffServSixTupleClfrEntry 8 }

diffServSixTupleClfrProtocol OBJECT-TYPE
    SYNTAX         Unsigned32 (0..255)
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The IP protocol to match against the IPv4 protocol number or the
       IPv6 Next-Header number in the packet.  A value of 255 means
       match all.  Note the protocol number of 255 is reserved by IANA,
       and Next-Header number of 0 is used in IPv6."
    DEFVAL         {255}
    ::= { diffServSixTupleClfrEntry 9 }

diffServSixTupleClfrDstL4PortMin OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The minimum value that the layer-4 destination port number in
       the packet must have in order to match this classifier entry."
    DEFVAL         {0}
    ::= { diffServSixTupleClfrEntry 10 }

diffServSixTupleClfrDstL4PortMax OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The maximum value that the layer-4 destination port number in
       the packet must have in order to match this classifier entry.
       This value must be equal to or greater than the value specified
       for this entry in diffServSixTupleClfrDstL4PortMin."
    DEFVAL         {65535}
    ::= { diffServSixTupleClfrEntry 11 }

diffServSixTupleClfrSrcL4PortMin OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The minimum value that the layer-4 source port number in the
       packet must have in order to match this classifier entry."
    DEFVAL         {0}
    ::= { diffServSixTupleClfrEntry 12 }

diffServSixTupleClfrSrcL4PortMax OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The maximum value that the layer-4 source port number in the
       packet must have in oder to match this classifier entry. This
       value must be equal to or greater than the value specified for
       this entry in diffServSixTupleClfrSrcL4PortMin."
    DEFVAL         {65535}
    ::= { diffServSixTupleClfrEntry 13 }

diffServSixTupleClfrStatus OBJECT-TYPE
    SYNTAX      RowStatus
    MAX-ACCESS  read-create
    STATUS  current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or
       deletion of a classifier. Any writ-
       able writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServSixTupleClfrEntry 14 }

--                                                                        |
-- Meters
--

diffServMeter          OBJECT IDENTIFIER ::= { diffServMIBObjects 3 }

--
-- This MIB supports a variety of Meters.  It includes a
-- specific definition for Meters whose parameter set can
-- be modelled using Token Bucket parameters.
-- Other metering parameter sets can be defined and used
-- when necessary.
--
-- Multiple meter elements may be logically cascaded using
-- their diffServMeterSucceedNext and diffServMeterFailNext
-- pointers if required.
-- One example of this might be for an AF PHB implementation
-- that uses multiple level conformance meters.

--
-- Cascading of individual meter elements in the MIB is
-- intended to be functionally equivalent to multiple level
-- conformance determination of a packet.  The sequential
-- nature of the representation is merely a notational
-- convenience for this MIB.
--
-- For example:
-- Conforming to RFC 2697, srTCM can be parameterized using
-- two sets of diffServMeterEntry and diffServTBMeterEntry. diffServTBParamEntry.               |
-- With the first set parameterizing the Committed Burst Size
-- token-bucket, second set parameterizing the Excess Burst Size
-- token-bucket.  With both set's diffServTBMeterRate diffServTBParamRate parameters          |
-- being used to reflect the Committed Information Rate value.
--
-- Conforming to RFC 2698, trTCM can be parameterized using
-- two sets of diffServMeterEntry and diffServTBMeterEntry. diffServTBParamEntry.               |
-- With the first set parameterizing the Peak Information Rate
-- and Peak Burst Size token-bucket, second set parameterizing
-- the Committed Information Rate and Committed Burst Size
-- token-bucket.
--
-- Conforming to RFC 2859, tswTCM can be parameterized using
-- two sets of diffServMeterEntry and diffServTBMeterEntry. diffServTBParamEntry.               |
-- With the first set parameterizing the Committed Target Rate,
-- second set parametering the Peak Target Rate.
-- With both set's diffServTBMeterInterval diffServTBParamInterval being used to                  |
-- reflect the Average Interval as specified by RFC 2859.
--

diffServMeterNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServMeterId instance.  If a configuring system attempts
       to create a new row in the diffServMeterTable using this value,
       that opera-
       tion operation will fail if the value has, in the meantime, been
       used to create another row that is currently valid."
    ::= { diffServMeter 1 }

diffServMeterTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServMeterEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table enumerates specific meters that a system may use to
       police, or shape, a stream of traffic. The traffic stream to be
       metered is determined by the diffserv functional datapath
       element(s) upstream of the meter i.e. by the object(s) that point
       to each entry in this table.  This may include all traffic on an
       interface.

       Specific meter details are to be found in table entry referenced
       by diffServMeterSpecific."
           REFERENCE
               "[MODEL] section 5.1"
    ::= { diffServMeter 2 }

diffServMeterEntry OBJECT-TYPE
    SYNTAX       DiffServMeterEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the meter table describes a single  con-
       formance conformance level
       of a meter."
    INDEX { diffServMeterId }
    ::= { diffServMeterTable 1 }

DiffServMeterEntry ::= SEQUENCE  {
    diffServMeterId                Unsigned32,
    diffServMeterSucceedNext       RowPointer,
    diffServMeterFailNext          RowPointer,
    diffServMeterSpecific          StaticRowPointer,
    diffServMeterStatus            RowStatus
}

diffServMeterId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Meter entries. The set of such
       identifiers spans the whole agent. Managers should obtain new
       values for row creation in this table by reading
       diffServMeterNextFree."
    ::= { diffServMeterEntry 1 }

diffServMeterSucceedNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "If the traffic does conform, this selects the next diffserv
       functional datapath element to handle traffic for this data path.
       This RowPointer should point to an instance of one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this attribute indicates no further
       Diffserv treatment is performed on traffic of this datapath.  The
       use of zeroDotZero is the normal usage for the last functional
       datapath element of the current data path.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zero-
       DotZero." zeroDotZero."
    DEFVAL      { zeroDotZero }
    ::= { diffServMeterEntry 2 }

diffServMeterFailNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "If the traffic does not conform, this selects the next diffserv
       functional datapath element to handle traffic for this data path.
       This RowPointer should point to an instance of one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this attribute indicates no further
       Diffserv treatment is performed on traffic of this datapath.  The
       use of zeroDotZero is the normal usage for the last functional
       datapath element of the current data path.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zero-
       DotZero." zeroDotZero."
    DEFVAL      { zeroDotZero }
    ::= { diffServMeterEntry 3 }

diffServMeterSpecific OBJECT-TYPE
    SYNTAX       StaticRowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This indicates the behaviour of the meter by  point-
       ing pointing to an
       entry containing detailed parameters. Note that entries in that
       specific table must be managed explicitly.

       For example, diffServMeterSpecific may point to an entry in  diffServTBMeterTable,        |
       diffServTBParamTable, which contains an instance of a single set
       of Token Bucket parameters."
    ::= { diffServMeterEntry 4 }

diffServMeterStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or
       deletion of a meter. Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServMeterEntry 5 }

--
-- Token Bucket Meter Parameter Table                                           |
--

diffServTBParam        OBJECT IDENTIFIER ::= { diffServMIBObjects 4 }     |

-- Each entry in the Token Bucket Meter Parameter Table parameterize            |
-- a single token bucket.  Multiple token buckets can be
-- used together to parameterize multiple levels of
-- conformance.
--
-- Entries of this table are used for both policing, as token             |
-- bucket parameters, and shaping, as leaky bucket parameters.            |
--                                                                        |
-- Note that an entry in the Token Bucket Meter Parameter Table can             |
-- be shared, pointed to, by multiple diffServMeterTable
-- and diffServSchedulerTable entries.                                    |
--

diffServTBMeterNextFree

diffServTBParamNextFree OBJECT-TYPE                                       |
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused     |
       for a diffServTBMeterId diffServTBParamId instance.  If a configuring system
       attempts to create a new row in the  diffServTBMeterTable diffServTBParamTable using     |
       this value, that operation will fail if the value has, in the  mean-
       time,
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServMeter 3 diffServTBParam 1 }

diffServTBMeterTable                                             |

diffServTBParamTable OBJECT-TYPE                                          |
    SYNTAX       SEQUENCE OF DiffServTBMeterEntry DiffServTBParamEntry                         |
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table enumerates a single set of token bucket meter
       parameters that a system may use to police or shape a stream of    |
       traffic.  Such meters are modelled here as having a single rate    |
       and a single burst size." size.  Multiple entries are used when multiple  |
       rates/burst sizes are needed."
    REFERENCE
        "[MODEL] section 5.1"
    ::= { diffServMeter 4 diffServTBParam 2 }

diffServTBMeterEntry                                             |

diffServTBParamEntry OBJECT-TYPE                                          |
    SYNTAX       DiffServTBMeterEntry       DiffServTBParamEntry                                     |
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry that describes a single set of token bucket
       meter              |
       parameters."
    INDEX { diffServTBMeterId diffServTBParamId }                                           |
    ::= { diffServTBMeterTable diffServTBParamTable 1 }

DiffServTBMeterEntry                                        |

DiffServTBParamEntry ::= SEQUENCE  {
    diffServTBMeterId                                      |
    diffServTBParamId              Unsigned32,
    diffServTBMeterType            INTEGER,
    diffServTBMeterRate                            |
    diffServTBParamType            OBJECT IDENTIFIER,                     |
    diffServTBParamRate            Unsigned32,
    diffServTBMeterBurstSize                            |
    diffServTBParamBurstSize       BurstSize,
    diffServTBMeterInterval                             |
    diffServTBParamInterval        Unsigned32,
    diffServTBMeterStatus                            |
    diffServTBParamStatus          RowStatus                              |

}

diffServTBMeterId

diffServTBParamId OBJECT-TYPE                                             |
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the  TBMeter TBParam entries. The set of such     |
       identifiers spans the whole agent. Managers should obtain new
       values for row creation in this table by reading diffServTBMeterNextFree."                   |
       diffServTBParamNextFree."
    ::= { diffServTBMeterEntry diffServTBParamEntry 1 }

diffServTBMeterType                                        |

diffServTBParamType OBJECT-TYPE                                           |
    SYNTAX       INTEGER       OBJECT IDENTIFIER                                        |
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The Metering/Shaping algorithm associated with the Token/Leaky    |
       Bucket parameters.

       {0 0} indicates this is unknown.                                   |

       Standard values for generic algorithms:                            |

       diffServTBParamSimpleTokenBucket, diffServTBParamAvgRate,          |
       diffServTBParamSrTCMBlind, diffServTBParamSrTCMAware,              |
       diffServTBParamTrTCMBlind, diffServTBParamTrTCMAware,              |
       diffServTBParamTswTCM

       are specified in this MIB as OBJECT-IDENTITYS; additional values   |
       may be further specified in other MIBs."
    REFERENCE
        "[MODEL] section 5"
    ::= {
                     other(1),        -- not listed here
                     tokenBucket(2),  -- diffServTBParamEntry 2 }                                        |

diffServTBParamRate OBJECT-TYPE                                           |
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The token-bucket rate, in kilobits per second (kbps).  This
       attribute is used for:  1. CIR in RFC 2697 for srTCM 2. PIR and
       CIR in RFC 2698 for trTCM 3. CTR and PTR in RFC 2859 for TSWTCM
       4. AverageRate used in [MODEL] section 5."
    ::= { diffServTBParamEntry 3 }                                        |

diffServTBParamBurstSize OBJECT-TYPE                                      |
    SYNTAX       BurstSize
    UNITS        "Bytes"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The maximum number of bytes in a single transmission burst.
       This attribute is used for:  1. CBS and EBS in RFC 2697 for srTCM
       2. CBS and PBS in RFC 2698 for trTCM 3. Burst Size used in
       [MODEL] section 5."
    ::= { diffServTBParamEntry 4 }                                        |

diffServTBParamInterval OBJECT-TYPE                                       |
    SYNTAX       Unsigned32
    UNITS        "microseconds"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The time interval used with the token bucket.  For:  1. Average
       Rate Meter, [MODEL] section 5.2.1, - Delta.  2. Simple Token
       Bucket
                     avgRate(3),      -- Average Rate
                     srTCMBlind(4),   -- srTCM, Color-blind
                     srTCMAware(5),   -- srTCM, Color-aware
                     trTCMBlind(6),   -- trTCM, Color-blind
                     trTCMAware(7),   -- Meter, [MODEL] section 5.1,
          - time interval t.  3. RFC 2859 TSWTCM, - AVG_INTERVAL.  4.
       RFC 2697 srTCM, RFC 2698 trTCM, Color-aware
                     tswTCM(8)        -- tswTCM - token bucket
          update time interval."
    ::= { diffServTBParamEntry 5 }                                        |

diffServTBParamStatus OBJECT-TYPE                                         |
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The type RowStatus variable controls the activation, deactivation, or
       deletion of meter using parameters specified by this
       TBMeter entry.

       Value a meter. Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServTBParamEntry 6 }                                        |

diffServTBParamSimpleTokenBucket OBJECT-IDENTITY                          |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "Value of tokenBucket(2) indicates the use of Two Parameter Token  |
       Bucket Meter as described in [MODEL] section 5.2.3.

       Value 5.2.3."               |
    REFERENCE                                                             |
        "[MODEL] sections 5 and 7.1.2"                                    |
    ::= { diffServTBParam 3 }                                             |

diffServTBParamAvgRate OBJECT-IDENTITY                                    |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "Value of avgRate(3) indicates the use of Average Rate Meter as    |
       described in [MODEL] section 5.2.1.

       Value 5.2.1."                               |
    REFERENCE                                                             |
        "[MODEL] sections 5 and 7.1.2"                                    |
    ::= { diffServTBParam 4 }                                             |

diffServTBParamSrTCMBlind OBJECT-IDENTITY                                 |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "Value of srTCMBlind(4) and srTCMAware(5) indicates the use of     |
       Single Rate Three Color Marker Metering as defined by RFC 2697,    |
       with `Color Blind' and `Color Aware' mode as described by the RFC.

       Value      |
       RFC."                                                              |
    REFERENCE                                                             |
        "[MODEL] sections 5 and 7.1.2"                                    |
    ::= { diffServTBParam 5 }                                             |

diffServTBParamSrTCMAware OBJECT-IDENTITY                                 |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "Value of trTCMBlind(6) srTCMBlind(4) and  trTCMAware(7) srTCMAware(5) indicates the use of  Two     |
       Single Rate Three Color Marker Metering as defined by RFC 2698, 2697,    |
       with `Color Blind' and `Color Aware' mode as described by the RFC.

       Value of tswTCM(8) indicates the use of Time  Sliding
       Window  Three Color Marker Metering as defined by RFC
       2859."      |
       RFC."                                                              |
    REFERENCE                                                             |
        "[MODEL] section 5"
    ::= { diffServTBMeterEntry 2 }

diffServTBMeterRate OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The  token-bucket  rate,  in  kilobits  per   second
       (kbps).   This  attribute  is used for: 1. CIR in RFC
       2697 for srTCM 2. PIR and CIR in RFC 2698  for  trTCM
       3.  CTR sections 5 and PTR in RFC 2859 for TSWTCM 4. AverageRate
       used in [MODEL] section 5." 7.1.2"                                    |
    ::= { diffServTBMeterEntry 3 diffServTBParam 6 }

diffServTBMeterBurstSize OBJECT-TYPE
    SYNTAX       BurstSize
    UNITS        "Bytes"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The maximum number of bytes in a single transmission
       burst.  This attribute is used for: 1. CBS                                             |

diffServTBParamTrTCMBlind OBJECT-IDENTITY                                 |
    STATUS       current                                                  |
    DESCRIPTION                                                           |
       "Value of trTCMBlind(6) and EBS in trTCMAware(7) indicates the use of     |
       Two Rate Three Color Marker Metering as defined by RFC 2697 for srTCM 2. CBS 2698, with  |
       `Color Blind' and PBS  in  RFC  2698  for
       trTCM 3. Burst Size used in [MODEL] section 5." `Color Aware' mode as described by the RFC."     |
    REFERENCE                                                             |
        "[MODEL] sections 5 and 7.1.2"                                    |
    ::= { diffServTBMeterEntry 4 diffServTBParam 7 }

diffServTBMeterInterval OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "microseconds"
    MAX-ACCESS   read-create                                             |

diffServTBParamTrTCMAware OBJECT-IDENTITY                                 |
    STATUS       current                                                  |
    DESCRIPTION
       "The time interval used with                                                           |
       "Value of trTCMBlind(6) and trTCMAware(7) indicates the token bucket.   For:
       1.  Average use of     |
       Two Rate  Meter,  [MODEL]  section  5.2.1, -
       Delta.  2. Simple Token Bucket Meter, [MODEL] section
       5.1,
          -  time  interval  t.   3.  RFC  2859  TSWTCM,   -
       AVG_INTERVAL.   4.  RFC 2697 srTCM, Three Color Marker Metering as defined by RFC 2698 trTCM, -
       token bucket
          update time interval." 2698, with  |
       `Color Blind' and `Color Aware' mode as described by the RFC."     |
    REFERENCE                                                             |
        "[MODEL] sections 5 and 7.1.2"                                    |
    ::= { diffServTBMeterEntry 5 diffServTBParam 8 }

diffServTBMeterStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create                                             |

diffServTBParamTswTCM OBJECT-IDENTITY                                     |
    STATUS       current                                                  |
    DESCRIPTION
       "The  RowStatus  variable  controls  the  activation,
       deactivation,  or  deletion                                                           |
       "Value of a meter. Any writable
       variable may be modified whether tswTCM(8) indicates the row is active or
       notInService." use of Time Sliding Window       |
       Three Color Marker Metering as defined by RFC 2859."               |
    REFERENCE                                                             |
        "[MODEL] sections 5 and 7.1.2"                                    |
    ::= { diffServTBMeterEntry 6 diffServTBParam 9 }                                             |

--
-- Actions
--

diffServAction         OBJECT IDENTIFIER ::= { diffServMIBObjects 4 5 }     |

--
-- The Action Table allows enumeration of the different
-- types of actions to be applied to a traffic flow.
--

diffServActionNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServActionId instance.  If a configuring system
       attempts to create a new row in the diffServActionTable using
       this value, that opera-
       tion operation will fail if the value has, in the
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServAction 1 }

diffServActionTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServActionEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Action Table enumerates actions that can be per-
       formed performed to a
       stream of traffic. Multiple actions can be concatenated.  For
       example, after marking a stream of traffic exiting from a meter,
       a device can then perform a count action of the conforming or  non-
       conforming
       non-conforming traffic.

       Specific actions are indicated by  diffServAction-
       Specific diffServActionSpecific which
       points to an entry of a specific action type parameterizing the
       action in detail."
    REFERENCE
        "[MODEL] section 6."
    ::= { diffServAction 2 }

diffServActionEntry OBJECT-TYPE
    SYNTAX       DiffServActionEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "Each entry in the action table allows description of one
       specific action to be applied to traffic."
    INDEX { diffServActionId }
    ::= { diffServActionTable 1 }

DiffServActionEntry ::= SEQUENCE  {
    diffServActionId                Unsigned32,
    diffServActionNext              RowPointer,
    diffServActionSpecific          StaticRowPointer,
    diffServActionType              INTEGER,
    diffServActionStatus            RowStatus
}

diffServActionId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Action entries. The set of such
       identifiers spans the whole agent. Managers should obtain new
       values for row creation in this table by reading
       diffServActionNextFree."
    ::= { diffServActionEntry 1 }

diffServActionNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This selects the next diffserv functional datapath element to
       handle traffic for this data path.  This RowPointer should point
       to an instance of one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this attribute indicates no further
       Diffserv treatment is performed on traffic of this datapath.  The
       use of zeroDotZero is the normal usage for the last functional
       datapath element of the current data path.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zero-
       DotZero." zeroDotZero."
    DEFVAL      { zeroDotZero }
    ::= { diffServActionEntry 2 }

diffServActionSpecific OBJECT-TYPE
    SYNTAX       StaticRowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "A pointer to an object instance providing additional information
       for the type of action indicated by this action table entry.

       For the standard actions defined by this MIB module, this should
       point to one of the following: a diffServDscpMarkActEntry, a
       diffServCountActEntry.  For other actions, it may point to an
       object instance defined in some other MIB."
    ::= { diffServActionEntry 3 }

diffServActionType OBJECT-TYPE
    SYNTAX       INTEGER {
                     other(1),       -- types not specified here
                     specific(2),    -- follow the Specific pointer
                     absoluteDrop(3) -- disallow traffic
                 }
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "Indicates the type of action. The values specific(2) must be
       associated with additional information, pointed to by
       diffServActionSpecific, with the actual action type indicated by
       the object being pointed to. The value absoluteDrop(3) has no
       associated  informa-
       tion information and will have a diffServActionSpecific
       value of zeroDotZero.  The use of other(1) is outside the scope
       of this definition, although the diffServAc-
       tionSpecific diffServActionSpecific pointer
       may be used in this case, to indicate other information."
    ::= { diffServActionEntry 4 }

diffServActionStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation or
       deletion of an action element. Any writable variable may be
       modified whether the row is active or notInService."
    ::= { diffServActionEntry 5 }

--
-- DSCP Mark Action Table
--
-- Rows of this table are pointed to by diffServActionSpecific
-- to provide detailed parameters specific to the DSCP
-- Mark action.
--
-- A single entry in this table can be shared, pointed to, by
-- multiple diffServActionTable entries, of same or different
-- datapaths.
--

diffServDscpMarkActTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServDscpMarkActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table enumerates specific DSCPs used for  mark-
       ing marking or
       remarking the DSCP field of IP packets. The entries of this table
       may be referenced by a diffSer-
       vActionSpecific diffServActionSpecific attribute."
    REFERENCE
        "[MODEL] section 6.1"
    ::= { diffServAction 3 }

diffServDscpMarkActEntry OBJECT-TYPE
    SYNTAX       DiffServDscpMarkActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the DSCP mark action table that describes a single
       DSCP used for marking."
    INDEX { diffServDscpMarkActDscp }
    ::= { diffServDscpMarkActTable 1 }

DiffServDscpMarkActEntry ::= SEQUENCE  {
    diffServDscpMarkActDscp          Dscp
}

diffServDscpMarkActDscp OBJECT-TYPE
    SYNTAX       Dscp
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The DSCP that this Action uses for marking/remarking traffic.
       Note that a DSCP value of -1 is not permit-
       ted permitted in this table.  It
       is quite possible that the only packets subject to this Action
       are already marked with this DSCP. Note also that Diffserv may
       result in packet remarking both on ingress to a net-
       work network and on
       egress from it and it is quite possible that ingress and egress
       would occur in the same router."
    ::= { diffServDscpMarkActEntry 1 }

--
-- Count Action Table
--
-- Due to the fact that the MIB structure allows multiple
-- cascading diffServActionEntry be used to describe
-- multiple actions for a datapath, the counter became an

-- optional action type.  In normal implementation, a
-- datapath either have counters or it doesn't, it is not
-- an element the management entity can add or remove.
-- The management entity can choose to read the counter or
-- not.  Hence it is recommended for implementation that
-- have counters to always configure the count action as
-- the first of multiple actions, for example before the
-- the absolute drop action.
--

diffServCountActNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServCountActId instance.
       If a configuring system attempts to create a new row
       in the diffServCountActTable using this value, that operation
       will fail if the value has, in the meantime, been used
       to create another row that is currently valid."
    ::= { diffServAction 4 }

diffServCountActTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServCountActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table contains counters for all the traffic passing through
       an action element."
    REFERENCE
        "[MODEL] section 6.4"
    ::= { diffServAction 5 }

diffServCountActEntry OBJECT-TYPE
    SYNTAX       DiffServCountActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the count action table describes a  sin-
       gle single set of
       traffic counters."
    INDEX { diffServCountActId }
    ::= { diffServCountActTable 1 }

DiffServCountActEntry ::= SEQUENCE  {
    diffServCountActId           Unsigned32,
    diffServCountActOctets       Counter32,
    diffServCountActHCOctets     Counter64,
    diffServCountActPkts         Counter32,
    diffServCountActHCPkts       Counter64,
    diffServCountActDiscontTime  TimeStamp,
    diffServCountActStatus       RowStatus
}

diffServCountActId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Count Action entries. The set of
       such identifiers spans the whole agent. Managers should obtain
       new values for row creation in this table by reading
       diffServCountActNextFree."
    ::= { diffServCountActEntry 1 }

diffServCountActOctets OBJECT-TYPE
    SYNTAX       Counter32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of octets at the Action datapath element.  On high
       speed devices, this object implements the least significant 32
       bits of  diffServCountActHCOc-
       tets. diffServCountActHCOctets.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of diffServCountActDiscontTime for this
       entry."
    ::= { diffServCountActEntry 2 }

diffServCountActHCOctets OBJECT-TYPE
    SYNTAX       Counter64
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of octets at the Action datapath element.  This
       object should be used on high speed interfaces.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of diffServCountActDiscontTime for this
       entry."
    ::= { diffServCountActEntry 3 }

diffServCountActPkts OBJECT-TYPE
    SYNTAX       Counter32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of packets at the Action datapath  ele-
       ment. element.  On high
       speed devices, this object implements the least significant 32
       bits of   diffServCoun-
       tActHCPkts. diffServCountActHCPkts.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of diffServCountActDiscontTime for this
       entry."
    ::= { diffServCountActEntry 4 }

diffServCountActHCPkts OBJECT-TYPE
    SYNTAX       Counter64
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of packets at the Action datapath  ele-
       ment. element.  This
       object should be used on high speed interfaces.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of diffServCountActDiscontTime for this
       entry."
    ::= { diffServCountActEntry 5 }

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 re-
       initialization of the local management subsystem, then this
       object contains a zero value."
    ::= { diffServCountActEntry 6 }

diffServCountActStatus 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."
    ::= { diffServCountActEntry 7 }

--                                                                        |
-- Algorithmic Drop Table
--

diffServAlgDrop        OBJECT IDENTIFIER ::= { diffServMIBObjects 5 6 }     |

diffServAlgDropNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServAlgDropId instance.  If a configuring system
       attempts to create a new row in the diffServAlgDropTable using
       this value, that operation will fail if the value has, in the  mean-
       time,
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServAlgDrop 1 }

diffServAlgDropTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServAlgDropEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The algorithmic drop table contains entries describ-
       ing describing an
       element that drops packets according to some algorithm."
    REFERENCE
        "[MODEL] section 7.1.3"
    ::= { diffServAlgDrop 2 }

diffServAlgDropEntry OBJECT-TYPE
    SYNTAX       DiffServAlgDropEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry describes a process that drops packets according to
       some algorithm.  Further details of the algorithm type are to be
       found in diffServAlgDropType and with more detail parameter entry
       pointed to by diffServAlgDropSpecific when necessary."
    INDEX { diffServAlgDropId }
    ::= { diffServAlgDropTable 1 }

DiffServAlgDropEntry ::= SEQUENCE  {
    diffServAlgDropId               Unsigned32,
    diffServAlgDropType             INTEGER,
    diffServAlgDropNext             RowPointer,
    diffServAlgDropQMeasure         RowPointer,
    diffServAlgDropQThreshold       Unsigned32,
    diffServAlgDropSpecific         StaticRowPointer,
    diffServAlgDropOctets           Counter32,
    diffServAlgDropHCOctets         Counter64,
    diffServAlgDropPkts             Counter32,
    diffServAlgDropHCPkts           Counter64,
    diffServAlgDropStatus           RowStatus
}

diffServAlgDropId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Algorithmic Dropper entries. The
       set of such identifiers spans the whole agent. Managers should
       obtain new values for row creation in this table by reading diffServAlgDrop-
       NextFree."
       diffServAlgDropNextFree."
    ::= { diffServAlgDropEntry 1 }

diffServAlgDropType OBJECT-TYPE
    SYNTAX       INTEGER {
                     other(1),
                     tailDrop(2),
                     headDrop(3),
                     randomDrop(4)
                 }
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The type of algorithm used by this dropper. A value of
       tailDrop(2) or headDrop(3) represents an algorithm that is
       completely specified by this MIB.  A value of other(1) requires
       further specification in some other MIB module.

       The tailDrop(2) algorithm is described as follows:
       diffServAlgDropQThreshold represents the depth of the queue,
       pointed to by diffServAlgDropQMeasure, at which all newly
       arriving packets will be dropped.

       The headDrop(3) algorithm is described as follows: if a packet
       arrives when the current depth of the queue, pointed to by
       diffServAlgDropQMeasure, is at diffSer-
       vAlgDropQThreshold, diffServAlgDropQThreshold, packets
       currently at the head of the queue are dropped to make room for
       the new packet to be enqueued at the tail of the queue.

       The randomDrop(4) algorithm is described as follows: on packet
       arrival, an algorithm is executed which may randomly drop the
       packet, or drop other packet(s) from the queue in its place. The
       specifics of the algorithm may be proprietary. For this
       algorithm, diffServAlgDropSpecific points to a diffServRandom-
       DropEntry
       diffServRandomDropEntry that describes the algorithm.  For this
       algorithm, diffServAlgQThreshold is understood to be the absolute
       maximum size of the queue and additional parameters are described
       in diffServRandomDropTable."
    ::= { diffServAlgDropEntry 2 }

diffServAlgDropNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This selects the next diffserv functional datapath element to
       handle traffic for this data path.  This RowPointer should point
       to an instance of one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this attribute indicates no further
       Diffserv treatment is performed on traffic of this datapath.  The
       use of zeroDotZero is the normal usage for the last functional
       datapath element of the current data path.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zero-
       DotZero." zeroDotZero."
    ::= { diffServAlgDropEntry 3 }

diffServAlgDropQMeasure OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "Points to an entry in the diffServQTable to indicate the queue
       that a drop algorithm is to monitor when deciding whether to drop
       a packet.  If the row pointed to does not exist, the algorithmic
       dropper element is considered inactive."
    ::= { diffServAlgDropEntry 4 }

diffServAlgDropQThreshold OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "Bytes"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "A threshold on the depth in bytes of the queue being measured at
       which a trigger is generated to the drop-
       ping dropping algorithm.

       For the tailDrop(2) or headDrop(3) algorithms, this represents
       the depth of the queue, pointed to by diffServAlgDropQMeasure, at
       which the drop action will take place. Other algorithms will need
       to define their own semantics for this threshold."
    ::= { diffServAlgDropEntry 5 }

diffServAlgDropSpecific OBJECT-TYPE
    SYNTAX       StaticRowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "Points to a table entry that provides further detail regarding a
       drop algorithm.

       Entries with diffServAlgDropType equal to other(1) may have this
       point to a table defined in another MIB module.

       Entries with diffServAlgDropType equal to  random-
       Drop(4) randomDrop(4) must have
       this point to an entry in diffSer-
       vRandomDropTable. diffServRandomDropTable.

       For all other algorithms, this should take the value
       zeroDotzero."
    ::= { diffServAlgDropEntry 6 }

diffServAlgDropOctets OBJECT-TYPE
    SYNTAX       Counter32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of octets that have been dropped by this drop
       process.  On high speed devices, this object implements the least
       significant 32 bits of  diffSer-
       vAlgDropHCOctets. diffServAlgDropHCOctets.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of ifCounterDiscontinuityTime appropriate
       to this inter-
       face." interface."
    ::= { diffServAlgDropEntry 7 }

diffServAlgDropHCOctets OBJECT-TYPE
    SYNTAX       Counter64
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of octets that have been dropped by this drop
       process.  This object should be used on high speed interfaces.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of ifCounterDiscontinuityTime appropriate
       to this inter-
       face." interface."
    ::= { diffServAlgDropEntry 8 }

diffServAlgDropPkts OBJECT-TYPE
    SYNTAX       Counter32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of packets that have been dropped by this drop
       process.  On high speed devices, this object implements the least
       significant 32 bits of  diffSer-
       vAlgDropHCPkts. diffServAlgDropHCPkts.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of ifCounterDiscontinuityTime appropriate
       to this inter-
       face." interface."
    ::= { diffServAlgDropEntry 9 }

diffServAlgDropHCPkts OBJECT-TYPE
    SYNTAX       Counter64
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of packets that have been dropped by this drop
       process.  This object should be used on high speed interfaces.

       Discontinuities in the value of this counter can occur at  re-initialization re-
       initialization of the management system and at other times as
       indicated by the value of ifCounterDiscontinuityTime appropriate
       to this inter-
       face." interface."
    ::= { diffServAlgDropEntry 10 }

diffServAlgDropStatus 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."
    ::= { diffServAlgDropEntry 11 }

--
-- Random Drop Table
--

diffServRandomDropNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServRandomDropId instance.  If a configuring system
       attempts to create a new row in the diffServRandomDropTable using
       this value, that operation will fail if the value has, in the  mean-
       time,
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServAlgDrop 3 }

diffServRandomDropTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServRandomDropEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The random drop table contains entries describing a process that
       drops packets randomly. Entries in this table is intended to be
       pointed to by  diffSer-
       vAlgDropSpecific." diffServAlgDropSpecific."
    REFERENCE
        "[MODEL] section 7.1.3"
    ::= { diffServAlgDrop 4 }

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."
    INDEX { diffServRandomDropId }
    ::= { diffServRandomDropTable 1 }

DiffServRandomDropEntry ::= SEQUENCE  {
    diffServRandomDropId               Unsigned32,
    diffServRandomDropMinThreshBytes   Unsigned32,
    diffServRandomDropMinThreshPkts    Unsigned32,
    diffServRandomDropMaxThreshBytes   Unsigned32,
    diffServRandomDropMaxThreshPkts    Unsigned32,
    diffServRandomDropInvProbMax       Unsigned32,
    diffServRandomDropInvWeight        Unsigned32,
    diffServRandomDropSamplingRate     Unsigned32,
    diffServRandomDropStatus           RowStatus
}

diffServRandomDropId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Random Drop entries. The set of
       such identifiers spans the whole agent. Managers should obtain
       new values for row creation in this table by reading
       diffServRandomDropNextFree."
    ::= { diffServRandomDropEntry 1 }

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  diffServRandomDrop-
       MinThreshPkts."
       diffServRandomDropMinThreshPkts."
    ::= { diffServRandomDropEntry 2 }

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 diffServRandomDropMinThresh-
       Bytes."
       diffServRandomDropMinThreshBytes."
    ::= { diffServRandomDropEntry 3 }

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 diffServRandomDropInvProbMax 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 4 }

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 diffServRandomDropInvProbMax 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 5 }

diffServRandomDropInvProbMax OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The worst case random drop probability, expressed as the inverse
       of the drop probability.  With special case of the value zero
       meaning zero probability of drop.

       For example, if every packet may be dropped in the worst case
       (100%), this has the value of 4,294,967,295."
    ::= { diffServRandomDropEntry 6 }

diffServRandomDropInvWeight OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The weighting of past history in affecting the  cal-
       culation 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 7 }

diffServRandomDropSamplingRate OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The number of times per second the queue is sampled for queue
       average calculation.  A value of zero means the queue is sampled
       approximately each time a packet is enqueued (or dequeued)."
    ::= { diffServRandomDropEntry 8 }

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 9 }

--                                                                        |
-- Queue Table
--

diffServQueue          OBJECT IDENTIFIER ::= { diffServMIBObjects 6 7 }     |

--
-- An entry of diffServQTable represents a FIFO queue diffserv
-- functional datapath element as described in [MODEL] section
-- 7.1.1.
-- Notice the specification of scheduling parameters for a queue
-- as part of the input to a scheduler functional datapath
-- element as described in [MODEL] section 7.1.2.  This allows
-- building of hierarchical queueing/scheduling.
-- A queue therefore is parameterized by:
-- 1. Which scheduler will service this queue, diffServQNext.
-- 2. How the scheduler will service this queue, with respect
--    to all the other queues the same scheduler needs to service,
--    diffServQSchdParam.
--
-- Notice one or more upstream diffserv datapath element may share,
-- point to, a diffServQTable entry as described in [MODEL] section
-- 7.1.1.
--
-- Each entry of the diffServQTable belongs to one and only one
-- datapath.
--

diffServQNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServQId instance.  If a configuring system attempts to
       create a new row in the diffServQTable using this value, that
       operation will fail if the value has, in the meantime, been used
       to create another row that is currently valid."
    ::= { diffServQueue 1 }

diffServQTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServQEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Queue Table enumerates the individual queues."
    REFERENCE
        "[MODEL] section 7.1.1"
    ::= { diffServQueue 2 }

diffServQEntry OBJECT-TYPE
    SYNTAX       DiffServQEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Queue Table describes a single queue.  With each
       entry belonging to one and only one datapath."
    INDEX { diffServQId }
    ::= { diffServQTable 1 }

DiffServQEntry ::= SEQUENCE  {
    diffServQId                      Unsigned32,
    diffServQNext                    RowPointer,
    diffServQSchdParam               StaticRowPointer,
    diffServQStatus                  RowStatus
}

diffServQId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Queue entries. The set of such
       identifiers spans the whole agent. Managers should obtain new
       values for row creation in this table by reading
       diffServQNextFree."
    ::= { diffServQEntry 1 }

diffServQNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This selects the next diffserv functional datapath element to
       handle traffic for this data path.  This RowPointer must point to
       an instance of one of:
         diffServSchedulerEntry

       A value of zeroDotZero in this attribute indicates an incomplete
       diffServQEntry instance.  An illegal con-
       figuration. configuration.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zero-
       DotZero." zeroDotZero."
    ::= { diffServQEntry 2 }

diffServQSchdParam OBJECT-TYPE
    SYNTAX       StaticRowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This StaticRowPointer indicates the entry in
       diffServSchdParamTable the scheduler, pointed to by
       diffServQNext, should use to service this queue.

       A value of zeroDotZero in this attribute indicates an incomplete
       diffServQEntry instance.  An illegal con-
       figuration. configuration.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zero-
       DotZero." zeroDotZero."
    ::= { diffServQEntry 3 }

diffServQStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or
       deletion of a queue. Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServQEntry 4 }

--
-- Scheduler Table
--

diffServScheduler      OBJECT IDENTIFIER ::= { diffServMIBObjects 7 8 }     |

--
-- The Scheduler Table is used for representing packet schedulers:
-- it provides flexibility for multiple scheduling algorithms, each
-- servicing multiple queues, to be used on the same logical/physical
-- interface.
-- Notice the servicing parameters the scheduler uses is
-- specified by each of its upstream functional datapath elements,
-- most likely queues or schedulers.
-- The coordination and coherency between the servicing parameters
-- of the scheduler's upstream functional datapath elements must
-- be maintained for the scheduler to function correctly.
--
-- The diffServSchedulerSchdParam attribute is used for specifying
-- the servicing parameters for output of a scheduler when its
-- downstream functional datapath element is another scheduler.
-- This is used for building hierarchical queue/scheduler.
--
-- More discussion of the scheduler functional datapath element
-- is in [MODEL] section 7.1.2.
--

diffServSchedulerPriority OBJECT-IDENTITY
    STATUS       current
    DESCRIPTION
       "For use  with  diffServSchedulerMethod  to  indicate
       Priority  scheduling  method, defined as an algorithm
       in which the presence of data in a queue  or  set  of
       queues  absolutely  precludes  dequeue  from  another
       queue or  set  of  queues.   Notice  attributes  from
       diffServSchdParamEntry of the queues/schedulers feed-
       ing this scheduler are used when determining the next
       packet to schedule."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServScheduler 1 }

diffServSchedulerWRR OBJECT-IDENTITY
    STATUS       current
    DESCRIPTION
       "For use  with  diffServSchedulerMethod  to  indicate
       Weighted  Round  Robin  scheduling method, defined as
       any algorithm in which a set of queues are visited in
       a  fixed  order,  and  varying amounts of traffic are
       removed from each queue in turn to implement an aver-
       age  output  rate  by  class.  Notice attributes from
       diffServSchdParamEntry of the queues/schedulers feed-
       ing this scheduler are used when determining the next
       packet to schedule."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServScheduler 2 }

diffServSchedulerWFQ OBJECT-IDENTITY
    STATUS       current
    DESCRIPTION
       "For use  with  diffServSchedulerMethod  to  indicate
       Weighted  Fair Queueing scheduling method, defined as
       any algorithm in which a set of queues are  conceptu-
       ally  visited  in some order, to implement an average
       output  rate  by  class.   Notice   attributes   from
       diffServSchdParamEntry of the queues/schedulers feed-
       ing this scheduler are Scheduler Table entries can be used when determining the next
       packet to schedule."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServScheduler 3 }

diffServSchedulerShaping OBJECT-IDENTITY
    STATUS       current
    DESCRIPTION
       "For use with diffServSchedulerMethod to indicate configure a shaper.             |
-- When diffServSchedulerMethod contains the
       scheduler OBJECT IDENTIFIER            |
-- diffServSchedulerShaper, the diffServSchedulerEntry is  being used            |
-- as a shaper.  As a shaper, diffServSchedulerSpecific will              |
-- reference a diffServTBParamTable entry to specify the                  |
-- Leaky Bucket parameters used for shaping.  Notice attri-
       butes    from    diffServSchdParamEntry    of the
       queues/schedulers  feeding  this  scheduler shaper.  Complex                  |
-- shapers can be parameterized by using the                              |
-- diffServSchedulerSucceedNext and diffServSchedulerFailNext             |
-- parameters the same way complex meters are used
       when determining constructed.                |
--                                                                        |
-- More discussion of the next packet to schedule."
    REFERENCE
        "[MODEL] scheduler functional datapath element
-- is in [MODEL] section 7.1.2"
    ::= { diffServScheduler 4 } 7.1.2.
--

diffServSchedulerNextFree OBJECT-TYPE                                     *
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServSchedulerId instance.  If a configuring system
       attempts to create a new row in the diffServSchedulerTable using
       this value, that operation will fail if the value has, in the  mean-
       time,
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServScheduler 5 1 }                                           |

diffServSchedulerTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServSchedulerEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Scheduler Table enumerates packet schedulers.  Multiple
       scheduling algorithms can be used on a given datapath, with each
       algorithm described by one diffServSchedulerEntry."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServScheduler 6 2 }                                           |

diffServSchedulerEntry OBJECT-TYPE
    SYNTAX       DiffServSchedulerEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Scheduler Table describing a single instance of
       a scheduling algorithm."
    INDEX { diffServSchedulerId }
    ::= { diffServSchedulerTable 1 }

DiffServSchedulerEntry ::= SEQUENCE  {
    diffServSchedulerId                   Unsigned32,
    diffServSchedulerNext
    diffServSchedulerSucceedNext          RowPointer,                     |
    diffServSchedulerFailNext             RowPointer,                     |
    diffServSchedulerMethod               OBJECT IDENTIFIER,
    diffServSchedulerSchdParam
    diffServSchedulerSpecific             StaticRowPointer,               |
    diffServSchedulerStatus               RowStatus
}

diffServSchedulerId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Scheduler entries. The set of such
       identifiers spans the whole agent. Managers should obtain new
       values for row creation in this table by reading
       diffServSchedulerNextFree."
    ::= { diffServSchedulerEntry 1 1 }

diffServSchedulerSucceedNext OBJECT-TYPE                                  |
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This selects the next diffserv functional datapath element to
       handle traffic for this data path.  This RowPointer should point
       to an instance of one of:
         diffServSchedulerEntry
         diffServQEntry As indicated by [MODEL] section 7.1.4.

       But this RowPointer can also point to an instance of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry For building of multiple TCBs for the same
       data path.

       This should point to another diffServSchedulerEntry for
       implementation of multiple scheduler methods for the same
       datapath, and for implementation of hierarchical schedulers.

       A value of zeroDotZero in this attribute indicates no further
       Diffserv treatment is performed on traffic of this datapath.  The
       use of zeroDotZero is the normal usage for the last functional
       datapath element of the current data path.

       If the row pointed to does not exist, the treatment is as if this
       attribute contains a value of zeroDotZero."                        |
    DEFVAL       { zeroDotZero }
    ::= { diffServSchedulerEntry 2 }

diffServSchedulerNext

diffServSchedulerFailNext OBJECT-TYPE                                     |
    SYNTAX       RowPointer                                               |
    MAX-ACCESS   read-create                                              |
    STATUS       current                                                  |
    DESCRIPTION
       "This                                                           |
       "Used when the Scheduler functions as a multi-rate shaper, in      |
       non-work conserving manner.  When the traffic does not conform to  |
       the leaky bucket parameter indicated by                            |
       diffServSchedulerSchdParam, this selects the next diffserv         |
       functional datapath element to handle traffic for this data path.  |
       This RowPointer should point to an instance of one of:             |
         diffServSchedulerEntry                                           |
         diffServQEntry As indicated by [MODEL] section 7.1.4.            |

       But this RowPointer can also point to an instance of:              |
         diffServClfrEntry                                                |
         diffServMeterEntry                                               |
         diffServActionEntry                                              |
         diffServAlgDropEntry For building of multiple TCBs for the same  |
       data path.                                                         |

       This should point to another diffServSchedulerEntry for            |
       implementation of multiple scheduler methods for
       the  same  datapath,  and   for   implementation   of
       hierarchical schedulers. multi-rate shaper.                               |

       A value of zeroDotZero in this attribute indicates no further      |
       Diffserv treatment is performed on traffic of this datapath.  The  |
       use of zeroDotZero is the normal usage for the last functional     |
       datapath element of the current data path.                         |

       If the row pointed to does not exist, the treatment is as if this  |
       attribute contains a value of zeroDotZero."                        |
    DEFVAL       { zeroDotZero }                                          |
    ::= { diffServSchedulerEntry 2 3 }                                      |

diffServSchedulerMethod OBJECT-TYPE
    SYNTAX       OBJECT IDENTIFIER
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The scheduling algorithm used by this Scheduler.  {0 0}
       indicates this is unknown.  Standard values for generic
       algorithms: diffServSchedulerPriority, diffServSchedulerWRR, and
       diffServSchedulerWFQ are specified in this MIB; additional values
       may be further specified in other MIBs."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServSchedulerEntry 3 4 }

diffServSchedulerSchdParam                                      |

diffServSchedulerSpecific OBJECT-TYPE                                     |
    SYNTAX       StaticRowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This StaticRowPointer indicates the entry in
       diffServSchdParamTable the higher level scheduler, pointed to by diffServSchedulerNext,   |
       diffServSchedulerSucceedNext, should use to service the output of
       this scheduler.  This attribute is only used when there is more
       than one level of scheduler.  And should have the value of
       zeroDotZero when not used."
    DEFVAL      { zeroDotZero }
    ::= { diffServSchedulerEntry 4 5 }                                      |

diffServSchedulerStatus OBJECT-TYPE                                       |
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or
       deletion of a queue. Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServSchedulerEntry 5 6 }                                      |

--                                                                        |
-- Scheduling Parameter Table
--
-- The scheduling parameters are separate from the Queue Entries
-- for reusability and for usage by both queues and schedulers,
-- and this follows the separation of datapath elements from
-- parameterization approach used throught out this MIB.
-- Usage of scheduling parameter table entry by schedulers allow
-- building of hierarchical scheduling.
--
-- The diffServSchdParamMaxRateAbs/Rel attributes are used to
-- construct non-work-conserving scheduler for the purpose of
-- traffic shaping.  These attributes limits the servicing of
-- the queue/scheduler, in affect, shaping the output of the
-- queue/scheduler, as described in [MODEL] section 7.2.
--

diffServSchdParamNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This object yields a value when read that is currently unused
       for a diffServSchdParamId instance.  If a configuring system
       attempts to create a new row in the diffServSchdParamTable using
       this value, that operation will fail if the value has, in the  mean-
       time,
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServScheduler 7 3 }                                           |

diffServSchdParamTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServSchdParamEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Scheduling Parameter Table enumerates individual sets of
       scheduling parameter that can be used/reused by Queues and
       Schedulers."
    ::= { diffServScheduler 8 4 }                                           |

diffServSchdParamEntry OBJECT-TYPE
    SYNTAX       DiffServSchdParamEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Scheduling Parameter Table describes a single
       set of scheduling parameter for use by queues and schedulers.

       Notice multiple inter-mixed of Queue and Scheduler entries can
       use the same Scheduler Parameter entry."
    INDEX { diffServSchdParamId }
    ::= { diffServSchdParamTable 1 }

DiffServSchdParamEntry ::= SEQUENCE  {
    diffServSchdParamId              Unsigned32,
    diffServSchdParamPriority        Unsigned32,
    diffServSchdParamMinRateAbs      Unsigned32,
    diffServSchdParamMinRateRel      Unsigned32,
    diffServSchdParamMaxRateAbs      Unsigned32,
    diffServSchdParamMaxRateRel      Unsigned32,
    diffServSchdParamBurstSize       BurstSize,
    diffServSchdParamStatus          RowStatus                            |
}

diffServSchdParamId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An index that enumerates the Scheduler Parameter entries. The
       set of such identifiers spans the whole agent. Managers should
       obtain new values for row creation in this table by reading diffServSchdParam-
       NextFree."
       diffServSchdParamNextFree."
    ::= { diffServSchdParamEntry 1 }

diffServSchdParamPriority OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The priority of this queue, input to be used as a  parame-
       ter the associated scheduler, relative  |
       to the  next  scheduler element downstream from
       this one.  A higher value  means  higher priority and
       should be serviced first." scheduler's other inputs."
    ::= { diffServSchdParamEntry 2 }

diffServSchdParamMinRateAbs OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The minimum absolute rate, in kilobits/sec, that a downstream
       scheduler element should allocate to this queue.  If the value is
       zero, then there is  effec-
       tively effectively no minimum rate guarantee.  If
       the value is non-zero, the scheduler will assure the servicing of
       this queue to at least this rate.

       Note that this attribute's value is coupled to that of
       diffServSchdParamMinRateRel:  changes to one will affect the
       value of the other. They are linked by the following equation:

         diffServSchdParamMinRateRel =

         diffServSchdParamMinRateRel = diffServSchdParamMinRateAbs * 10,000,000/ifSpeed

       or, if appropriate:

         diffServSchdParamMinRateRel = diffServSchdParamMinRateAbs * 10 / ifHighSpeed"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServSchdParamEntry 3 }

diffServSchdParamMinRateRel OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The minimum rate that a downstream scheduler element should
       allocate to this queue, relative to the maximum rate of the
       interface as reported by ifSpeed or ifHighSpeed, in units of
       1/10,000 of 1.  If the value is zero, then there is effectively
       no minimum rate guarantee.  If the value is non-zero, the
       scheduler will assure the servicing of this queue to at least
       this rate.

       Note that this attribute's value is coupled to that of
       diffServSchdParamMinRateAbs:  changes to one will affect the
       value of the other. They are linked by the following equation:

         diffServSchdParamMinRateAbs = ifSpeed * 10,000,000/ifSpeed diffServSchdParamMinRateRel/10,000,000

       or, if appropriate:

         diffServSchdParamMinRateRel =

         diffServSchdParamMinRateAbs = ifHighSpeed * 10 diffServSchdParamMinRateRel / ifHighSpeed" 10"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServSchdParamEntry 3 4 }

diffServSchdParamMinRateRel

diffServSchdParamMaxRateAbs OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The minimum maximum rate in kilobits/sec that a downstream scheduler
       element should allocate to this queue, relative to the max-
       imum rate of the interface as reported by ifSpeed  or
       ifHighSpeed, in units of 1/10,000 of 1. queue. If the value is zero, then
       there is effectively no  minimum maximum rate
       guarantee. limit and that the scheduler
       should attempt to be work-conserving for this queue.  If the
       value is non-zero, the scheduler will assure limit the servicing of this
       queue to to, at  least most, this rate. rate in a non-work-conserving manner.

       Note that this attribute's value is coupled to that of  diffServSchdParamMinRateAbs:
       diffServSchdParamMaxRateRel:  changes to one will affect the
       value of the other. They are linked by the following equation:

         diffServSchdParamMinRateAbs

         diffServSchdParamMaxRateRel = ifSpeed diffServSchdParamMaxRateAbs *
                      diffServSchdParamMinRateRel/10,000,000 10,000,000/ifSpeed

       or, if appropriate:

         diffServSchdParamMinRateAbs

         diffServSchdParamMaxRateRel = ifHighSpeed diffServSchdParamMaxRateAbs *
                            diffServSchdParamMinRateRel 10 / 10" ifHighSpeed"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServSchdParamEntry 4 5 }

diffServSchdParamMaxRateAbs

diffServSchdParamMaxRateRel OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The maximum rate in kilobits/sec that a downstream scheduler element should
       allocate to this queue. queue, relative to the maximum rate of the
       interface as reported by ifSpeed or ifHighSpeed, in units of
       1/10,000 of 1.  If the value is zero, then there is effectively
       no  max-
       imum maximum rate limit and that the scheduler should attempt to be
       work-conserving for this queue.  If the value is non-zero, the
       scheduler will limit the servicing of this queue to, at most,
       this rate in a  non-work-
       conserving non-work-conserving manner.

       Note that this attribute's value is coupled to that of  diffServSchdParamMaxRateRel:
       diffServSchdParamMaxRateAbs:  changes to one will affect the
       value of the other. They are linked by the following equation:

         diffServSchdParamMaxRateRel =

         diffServSchdParamMaxRateAbs = ifSpeed * 10,000,000/ifSpeed diffServSchdParamMaxRateRel/10,000,000

       or, if appropriate:

         diffServSchdParamMaxRateRel =

         diffServSchdParamMaxRateAbs = ifHighSpeed * 10 diffServSchdParamMaxRateRel / ifHighSpeed" 10"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServSchdParamEntry diffServSchdParamEntry 6 }

diffServSchdParamStatus OBJECT-TYPE                                       |
    SYNTAX       RowStatus                                                |
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or  |
       deletion of a queue. Any writable variable may be modified         |
       whether the row is active or notInService."
    ::= { diffServSchdParamEntry 7 }

diffServSchedulerPriority OBJECT-IDENTITY                                 |
    STATUS       current
    DESCRIPTION
       "For use with diffServSchedulerMethod to indicate Priority         |
       scheduling method, defined as an algorithm in which the presence   |
       of data in a queue or set of queues absolutely precludes dequeue   |
       from another queue or set of queues.  Notice attributes from       |
       diffServSchdParamEntry of the queues/schedulers feeding this       |
       scheduler are used when determining the next packet to schedule."
    REFERENCE                                                             |
        "[MODEL] section 7.1.2"                                           |
    ::= { diffServScheduler 5 }

diffServSchdParamMaxRateRel OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create                                           |

diffServSchedulerWRR OBJECT-IDENTITY                                      |
    STATUS       current                                                  |
    DESCRIPTION
       "The maximum rate that a downstream scheduler element
       should  allocate  to this queue, relative                                                           |
       "For use with diffServSchedulerMethod to the max-
       imum rate of the interface indicate Weighted Round   |
       Robin scheduling method, defined as reported by ifSpeed  or
       ifHighSpeed, any algorithm in units of 1/10,000 which a set   |
       of 1.  If the value
       is zero, then there is effectively  no  maximum  rate
       limit queues are visited in a fixed order, and  the  scheduler should attempt to be work-
       conserving for this queue.  If the value is non-zero,
       the  scheduler will limit the servicing varying amounts of this     |
       traffic are removed from each queue
       to, at  most,  this  rate in  a  non-work-conserving
       manner.

       Note that this attribute's value is coupled  to  that
       of  diffServSchdParamMaxRateAbs:  changes turn to one will
       affect the value implement an        |
       average output rate by class.  Notice attributes from              |
       diffServSchdParamEntry of the other. They queues/schedulers feeding this       |
       scheduler are linked by used when determining the
       following equation:

         diffServSchdParamMaxRateAbs = ifSpeed *
                      diffServSchdParamMaxRateRel/10,000,000

       or, if appropriate:

         diffServSchdParamMaxRateAbs = ifHighSpeed *
                           diffServSchdParamMaxRateRel / 10" next packet to schedule."  |
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"                                                             |
        "[MODEL] section 7.1.2"                                           |
    ::= { diffServSchdParamEntry diffServScheduler 6 }

diffServSchdParamBurstSize OBJECT-TYPE
    SYNTAX       BurstSize
    UNITS        "Bytes"
    MAX-ACCESS   read-create                                           |

diffServSchedulerWFQ OBJECT-IDENTITY                                      |
    STATUS       current                                                  |
    DESCRIPTION
       "The maximum number                                                           |
       "For use with diffServSchedulerMethod to indicate Weighted Fair    |
       Queueing scheduling method, defined as any algorithm in which a    |
       set of queues are conceptually visited in some order, to           |
       implement an average output rate by class.  Notice attributes      |
       from diffServSchdParamEntry of bytes in a single transmission
       burst.   This  attribute is the queues/schedulers feeding this  |
       scheduler are used when diffServSchedu-
       lerMethod of a downstream Scheduler element  is  used
       for shaping traffic exiting this queue/scheduler." determining the next packet to schedule."  |
    REFERENCE                                                             |
        "[MODEL] section 7.1.2"                                           |
    ::= { diffServSchdParamEntry diffServScheduler 7 }

diffServSchdParamStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create                                           |

diffServSchedulerShaper OBJECT-IDENTITY                                   |
    STATUS       current                                                  |
    DESCRIPTION
       "The  RowStatus  variable  controls                                                           |
       "For use with diffServSchedulerMethod to indicate the  activation,
       deactivation,  or  deletion  of              |
       diffServSchedulerEntry is being used to describe a queue. Any writable
       variable may Shaper.  The    |
       diffServSchedulerSpecific attribute for a Shaper will point to an  |
       entry in the diffServTBParamTable for the shaper's Leaky Bucket    |
       parameters.  Notice multi-rate, multi-color shapers can be modified whether         |
       parameterized by use of diffServSchedulerSucceedNext and           |
       diffServSchedulerFailNext the row is active or
       notInService." same way multi-rate, multi-color     |
       meters are parameterized with diffServMeterSucceedNext and         |
       diffServMeterFailNext parameters."                                 |
    REFERENCE                                                             |
        "[MODEL] section 7.1.2"                                           |
    ::= { diffServSchdParamEntry diffServScheduler 8 }                                           |

--
-- MIB Compliance statements.
--

diffServMIBCompliances OBJECT IDENTIFIER ::= { diffServMIBConformance 1 }
diffServMIBGroups      OBJECT IDENTIFIER ::= { diffServMIBConformance 2 }

diffServMIBCompliance MODULE-COMPLIANCE
    STATUS current
    DESCRIPTION
       "This MIB may be implemented as a read-only or as a read-create
       MIB. As a result, it may be used for mon-
       itoring monitoring or for
       configuration."
    MODULE -- This Module
    MANDATORY-GROUPS {
        diffServMIBDataPathGroup,
        diffServMIBClfrGroup,
        diffServMIBClfrElementGroup,
        diffServMIBSixTupleClfrGroup,
        diffServMIBActionGroup,                                           |
        diffServMIBAlgDropGroup,
        diffServMIBQGroup, diffServMIBSchedulerGroup,
        diffServMIBSchdParamGroup }

-- The groups:
--        diffServMIBCounterGroup
--        diffServMIBHCCounterGroup
--        diffServMIBVHCCounterGroup
--
-- are mutually exclusive; at most one of these groups is implemented
-- for a particular interface.  When any of these groups is implemented
-- for a particular interface, then ifCounterDiscontinuityGroup from
-- [IFMIB]  must also be implemented for that interface.

-- note that the diffServMIBStaticGroup is
-- mandatory for implementations that implement a
-- read-write or read-create mode.

    GROUP diffServMIBCounterGroup
    DESCRIPTION
       "This group is mandatory for table objects indexed by ifIndex for
       which the value of the corresponding instance of ifSpeed is less
       than or equal to 20,000,000 bits/second."

    GROUP diffServMIBHCCounterGroup
    DESCRIPTION
       "This group is mandatory for table objects indexed by ifIndex for
       which the value of the corresponding instance of ifSpeed is
       greater than 20,000,000 bits/second."

    GROUP diffServMIBVHCCounterGroup
    DESCRIPTION
       "This group is mandatory for table objects indexed by ifIndex for
       which the value of the corresponding instance of ifSpeed is
       greater than 650,000,000 bits/second."

    GROUP diffServMIBMeterGroup
    DESCRIPTION
       "This group is mandatory for devices that implement metering
       functions."

    GROUP diffServMIBTBMeterGroup diffServMIBTBParamGroup                                         |
    DESCRIPTION
       "This group is mandatory for devices that implement token-bucket
       metering functions."

    GROUP diffServMIBDscpMarkActGroup
    DESCRIPTION
       "This group is mandatory for devices that implement DSCP-Marking
       functions."

    GROUP diffServMIBRandomDropGroup
    DESCRIPTION
       "This group is mandatory for devices that implement Random Drop
       functions."

    GROUP diffServMIBStaticGroup
    DESCRIPTION
       "This group is mandatory for devices that allow crea-
       tion creation of rows
       in any of the writable tables of this MIB."

    OBJECT diffServClfrStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServClfrElementOrder diffServClfrElementPrecedence                                  |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServClfrElementNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServClfrElementSpecific
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServClfrElementStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrDstAddrType
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrDstAddr
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrDstAddrMask
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrSrcAddrType
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrSrcAddr
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrSrcAddrMask
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrDscp
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrProtocol
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrSrcL4PortMin
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrSrcL4PortMax
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrDstL4PortMin
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrDstL4PortMax
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSixTupleClfrStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServMeterSucceedNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServMeterFailNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServMeterSpecific
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServMeterStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
    OBJECT diffServTBMeterType diffServTBParamType                                            |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServTBMeterRate diffServTBParamRate                                            |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServTBMeterBurstSize diffServTBParamBurstSize                                       |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServTBMeterInterval diffServTBParamInterval                                        |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServTBMeterStatus diffServTBParamStatus                                          |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServActionNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServActionSpecific
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServActionType
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
    OBJECT diffServActionStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServCountActStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServAlgDropType
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServAlgDropNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServAlgDropQMeasure
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServAlgDropQThreshold
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServAlgDropSpecific
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServAlgDropStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
    OBJECT diffServRandomDropMinThreshBytes
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropMinThreshPkts
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropMaxThreshBytes
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropMaxThreshPkts
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropInvProbMax
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropInvWeight
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropSamplingRate
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
    OBJECT diffServQNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServQSchdParam
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServQStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchedulerNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchedulerMethod diffServSchedulerSucceedNext                                   |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchedulerSchdParam diffServSchedulerFailNext                                      |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchedulerStatus diffServSchedulerMethod                                        |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchdParamPriority diffServSchedulerSchdParam                                     |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchdParamMinRateAbs diffServSchedulerStatus                                        |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
    OBJECT diffServSchdParamMinRateRel diffServSchdParamPriority                                      |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchdParamMaxRateAbs diffServSchdParamMinRateAbs                                    |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchdParamMaxRateRel diffServSchdParamMinRateRel                                    |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchdParamBurstSize diffServSchdParamTBParam                                       |
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServSchdParamStatus                                        *
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    ::= { diffServMIBCompliances 1 }

diffServMIBDataPathGroup OBJECT-GROUP                                     |
    OBJECTS {
        diffServDataPathStart, diffServDataPathStatus
    }
    STATUS current
    DESCRIPTION
       "The Data Path Group defines the MIB Objects that describe a data
       path."
    ::= { diffServMIBGroups 1 }

diffServMIBClfrGroup OBJECT-GROUP
    OBJECTS {
        diffServClfrStatus
    }
    STATUS current
    DESCRIPTION
       "The Classifier Group defines the MIB Objects that describe a
       generic classifier."
    ::= { diffServMIBGroups 2 }

diffServMIBClfrElementGroup OBJECT-GROUP
    OBJECTS {
        diffServClfrElementOrder,
        diffServClfrElementPrecedence, diffServClfrElementNext,           |
        diffServClfrElementSpecific, diffServClfrElementStatus
    }
    STATUS current
    DESCRIPTION
       "The Classifier Element Group defines the MIB Objects that
       describe the classifier elements that make up a generic
       classifier."
    ::= { diffServMIBGroups 3 }

diffServMIBSixTupleClfrGroup OBJECT-GROUP
    OBJECTS {
        diffServSixTupleClfrDstAddrType, diffServSixTupleClfrDstAddr,
        diffServSixTupleClfrDstAddrMask,
        diffServSixTupleClfrSrcAddrType, diffServSixTupleClfrSrcAddr,
        diffServSixTupleClfrSrcAddrMask,
        diffServSixTupleClfrDscp, diffServSixTupleClfrProtocol,
        diffServSixTupleClfrDstL4PortMin,
        diffServSixTupleClfrDstL4PortMax,
        diffServSixTupleClfrSrcL4PortMin,
        diffServSixTupleClfrSrcL4PortMax,
        diffServSixTupleClfrStatus
    }
    STATUS current
    DESCRIPTION
       "The Six-tuple Classifier Group defines the MIB Objects that
       describe a classifier element for match-
       ing matching on 6 fields of an IP
       and upper-layer protocol header."
    ::= { diffServMIBGroups 4 }

diffServMIBMeterGroup OBJECT-GROUP
    OBJECTS {
        diffServMeterSucceedNext, diffServMeterFailNext,
        diffServMeterSpecific, diffServMeterStatus
    }
    STATUS current
    DESCRIPTION
       "The Meter Group defines the objects used in describ-
       ing describing a generic
       meter element."
    ::= { diffServMIBGroups 5 }

diffServMIBTBMeterGroup

diffServMIBTBParamGroup OBJECT-GROUP                                      |
    OBJECTS {
        diffServTBMeterType,
        diffServTBMeterRate, diffServTBMeterBurstSize,
        diffServTBMeterInterval, diffServTBMeterStatus
        diffServTBParamType,                                              |
        diffServTBParamRate, diffServTBParamBurstSize,                    |
        diffServTBParamInterval, diffServTBParamStatus                    |
    }
    STATUS current
    DESCRIPTION
       "The Token-Bucket Meter Group defines the objects used in
       describing a token bucket meter element."
    ::= { diffServMIBGroups 6 }

diffServMIBActionGroup OBJECT-GROUP
    OBJECTS {
        diffServActionNext, diffServActionSpecific,
        diffServActionType, diffServActionStatus
    }
    STATUS current
    DESCRIPTION
       "The Action Group defines the objects used in describing a
       generic action element."
    ::= { diffServMIBGroups 7 }

diffServMIBDscpMarkActGroup OBJECT-GROUP
    OBJECTS {
        diffServDscpMarkActDscp
    }
    STATUS current
    DESCRIPTION
       "The DSCP Mark Action Group defines the objects used in
       describing a DSCP Marking Action element."
    ::= { diffServMIBGroups 8 }

diffServMIBCounterGroup OBJECT-GROUP
    OBJECTS {
        diffServClfrElementPkts,                                          |
        diffServCountActOctets,
        diffServCountActPkts,
        diffServCountActDiscontTime,
        diffServCountActStatus,
        diffServAlgDropOctets,
        diffServAlgDropPkts
    }
    STATUS current
    DESCRIPTION
       "A collection of objects providing information specific to non-high non-
       high speed (non-high speed interfaces transmit and receive at
       speeds less than or equal to 20,000,000 bits/second)   packet-oriented packet-
       oriented network interfaces."
    ::= { diffServMIBGroups 9 }

diffServMIBHCCounterGroup OBJECT-GROUP
    OBJECTS {
        diffServClfrElementPkts,                                          |
        diffServCountActOctets, diffServCountActHCOctets,
        diffServCountActPkts,
        diffServCountActDiscontTime,
        diffServCountActStatus,
        diffServAlgDropOctets, diffServAlgDropHCOctets,
        diffServAlgDropPkts
    }
    STATUS current
    DESCRIPTION
       "A collection of objects providing information specific to high
       speed (high speed interfaces transmit and receive at speeds
       greater than 20,000,000 but less than or equals to 650,000,000
       bits/second) packet-oriented network interfaces."
    ::= { diffServMIBGroups 10 }

diffServMIBVHCCounterGroup OBJECT-GROUP
    OBJECTS {
        diffServClfrElementPkts, diffServClfrElementHCPkts,               |
        diffServCountActOctets, diffServCountActHCOctets,
        diffServCountActPkts, diffServCountActHCPkts,
        diffServCountActDiscontTime,
        diffServCountActStatus,
        diffServAlgDropOctets, diffServAlgDropHCOctets,
        diffServAlgDropPkts, diffServAlgDropHCPkts
    }
    STATUS current
    DESCRIPTION
       "A collection of objects providing information specific to  very-high very-
       high speed (very-high speed inter-
       faces interfaces transmit and receive at
       speeds greater than 650,000,000 bits/second) packet-oriented
       network interfaces."
    ::= { diffServMIBGroups 11 }

diffServMIBAlgDropGroup OBJECT-GROUP
    OBJECTS {
        diffServAlgDropType, diffServAlgDropNext,
        diffServAlgDropQMeasure, diffServAlgDropQThreshold,
        diffServAlgDropSpecific, diffServAlgDropStatus
    }
    STATUS current
    DESCRIPTION
       "The Algorithmic Drop Group contains the objects that describe
       algorithmic dropper operation and configura-
       tion." configuration."
    ::= { diffServMIBGroups 12 }

diffServMIBRandomDropGroup OBJECT-GROUP
    OBJECTS {
        diffServRandomDropMinThreshBytes,
        diffServRandomDropMinThreshPkts,
        diffServRandomDropMaxThreshBytes,
        diffServRandomDropMaxThreshPkts,
        diffServRandomDropInvProbMax,
        diffServRandomDropInvWeight,
        diffServRandomDropSamplingRate,
        diffServRandomDropStatus
    }
    STATUS current
    DESCRIPTION
       "The Random Drop Group augments the Algorithmic Drop Group for
       random dropper operation and configuration."
    ::= { diffServMIBGroups 13 }

diffServMIBQGroup OBJECT-GROUP
    OBJECTS {
        diffServQNext, diffServQSchdParam,
        diffServQStatus
    }
    STATUS current
    DESCRIPTION
       "The Queue Group contains the objects that describe an
       interface's queues."
    ::= { diffServMIBGroups 14 }

diffServMIBSchedulerGroup OBJECT-GROUP
    OBJECTS {
        diffServSchedulerNext,
        diffServSchedulerSucceedNext, diffServSchedulerFailNext,          |
        diffServSchedulerMethod, diffServSchedulerSchdParam,              |
        diffServSchedulerStatus                                           |
    }
    STATUS current
    DESCRIPTION
       "The Scheduler Group contains the objects that describe packet
       schedulers on interfaces."
    ::= { diffServMIBGroups 15 }

diffServMIBSchdParamGroup OBJECT-GROUP
    OBJECTS {
        diffServSchdParamPriority,
        diffServSchdParamMinRateAbs, diffServSchdParamMinRateRel,
        diffServSchdParamMaxRateAbs, diffServSchdParamMaxRateRel,
        diffServSchdParamBurstSize,
        diffServSchdParamTBParam, diffServSchdParamStatus                 |
    }
    STATUS current
    DESCRIPTION
       "The Scheduler Parameter Group contains the objects that describe
       packet schedulers' parameters on inter-
       faces." interfaces."
    ::= { diffServMIBGroups 16 }

diffServMIBStaticGroup OBJECT-GROUP
    OBJECTS {
        diffServClfrNextFree, diffServClfrElementNextFree,
        diffServSixTupleClfrNextFree,
        diffServMeterNextFree, diffServTBMeterNextFree, diffServTBParamNextFree,                   |
        diffServActionNextFree, diffServCountActNextFree,
        diffServAlgDropNextFree, diffServRandomDropNextFree,
        diffServQNextFree, diffServSchedulerNextFree,
        diffServSchdParamNextFree
    }
    STATUS current
    DESCRIPTION
       "The Static Group contains readable scalar objects used in
       creating unique identifiers for classifiers, meters, actions and
       queues. These are required  when-
       ever whenever row creation operations on
       such tables are sup-
       ported." supported."
    ::= { diffServMIBGroups 17 }

END

8.  Acknowledgments

This MIB builds on all the work that has gone into the Informal
Management Model for Diffserv routers, DiffServ Routers, Diffserv PIB, and DiffServ Diffserv Policy  |
MIB (SNMPCONF WG).  It has been developed with the active involvement of
many people, but most notably Yoram Bernet, Steve Blake, Brian
Carpenter, Dave Durham, Michael Fine, Victor Firoiu, Jeremy Greene, Dan   |
Grossman, Roch Guerin, Scott Hahn, Joel Halpern, Harrie Hazewinkel, Van   |
Jacobsen, Keith McCloghrie, Bob Moore, Kathleen Nichols, Ping Pan, Nabil
Seddigh, Bert Wijnen, Victor Firoiu, John Seligson, Michael Fine, Walter Weiss, Joel Halpern, and Harrie Hazewinkel. Bert Wijnen.                    |

9.  Security Considerations

It is clear that this MIB is potentially useful for configuration, and
anything that can be configured can be misconfigured, with potentially
disastrous effect.

At this writing, no security holes have been identified beyond those
that SNMP Security is itself intended to address. These relate primarily
to controlled access to sensitive information and the ability to
configure a device - or which might result from operator error, which is
beyond the scope of any security architecture.

There are a number of management objects defined in this MIB that have a
MAX-ACCESS clause of read-write and/or read-create. Such objects may be
considered sensitive or vulnerable in some network environments.  The
support for SET operations in a non-secure environment without proper
protection can have a negative effect on network operations. The use of
SNMP Version 3 is recommended over prior versions for configuration
control as its security model is improved.

There are a number of managed objects in this MIB that may contain
information that may be sensitive from a business perspective, in that
they may represent a customer's service contract or the filters that the
service provider chooses to apply to a customer's ingress or egress
traffic. There are no objects which are sensitive in their own right,
such as passwords or monetary amounts.

It may be important to control even GET access to these objects and
possibly to even encrypt the values of these object when sending them
over the network via SNMP. Not all versions of SNMP provide features for

such a secure environment.

SNMPv1 by itself is not a secure environment. Even if the network itself
is secure (for example by using IPSec), even then, there is no control
as to who on the secure network is allowed to access and GET/SET
(read/change/create/delete) the objects in this MIB.

It is recommended that the implementers consider the security features
as provided by the SNMPv3 framework. Specifically, the use of the User-
based Security Model [12] and the View-based Access Control Model [15]
is recommended.

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
access to the objects only to those principals (users) that have
legitimate rights to indeed GET or SET (change/create/delete) them.

10.  References

[1]  Harrington, D., Presuhn, R., and B. Wijnen, "An Architecture for
     Describing SNMP Management Frameworks", RFC 2571, Cabletron
     Systems, Inc., BMC Software, Inc., IBM T. J. Watson Research, April
     1999

[2]  Rose, M., and K. McCloghrie, "Structure and Identification of
     Management Information for TCP/IP-based Internets", RFC 1155, STD

[3]  Rose, M., and K. McCloghrie, "Concise MIB Definitions", RFC 1212,
     STD 16, Performance Systems International, Hughes LAN Systems,

[4]  M. Rose, "A Convention for Defining Traps for use with the SNMP",

[5]  McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M.,
     and S. Waldbusser, "Structure of Management Information Version 2
     (SMIv2)", RFC 2578, STD 58, Cisco Systems, SNMPinfo, TU
     Braunschweig, SNMP Research, First Virtual Holdings, International

[6]  McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M.,
     and S. Waldbusser, "Textual Conventions for SMIv2", RFC 2579, STD
     58, Cisco Systems, SNMPinfo, TU Braunschweig, SNMP Research, First

[7]  McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J., Rose, M.,
     and S. Waldbusser, "Conformance Statements for SMIv2", RFC 2580,
     STD 58, Cisco Systems, SNMPinfo, TU Braunschweig, SNMP Research,

[8]  Case, J., Fedor, M., Schoffstall, M., and J. Davin, "Simple Network
     Management Protocol", RFC 1157, STD 15, SNMP Research, Performance
     Systems International, Performance Systems International, MIT
     Laboratory for Computer Science, May 1990.

[9]  Case, J., McCloghrie, K., Rose, M., and S. Waldbusser,
     "Introduction to Community-based SNMPv2", RFC 1901, SNMP Research,
     Inc., Cisco Systems, Inc., Dover Beach Consulting, Inc.,
     International Network Services, January 1996.

[10] Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Transport
     Mappings for Version 2 of the Simple Network Management Protocol
     (SNMPv2)", RFC 1906, SNMP Research, Inc., Cisco Systems, Inc.,
     Dover Beach Consulting, Inc., International Network Services,
     January 1996.

[11] Case, J., Harrington D., Presuhn R., and B. Wijnen, "Message
     Processing and Dispatching for the Simple Network Management
     Protocol (SNMP)", RFC 2572, SNMP Research, Inc., Cabletron Systems,

[12] Blumenthal, U., and B. Wijnen, "User-based Security Model (USM) for
     version 3 of the Simple Network Management Protocol (SNMPv3)", RFC

[13] Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Protocol
     Operations for Version 2 of the Simple Network Management Protocol
     (SNMPv2)", RFC 1905, SNMP Research, Inc., Cisco Systems, Inc.,
     Dover Beach Consulting, Inc., International Network Services,
     January 1996.

[14] Levi, D., Meyer, P., and B. Stewart, "SNMPv3 Applications", RFC
     2573, SNMP Research, Inc., Secure Computing Corporation, Cisco

[15] Wijnen, B., Presuhn, R., and K. McCloghrie, "View-based Access
     Control Model (VACM) for the Simple Network Management Protocol
     (SNMP)", RFC 2575, IBM T. J. Watson Research, BMC Software, Inc.,

[16] Case, J., Mundy, R., Partain, D., and B. Stewart, "Introduction to
     Version 3 of the Internet-standard Network Management Framework",
     RFC 2570, SNMP Research, Inc., TIS Labs at Network Associates,

[ACTQMGMT]
     V. Firoiu, M. Borden "A Study of Active Queue Management for
     Congestion Control", March 2000, In IEEE Infocom 2000,
     http://www.ieee-infocom.org/2000/papers/405.pdf

[AQMROUTER]
     V.Misra, W.Gong, D.Towsley "Fuid-based analysis of a network of AQM
     routers supporting TCP flows with an application to RED", In
     SIGCOMM 2000,
     http://www.acm.org/sigcomm/sigcomm2000/conf/paper/sigcomm2000-4-
     3.ps.gz

[AF-PHB]
     J. Heinanen, F. Baker, W. Weiss, J. Wroclawski, "Assured Forwarding
     PHB Group.", RFC 2597, June 1999.

[DSARCH]
     S. Blake, D. Black, M. Carlson, E. Davies, Z. Wang, W. Weiss, "An
     Architecture for Differentiated Service", RFC 2475, December 1998.

[DSFIELD]
     K. Nichols, S. Blake, F. Baker, D. Black, "Definition of the
     Differentiated Services Field (DS Field) in the IPv4 and IPv6
     Headers", RFC 2474, December 1998.

[DSPIB]
     M. Fine, K. McCloghrie, J. Seligson, K. Chan, S. Hahn, A. Smith,
     "Differentiated Services Policy Information Base", Internet Draft

[DSTERMS]
     D. Grossman, "New Terminology for Diffserv", Internet Draft
     <draft-ietf-diffserv-new-terms-02.txt>, November 1999.

[EF-PHB]
     V. Jacobson, K. Nichols, K. Poduri, "An Expedited Forwarding PHB."
     RFC 2598, June 1999.

[IFMIB]
     K. McCloghrie, F. Kastenholz, "The Interfaces Group MIB using
     SMIv2", RFC 2233, November 1997.

[INETADDRESS]
     Daniele, M., Haberman, B., Routhier, S., Schoenwaelder, J.,
     "Textual Conventions for Internet Network Addresses.", RFC 2851,
     June 2000.

[INTSERVMIB]
     F. Baker, J. Krawczyk, A. Sastry, "Integrated Services Management
     Information Base using SMIv2", RFC 2213, September 1997.

[MODEL]
     Y. Bernet, S. Blake, A. Smith, D. Grossman, "An Informal Management
     Model for Diffserv Routers", Internet Draft <draft-ietf-diffserv-
     model-04.txt>, July 2000.

[POLTERM]
     F. Reichmeyer,  D. Grossman, J. Strassner, M. Condell, "A Common
     Terminology for Policy Management", Internet Draft <draft-

[QUEUEMGMT]
     B. Braden et al., "Recommendations on Queue Management and
     Congestion Avoidance in the Internet", RFC 2309, April 1998.

[RED93]
     "Random Early Detection", 1993.

[SRTCM]
     J. Heinanen, R. Guerin, "A Single Rate Three Color Marker", RFC
     2697, September 1999.

[TRTCM]
     J. Heinanen, R. Guerin, "A Two Rate Three Color Marker", RFC 2698,
     September 1999.

[TSWTCM]
     W. Fang, N. Seddigh, B. Nandy "A Time Sliding Window Three Colour
     Marker", RFC 2859, June 2000.

11.  Authors' Addresses

     Fred Baker
     Cisco Systems
     519 Lado Drive
     Santa Barbara, California 93111
     fred@cisco.com
     Kwok Ho Chan
     Nortel Networks
     600 Technology Park Drive
     Billerica, MA 01821
     khchan@nortelnetworks.com

     Andrew Smith
     Allegro Networks
     6399 San Ignacio Ave
     San Jose, CA 95119
     andrew@allegronetworks.com

Table of Contents

1 The SNMP Management Framework ...................................    2
2 Introduction ....................................................    4
2.1 Relationship to the Diffserv Informal Management Model ........  for  Diffserv
     Router .......................................................    4
2.2 Relationship to other MIBs and Policy Management ..............    5
2.3 MIB Overview ..................................................    5
3 Structure of this MIB ...........................................    6
3.1 DiffServ Diffserv Data Paths ...........................................    7
3.1.1 Data Path Table .............................................    7
3.2 Classifiers ...................................................    8    7
3.2.1 Classifier Table ............................................    9
3.2.2 Classifier Element Table ....................................    9
3.2.3 Filter Table - IP Six-Tuple Classifier Table ................    9
3.3 Meters ........................................................    9
3.3.1 Meter Table .................................................   10
3.3.2 Token-Bucket Meter Table ....................................   10
3.4 Actions .......................................................   10
3.4.1 DSCP Mark Action Table ......................................   11
3.4.2 Count Action Table ..........................................   11
3.4.3 Absolute Drop Action ........................................   11
3.5 Queueing Queuing Elements ............................................. ..............................................   11
3.5.1 Algorithmic Dropper Table ...................................   12   11
3.5.2 Random Dropper Table ........................................   13
3.5.3 Queues and Schedulers .......................................   14
4 MIB Usage Example ...............................................   16
4.1 Model's Example ...............................................   16
4.2 Additional Data Path Example ..................................   19
4.2.1 Data Path and Classifier Example Discussion .................   19
4.2.2 Meter and Action Example Discussion .........................   22

4.2.3 Queue and Scheduler Example Discussion ......................   23   22
5 Conventions used in this MIB ....................................   23
5.1 The use of RowPointer .........................................   23
5.2 The use of StaticRowPointer ...................................   24
5.3 Conceptual row creation and deletion ..........................   24
6 Extending this MIB ..............................................   25
7 MIB Definition ..................................................   26
8 Acknowledgments .................................................   97   98
9 Security Considerations .........................................   97   98
10 References .....................................................   98   99
11 Authors' Addresses .............................................  101  102

12.  Full Copyright

   Copyright (C) The Internet Society (2000). All Rights Reserved.

   This document and translations of it may be copied and furnished to
   others, and derivative works that comment on or otherwise explain it   |
   or assist in its implmentation implementation may be prepared, copied, published
   and distributed, in whole or in part, without restriction of any
   kind, provided that the above copyright notice and this paragraph are
   included on all such copies and derivative works. However, this
   document itself may not be modified in any way, such as by removing
   the copyright notice or references to the Internet Society or other
   Internet organizations, except as needed for the purpose of
   developing Internet standards in which case the procedures for
   copyrights defined in the Internet Standards process must be
   followed, or as required to translate it into languages other than
   English.

   The limited permissions granted above are perpetual and will not be
   revoked by the Internet Society or its successors or assigns.

   This document and the information contained herein is provided on an
   "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
   TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
   BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
   HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.