Internet Engineering Task Force                                 F. Baker
Diffserv Working Group                                     Cisco Systems
INTERNET-DRAFT                                                   K. Chan
Expires January June 2001                                        Nortel Networks
draft-ietf-diffserv-mib-04.txt
draft-ietf-diffserv-mib-05.txt                                  A. Smith
                                                                <editor>
                                                           November 2000
                  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 [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

This MIB is designed according to the Differentiated Services Informal
Management Model documented in [MODEL]. The model describes the way that
ingress and egress interfaces of an 'n'-port router are modelled. It
describes the configuration and management of a Diffserv interface in
terms of a Transmission Control Traffic Conditioning Block (TCB) which contains, by
definition, zero or more classifiers, meters, actions, algorithmic
droppers, queues and schedulers. These elements are arranged according
to the QoS policy being expressed, always in that order. Traffic may be
classified; classified traffic may be metered; each stream of traffic
identified by a combination of classifiers and meters may have some set
of actions performed on it; it may have dropping algorithms applied and
it may ultimately be stored into a queue before being scheduled out to
its next destination, either onto a link or to another TCB. When the
treatment for a given packet must have any of those elements repeated in
a way that breaks the permitted sequence {classifier, meter, action,
algorithmic dropper, queue, scheduler}, this must be modelled by
cascading multiple TCBs.

The 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 - it only
refers in passing to the higher-level TCBs.  The
higher level concept of a TCB when is not required in the parameterization or
in the linking together of the individual elements, hence it is
necessary to distinguish not used
in the MIB itself and only mentioned in the text for relating the MIB
with the [MODEL].  The actual distinguishing of which TCB, of several, TCB a particular specific
element is a part.  Literal TCBs are enumerated for Classifier elements: this part of is
necessary to distinguish different, but overlapping, classification
policies in different TCBs. However, TCBs are not enumerated needed for other
elements. When the instructmentation of a TCB performs no classification device
to support the literal functionalities of DiffServ, but it is useful for
conceptual reasons.  By not including TCB notion in its parameters, this
MIB allow any grouping of the
succeeding elements to construct TCBs, using rules
indicated by the [MODEL].  This will minimize changes to this MIB if
rules in [MODEL] changes.

The notion of a Data Path is not used in their instance (index) as there is no
need this MIB to distinguish them - each element indicate the DiffServ
processing a packet may experience.  This Data Path is unique already. 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 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.  These elements are instantiated 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 a
very detailed manner, typically indexed by interface, direction and
other indices. this MIB is coupled with interface thru the use of
diffServDataPathTable.  The concept of "interface" is as for the
InterfaceIndex/ifIndex of the IETF Interfaces MIB [IFMIB].

Other MIBs and data structure definitions for policy management
mechanisms other than SNMP/SMIv2 are likely to exist in the future for
the purposes of abstracting the model in other ways.

In particular, abstractions in the direction of less detailed
definitions of Diffserv functionality are likely e.g. some form of "Per-
Hop
"Per-Hop Behaviour"-based definition involving a template of detailed
object values which is applied to specific instances of objects in this
MIB semi-automatically.

Another possible direction of abstraction is one using a concept of
"roles" (often, but not always, applied to interfaces). In this case, it
may be possible to re-use the object definitions in this MIB but with
different indexing variables e.g. MIB, especially
the parameterization tables.  The Data Path table will help in the reuse
of the data path linkage tables by mechanically replacing 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

In this MIB, we model

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

In this MIB, we model the ingress and egress portions of a router 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 the packet is part of  is within conforming or outside not
     conforming to its rate 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 the starting point of
     DiffServ datapaths within a single DiffServ device.  This table
     descibes interface and interface direction specific data paths.

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 (an exponential
     weighted moving average meter). 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" 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
     Queue, Scheduler
     A general extensible framework for parameterizing queuing and Algorithmic Dropper Tables.
     scheduler systems.  The queue measurement dependent algorithmic
     droppers are also described here.

3.  Structure of this MIB

3.1.  Classifiers

The classifier 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

This MIB is used to send these structured with separate streams to appropriate
Meter, Action, Queue, Scheduler and Algorithmic Dropper elements.  For
example, to indicate a multi-stage meter, sub-classes tables for purpose of traffic may be
sent to different meter stages: e.g. in an implementation DiffServ data
path description and DiffServ treatment parameterization of the Assured
Forwarding (AF) PHB [AF-PHB], AF11 traffic might be sent to DiffServ
device.  The data path description and/or the first
meter, AF12 traffic might treatment parameterization
tables can each be sent to reuse independently, allowing the second and AF13 traffic sent flexibility to
the second meter stage's out-of-profile action.

3.1.1.  Classifier Table

The structure of the classifier table, as described in [MODEL], is
maintain a
sequence common data construct for DiffServ device configuration and
provisioning, independent of unambiguous tests. Within each stage in the sequence, it
must not be important configuration/provisioning method used.

The definitions in which order the tests this MIB are made. This is to
facilitate optimized implementations such as index trees. Order is
present only intented to resolve ambiguity: for that reason be reused by the stage in DiffServ
PIB and SNMPCONF working group's DiffServ Policy MIB.  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.

3.1.  DiffServ Data Paths

This part of the
sequence is referred MIB provide instrumentation for connecting the DiffServ
Functional Elements within a single DiffServ device.  Please refer to here and in
the [MODEL] as for discussions on the "precedence" valid sequencing and grouping of
DiffServ Functional Elements.  Given some basic information, e.g.
ifIndex and interface direction, the
classifier stage: stages with higher values of precedence first DiffServ Functional Element
is determined.  Subsequent DiffServ Functional Elements are compared
first; provided by
the order "Next" pointer attribute of tests for entries each entry of the same precedence is
unimportant.

An important form data path tables.
Description of classifier how this "Next" pointer is "everything else": the final stage of
the classifier i.e. the one with the lowest precedence, must be
"complete" since the result of an incomplete classifier used in each table is not
necessarily deterministic - see [MODEL] section 4.1.2. provided
in their respective section.

The definition of the actual filter to data path can be used by the classifier is
referenced via redefined to allow a RowPointer: different level of control
other than interface level control currently defined in this enables MIB.  There
is on-going work in this area, most notably the use development 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 Policy
Information Base in this DiffServ and RAP working groups, and DiffServ Policy
MIB module.

The classifiers specified here are at in SNMPCONF working group.

3.1.1.  Data Path Table

Entries in the interface level i.e. they are
indexed by ifIndex: they may be derived from some more general policies
e.g. something based on interface roles, but such discussion is outside Data Path Table provide the scope of this document. See e.g. [POLTERM] section 4 DiffServ treatment starting
points for a
discussion all packets of Roles.

3.1.2.  IP Six-Tuple Classifier Table

This MIB includes a definition for an IP Six-Tuple Classifier, used for
IP traffic classification. Entries this DiffServ device. Each entry in this filter table are referenced
from the RowPointer diffServClassifierPattern attributes of classifier table entries.

A Behavior Aggregate (BA) Classifier, acting only on DSCPs, is a simple
form of the IP Six-Tuple Classifier. It
is represented indexed by having the
diffServSixTupleClfrDscp attribute set to the desired DSCP ifIndex and all other
classification attributes set to match-all, their default settings. The
alternative approach the direction of providing a specific definition in this MIB the packet flow.  There
should be at most two entries for
a BA Classifier was discussed each interface, one for ingress and rejected.
one for egress.  Each entry in provides the IP Six-Tuple Classifier Table defines first DiffServ Functional
Element each packet at a single filter.
The textual convention of InetAddress [INETADDR] specific interface traveling a specific
relative direction should experience.  Notice this table is used for both IPv4
and IPv6 addressing.  The interface
specific, with the use of IP Six-Tuple Classifiers is discussed ifIndex.  As indicated in [DSARCH] and abstract examples of how they might be configured are
provided in [MODEL].

3.2.  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 2.2, with
some number (two or more) modification/extension of
potential results. A given packet is said to "conform" to the meter if,
at the time that the packet is being looked at, Data Path Table, most of the stream appears to tables
and their entries are reusable by other Policy Management mechanisms.
For indication of none existence of DiffServ Treatments, entries can be
within
created with zeroDotZero in the meter's profile. MIB syntax makes it easiest diffServDataPathStart attribute to define
indicate this
as a sequence explicitly.  The none existence of one or more cascaded pass/fail tests, modeled here as
if-then-else constructs.  It DiffServ Treatment can
also be indicated implicitly by not having the entry at all. The
explicit/implicit selection is important up to understand that this way of
modelling the implementation.  This means
allow normal IP device processing when zeroDotZero is used in the
diffServDataPathStart attribute, or when the entry does not imply anything about exist.
Normal IP device processing will depend on the implementation being
"sequential": multi-rate/multi-profile meters e.g. those designed to
support [SRTCM] or [TRTCM], device, for example, this
can still be modelled 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 forwarding the
MIB structure.

3.2.1.  Meter Table packet.

3.2.  Classifiers

The generic meter table classifier, classifier element, and filter tables determine how
traffic is used as a base for all more specific forms of
meter.  The definition sorted out. They identify separable classes of parameters specific traffic, by
reference to the type of meter used

is referenced via a pointer an appropriate filter, which may select anything from an
individual micro-flow to a table containing those specifics with
the instance within that table aggregates identified by the same indices as for the
base meter table.  This enables the use of any sort of specific meter
table that one might wish to design, standard or proprietary. DSCP.

The
specific meter table classification is used to send these separate streams to appropriate
Meter, Action, Queue, Scheduler and Algorithmic Dropper elements. For
example, to indicate a multi-stage meter, sub-classes of traffic may be, but does not need be
sent to be, defined different meter stages: e.g. in this
MIB module.

3.2.2.  Token-Bucket Meter Table

This is included as an example of a common type implementation of meter.  Entries in
this table are referenced from the RowPointer diffServMeterSpecific
attributes of meter table entries.  The parameters are represented by a
rate diffServTBMeterRate and a burst size diffServTBMeterBurstSize.

3.3.  Actions

Actions include "no action", "mark Assured
Forwarding (AF) PHB [AF-PHB], AF11 traffic might be sent to the first
meter, AF12 traffic with a DSCP", "drop might be sent to the
traffic" or "count it". Other tasks such as "shape second and AF13 traffic sent to
the traffic" or "drop
based on some algorithm" are handled elsewhere as queueing mechanisms,
rather than actions, consistent with [MODEL]. second meter stage's out-of-profile action.

The "multiplexer",
"replicator" and "null" actions concept of a classifier is the same as described in [MODEL] are accomplished
implicitly by means [MODEL].  The
structure of the RowPointer structures of classifier and classifier element tables, is the other elements.

This MIB uses the Action Table diffServActionTable to organize one
Action's relationship with same
as the element(s) before and after it. It allows
Actions to classifier described in [MODEL].  Within each classifier, it must
not be cascaded important in which order the tests are made. This is to enable multiple Actions be applied
facilitate optimized implementations such as index trees. Order is
present only to a single
traffic stream resolve ambiguity, by using each entry's diffServActionNext attribute.  The
diffServActionNext attribute use of the last action entry "order" here and
"precedence" in [MODEL].  Filter with higher values of order are
compared first; the chain
points to the next element in order of tests for entries of the TCB, if any, e.g.  a Queueing element.
It same order is
unimportant.

A datapath may also point at a next TCB. consist of more than one classifier.  There may be
overlap of filter specification between filters of different
classifiers.  The parameters needed for each Action first classifier functional datapath element will depend on
encountered, as determined by the type sequencing of
Action to be taken. Hence there are specific Action Tables for all the
different Action types.  This flexibility allows additional Actions diffserv functional
datapath elements, will be
specified in future revisions used first.

An important form of this MIB, or in other MIBs and also
allows for classifier is "everything else": the use final stage of proprietary Actions without impact on those
defined here.

3.3.1.  DSCP Mark Action Table

This Action is applied to traffic in order to mark it
the classifier i.e. the one with a Diffserv
Codepoint (DSCP) value, specified in the diffServDscpMarkActTable.
Other marking actions might lowest precedence, must be specified elsewhere - these are outside
"complete" since the scope result of this MIB.

3.3.2.  Count Action Table

Count Actions are used an incomplete classifier is not
necessarily deterministic - see [MODEL] section 4.1.2.

The definition of the actual filter to count be used by the traffic passing along classifier is
referenced via a particular
path through RowPointer: this enables the model. If specified, they are likely 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 placed
first, before other types
derived from some more general policies e.g. something based on
interface roles, but such discussion is outside the scope of Action. For example, when both this
document. See e.g. [POLTERM] section 4 for a Count and
an Absolute Dropper Action discussion of Roles.

3.2.1.  Classifier Table

Classifiers are specified, organized by entries of the Count Action needs Classifier Table.  With each
entry corresponds to
count a single Classifier.  It is the traffic stream before any traffic gets dropped.  Note entries in the
Classifier Table that
there are counters contained directly get linked from the upstream diffserv functional
datapath element, i.e. an entry in Algorithmic Dropper elements diffServDataPathTable.  A data path
may consist of more than one Classifier, the order the classification
processes aplies to
indicate the amount of traffic dropped by those elements.

Counters is the same as the order the classifier
table entries are arranged linked in the data path.

3.2.2.  Classifier Element Table

While the Classifier Table entries handles the input side of the
Classifier, the Classifier Element Table enumerates each branch of the
fan-out of a single table but Classifier, associating each fan-out branch with separate conformance
statements a Filter
for low-speed and high-speed interfaces, consistent with
[IFMIB].

3.3.3.  Absolute Drop Action

This action just silently discards all discriminating the traffic presented to it, without
counting it. This action has no additional parameters and so for that branch. Each Classifier Element
table entry is
represented only as a diffServActionSpecific pointing to
diffServAbsoluteDropAction without any specific parameters.

3.4.  Queueing Elements

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

3.4.1.  Algorithmic Dropper Table

Algorithmic Droppers have a close relationship with queueing: they are
represented in this MIB Classifier, indicated by entries in
diffServClfrElementClfrId.

3.2.3.  Filter Table - IP Six-Tuple Classifier Table

This MIB includes one Filter Table, a definition for an Algorithmic Dropper Table. IP Six-Tuple
Classifier, used for IP traffic classification. 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 be
introduced at in this point: Classifier elements here can then distinguish filter
table are referenced from the different types RowPointer diffServClfrElementSpecific
attributes of traffic classifier element table entries.

A Behavior Aggregate (BA) Classifier, acting only on which dropping DSCPs, is to act and a simple
form of the
treatment for each type IP Six-Tuple Classifier. It is described represented by a separate diffServAlgDropEntry.

Algorithmic Droppers may also contain a pointer to specific detail of having the drop algorithm. This MIB defines
diffServSixTupleClfrDscp attribute set to the detail for three drop
algorithms: Tail Drop, Head Drop desired DSCP and Random Drop; all other algorithms are
outside the scope
classification attributes set to match-all, their default settings. The
alternative approach of providing a specific definition in this MIB modele but for
a BA Classifier was discussed and rejected.

Each entry in the general framework IP Six-Tuple Classifier Table defines a single filter.
The textual convention of InetAddress [INETADDR] is
intended to allow used for their inclusion via other MIB modules.

One generally-applicable parameter both IPv4
and IPv6 addressing.  The use of a dropper IP Six-Tuple Classifiers is the specification discussed
in [DSARCH] and abstract examples of
a queue-depth threshold 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 drop action set of thresholds and produces some number (two or more) of

potential results. A given packet is said to start. This is
represented in this MIB, as a base attribute of the Algorithmic Dropper
entry, by pointing "conform" to the queue for which depth meter if,
at the time that the packet is being looked at, the stream appears to be compared and
within the depth threshold meter's profile. MIB syntax makes it easiest to compare against.

o    A Tail Dropper requires the specification of define this
as a maximum queue depth
     threshold: when the queue pointed at by diffServAlgDropQMeasure
     reaches that depth threshold, diffServAlgDropQThresh, any new
     traffic arriving at the dropper sequence of one or more cascaded pass/fail tests, modeled here as
if-then-else constructs. It is discarded. This algorithm uses
     only parameters important to understand that are part this way of
modelling does not imply anything about 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 implementation being
"sequential": multi-rate/multi-profile meters e.g. those designed to
support [SRTCM] or [TRTCM], can still be modelled this way even if they,
of necessity, share information between the queue is discarded. This algorithm
     uses only parameters that are part of stages: the diffServAlgDropEntry.

o    Random Droppers stages are recommended
introduced merely as a way to control congestion, in
     [QUEUEMGMT] and called for notational convenience in the [AF-PHB]. Various implementations
     exist, which agree on marking or dropping just enough traffic order to
     communicate with TCP-like protocols about congestion avoidance, but
     differ markedly on their specific parameters. This simplify the
MIB attempts to
     offer structure.

3.3.1.  Meter Table

The generic meter table is used as a minimal set of controls base for any random dropper, but expects
     that vendors will augment 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 with additional controls and
     status in accordance with their implementation. containing those specifics.  This algorithm
     requires additional parameters on top
enables the use of those 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
     diffServAlgDropEntry: these are discussed below.

3.4.2.  Random Dropper this MIB module.

3.3.2.  Token-Bucket Meter Table

One

This is included as an example of a random dropper is a RED-like dropper.  An example common type of
the representation chosen meter.  Entries in
this MIB for table are referenced from the RowPointer 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 element is shown provided by the
diffServTBMeterType attribute.  Additional meter parameterization tables
can be defined in
Figure 1.

Random droppers often have their drop probability function described as this or other MIB when necessary.

3.4.  Actions

Actions include "no action", "mark the traffic with a plot 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 mechanisms,
rather than actions, consistent with [MODEL].  The "multiplexer",
"replicator" and "null" actions described in [MODEL] are accomplished
implicitly by means of drop probability (P) against averaged queue length (Q).
(Qmin,Pmin) then defines the start RowPointer structures of the characteristic plot.  Normally
Pmin=0, meaning other elements.

This MIB uses the Action Table diffServActionTable to organize one
Action's relationship with average queue length below Qmin, there will the element(s) before and after it. It allows
Actions to be no
drops.  (Qmax,Pmax) defines cascaded to enable multiple Actions be applied to a "knee" on single
traffic stream by using each entry's diffServActionNext attribute.  The
diffServActionNext attribute of the plot, after which point last action entry in the
drop probability become more progressive (greater slope).  (Qclip,1)
defines chain
points to the queue length next element in the TCB, if any, e.g.  a Queueing element.

It may also point at which all packets a next TCB.

The parameters needed for each Action element will be dropped. Notice
this is different from Tail Drop because this uses an averaged queue
length.  although it is possible for Qclip = Qmax. In depend on the MIB module,
diffServRandomDropMinThreshBytes and diffServRandomDropMinThreshPkts
represent Qmin.  diffServRandomDropMaxThreshBytes and
diffServRandomDropMaxThreshPkts represent Qmax.

      +-------------+      +-----------+
  --->| Next   --------+-->| Next    ---------> to Scheduler
      | Thresh=100k |  |   | Min=none  |
      | Measure -------+   | Max=none  |
      | Type=random |      | Pri=10    |
      | Specif  -------+   | Type=fifo |
      +-------------+  |   +-----------+
        AlgDrop.3      |  Queue.ifIndex.4
                       |
                       |   +--------------+
                       +-->| Minthresh=10k|
                           | Maxthresh=80k|
                           | Weight=1/16  |
                           | ProbMax= 0.5 |
                           +--------------+
                            RandomDrop.3

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

diffServRandomDropProbMax represents Pmax. This MIB does not represent
Pmin (assumed to be zero unless otherwise represented) or Qclip (assumed
Action to be Qmax unless otherwise represented).

Each random dropper specification is associated with a queue. This
allows multiple drop processes (of same or different types) be
associated with taken. Hence there are specific Action Tables for all the same queue, as
different PHB implementations may
require. Action types.  This also flexibility allows for sequences of multiple droppers if
necessary.

The calculation additional Actions be
specified in future revisions of a smoothed queue length may this MIB, or in other MIBs and also have an important
bearing on
allows for the behaviour 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 dropper: parameters may include the
sampling interval and diffServDscpMarkActTable. Other
marking actions might be specified elsewhere - these are outside the weight
scope of each sample. The performance may be
very sensitive this MIB.

3.4.2.  Count Action Table

Count Actions are used to count the values of these parameters and traffic passing along a wide range of
possible values may be required due particular
path through the model. If specified, they are likely to a wide range be placed
first, before other types of link speeds. Most
algorithms include Action. For example, when both a sample weight, represented here by
diffServRandomDropInvWeight. Count and
an Absolute Dropper Action are specified, the Count Action needs to
count the traffic stream before any traffic gets dropped.  Note however that
there is ongoing research
on this topic, see e.g. [ACTQMGMT].

Additional parameters may be added are counters contained directly in an enterprise MIB module, e.g. by
using AUGMENTS on this table, Algorithmic Dropper elements to handle aspects
indicate the amount of random drop
algorithms that traffic dropped by those elements.

Counters are not standardised here.

NOTE: Deterministic Droppers can be viewed as arranged in a special case of Random
Droppers single table but with the drop probability restricted to 0 separate conformance
statements for low-speed and 1. Hence
Deterministic Droppers might be described by a Random Dropper high-speed interfaces, consistent with Pmin

= 0, Pmax = 1, Qmin = Qmax = Qclip, the averaged queue length at which
dropping occurs.
[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 Elements

These include Algorithmic Droppers, Queues and Schedulers

The Queue Table models simple FIFO queues, as described which are all
inter-related in [MODEL]
section 7.1.1.  The Scheduler Table allows flexibility in constructing
both simple and somewhat more complex their use of queueing 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.

The entries in the Queue techniques.

3.5.1.  Algorithmic Dropper Table

Algorithmic Droppers have attributes which include a
specification of the scheduler which services the queue. They close relationship with queueing: they are
pointed at
represented in this MIB by the "next" attributes of the upstream elements e.g.
diffServMeterSucceedNext.  Note that multiple upstream elements may
direct entries in an Algorithmic Dropper Table.
Entries contain a diffServAlgDropNext attribute which indicates to which
queue they sink their traffic traffic.

An Algorithmic Dropper is assumed to the same Queue Table entry. For example, the
Assured Forwarding PHB suggests that operate indiscriminately on all traffic marked AF11, AF12 or
AF13 be placed in
packets that are presented at its input. If it is necessary to perform
additional classification on the same queue, after metering, without reordering.
This would stream then a separate TCB must be represented by having the diffServMeterSucceedNext of each
upstream meter point
introduced at the same entry in the Queue Table.

The Scheduler Table represented in this MIB module contains entries,
each point: Classifier elements here can then distinguish
the different types of traffic on which represents dropping is to act and the algorithm in use
treatment for servicing the one or
more queues that feed it. The [MODEL] section 7.1.2 describes a
scheduler with multiple inputs: this each type is represented in the MIB described by
including the scheduling parameters associated with a scheduler input in
the Queue Table entry that feeds it and having that point at one
particular Scheduler Table entry. In this way, sets of Queues can be
grouped together as inputs separate diffServAlgDropEntry.

Algorithmic Droppers may also contain a pointer to specific detail of
the same Scheduler. drop algorithm, diffServAlgDropSpecific. This table serves to
represent the example scheduler described in MIB defines the [MODEL]: detail
for three drop algorithms: Tail Drop, Head Drop and Random Drop; other more
complex representations might be created
algorithms are outside the scope of this MIB.

Each scheduler input, as represented by a Queue Table entry, MIB module but the general
framework is assigned
a priority with respect intended to all the other inputs feeding the same
scheduler.  A higher-priority input will be serviced first over a lower-
priority input, assuming that all guarantees have already been met.
This priority parameter, used on its own with default values allow for the their inclusion via other parameters, serves to allow representation MIB
modules.

One generally-applicable parameter of a Strict Priority
scheduler.

For Weighted Queueing algorithms e.g. WFQ, WRR, dropper is the "weight" specification of
a given
scheduler input is represented with a Minimum Service Rate leaky-bucket
profile queue-depth threshold at which provides guaranteed bandwidth some drop action is to that input, if required. start. This is represented, as were token-bucket meters, by a rate
diffServQueueMinRateAbs and a burst size diffServQueueMinBurstSize. The
rate may, alternatively, be
represented by a relative value, in this MIB, as a

fraction base attribute, diffServAlgDropQThreshold,
of the interface's current line rate, diffServQueueMinRateRel Algorithmic Dropper entry.  The queue for which depth is 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
compared and changes in one may be
reflected in the other.

An input may also be capable of acting as a non-work-conserving [MODEL]
traffic shaper: this depth threshold to compare against, is done by defining specified with
diffServAlgDropQMeasure.

o    A Tail Dropper requires the specification of a Maximum Service Rate leaky-
bucket profile in order to limit maximum queue depth
     threshold: when the scheduler bandwidth available to queue pointed at by diffServAlgDropQMeasure
     reaches that input.  This depth threshold, diffServAlgDropQThresh, any new
     traffic arriving at the dropper is represented, similarly to discarded. This algorithm uses
     only parameters that are part of the minimum rate, by a
rate diffServQueueMaxRateAbs and diffServAlgDropEntry.

o    A Head Dropper requires the specification of a burst size diffServQueueMaxBurstSize.
The rate may, alternatively, be represented maximum queue depth
     threshold: when the queue pointed at by a relative value, as a
fraction of diffServAlgDropQMeasure
     reaches that depth threshold, diffServAlgDropQThresh, traffic
     currently at the interface's current line rate, diffServQueueMaxRateRel.

3.4.4.  Example head of Algorithmic Droppers, Queues and Schedulers

As an example, the hypothetical queue/scheduler configuration shown in
[MODEL] section 8.1 queue is shown discarded. This algorithm
     uses only parameters that are part of the diffServAlgDropEntry.

o    Random Droppers are recommended as a way to control congestion, in Table 1.

Queues 1
     [QUEUEMGMT] and 3 are serviced called for long in the [AF-PHB]. Various implementations
     exist, which agree on marking or dropping just enough traffic to give them
     communicate with TCP-like protocols about congestion avoidance, but
     differ markedly on their promised
bandwidths and burst sizes, if they need them.  Queue 2 is then serviced
up specific parameters. This MIB attempts to its maximum limit profile.  Only then does Queue 4 get an
opportunity to send its traffic.  As an example
     offer a minimal set of controls for any random dropper, but expects
     that vendors will augment the use 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
structures, for this element is shown in Figure 2 shows how 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 example would start of the characteristic plot.  Normally
Pmin=0, meaning with average queue length below Qmin, there will be represented.

  QId MinRate           MaxRate           Priority   Scheduler
  --- ----------------  ----------------  --------   ---------
  1   100kbps/20kbyte   none/none           20       Scheduler.1
  2   none/none         100kbps/100kbyte    40       Scheduler.1
  3   200kbps/20kbyte   none/none           20       Scheduler.1
  4   none/none         none/none           10       Scheduler.1

  SchedId   Type
  -------   ------------------
  1         weightedRoundRobin

      Table 1: Example Queue no
drops.  (Qmax,Pmax) defines a "knee" on the plot, after which point the
drop probability become more progressive (greater slope).  (Qclip,1)
defines the queue length at which all packets will be dropped. Notice
this is different from Tail Drop because this uses an averaged queue
length.  although it is possible for Qclip = Qmax. In the MIB module,
diffServRandomDropMinThreshBytes and Scheduler Parameters
                          +-----------+
  ----------------------->| Next    -----+
                          | Min=Profl4|  |
                          | Max=none  |  |
                          | Pri=20    |  |
                          | Type=fifo |  |
                          +-----------+  |
                         Queue.ifIndex.1 |
                                         |
      +-----------+       +-----------+  |
  --->| Next    -----+--->| Next   ------+
      | Thresh=1k |  |    | Min=none  |  |
      | Measure -----+    | Max=Profl5|  |
      | Type=Tail |       | Pri=40    |  |
      | Spec=none |       | Type=fifo |  |    +----------+
      +-----------+       +-----------+  +--->| Next   -----> 0.0
        Dropper.1        Queue.ifIndex.2 |    | Algrm=wrr| diffServRandomDropMinThreshPkts
represent Qmin.  diffServRandomDropMaxThreshBytes and
diffServRandomDropMaxThreshPkts represent Qmax.
diffServRandomDropInvProbMax represents Pmax. This MIB does not
represent Pmin (assumed to be zero unless otherwise represented) or next TCB
                                         |    +----------+
      +-----------+
Qclip (assumed to be Qmax unless otherwise represented).

Each random dropper specification is associated with a queue. This
allows multiple drop processes (of same or different types) be
associated with the same queue, as different PHB implementations may

      +-------------+      +-----------+  |   Scheduler.ifIndex.1
  --->| Next    -----+--->|   --------+-->| Next    -----+    ---------> to Scheduler
      | Thresh=2k Thresh=100k |  |   | Min=Profl3| Min=none  |
      | Measure -----+ -------+   | Max=none  |
      |
      | Type=Tail |       | Pri=20 Type=random |      | Pri=10    | Spec=none
      | Specific ------+   | Type=fifo |
      +-------------+  |   +-----------+       +-----------+  |
        Dropper.2        Queue.ifIndex.3 |
                                         |
      +-----------+       +-----------+  |
  --->| Next   ------+--->| Next    -----+
      | Thresh=4k |  |    | Min=none  |
      | Measure -----+    | Max=none  |
        AlgDrop.3      | Type=Tail  Queue.4
                       |
                       | Pri=10   +--------------+
                       +-->| Minthresh=10k|
                           | Maxthresh=80k|
                           | Spec=none Weight=1/16  |
                           | Type=fifo ProbMax= 0.5 |
      +-----------+       +-----------+
        Dropper.3        Queue.ifIndex.4
                           +--------------+
                            RandomDrop.3

  Figure 2: 1: Example Use of the use RandomDropTable for Random Droppers

require.  This also allows for sequences of Queueing elements

4.  Conventions used in this MIB

4.1. multiple droppers if
necessary.

The use calculation of RowPointer

RowPointer is a textual convention used to identify a conceptual row in smoothed queue length may also have an SNMP Table by pointing to one important
bearing on the behaviour of its objects. In this MIB, it is used
in two ways: to indicate indirection and to indicate succession.

When used for indirection as in the diffServClassifierTable, dropper: parameters may include the idea is
to allow other MIBs, including proprietary ones, to define new and
arcane classifiers - MAC headers, IPv4 and IPv6 headers, BGP Communities
sampling rate and all sorts the weight of other things - whilst still utilising each sample. The performance may be very
sensitive to the structures values of
this MIB. This is these parameters and a form wide range of class inheritance (in "object oriented"
language): it allows base object definitions ("classes") to possible
values may be extended
in proprietary or standard ways, in the future, required due to a wide range of link speeds. Most
algorithms include a sample weight, represented here by other documents.

When used for succession, it answers
diffServRandomDropInvWeight.  The availability of
diffServRandomDropSamplingRate as readable is important, the question "what happens next?".
Rather than presume that information
provided by Sampling Rate is essential to the next table must configuration of
diffServRandomDropInvWeight.  Having Sampling Rate be configurable is
also helpful, as specified in the
conceptual model [MODEL] and providing its index, line speed increases, the RowPointer takes
you ability to the MIB row representing have queue
sampling be less frequent than packet arrival is needed.  Note however
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 there is used to build the TCBs
     described in [MODEL]: ongoing research on this MIB does not model TCBs directly - it
     operates at a lower level of abstraction using only individual
     elements, connected topic, see e.g. [ACTQMGMT] and
[AQMROUTER].

Additional parameters may be added in succession an enterprise MIB module, e.g. by RowPointers. Therefore, the
     concept
using AUGMENTS on this table, to handle aspects of TCBs enclosing individual functional datapath elements
     is random drop
algorithms that are not applicable to this MIB, although such a concept may standardised here.

NOTE: Deterministic Droppers can 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 viewed as a dangling RowPointer (or
potentially does in the special case of a Meter element) should Random
Droppers with the drop probability restricted to 0 and 1. Hence
Deterministic Droppers might be treated described by a Random Dropper with Pmin
= 0, Pmax = 1, Qmin = Qmax = Qclip, the agent averaged queue length at which
dropping occurs.

3.5.3.  Queues and Schedulers

The Queue Table models simple FIFO queues, as if it were operationally deactivated. For example, if described in [MODEL]
section 7.1.1.  The Scheduler Table allows flexibility in constructing
both simple and somewhat more complex queueing hierarchies from those
queues.  Of course, since TCBs can be cascaded multiple times on an
Action element has a dangling diffServActionNext RowPointer
interface, even more complex hierarchies can be constructed that does
not point to an existent table entry (and is not zeroDotZero), then none way
also.

Queue Table entries are pointed at by the "next" attributes of the subsequent
upstream elements in e.g. diffServMeterSucceedNext.  Note that particular chain should have any
effect on the multiple
upstream elements may direct their traffic proceeding down this chain and the Classification
or Meter element which lead to this Action element is not considered to
be active.  Other parts of the device configuration remain in effect, of
course, but this rule simply removes same Queue Table
entry. For example, the Assured Forwarding PHB suggests that all ambiguity from traffic
marked AF11, AF12 or AF13 be placed in the operational
system.

4.2.  Conceptual row creation and deletion

A number same queue, after metering,
without reordering. This would be represented by having the
diffServMeterSucceedNext of conceptual tables defined each upstream meter point at the same entry
in this MIB use as an index an
arbitrary integer value, unique across the scope Queue Table.

Notice 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 agent. In order
to help with multi-manager row-creation problems, a mechanism must be
provided to allow a manager to obtain unique values algorithm in use for such an index
and to ensure that, when used, servicing
the manager knows whether it got what it
wanted one or not.

Typically, such a table has an associated NextFree variable e.g.
diffServClassifierNextFree which provides more queues that feed it. The [MODEL] section 7.1.2 describes
a suitable value for scheduler with multiple inputs: this is represented in the index
of MIB by
having the next row to scheduling parameters be created e.g. diffServClassifierId. A special
value, 0, is used to indicate that no more entries associated with each input.  In this
way, sets of Queues can be created by grouped together as inputs to the
agent. The same
Scheduler.  This table also has a columnar Status attribute with RowStatus
syntax [6].

If a manager attempts serves to create a conceptual row represent the example scheduler
described in the table (by a SET
operation [MODEL]: other more complex representations might be
created outside of this MIB.

Scheduler Parameter Table entries are used to parameterized each input
that contains feeds into a varbind setting the Status to scheduler.  The inputs can be a value mixture of
either createAndGo or createAndWait) Queue Table
and if 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 agent has sufficient
resources and has no other conceptual row with inputs feeding the
same indices, scheduler, with default values for the
agent other parameters.  A
higher-priority input will create the row and return success. If be serviced first over a lower-priority
input, assuming that all guarantees have already been met.

For Weighted Queueing algorithms e.g. WFQ, WRR, the agent has
insufficient resources or such "weight" of a row given
scheduler input is already existent then it returns
an error. A manager must be prepared represented with a Minimum Service Rate leaky-bucket
profile which provides guaranteed bandwidth to try again in such circumstances,
probably that input, if required.
This is represented, as were token-bucket meters, by re-reading a rate
diffServSchdParamMinRateAbs. The rate may, alternatively, be represented
by a relative value, as a fraction of the NextFree interface's current line rate,
diffServSchdParamMinRateRel to obtain a new index value assist in case cases where line rates are
variable or where a second manager had got higher-level policy might be expressed in between the first manager's read terms of the
NextFree value and the first manager's row-creation attempt. The use
fractions of
RowStatus is covered in more detail network resources. The two rate parameters are inter-
related and changes in [6].

5.  Editorial information

<this section will one may be removed before publication>

5.1.  Open Issues resolved reflected in previous drafts

(0)  Terminology the other.

An input may also be capable of acting as a non-work-conserving [MODEL]
traffic shaper: this is more done by defining a Maximum Service Rate leaky-
bucket profile in line with [MODEL], [POLTERM] and [DSTERM].
     Discarder -> "Algorithmic Dropper", "Monitor" -> "Counter"
     "Classifier element" -> "Filter"

(1)  Cascaded token-buckets is not equivalent order to multi-rate token-
     bucket: do we need limit the scheduler bandwidth available to fix this
that input. This is represented, similarly to the minimum rate, by allowing a multi-rate TB in the
     MIB? Or,
rate diffServSchdParamMaxRateAbs. The rate may, alternatively, be
represented by defining cascaded buckets to mean "multi-rate". (assume a relative value, as a fraction of the latter - see text in 2.3)

(2)  Markers: model only describes DSCP-markers: do we need to interface's
current line rate, diffServSchdParamMaxRateRel.

Notice hierarchical schedulers can be able
     to extend this to other sorts (e.g. 802.1p), even if we do not
     represent them in parameterized using this MIB today? (yes). No MIB changes, just
     words.

(3)  Counters: should specific blocks include their own or by
having Scheduler Table entries feeds into Scheduler Table entry.

3.5.4.  Example of Algorithmic Droppers, Queues and Schedulers

As an example, the hypothetical queue/scheduler configuration shown in
[MODEL] section 8.1 is a "counter
     action", as described shown in the Model, sufficient to count all paths
     through a device? (as appropriate). Per-queue counters are
     derivable from "action" ones.  Per-classifier counters: may feed
     through from clasifiers to distinct counter actions.

(4) Table 1.

  QId MinRate           MaxRate           Priority   Scheduler
  --- ----------------  ----------------  --------   ---------
  1   100kbps/20kbyte   none/none           20       Scheduler.1
  2   none/none         100kbps/100kbyte    40       Scheduler.1
  3   200kbps/20kbyte   none/none           20       Scheduler.1
  4   none/none         none/none           10       Scheduler.1

  SchedId   Type
  -------   ------------------
  1         weightedRoundRobin

      Table 1: Example Queue Sets: and Scheduler Parameters

Queues 1 and 3 are these generally applicable? (no). The example in
     section 2.5.1 is hard serviced for long enough to follow: we should describe this example in
     [MODEL] give them their promised
bandwidths and then show how it maps to MIB in the MIB draft. - DONE

(5)  Do we burst sizes, if they need scheduling units of "packets"? (NO) Should we use "kbps"
     or just "bps" for rates? DONE - all rates are in kbps.

(6)  Are "absolute" rates sufficient or should we include "relative to
     line speed" ones as well? (yes) - DONE - explained that these are
     interrelated.

(7)  Scheduler weights vs. rates vs. priorities: this them. Queue 2 is confusing -
     suggest we stick then serviced
up to rates and priorities (see Model draft 7.1.2) -
     DONE.

(8) its maximum limit profile. Only then does Queue Measure table:

o    This allows for RIO - multiple averaging functions for 4 get an
opportunity to send its traffic.  As an example of the use of the same
     queue: is this needed? OUT OF SCOPE.

o    mixes config with status objects - split these? N/A.

o    do we need floating-point representation for "weight"? N/A.

o    do we need MIB visibility for average queue depth? N/A.

o    do we need MIB-configurable averaging functions (sample
     weight/interval)?  (maybe just "sample weight") - NO: averaging
     functions will
structures, Figure 2 shows how the example would be left out although framework allows for their
     inclusion separately.

(9)  Counter compliance: paste text from IF-MIB re line-speeds. Do you
     still represented.

                          +-----------+
  ----------------------->| Next    -----+
                          | Min=Profl4|  |
                          | Max=none  |  |
                          | Pri=20    |  |
                          | Type=fifo |  |
                          +-----------+  |
                         Queue.1         |
                                         |
      +-----------+       +-----------+  |
  --->| Next    -----+--->| Next   ------+
      | Thresh=1k |  |    | Min=none  |  |
      | Measure -----+    | Max=Profl5|  |
      | Type=Tail |       | Pri=40    |  |
      | Spec=none |       | Type=fifo |  |    +----------+
      +-----------+       +-----------+  +--->| Next   -----> 0.0
        Dropper.1        Queue.2         |    | Algrm=wrr|  or next TCB
                                         |    +----------+
      +-----------+       +-----------+  |   Scheduler.1
  --->| Next    -----+--->| Next    -----+
      | Thresh=2k |  |    | Min=Profl3|  |
      | Measure -----+    | Max=none  |  |
      | Type=Tail |       | Pri=20    |  |
      | Spec=none |       | Type=fifo |  |
      +-----------+       +-----------+  |
        Dropper.2        Queue.3         |
                                         |
      +-----------+       +-----------+  |
  --->| Next   ------+--->| Next    -----+
      | Thresh=4k |  |    | Min=none  |
      | Measure -----+    | Max=none  |
      | Type=Tail |       | Pri=10    |
      | Spec=none |       | Type=fifo |
      +-----------+       +-----------+
        Dropper.3        Queue.4

      Figure 2: Example of the use of Queueing elements

4.  MIB Usage Example

This section provides some examples on how the different table entries
of this MIB may be used to parameterize a DiffServ Device.  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.

+---------------------+
|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|  +-->|CounterAct1|
                     +-------+        +--------+      +-----------+

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

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

      Figure 3: Data Path Example Part 1
     +-------------+      +------------------+     +----------------------+
---->|Q            |   +->|Scheduler         |  +->|Scheduler             |
     | Id=EF       |   |  | Id=DiffServ      |  |  | Id=Shaping           |
     | Next -------+---+  | Next ------------+--+  | Next=zeroDotZero     |
     | SchdParam -+|   |  | Method=priorityq |     | Method=priorityq     |
     +------------++   |  | SchdParam -+     |     | SchdParam=zeroDotZero|
                  |    |  +------------+-----+     +----------------------+
     +------------+    |               |
     |                 |  +------------+
     |  +-----------+  |  |
     +->|SchdParamEF|  |  |  +----------------+
        +-----------+  |  +->|SchdParamShaping|
                       |     +----------------+
                       |
                       |
                       +-----------------------------------------+
                                                                 |
                                                                 |
    +----------------+       +-------------+                     |
--->|AlgDrop         |    +->|Q            |                     |
    | Id=AF11        |    |  | Id=AF1X     |    +-------------+  |
    | Type=randomDrop|    |  | Next -------+--->|Scheduler    |  |
    | Next ----------+-+--+  | SchdParam -+|    | Id=AF       |  |
    | QMeasure ------+-+  |  +------------++    | Next -------+--+
    | QThreshold     |    |               |     | Method=wfq  |
    | Specific -+    |    |  +------------+     | SchdParam -+|
    +-----------+----+    |  |                  +------------++
                |         |  |  +-------------+              |
    +-----------+         |  +->|SchdParamAF1X| +------------+
    |  +--------------+   |     +-------------+ |
    +->|RandomDropAF11|   |                     |  +-----------+
       +--------------+   |                     +->|SchdParamAF|
                          |                        +-----------+
    +----------------+    |
--->|AlgDrop         |    |
    | Id=AF12        |    |
    | Type=randomDrop|    |
    | Next ----------+-+--+
    | QMeasure ------+-+
    | QThreshold     |
    | Specific -+    |
    +-----------+----+
                |
    +-----------+
    |  +--------------+
    +->|RandomDropAF12|
       +--------------+

      Figure 4: Data Path Example Part 2

4.1.  Data Path and Classifier Example Discussion

The example in Figure 4 shows a single DataPathTable entry feeding into
a single Classifier entry, with three ClfrElement 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
function datapath elements in Figure 3.  This second level of
classifiers and their subsequent function datapath elements would be
considered as in another TCB.

This multi-level classification allow the construction of traffic
seperations like:
  if (dept1)
  {
    if (appl1) then take dept1-appl1-action.
    if (appl2) then take dept1-appl2-action.
    if (appl3) then take dept1-appl3-action.
  }
  if (dept2)
  {
    if (appl1) then take dept2-appl1-action.
    if (appl2) then take dept2-appl2-action.
    if (appl3) then take dept2-appl3-action.
  }
  if (dept3)
  {
    if (appl1) then take dept3-appl1-action.
    if (appl2) then take dept3-appl2-action.
    if (appl3) then take dept3-appl3-action.
  }

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

4.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 TBMeter entries
for parameterization, a second level Meter and TBMeter table entries may
be used.  For example, for 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 3.  This is purposely done
to indicate all datapaths 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.3.  Queue and Scheduler Example Discussion

Example in Figure 4 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 4, 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 method.  The AF2X and
AF3X queues are not shown in Figure 4, they can be very much like AF1X
queue setup.

Another traffic stream, EF, is handled by the EF queue.  Scheduler
DiffServ services output of EF queue using SchdParamEF, and output of AF
scheduler using SchdParamAF, with Weighted Fair Queueing 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 4.  For shaping, the diffServSchdParamMaxRate
attributes should be used.  The output of the Shaping Scheduler is
indicated using its Next pointer with value of zeroDotZero, the output
port.

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
in two ways: to indicate indirection and to indicate succession.

When used for indirection as in the diffServClassifierTable, the idea is
to allow other MIBs, including proprietary ones, to define new and
arcane classifiers - MAC headers, IPv4 and IPv6 headers, BGP Communities
and all sorts of other things - whilst still utilising the structures of
this MIB. This is a form of class inheritance (in "object oriented"
language): it allows base object definitions ("classes") to be extended
in proprietary or standard ways, in the future, by other documents.

When used for succession, it answers the question "what happens next?".
Rather than presume that the next table must be as specified in the

conceptual model [MODEL] and providing its index, the RowPointer takes
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 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 (or
potentially does in the case of a Meter element) should be treated by
the agent as if it were operationally deactivated. For example, if an
Action element has a dangling diffServActionNext RowPointer that does
not point to an existent table entry (and is not zeroDotZero), then none
of the subsequent elements in that particular chain should have any
effect on the traffic proceeding down this chain and the Classification
or Meter element which lead to this Action element is not considered to
be active.  Other parts of the device configuration remain in effect, of
course, but this rule simply removes all ambiguity from the operational
system.

5.2.  Conceptual row creation and deletion

A number of conceptual tables defined in this MIB use as an index an
arbitrary integer value, unique across the scope of the agent. In order
to help with multi-manager row-creation problems, a mechanism must be
provided to allow a manager to obtain unique values for such an index
and to ensure that, when used, the manager knows whether it got what it
wanted or not.

Typically, such a table has an associated NextFree variable e.g.
diffServClassifierNextFree which provides a suitable value for the index
of the next row to be created e.g. diffServClassifierId. A special
value, 0, is used to indicate that no more entries can be created by the
agent. The table also has a columnar Status attribute with RowStatus
syntax [6].

If a manager attempts to create a conceptual row in the table (by a SET
operation that contains a varbind setting the Status to a value of
either createAndGo or createAndWait) and if the agent has sufficient
resources and has no other conceptual row with the same indices, the

agent will create the row and return success. If the agent has
insufficient resources or such a row is already existent then it returns
an error. A manager must be prepared to try again in such circumstances,
probably by re-reading the NextFree to obtain a new index value in case
a second manager had got in between the first manager's read of the
NextFree value and the first manager's row-creation attempt. The use of
RowStatus is covered in more detail in [6].

6.  Editorial information

<this section will be removed before publication>

6.1.  Open Issues resolved in previous drafts

(0)  Terminology is more in line with [MODEL], [POLTERM] and [DSTERM].
     Discarder -> "Algorithmic Dropper", "Monitor" -> "Counter"
     "Classifier element" -> "Filter"

(1)  Cascaded token-buckets is not equivalent to multi-rate token-
     bucket: do we need to fix this by allowing a multi-rate TB in the
     MIB? Or, by defining cascaded buckets to mean "multi-rate". (assume
     the latter - see text in 2.3)

(2)  Markers: model only describes DSCP-markers: do we need to be able
     to extend this to other sorts (e.g. 802.1p), even if we do not
     represent them in this MIB today? (yes). No MIB changes, just
     words.

(3)  Counters: should specific blocks include their own or is a "counter
     action", as described in the Model, sufficient to count all paths
     through a device? (as appropriate). Per-queue counters are
     derivable from "action" ones.  Per-classifier counters: may feed
     through from clasifiers to distinct counter actions.

(4)  Queue Sets: are these generally applicable? (no). The example in
     section 2.5.1 is hard to follow: we should describe this example in
     [MODEL] and then show how it maps to MIB in the MIB draft. - DONE

(5)  Do we need scheduling units of "packets"? (NO) Should we use "kbps"
     or just "bps" for rates? DONE - all rates are in kbps.

(6)  Are "absolute" rates sufficient or should we include "relative to
     line speed" ones as well? (yes) - DONE - explained that these are
     interrelated.

(7)  Scheduler weights vs. rates vs. priorities: this is confusing -
     suggest we stick to rates and priorities (see Model draft 7.1.2) -
     DONE.

(8)  Queue Measure table:

o    This allows for RIO - multiple averaging functions for the same
     queue: is this needed? OUT OF SCOPE.

o    mixes config with status objects - split these? N/A.

o    do we need floating-point representation for "weight"? N/A.

o    do we need MIB visibility for average queue depth? N/A.

o    do we need MIB-configurable averaging functions (sample
     weight/interval)?  (maybe just "sample weight") - NO: averaging
     functions will be left out although framework allows for their
     inclusion separately.

(9)  Counter compliance: paste text from IF-MIB re line-speeds. Do you
     still have to do the low-speed counters for fast interfaces? YES.
     DONE.

(10) Meters: are these mandatory for compliance? NO

(11) Discussion material: move most of this to Model draft e.g. most of
     3.1, 3.3, "Dropper/discarder" part of 3.4, nearly all of 3.5. Just
     leave the "how does the MIB map from the Model" parts in the MIB
     draft, no general discussion. DONE.

(12) Counters: merged in 32-bit and 64-bit counters - conformance
     statements sort out which ones must be implemented. This is
     consistent with [IFMIB]. DONE.

(13) Droppers: we used to have a common "dropper" table that represented
     all of: dropAlways, randomDrop, tailDrop with just some parameters
     valid for the simpler ones. A simpler representation is to define
     specific dropper tables for each type (e.g. a single OID to point
     at for dropAlways since it is always the last action in a chain)
     but this would mean a larger number of (simpler) MIB objects.
     CHANGES: dropAlways is still an Action but the others are moved to
     a diffServAlgDropTable. This table can handle tail/head/random drop
     - others by extension.

(14) Should TBMeterTable just AUGMENT the MeterTable, should it use same
     indices or are separate structures linked by RowPointers
     preferable? (same indices without RowPointer).

(15) Do we need to model multiple queues feeding back into a single
     dropper algorithm? (yes).  If so, the current single-queue pointer
     and threshold will not be adequate - should we leave them in? They
     will be useful for many, but not all, dropper algorithms. (yes)

(17) We have concepts of "inbound" and "outbound" directions: but if we
     have a series of multiple TCBs on a given interface for the same
     direction (allowed by the model) then we do not have a way to
     indicate "this is the 1st one". Moreover, it is a somewhat
     convoluted process to then find the 2nd, 3rd etc. ones - you would
     have to follow the RowPointers to get there: should we explicitly
     have an index to enable/help these lookup operations? Note: this is
     not the same issue as needing a "precedence" for each filter entry
     of a classifier (yes - added another index to classifiers to
     represent what TCB they operate at for a given
     interface/direction).

6.2.  Open Issues resolved in this draft

(13) Droppers: slight change to previous resolution. MIB can now handle
     tail/head/random drop using diffServAlgDropTable and
     diffServRandomDropTable.

(18) Should manager be allowed to create Queue elements or should agent
     be in control of this? (the former)

(19) Should manager be allowed to create Scheduler elements or should
     agent be in control of this? (the former)

(20) Related to (17) above, do we also need a "TCB index" for elements
     other than classifiers? (no)

(21) Do we need diffServAlgDropType of both "headDrop" and "tailDrop" or
     should we just represent the tail dropper by placing a dropper
     after the queue instead of before the queue, as linked by the
     diffServQNext and diffServAlgDropNext RowPointers? (the former -
     dropper is always in front of the queue in this model).

(22) Do we need to support RED algorithms for algorithm parameter
     configuration and monitoring? If so, what variables are needed?
     (Added diffServRandomDropTable).

(24) diffServAlgDropQThreshold needs UNITS (Bytes).

(25) Dangling RowPointers: should we mandate that these are never
     permitted? Or just define the behaviour if they do dangle? (We
     define it such that elements that have dangling pointers, as well
     as upstream elements that point to them, are considered "not
     activated")

(26) Discontinuity times for MIB counters - is
     ifCounterDiscontinuityTime adequate? (no: added
     diffServCountActDiscontTime).

(27) How do we handle dropper algorithms that require additional
     classification information in order to do their job? If a
     Classifier is needed then create a new TCB for it at the point just
     before the dropper: use ordinary Classifier elements in this TCB.

(28) Indexing of table entries and uniqueness hints: is TestAndIncr the
     correct tool to use? (no: RowStatus is the right tool for ensuring
     uniqueness; use a NextFree variable as a hint).

(32) Miscellaneous clarifications - thanks Bob.

6.3.  Still Open Issues

(16) Should the creation of counter actions be under the control of
     manager or agent: should a diffServActionEntry and
     diffServCountActEntry appear by magic (does the agent know what
     counters it can and cannot maintain on a given interface)? (no) If
     no, should diffServCountActEntry appear magically when a
     diffServAction element is created which points at the
     diffServCountActTable (then would be no need for
     diffServCountActStatus)? (no)

(23) Do daughter entries of derived table entries need to exist
     independently of the parent?  Examples are
     diffServMeterEntry/diffServTBMeterEntry,
     diffServActionEntry/diffServCountActEntry and
     diffServAlgDropEntry/diffServRandomDropEntry (assume they must be
     independent of the equivalent entry in diffServMeterTable which
     points at the TB table - needs diffServTBMeterStatus: daughters
     must be created explicitly by manager).

(30) Related to (17) - multi-manager creation of TCBs:
     diffServClassifierId is unique across the agent, for all values of
     diffServClassifierTcb but there is no "next free" variable to
     report the next TCB to use. This can lead to a race condition when
     2 managers are duelling to create entries with the same value of
     diffServClassifierTcb. There are also legitimate reasons for
     different managers to be "creating" the *same* TCB so a
     conventional "next free" is not a good solution. Is this a rare
     enough occurence given a suitable choice of diffServClassifierTcb
     e.g. pseudo-random? (yes).

(31) When inheritance is needed and parent/daughter share indexing, the
     parent often points to the daughter using a "Specific" attribute
     e.g. diffServMeterSpecific, diffServActionSpecific,
     diffServAlgDropSpecific. If this is a RowPointer and points to the
     associated row in the daughter's table, there is redundant
     information which gives scope for additional error cases. So,
     wherever possible, should we remove this redundant information by
     making the "Specific" attribute point only to the base of the
     daughter table and make it an OBJECT IDENTIFIER? The con is that
     this is an unusual use of MIB pointers (point at table base, not
     individual entries).

7.  MIB Outline

The authors think a MIB outline will assist the reader and can be used
as a quick reference.

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

diffServDataPath       OBJECT IDENTIFIER ::= { diffServMIBObjects 1 }

diffServDataPathTable OBJECT-TYPE
    ::= { diffServDataPath 1 }
diffServDataPathEntry OBJECT-TYPE
    INDEX { ifIndex, diffServDataPathIfDirection }
    ::= { diffServDataPathTable 1 }
DiffServDataPathEntry ::= SEQUENCE  {
    diffServDataPathIfDirection    IfDirection,
    diffServDataPathStart          RowPointer,
    diffServDataPathStatus         RowStatus
}

diffServClassifier     OBJECT IDENTIFIER ::= { diffServMIBObjects 2 }

diffServClfrNextFree OBJECT-TYPE
    ::= { diffServClassifier 1 }
diffServClfrTable OBJECT-TYPE
    ::= { diffServClassifier 2 }
diffServClfrEntry OBJECT-TYPE
    INDEX { diffServClfrId }
    ::= { diffServClfrTable 1 }
DiffServClfrEntry ::= SEQUENCE  {
    diffServClfrId              Unsigned32,
    diffServClfrStatus          RowStatus
}

diffServClfrElementNextFree OBJECT-TYPE
    ::= { diffServClassifier 3 }
diffServClfrElementTable OBJECT-TYPE
    ::= { diffServClassifier 4 }
diffServClfrElementEntry OBJECT-TYPE
    INDEX { diffServClfrElementClfrId, diffServClfrElementId }
    ::= { diffServClfrElementTable 1 }
DiffServClfrElementEntry ::= SEQUENCE  {
    diffServClfrElementId          Unsigned32,
    diffServClfrElementClfrId      Unsigned32,
    diffServClfrElementOrder       Unsigned32,
    diffServClfrElementNext        RowPointer,
    diffServClfrElementSpecific    RowPointer,
    diffServClfrElementStatus      RowStatus
}

diffServSixTupleClfrNextFree OBJECT-TYPE
    ::= { diffServClassifier 5 }
diffServSixTupleClfrTable OBJECT-TYPE
    ::= { diffServClassifier 6 }
diffServSixTupleClfrEntry OBJECT-TYPE
    INDEX { diffServSixTupleClfrId }
    ::= { diffServSixTupleClfrTable 1 }
DiffServSixTupleClfrEntry ::= SEQUENCE {
    diffServSixTupleClfrId           Unsigned32,
    diffServSixTupleClfrDstAddrType  InetAddressType,
    diffServSixTupleClfrDstAddr      InetAddress,
    diffServSixTupleClfrDstAddrMask  Unsigned32,
    diffServSixTupleClfrSrcAddrType  InetAddressType,
    diffServSixTupleClfrSrcAddr      InetAddress,
    diffServSixTupleClfrSrcAddrMask  Unsigned32,
    diffServSixTupleClfrDscp         Dscp,
    diffServSixTupleClfrProtocol     Unsigned32,
    diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrStatus       RowStatus
}

diffServMeter          OBJECT IDENTIFIER ::= { diffServMIBObjects 3 }

diffServMeterNextFree OBJECT-TYPE
    ::= { diffServMeter 1 }
diffServMeterTable OBJECT-TYPE
    ::= { diffServMeter 2 }
diffServMeterEntry OBJECT-TYPE
    INDEX { diffServMeterId }
    ::= { diffServMeterTable 1 }
DiffServMeterEntry ::= SEQUENCE  {
    diffServMeterId                Unsigned32,
    diffServMeterSucceedNext       RowPointer,
    diffServMeterFailNext          RowPointer,
    diffServMeterSpecific          RowPointer,
    diffServMeterStatus            RowStatus
}

diffServTBMeterNextFree OBJECT-TYPE
    ::= { diffServMeter 3 }
diffServTBMeterTable OBJECT-TYPE
    ::= { diffServMeter 4 }
diffServTBMeterEntry OBJECT-TYPE
    INDEX { diffServTBMeterId }
    ::= { diffServTBMeterTable 1 }
DiffServTBMeterEntry ::= SEQUENCE  {
    diffServTBMeterId              Unsigned32,
    diffServTBMeterType            INTEGER,
    diffServTBMeterRate            Unsigned32,
    diffServTBMeterBurstSize       BurstSize,
    diffServTBMeterInterval        Unsigned32,
    diffServTBMeterStatus          RowStatus
}

diffServAction         OBJECT IDENTIFIER ::= { diffServMIBObjects 4 }

diffServActionNextFree OBJECT-TYPE
    ::= { diffServAction 1 }
diffServActionTable OBJECT-TYPE
    ::= { diffServAction 2 }
diffServActionEntry OBJECT-TYPE
    INDEX { diffServActionId }
    ::= { diffServActionTable 1 }
DiffServActionEntry ::= SEQUENCE  {
    diffServActionId                Unsigned32,
    diffServActionNext              RowPointer,
    diffServActionSpecific          RowPointer,
    diffServActionType              INTEGER,
    diffServActionStatus            RowStatus
}

diffServDscpMarkActNextFree OBJECT-TYPE
    ::= { diffServAction 3 }
diffServDscpMarkActTable OBJECT-TYPE
    ::= { diffServAction 4 }
diffServDscpMarkActEntry OBJECT-TYPE
    INDEX { diffServDscpMarkActId }
    ::= { diffServDscpMarkActTable 1 }
DiffServDscpMarkActEntry ::= SEQUENCE  {
    diffServDscpMarkActId            Unsigned32,
    diffServDscpMarkActDscp          Dscp,
    diffServDscpMarkActStatus        RowStatus
}

diffServCountActNextFree OBJECT-TYPE
    ::= { diffServAction 5 }
diffServCountActTable OBJECT-TYPE
    ::= { diffServAction 6 }
diffServCountActEntry OBJECT-TYPE
    INDEX { diffServCountActId }
    ::= { diffServCountActTable 1 }
DiffServCountActEntry ::= SEQUENCE  {
    diffServCountActId           Unsigned32,
    diffServCountActOctets       Counter32,
    diffServCountActHCOctets     Counter64,
    diffServCountActPkts         Counter32,
    diffServCountActHCPkts       Counter64,
    diffServCountActDiscontTime  TimeStamp,
    diffServCountActStatus       RowStatus
}

diffServAlgDrop        OBJECT IDENTIFIER ::= { diffServMIBObjects 5 }

diffServAlgDropNextFree OBJECT-TYPE
    ::= { diffServAlgDrop 1 }
diffServAlgDropTable OBJECT-TYPE
    ::= { diffServAlgDrop 2 }
diffServAlgDropEntry OBJECT-TYPE
    INDEX { diffServAlgDropId }
    ::= { diffServAlgDropTable 1 }
DiffServAlgDropEntry ::= SEQUENCE  {
    diffServAlgDropId               Unsigned32,
    diffServAlgDropType             INTEGER,
    diffServAlgDropNext             RowPointer,
    diffServAlgDropQMeasure         RowPointer,
    diffServAlgDropQThreshold       Unsigned32,
    diffServAlgDropSpecific         RowPointer,
    diffServAlgDropOctets           Counter32,
    diffServAlgDropHCOctets         Counter64,
    diffServAlgDropPkts             Counter32,
    diffServAlgDropHCPkts           Counter64,
    diffServAlgDropStatus           RowStatus
}

diffServRandomDropNextFree OBJECT-TYPE
    ::= { diffServAlgDrop 3 }
diffServRandomDropTable OBJECT-TYPE
    ::= { diffServAlgDrop 4 }
diffServRandomDropEntry OBJECT-TYPE
    INDEX { diffServRandomDropId }
    ::= { diffServRandomDropTable 1 }
DiffServRandomDropEntry ::= SEQUENCE  {
    diffServRandomDropId               Unsigned32,
    diffServRandomDropMinThreshBytes   Unsigned32,
    diffServRandomDropMinThreshPkts    Unsigned32,
    diffServRandomDropMaxThreshBytes   Unsigned32,
    diffServRandomDropMaxThreshPkts    Unsigned32,
    diffServRandomDropInvProbMax       Unsigned32,
    diffServRandomDropInvWeight        Unsigned32,
    diffServRandomDropSamplingRate     Unsigned32,
    diffServRandomDropStatus           RowStatus
}

diffServQueue          OBJECT IDENTIFIER ::= { diffServMIBObjects 6 }

diffServQNextFree OBJECT-TYPE
    ::= { diffServQueue 1 }
diffServQTable OBJECT-TYPE
    ::= { diffServQueue 2 }
diffServQEntry OBJECT-TYPE
    INDEX { diffServQId }
    ::= { diffServQTable 1 }
DiffServQEntry ::= SEQUENCE  {
    diffServQId                      Unsigned32,
    diffServQNext                    RowPointer,
    diffServQSchdParam               RowPointer,
    diffServQStatus                  RowStatus
}

diffServScheduler      OBJECT IDENTIFIER ::= { diffServMIBObjects 7 }

diffServSchedulerNextFree OBJECT-TYPE
    ::= { diffServScheduler 1 }
diffServSchedulerTable OBJECT-TYPE
    ::= { diffServScheduler 2 }
diffServSchedulerEntry OBJECT-TYPE
    INDEX { diffServSchedulerId }
    ::= { diffServSchedulerTable 1 }
DiffServSchedulerEntry ::= SEQUENCE  {
    diffServSchedulerId                   Unsigned32,
    diffServSchedulerNext                 RowPointer,
    diffServSchedulerMethod               INTEGER,
    diffServSchedulerSchdParam            RowPointer,
    diffServSchedulerStatus               RowStatus
}

diffServSchdParamNextFree OBJECT-TYPE
    ::= { diffServScheduler 3 }
diffServSchdParamTable OBJECT-TYPE
    ::= { diffServScheduler 4 }
diffServSchdParamEntry OBJECT-TYPE
    INDEX { diffServSchdParamId }
    ::= { diffServSchdParamTable 1 }
DiffServSchdParamEntry ::= SEQUENCE  {
    diffServSchdParamId              Unsigned32,
    diffServSchdParamPriority        Unsigned32,
    diffServSchdParamMinRateAbs      Unsigned32,
    diffServSchdParamMinRateRel      Unsigned32,
    diffServSchdParamMaxRateAbs      Unsigned32,
    diffServSchdParamMaxRateRel      Unsigned32,
    diffServSchdParamStatus          RowStatus
}

8.  MIB Definition

DIFF-SERV-MIB DEFINITIONS ::= BEGIN

    IMPORTS
    Integer32, Unsigned32, Counter32, Counter64,
    MODULE-IDENTITY, OBJECT-TYPE, 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;

diffServMib MODULE-IDENTITY
    LAST-UPDATED "200011030000Z"
    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
               E-mail: ah_smith@pacbell.net"
    DESCRIPTION
       "This MIB defines the objects necessary to do  manage  a
       device  that  uses the low-speed counters for fast interfaces? YES.
     DONE.

(10) Meters: are these mandatory Differentiated Services Archi-
       tecture  described  in  RFC  2475  and  the  Informal
       Management  Model for compliance? NO

(11) Discussion material: move most of DiffServ Routers in draft-ietf-
       diffserv-model-04.txt."
    REVISION "200011030000Z"
    DESCRIPTION
       "Initial version, published as RFC xxxx."
    ::= { mib-2 12345 }  -- anybody who uses this to Model draft e.g. most of
     3.1, 3.3, "Dropper/discarder" part of 3.4, nearly all of 3.5. Just
     leave unassigned
                         -- number deserves the "how does wrath of IANA

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

-- These textual conventions have no effect on either the MIB map from syntax
-- nor the Model" parts in semantics of any managed object.  Objects defined
-- using this convention are always encoded by means of the MIB
     draft, no general discussion. DONE.

(12) Counters: merged in 32-bit and 64-bit counters - conformance
     statements sort out which ones must be implemented. This is
     consistent with [IFMIB]. DONE.

(13) Droppers: we used to have a common "dropper" table
-- rules that represented
     all of: dropAlways, randomDrop, tailDrop with just some parameters
     valid for the simpler ones. A simpler representation is to define
     specific dropper tables their primitive type.

Dscp ::= TEXTUAL-CONVENTION
    DISPLAY-HINT "d"
    STATUS   current
    DESCRIPTION
       "The IP header Diffserv Code-Point that may  be  used
       for each type (e.g.  discriminating or marking a single OID to point
     at for dropAlways since it traffic stream.  The
       value -1 is always the last action in used to  indicate  a chain)
     but this would mean  wildcard  i.e.  any
       value."
    SYNTAX   Integer32 (-1 | 0..63)

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

IfDirection ::= TEXTUAL-CONVENTION
    STATUS current
    DESCRIPTION
       "Specifies a direction of (simpler) MIB objects.
     CHANGES: dropAlways is still data travel  on  an Action but  inter-
       face.  'inbound' traffic is operated on during recep-
       tion from the others are moved interface, while 'outbound' traffic  is
       operated on prior to
     a diffServAlgDropTable. This transmission on the interface."
    SYNTAX  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 can handle tail/head/random drop
     - others
-- is indexed by extension.

(14) Should TBMeterTable just AUGMENT ifIndex and ifDirection.  Each entry provides
-- the MeterTable, should it use same
     indices or are separate structures linked by RowPointers
     preferable? (same indices without RowPointer).

(15) Do we need first diffserv functional datapath element to model multiple queues feeding back into a single
     dropper algorithm? (yes).  If so, the current single-queue pointer
     and threshold will not be adequate - should we leave them in? They
     will be useful process data
-- flow for many, but not all, dropper algorithms. (yes)

(17) We have concepts of "inbound" and "outbound" directions: but if we each specific datapath.  This table should have a series of multiple TCBs on a given interface two
-- entries for each 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
     direction (allowed 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 model) then we do not have a way interface
       and traffic direction.  The first diffserv functional
       datapath element to
     indicate "this handle traffic for this data path
       is defined by a RowPointer, diffServDataPathStart, in
       the 1st one". Moreover, it is 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 somewhat
     convoluted process to then find  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 2nd, 3rd etc. ones - you would
     have 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 follow  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.

       If the RowPointers to get there: should we explicitly
     have an index row pointed to enable/help these lookup operations? Note:  does  not  exist,  this  whole
       diffserv datapath is
     not ignored."
    ::= { diffServDataPathEntry 2 }

diffServDataPathStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The  RowStatus  variable  controls  the same issue as needing a "precedence" for each filter entry  activation,
       deactivation,  or  deletion of a classifier (yes - added another index to classifiers to
     represent what TCB they operate at for a given
     interface/direction).

5.2.  Open Issues resolved in this draft

(13) Droppers: slight change to previous resolution. MIB can now handle
     tail/head/random drop using diffServAlgDropTable and
     diffServRandomDropTable.

(18) Should manager row/entry. Any writ-
       able variable may be allowed to create Queue elements  modified  whether  the  row  is
       active or should agent
     be in control notInService."
    ::= { diffServDataPathEntry 3 }

--
-- Classifiers
--

diffServClassifier     OBJECT IDENTIFIER ::= { diffServMIBObjects 2 }

--
-- Classifier Table
--
-- Classifier allows multiple classifier elements, of this? (the former)

(19) Should manager be allowed to create Scheduler elements same or should
     agent different
-- types, to be in control of this? (the former)

(20) Related used together.
-- A classifier must completely classify all packets presented to (17) above, do we also need it,
-- this means all traffic handled by a "TCB index" for elements
     other than classifiers? (no)

(21) Do we need diffServAlgDropType of both "headDrop" and "tailDrop" or
     should we just represent classifier must match
-- at least one classifier element within the tail dropper classifier,

-- with the classifier element parameters specified by placing a dropper
     after the queue instead filter.
--
-- If there is ambiguity between classifier elements of before different
-- classifier, the queue, as linked precedence is indicated by the
     diffServQNext and diffServAlgDropNext RowPointers? (the former -
     dropper is always in front of order the queue classifiers
-- are linked, the first classifier in this model).

(22) Do we need the link is applied to support RED algorithms 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 algorithm parameter
     configuration and monitoring? a diffServClfrId instance.  If so, what variables are needed?
     (Added diffServRandomDropTable).

(24) diffServAlgDropQThreshold needs UNITS (Bytes).

(25) Dangling RowPointers: should we mandate that these are never
     permitted? Or just define a
       configuring system attempts to create a  new  row  in
       the behaviour  diffServClfrTable  using this value, that opera-
       tion will fail if they do dangle? (We
     define it such 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 that have dangling pointers, as well
     as upstream  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 that point belonging to them, are considered "not
     activated")

(26) Discontinuity times for MIB counters - is
     ifCounterDiscontinuityTime adequate?  (no: added
     diffServCountActDiscontTime).

(27) How do we handle dropper algorithms 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 require additional
     classification information in order to do their job? If a
     Classifier is needed then create a new TCB for it at enumerates the point just
     before classifier entries. The
       set  of  such  identifiers  spans  the dropper: use ordinary Classifier elements  whole  agent.
       Managers should obtain new values for row creation in
       this TCB.

(28) Indexing of table entries and uniqueness hints: is TestAndIncr the
     correct tool to use? (no: by reading diffServClfrNextFree."
    ::= { diffServClfrEntry 1 }

diffServClfrStatus OBJECT-TYPE
    SYNTAX       RowStatus is
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The  RowStatus  variable  controls  the right tool for ensuring
     uniqueness; use  activation,
       deactivation,  or deletion of a NextFree classifier. Any writ-
       able variable may be  modified  whether  the  row  is
       active or notInService."
    ::= { diffServClfrEntry 2 }

--
-- Classifier Element Table
--
-- Entries in the classifier element table serves as a hint).

(32) Miscellaneous clarifications - thanks Bob.

5.3.  Still Open Issues

(16) Should

-- the creation 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 counter actions be under the control fan-out characteristic of
     manager a classifier
-- indicated in [MODEL] section 4.1.  A classifier is madeup
-- of one or agent: should more classifier elements.
--

diffServClfrElementNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This  object  yields  a diffServActionEntry and
     diffServCountActEntry appear by magic (does the agent know what
     counters it can and cannot maintain on  value  when  read  that  is
       currently    unused   for   a given interface)? (no)   diffServClfrElementId
       instance.  If
     no, should diffServCountActEntry appear magically when a
     diffServAction element 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 created which points at currently valid."
    ::= { diffServClassifier 3 }

diffServClfrElementTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServClfrElementEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The classifier element table  enumerates  the
     diffServCountActTable (then would be no need for
     diffServCountActStatus)? (no)

(23) Do daughter  rela-
       tionship  between  classification patterns and subse-
       quent downstream diffserv  functional  datapath  ele-
       ments.   Classification  parameters  are  defined  by
       entries   of derived table entries need   filter   tables    pointed    to exist
     independently    by
       diffServClfrElementSpecific.   There  can  be  filter
       tables of the parent?  Examples are
     diffServMeterEntry/diffServTBMeterEntry,
     diffServActionEntry/diffServCountActEntry different types, and
     diffServAlgDropEntry/diffServRandomDropEntry (assume  they must  can  be
     independent  inter-
       mixed  and used within a classifier.  An example of the equivalent a
       filter table defined in this  MIB  is  diffServSixTu-
       pleClfrTable,  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 diffServMeterTable which
     points at the TB classifier element table - needs diffServTBMeterStatus: daughters
     must be created explicitly by manager).

(30) Related to (17) - multi-manager creation describes a
       single element of TCBs:
     diffServClassifierId is unique across the agent, for all values classifier."
    INDEX { diffServClfrElementClfrId, diffServClfrElementId }
    ::= { diffServClfrElementTable 1 }

DiffServClfrElementEntry ::= SEQUENCE  {
    diffServClfrElementId          Unsigned32,
    diffServClfrElementClfrId      Unsigned32,
    diffServClfrElementOrder       Unsigned32,
    diffServClfrElementNext        RowPointer,
    diffServClfrElementSpecific    RowPointer,
    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
     diffServClassifierTcb but there 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 no "next free" variable to
     report the next TCB to use.  a part of.  This can lead needs to a race condition when be
       the value of diffServClfrId attribute for an existing
       row in diffServClfrTable."
    ::= { diffServClfrElementEntry 2 managers }

diffServClfrElementOrder OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The relative order in which classifier elements  are duelling to create entries
       applied:   higher  numbers  represent classifier ele-
       ment with  higher  precedence.   Classifier  elements
       with the same value of
     diffServClassifierTcb. There order  must  be  unambiguous  i.e. they
       must define non-overlapping patterns, and  are also legitimate reasons for
     different managers   con-
       sidered   to   be "creating"  applied   simultaneously   to  the *same* TCB so a
     conventional "next free" is not a good solution.  Is this a rare
     enough occurence given a suitable choice of diffServClassifierTcb
     e.g. pseudo-random? (yes).

(31) When inheritance is needed and parent/daughter share indexing,
       traffic stream. Clas- sifier elements with  different
       order   may  overlap in their  filters:  the
     parent often points to classif-
       ier element with the daughter using a "Specific" attribute
     e.g. diffServMeterSpecific, diffServActionSpecific,
     diffServAlgDropSpecific. If this highest order  that  matches  is
       taken.

       On a RowPointer and points to the
     associated row given interface, there must be a complete  clas-
       sifier   in   place   at  all  times in   the daughter's table, 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 redundant
     information which gives scope for additional error cases. So,
     wherever possible, should we remove this redundant information by
     making  no  such  requirement in the "Specific" egress direc-
       tion."
    DEFVAL { 0 }
    ::= { diffServClfrElementEntry 3 }

diffServClfrElementNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This attribute point only to provides one branch  of  the base  fan-out
       functionality  of  a  classifier described in [MODEL]
       section 4.1.

       This selects the
     daughter table and make it an OBJECT IDENTIFIER? The con is that next  diffserv  functional  datapath
       element  to  handle traffic for this is data path.  This
       RowPointer should point to an unusual use instance of MIB pointers (point at table base, not
     individual entries).

6.  MIB Definition

DIFF-SERV-MIB DEFINITIONS ::= BEGIN

    IMPORTS
    Unsigned32, Counter32, Counter64, OBJECT-TYPE,
    MODULE-IDENTITY, 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;

diffServMib MODULE-IDENTITY
    LAST-UPDATED "200007130000Z"
    ORGANIZATION "IETF Diffserv WG"
    CONTACT-INFO
       "       Brian Carpenter (co-chair one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this attribute indicates no
       further Diffserv WG)
               c/o iCAIR
               1890 Maple Ave, #150
               Evanston, IL 60201, USA
       Phone:  +1 847 467 7811
       E-mail: brian@icair.org

               Kathleen Nichols (co-chair treatment is performed on traffic of Diffserv WG)
               Packet Design
       E-mail: nichols@packetdesign.com

               Fred Baker (author)
               Cisco Systems
               519 Lado Drive
               Santa Barbara, CA 93111, USA
       E-mail: fred@cisco.com

               Kwok Ho Chan (author)
               Nortel Networks
               600 Technology Park Drive
               Billerica, MA 01821, USA
       E-mail: khchan@nortelnetworks.com

               Andrew Smith (author)
       E-mail: ah_smith@pacbell.net"
    DESCRIPTION
       "This MIB defines
       this datapath.

       If the objects necessary row pointed to manage a device that
       uses the Differentiated Services Architecture described in RFC
       2475 and does not exist,  the Informal Management Model for DiffServ Routers in
       draft-ietf-diffserv-model-04.txt."
    REVISION "200007130000Z"
    DESCRIPTION
       "Initial version, published  treatment
       is  as RFC xxxx."  if  this  attribute contains a value of zero-
       DotZero."
    ::= { mib-2 12345 diffServClfrElementEntry 4 }  -- anybody who uses this unassigned
                         -- number deserves

diffServClfrElementSpecific OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "A pointer to a  valid  entry   in   another   table,
       filter table, that describes  the applicable classif-
       ication parameters, e.g.  an entry in  diffServSixTu-
       pleClfrTable.

       If the wrath of IANA

diffServObjects        OBJECT IDENTIFIER ::= row pointed to does not exist, the  classifier
       element is ignored.

       The value zeroDotZero is interpreted  to  match  any-
       thing  not  matched  by  another classifier element -
       only one such entry may exist for each classifier."
    DEFVAL { diffServMib 1 zeroDotZero }
diffServTables         OBJECT IDENTIFIER
    ::= { diffServMib 2 diffServClfrElementEntry 5 }
diffServMIBConformance OBJECT IDENTIFIER

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."
    ::= { diffServMib 3 diffServClfrElementEntry 6 }

-- These textual conventions have no effect
-- IP Six-Tuple Classification Table
--
-- Classification based on either 6 different fields in the syntax IP
-- nor the semantics of any managed object.  Objects defined header. This is intended to be IP-version-independent.
-- using Filters, entries in this convention are always encoded table, may be shared, pointed to,
-- by means multiple diffServClfrElementEntry, of same or different
-- datapaths in the same system.
-- rules that define their primitive type.

Dscp ::= TEXTUAL-CONVENTION
    DISPLAY-HINT "d"

diffServSixTupleClfrNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The IP header Diffserv Code-Point
       "This object yields a value when read that may be used is currently unused
       for
       discriminating or marking a traffic stream.  The 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 -1 is has, in the meantime, been used
       to indicate a wildcard i.e. any value."
    SYNTAX   INTEGER (-1 | 0..63)

SixTupleClfrL4Port create another row that is currently valid."
    ::= TEXTUAL-CONVENTION
    DISPLAY-HINT "d" { diffServClassifier 5 }

diffServSixTupleClfrTable OBJECT-TYPE
    SYNTAX   SEQUENCE OF DiffServSixTupleClfrEntry
    MAX-ACCESS   not-accessible
    STATUS   current
    DESCRIPTION
       "A value indicating table of IP Six-Tuple  Classifier  filter  entries
       that a Layer-4 protocol port number."
    SYNTAX   INTEGER (0..65535)

IfDirection system may use to identify IP traffic."
    REFERENCE
        "[MODEL] section 4.2.2"
    ::= TEXTUAL-CONVENTION { diffServClassifier 6 }

diffServSixTupleClfrEntry OBJECT-TYPE
    SYNTAX       DiffServSixTupleClfrEntry
    MAX-ACCESS   not-accessible
    STATUS   current
    DESCRIPTION
       "Specifies
       "An IP Six-Tuple Classifier entry describes a direction of data travel on an interface. 'inbound'
       traffic is operated on during reception from the interface, while
       'outbound' traffic is operated on prior to transmission on the
       interface."
    SYNTAX  INTEGER  single
       filter."
    INDEX {
                inbound(1),     -- ingress interface
                outbound(2)     -- egress interface diffServSixTupleClfrId }

--
-- Classifiers
--

--
-- Classifier Table
--

-- The Classifier Table allows us to enumerate the relationship
-- between arbitrary classifiers and the subsequent downstream
-- Diffserv elements.

diffServClassifierTable
    ::= { diffServSixTupleClfrTable 1 }

DiffServSixTupleClfrEntry ::= SEQUENCE {
    diffServSixTupleClfrId           Unsigned32,
    diffServSixTupleClfrDstAddrType  InetAddressType,
    diffServSixTupleClfrDstAddr      InetAddress,
    diffServSixTupleClfrDstAddrMask  Unsigned32,
    diffServSixTupleClfrSrcAddrType  InetAddressType,
    diffServSixTupleClfrSrcAddr      InetAddress,
    diffServSixTupleClfrSrcAddrMask  Unsigned32,
    diffServSixTupleClfrDscp         Dscp,
    diffServSixTupleClfrProtocol     Unsigned32,
    diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrStatus       RowStatus
}

diffServSixTupleClfrId OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServClassifierEntry         Unsigned32
    MAX-ACCESS     not-accessible
    STATUS     current
    DESCRIPTION
       "The classifier table defines the classifiers
       "An index that are applied to
       traffic arriving at this interface in a particular direction.
       Specific classifiers are defined by RowPointers in enumerates the entries  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 which identify entries in filter tables  by  reading
       diffServSixTupleClfrNextFree."
    ::= { diffServSixTupleClfrEntry 1 }

diffServSixTupleClfrDstAddrType OBJECT-TYPE
    SYNTAX         InetAddressType
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The type of specific
       types, e.g.  Multi-Field Classifiers (MFCs) for IP are defined in  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 diffServSixTupleClfrTable. Other classifier types may be
       defined elsewhere."
    REFERENCE
        "[MODEL] section 4.1" packet's  desti-
       nation IP address."
    ::= { diffServTables 1 diffServSixTupleClfrEntry 3 }

diffServClassifierEntry

diffServSixTupleClfrDstAddrMask OBJECT-TYPE
    SYNTAX       DiffServClassifierEntry         Unsigned32
    UNITS          "bits"
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
       "An entry
       "The length of a mask for the matching of the  desti-
       nation  IP address.  Masks are constructed by setting
       bits in sequence from the classifier table describes a single element most-significant bit  down-
       wards    for   diffServSixTupleClfrDstAddrMask   bits
       length. All other bits in the mask, up to the  number
       needed to fill the length of the classifier."
    INDEX { ifIndex, diffServClassifierIfDirection,
            diffServClassifierTcb, diffServClassifierId }
    ::= { diffServClassifierTable 1 }

DiffServClassifierEntry address diffServSix-
       TupleClfrDstAddr are cleared to zero.  A zero bit  in
       the mask then means that the corresponding bit in the
       address always matches."
    DEFVAL         {0}
    ::= SEQUENCE {
    diffServClassifierIfDirection  IfDirection,
    diffServClassifierTcb          Unsigned32,
    diffServClassifierId           Unsigned32,
    diffServClassifierFilter       RowPointer,
    diffServClassifierNext         RowPointer,
    diffServClassifierPrecedence   Unsigned32,
    diffServClassifierStatus       RowStatus diffServSixTupleClfrEntry 4 }

diffServClassifierIfDirection

diffServSixTupleClfrSrcAddrType OBJECT-TYPE
    SYNTAX  IfDirection         InetAddressType
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
       "Specifies the direction for which this classifier entry applies
       on
       "The type of IP source address used by this interface."  classif-
       ier entry."
    ::= { diffServClassifierEntry 1 diffServSixTupleClfrEntry 5 }

diffServClassifierTcb

diffServSixTupleClfrSrcAddr OBJECT-TYPE
    SYNTAX       Unsigned32         InetAddress
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
       "Specifies the TCB of which this classifier element is a part.
       Lower numbers indicate an element that belongs to a classifier
       that is part of a TCB that is, at least conceptually, applied to
       traffic before those with higher numbers - this is necessary to
       resolve ambiguity in cases where different TCBs contain filters
       that overlap with each other.

       A manager wanting to create a new TCB should either first search
       this table for existing entries and pick a value for this
       variable that is not currently represented - some form of pseudo-
       random choice is likely
       "The IP  address  to minimise collisions. After successful
       creation  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 conceptual row using mask for the chosen value, matching of the manager
       should check again that there  source
       IP address.  Masks are no other rows with this value
       that have been created constructed by a different manager that could,
       potentially, interfere with setting bits in
       sequence from the classifier elements that 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 are
       desired." cleared to zero.  A  zero  bit  in
       the mask then means that the corresponding bit in the
       address always matches."
    DEFVAL         {0}
    ::= { diffServClassifierEntry 2 diffServSixTupleClfrEntry 7 }

diffServClassifierId

diffServSixTupleClfrDscp OBJECT-TYPE
    SYNTAX       Unsigned32         Dscp
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
       "A classifier ID
       "The value that enumerates the classifier elements. The set
       of such identifiers spans the whole agent. Managers should obtain
       new values for row creation DSCP in the packet must  have  to
       match  this table by reading
       diffServClassifierNextFree."  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}
    ::= { diffServClassifierEntry 3 diffServSixTupleClfrEntry 8 }

diffServClassifierFilter

diffServSixTupleClfrProtocol OBJECT-TYPE
    SYNTAX       RowPointer         Unsigned32 (0..255)
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "A pointer
       "The IP protocol to a valid entry in another table that describes match against the
       applicable classification filter, e.g. an entry  IPv4  protocol
       number  in
       diffServSixTupleClfrTable.  If the row pointed to does not exist,  the classifier is ignored.

       The  packet.  A value zeroDotZero is interpreted to match anything not
       matched by another classifier - only one such entry may exist in
       this table." of zero means match
       all."
    DEFVAL { zeroDotZero }         {0}
    ::= { diffServClassifierEntry 4 diffServSixTupleClfrEntry 9 }

diffServClassifierNext

diffServSixTupleClfrDstL4PortMin OBJECT-TYPE
    SYNTAX       RowPointer         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "This selects the next datapath element to handle packets
       matching
       "The minimum value that the filter pattern. For example, this can point to an
       entry layer-4 destination  port
       number in a meter, action, algorithmic dropper or queue table.

       If the row pointed packet must have in order to does not exist, the match this
       classifier element is
       ignored." entry."
    DEFVAL         {0}
    ::= { diffServClassifierEntry 5 diffServSixTupleClfrEntry 10 }

diffServClassifierPrecedence

diffServSixTupleClfrDstL4PortMax OBJECT-TYPE
    SYNTAX       Unsigned32         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The relative precedence maximum value that the layer-4 destination  port
       number in which classifiers are applied: higher
       numbers represent classifiers with higher precedence.
       Classifiers with the same precedence must be unambiguous i.e.
       they packet must define non-overlapping patterns, and are considered have in order to match this
       classifier entry. This value  must  be applied simultaneously  equal  to  or
       greater  than  the traffic stream. Classifiers with
       different precedence may overlap  value specified for this entry in their filters: the classifier
       with the highest precedence
       diffServSixTupleClfrDstL4PortMin."
    DEFVAL         {65535}
    ::= { diffServSixTupleClfrEntry 11 }

diffServSixTupleClfrSrcL4PortMin OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The minimum  value  that matches is taken.

       On a given interface, there must be a complete classifier in
       place at all times for  the first TCB (lowest value of
       diffServClassifierTcb)  layer-4  source  port
       number in the ingress direction. This means that
       there will always be one or more filters that match every
       possible pattern that could be presented packet must have in an incoming packet.
       There is no such requirement for subsequent TCBs 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 ingress
       direction, nor for any TCB packet must have in oder to match this
       classifier entry. This value  must  be  equal  to  or
       greater  than  the egress direction."  value specified for this entry in
       diffServSixTupleClfrSrcL4PortMin."
    DEFVAL { 0 }         {65535}
    ::= { diffServClassifierEntry 6 diffServSixTupleClfrEntry 13 }

diffServClassifierStatus

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 writable variable may  activation,
       deactivation,  or deletion of a classifier. Any writ-
       able 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.
-- 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 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.
-- 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 modified
       whether parameterized using
-- two sets of diffServMeterEntry and diffServTBMeterEntry.
-- With the row is active or notInService."
    ::= { diffServClassifierEntry 7 }

diffServClassifierNextFree first set parameterizing the Committed Target Rate,
-- second set parametering the Peak Target Rate.
-- With both set's diffServTBMeterInterval 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
       currently  unused for a diffServClassifierId diffServMeterId instance.  If
       a configuring system attempts to create a new row  in
       the diffServClassifierTable  diffServMeterTable using this value, that operation opera-
       tion will fail if the value  has,  in  the  meantime,
       been  used  to  create  another row that is currently
       valid."
    ::= { diffServObjects diffServMeter 1 }

--
-- IP Six-Tuple Classification Table
--
-- Classification based on 6 different fields in the IP
-- header. This is intended to be IP-version-independent.
--

diffServSixTupleClfrTable

diffServMeterTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServSixTupleClfrEntry DiffServMeterEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "A
       "This table of IP Six-Tuple Classifier filter entries enumerates specific meters that a  system
       may use to identify IP traffic." 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 4.2.2" 5.1"
    ::= { diffServTables diffServMeter 2 }

diffServSixTupleClfrEntry

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

DiffServSixTupleClfrEntry

DiffServMeterEntry ::= SEQUENCE  {
    diffServSixTupleClfrId           Unsigned32,
    diffServSixTupleClfrDstAddrType  InetAddressType,
    diffServSixTupleClfrDstAddr      InetAddress,
    diffServSixTupleClfrDstAddrMask  Unsigned32,
    diffServSixTupleClfrSrcAddrType  InetAddressType,
    diffServSixTupleClfrSrcAddr      InetAddress,
    diffServSixTupleClfrSrcAddrMask
    diffServMeterId                Unsigned32,
    diffServSixTupleClfrDscp         Dscp,
    diffServSixTupleClfrProtocol     INTEGER,
    diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrStatus
    diffServMeterSucceedNext       RowPointer,
    diffServMeterFailNext          RowPointer,
    diffServMeterSpecific          RowPointer,
    diffServMeterStatus            RowStatus
}

diffServSixTupleClfrId

diffServMeterId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "A unique identifier for
       "An index that enumerates the filter. Filters may be shared by
       multiple interfaces in Meter entries. The  set
       of  such  identifiers spans the same system. whole agent. Managers
       should obtain new values for  row  creation  in  this
       table by reading
       diffServSixTupleClfrNextFree." diffServMeterNextFree."
    ::= { diffServSixTupleClfrEntry diffServMeterEntry 1 }

diffServSixTupleClfrDstAddrType

diffServMeterSucceedNext OBJECT-TYPE
    SYNTAX         InetAddressType       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The type
       "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 IP destination address used by one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this classifier
       entry." attribute indicates no
       further Diffserv treatment is performed on traffic of
       this datapath.

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

diffServSixTupleClfrDstAddr

diffServMeterFailNext OBJECT-TYPE
    SYNTAX         InetAddress       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The IP address
       "If the traffic does not conform,  this  selects  the
       next  diffserv  functional datapath element to match against 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.

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

diffServSixTupleClfrDstAddrMask

diffServMeterSpecific OBJECT-TYPE
    SYNTAX         Unsigned32
    UNITS          "bits"       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The length of a mask for
       "This indicates the matching behaviour of the destination IP
       address.  Masks are constructed meter by setting bits in sequence from
       the most-significant bit downwards for
       diffServSixTupleClfrDstAddrMask bits length. All other bits in
       the mask, up to the number needed to fill the length of the
       address diffServSixTupleClfrDstAddr are cleared  point-
       ing  to zero.  A zero
       bit an entry containing detailed parameters. Note
       that entries in the mask then means that the corresponding bit specific table must  be  managed
       explicitly.

       For example, diffServMeterSpecific may  point  to  an
       entry  in the
       address always matches."
    DEFVAL         {0}  diffServTBMeterTable,  which  contains  an
       instance of a single set of Token Bucket parameters."
    ::= { diffServSixTupleClfrEntry diffServMeterEntry 4 }

diffServSixTupleClfrSrcAddrType

diffServMeterStatus OBJECT-TYPE
    SYNTAX         InetAddressType       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The type  RowStatus  variable  controls  the  activation,
       deactivation,  or  deletion  of IP source address used by this classifier entry." a meter. Any writable
       variable may be modified whether the row is active or
       notInService."
    ::= { diffServSixTupleClfrEntry diffServMeterEntry 5 }

diffServSixTupleClfrSrcAddr

--
-- Token Bucket Meter Table
--
-- Each entry in the Token Bucket Meter Table parameterize
-- a single token bucket.  Multiple token buckets can be
-- used together to parameterize multiple levels of
-- conformance.
--
-- Note that an entry in the Token Bucket Meter Table can
-- be shared, pointed to, by multiple diffServMeterTable

-- entries.
--

diffServTBMeterNextFree OBJECT-TYPE
    SYNTAX         InetAddress       Unsigned32
    MAX-ACCESS     read-create   read-only
    STATUS       current
    DESCRIPTION
       "The IP address
       "This  object  yields  a  value  when  read  that  is
       currently  unused  for  a diffServTBMeterId instance.
       If a configuring system attempts to match against create a new  row
       in  the source IP address of each
       packet."  diffServTBMeterTable  using this value, that
       operation will fail if the value has,  in  the  mean-
       time,  been  used  to  create  another  row  that  is
       currently valid."
    ::= { diffServSixTupleClfrEntry 6 diffServMeter 3 }

diffServSixTupleClfrSrcAddrMask

diffServTBMeterTable OBJECT-TYPE
    SYNTAX         Unsigned32
    UNITS          "bits"       SEQUENCE OF DiffServTBMeterEntry
    MAX-ACCESS     read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "The length of
       "This table enumerates a mask for the matching single set of the source IP address.
       Masks are constructed by setting bits in sequence from the most-
       significant bit downwards for diffServSixTupleClfrSrcAddrMask
       bits length. All other bits in the mask, up to the number needed  token  bucket
       meter  parameters  that  a system may use to fill the length police a
       stream of the address diffServSixTupleClfrSrcAddr traffic.  Such meters are
       cleared to zero.  A zero bit in the mask then means that the
       corresponding bit in the address always matches."
    DEFVAL         {0} modelled here  as
       having a single rate and a single burst size."
    REFERENCE
        "[MODEL] section 5.1"
    ::= { diffServSixTupleClfrEntry 7 diffServMeter 4 }

diffServSixTupleClfrDscp

diffServTBMeterEntry OBJECT-TYPE
    SYNTAX         Dscp       DiffServTBMeterEntry
    MAX-ACCESS     read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "The value that the DSCP in the packet must have to match this
       entry. A value of -1 indicates
       "An entry that describes a specific DSCP value has not
       been defined and thus all DSCP values are considered a match."
    DEFVAL         {-1} single set of token bucket
       meter parameters."
    INDEX { diffServTBMeterId }
    ::= { diffServSixTupleClfrEntry 8 diffServTBMeterTable 1 }

diffServSixTupleClfrProtocol

DiffServTBMeterEntry ::= SEQUENCE  {
    diffServTBMeterId              Unsigned32,
    diffServTBMeterType            INTEGER,
    diffServTBMeterRate            Unsigned32,
    diffServTBMeterBurstSize       BurstSize,
    diffServTBMeterInterval        Unsigned32,
    diffServTBMeterStatus          RowStatus
}

diffServTBMeterId OBJECT-TYPE
    SYNTAX         INTEGER (0..255)       Unsigned32
    MAX-ACCESS     read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "The IP protocol to match against the IPv4 protocol number in
       "An index that enumerates the
       packet. A value  TBMeter  entries.  The
       set  of zero means match all."
    DEFVAL         {0}  such  identifiers  spans  the  whole  agent.
       Managers should obtain new values for row creation in
       this table by reading diffServTBMeterNextFree."
    ::= { diffServSixTupleClfrEntry 9 diffServTBMeterEntry 1 }

diffServSixTupleClfrDstL4PortMin

diffServTBMeterType OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port       INTEGER {
                     other(1),        -- not listed here
                     tokenBucket(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),   -- trTCM, Color-aware
                     tswTCM(8)        -- tswTCM
                 }
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The minimum value that type of meter using parameters specified by this
       TBMeter entry.

       Value of tokenBucket(2)  indicates  the  use  of  Two
       Parameter  Token Bucket Meter as described in [MODEL]
       section 5.2.3.

       Value of avgRate(3) indicates the use of Average Rate
       Meter as described in [MODEL] section 5.2.1.

       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 of trTCMBlind(6)  and  trTCMAware(7)  indicates
       the  use  of  Two Rate Three Color Marker Metering as
       defined by RFC 2698, with `Color  Blind'  and  `Color
       Aware' mode as described by the layer-4 destination port number in RFC.

       Value of tswTCM(8) indicates the packet must have in order to match this classifier entry."
    DEFVAL         {0} use of Time  Sliding
       Window  Three Color Marker Metering as defined by RFC
       2859."
    REFERENCE
        "[MODEL] section 5"
    ::= { diffServSixTupleClfrEntry 10 diffServTBMeterEntry 2 }

diffServSixTupleClfrDstL4PortMax

diffServTBMeterRate OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The maximum value that the layer-4 destination port number in
       the packet must have  token-bucket  rate,  in order to match this classifier entry.  kilobits  per   second
       (kbps).   This value must be equal to or greater that the value specified  attribute  is used for: 1. CIR in RFC
       2697 for this entry srTCM 2. PIR and CIR in diffServSixTupleClfrDstL4PortMin."
    DEFVAL         {65535} FRC 2698  for  trTCM
       3.  CTR and PTR in RFC 2859 for TSWTCM 4. AverageRate
       used in [MODEL] section 5."
    ::= { diffServSixTupleClfrEntry 11 diffServTBMeterEntry 3 }

diffServSixTupleClfrSrcL4PortMin

diffServTBMeterBurstSize OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port       BurstSize
    UNITS        "Bytes"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The minimum value that the layer-4 source port maximum number of bytes in the
       packet must have a single transmission
       burst.  This attribute is used for: 1. CBS and EBS in order to match this classifier entry."
    DEFVAL         {0}
       RFC 2697 for srTCM 2. CBS and PBS  in  FRC  2698  for
       trTCM 3. Burst Size used in [MODEL] section 5."
    ::= { diffServSixTupleClfrEntry 12 diffServTBMeterEntry 4 }

diffServSixTupleClfrSrcL4PortMax

diffServTBMeterInterval OBJECT-TYPE
    SYNTAX         SixTupleClfrL4Port       Unsigned32
    UNITS        "microseconds"
    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 that time interval used with the value specified for
       this entry in dsSixTupleIpSrcL4PortMin."
    DEFVAL         {65535} token bucket.   For:
       1.  Average  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, RFC 2698 trTCM, -
       token bucket
          update time interval."
    ::= { diffServSixTupleClfrEntry 13 diffServTBMeterEntry 5 }

diffServSixTupleClfrStatus

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

diffServSixTupleClfrNextFree

--
-- Actions
--

diffServAction         OBJECT IDENTIFIER ::= { diffServMIBObjects 4 }

--
-- 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
       currently unused for a diffServSixTupleClfrId diffServActionId instance.  If
       a configuring system attempts to create a new row  in
       the diffServSixTupleClfrTable diffServActionTable using this value, that operation opera-
       tion will fail if the value  has,  in  the  meantime,
       been  used  to  create  another row that is currently
       valid."
    ::= { diffServObjects 2 diffServAction 1 }

--
-- Meters
--
-- This MIB includes definitions for a generic Meter
-- Table as well as specific definitions for Token-
-- Bucket Meters, as one example of possible meters.
--

diffServMeterTable

diffServActionTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServMeterEntry DiffServActionEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table
       "The Action Table enumerates generic meters actions that a system may use can be per-
       formed  to
       police  a stream of traffic.  The traffic stream to Multiple actions can
       be metered is
       determined by the element(s) upstream concatenated.  For example, after marking a stream
       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.  exiting  from a meter, a device can then
       perform a count action  of  the  conforming  or  non-
       conforming traffic.

       Specific meter details actions  are  indicated  by  diffServAction-
       Specific  which  points  to be found  an  entry  of a specific
       action type parameterizing the action in diffServMeterSpecific." detail."
    REFERENCE
        "[MODEL] section 5.1" 6."
    ::= { diffServTables 3 diffServAction 2 }

diffServMeterEntry

diffServActionEntry OBJECT-TYPE
    SYNTAX       DiffServMeterEntry       DiffServActionEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An
       "Each entry in the meter action table describing a single meter." allows description of
       one specific action to be applied to traffic."
    INDEX { ifIndex, diffServMeterIfDirection,
            diffServMeterId diffServActionId }
    ::= { diffServMeterTable diffServActionTable 1 }

DiffServMeterEntry

DiffServActionEntry ::= SEQUENCE  {
    diffServMeterIfDirection       IfDirection,
    diffServMeterId
    diffServActionId                Unsigned32,
    diffServMeterSucceedNext
    diffServActionNext              RowPointer,
    diffServMeterFailNext
    diffServActionSpecific          RowPointer,
    diffServMeterSpecific          OBJECT IDENTIFIER,
    diffServMeterStatus
    diffServActionType              INTEGER,
    diffServActionStatus            RowStatus
}

diffServMeterIfDirection OBJECT-TYPE
    SYNTAX       IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "Specifies the direction for which this meter entry applies on
       this interface."
    ::= { diffServMeterEntry 1 }

diffServMeterId

diffServActionId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This identifies a meter entry.
       "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 diffServMeterNextFree." diffServActionNextFree."
    ::= { diffServMeterEntry 2 diffServActionEntry 1 }

diffServMeterSucceedNext

diffServActionNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "If the traffic does conform to the meter, this indicates
       "This selects the next diffserv  functional  datapath
       element  to  handle the traffic e.g. for this data path.  This
       RowPointer should point to an Action or
       another Meter datapath element.

       The instance of one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this variable attribute indicates no
       further Diffserv treatment is performed on this traffic by the current
       interface for of
       this interface direction. datapath.

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

diffServMeterFailNext

diffServActionSpecific OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "If the traffic does not conform
       "A pointer to an object instance providing additional
       information  for the meter, type of action indicated by this indicates the
       next datapath element to handle
       action table entry.

       For the traffic e.g. an Action or
       Meter datapath element.

       The value zeroDotZero in this variable indicates no further
       Diffserv treatment is performed on this traffic standard actions defined by the current
       interface for this interface direction. If the row pointed MIB  module,
       this   should  point  to
       does not exist,  one  of  the meter element is considered inactive."
    DEFVAL      { zeroDotZero }  following:  a
       diffServDscpMarkActEntry,  a   diffServCountActEntry.
       For other actions, it may point to an object instance
       defined in some other MIB."
    ::= { diffServMeterEntry 4 diffServActionEntry 3 }

diffServMeterSpecific

diffServActionType OBJECT-TYPE
    SYNTAX       OBJECT IDENTIFIER       INTEGER {
                     other(1),       -- types not specified here
                     specific(2),    -- follow the Specific pointer
                     absoluteDrop(3) -- disallow traffic
                 }
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "This indicates
       "Indicates the behaviour type of the meter by pointing to a table
       containing detailed parameters. Note that entries in that
       specific table action. The values specific(2)
       must   be managed explicitly.

       One example of  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  and will have a valid object would be diffServTBMeterTable,
       whose entries are indexed by diffServActionSpecific value of
       zeroDotZero.  The use  of  other(1)  is  outside  the same variables as this table,
       for describing an instance
       scope  of a token-bucket meter."  this  definition, although the diffServAc-
       tionSpecific pointer may be used  in  this  case,  to
       indicate other information."
    ::= { diffServMeterEntry 5 diffServActionEntry 4 }

diffServMeterStatus

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

diffServMeterNextFree

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

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

--
-- Token-Bucket Meter Table
--

diffServTBMeterTable

diffServDscpMarkActTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServTBMeterEntry DiffServDscpMarkActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table enumerates specific token-bucket meters that a system
       may use to police a stream of traffic.  Such meters are modelled
       here as having a single rate and a burst size.

       Multiple meter elements may be logically cascaded using their
       diffServMeterSucceedNext pointers if a multi-rate token bucket is
       needed.  One example of this might be for an AF PHB
       implementation that DSCPs used two-rate meters.  Such cascading of
       meter elements of specific type of token-bucket indicates
       forwarding behaviour that is functionally equivalent to a multi-
       rate meter: the sequential nature of the representation is merely
       a notational convenience for this MIB.

       Entries in this table share indexing with a parent
       diffServMeterEntry although they must be managed (e.g.
       created/deleted) by explicit management action, independently of  mark-
       ing  or  remarking  the associated value DSCP field of diffServMeterSpecific." IP packets. The
       entries of this table may be referenced by a diffSer-
       vActionSpecific attribute."
    REFERENCE
        "[MODEL] section 5.1.3" 6.1"
    ::= { diffServTables diffServAction 4 }

diffServTBMeterEntry

diffServDscpMarkActEntry OBJECT-TYPE
    SYNTAX       DiffServTBMeterEntry       DiffServDscpMarkActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An  entry  in  the  DSCP  mark  action  table   that
       describes a single token-bucket meter, indexed by
       the same variables as a diffServMeterEntry." DSCP used for marking."
    INDEX { ifIndex, diffServMeterIfDirection,
            diffServMeterId diffServDscpMarkActId }
    ::= { diffServTBMeterTable diffServDscpMarkActTable 1 }

DiffServTBMeterEntry

DiffServDscpMarkActEntry ::= SEQUENCE  {
    diffServTBMeterRate
    diffServDscpMarkActId            Unsigned32,
    diffServTBMeterBurstSize         BurstSize
    diffServTBMeterStatus
    diffServDscpMarkActDscp          Dscp,
    diffServDscpMarkActStatus        RowStatus
}

diffServTBMeterRate

diffServDscpMarkActId OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "The token-bucket rate,
       "An index that enumerates the  Mark  Action  entries.
       The  set  of  such identifiers spans the whole agent.
       Managers should obtain new values for row creation in kilobits per second (kbps)."
       this table by reading diffServDscpMarkActNextFree."
    ::= { diffServTBMeterEntry diffServDscpMarkActEntry 1 }

diffServTBMeterBurstSize

diffServDscpMarkActDscp OBJECT-TYPE
    SYNTAX       BurstSize
    UNITS        "Bytes"       Dscp
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "The maximum number DSCP that this Action uses for marking/remarking
       traffic.  Note that a DSCP value of bytes -1 is not permit-
       ted in a single transmission burst.  The
       interval over which the burst this table.  It is  quite  possible  that  the
       only  packets  subject  to be measured can be derived as
       diffServTBMeterBurstSize*8*1000/diffServTBMeterRate."  this  Action  are already
       marked with this DSCP. Note also  that  Diffserv  may
       result  in packet remarking both on ingress to a net-
       work and on egress from it and it is  quite  possible
       that  ingress  and  egress  would  occur  in the same
       router."
    ::= { diffServTBMeterEntry diffServDscpMarkActEntry 2 }

diffServTBMeterStatus

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

--
-- Actions 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 Action Table allows enumeration the first of multiple actions, for example before the different
-- types of actions to be applied to a traffic flow. the absolute drop action.
--

diffServActionTable

diffServCountActNextFree OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServActionEntry       Unsigned32
    MAX-ACCESS   not-accessible   read-only
    STATUS       current
    DESCRIPTION
       "The Action Table enumerates actions that can be performed to a
       stream of traffic. Multiple actions can be concatenated.  For
       example, after marking
       "This object yields a stream of traffic exiting from value when read that is currently unused
       for a meter, diffServCountActId instance.
       If a device can then perform configuring system attempts to create a count action of new row
       in the conforming or
       non-conforming traffic.

       Specific actions are indicated by diffServActionSpecific which
       points diffServCountActTable using this value, that operation
       will fail if the value has, in the meantime, been used
       to create another object which describes row that is currently valid."
    ::= { diffServAction 5 }

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 in further
       detail." element."
    REFERENCE
        "[MODEL] section 6." 6.4"
    ::= { diffServTables 5 diffServAction 6 }

diffServActionEntry

diffServCountActEntry OBJECT-TYPE
    SYNTAX       DiffServActionEntry       DiffServCountActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the count action table describing the actions applied to describes a  sin-
       gle set of traffic arriving at its input." counters."
    INDEX { ifIndex, diffServActionIfDirection,
            diffServActionId diffServCountActId }
    ::= { diffServActionTable diffServCountActTable 1 }

DiffServActionEntry

DiffServCountActEntry ::= SEQUENCE  {
    diffServActionIfDirection       IfDirection,
    diffServActionId
    diffServCountActId           Unsigned32,
    diffServActionNext              RowPointer,
    diffServActionSpecific          OBJECT IDENTIFIER,
    diffServActionStatus
    diffServCountActOctets       Counter32,
    diffServCountActHCOctets     Counter64,
    diffServCountActPkts         Counter32,
    diffServCountActHCPkts       Counter64,
    diffServCountActDiscontTime  TimeStamp,
    diffServCountActStatus       RowStatus
}

diffServActionIfDirection OBJECT-TYPE
    SYNTAX       IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "Specifies the direction for which this action entry applies on
       this interface."
    ::= { diffServActionEntry 1 }

diffServActionId

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

diffServActionNext

diffServCountActOctets OBJECT-TYPE
    SYNTAX       RowPointer       Counter32
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "The Next pointer indicates the next datapath element to handle number of octets at the traffic.  For example, a queue Action datapath element.

       The value zeroDotZero in
       On  high  speed  devices,  this variable indicates no further
       DiffServ treatment is performed on object implements the
       least significant 32  bits  of  diffServCountActHCOc-
       tets.

       Discontinuities in the  value  of  this flow  counter  can
       occur  at  re-initialization of the management system
       and at other times  as  indicated  by  the current
       interface  value  of
       diffServCountActDiscontTime for this interface direction. If the row pointed to
       does not exist, the action element is considered inactive."
    DEFVAL      { zeroDotZero } entry."
    ::= { diffServActionEntry 3 diffServCountActEntry 2 }

diffServActionSpecific

diffServCountActHCOctets OBJECT-TYPE
    SYNTAX       OBJECT IDENTIFIER       Counter64
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "A pointer to an
       "The number of octets at the Action datapath element.
       This object instance providing additional information
       for should be used on high speed interfaces.

       Discontinuities in the type  value  of action indicated by  this action table entry.

       For  counter  can
       occur  at  re-initialization of the standard actions defined management system
       and at other times  as  indicated  by  the  value  of
       diffServCountActDiscontTime for this MIB module, this should
       point to one entry."
    ::= { diffServCountActEntry 3 }

diffServCountActPkts OBJECT-TYPE
    SYNTAX       Counter32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The number of packets at the following: a diffServDscpMarkActEntry, a
       diffServCountActEntry, the diffServAbsoluteDropAction OID.  For
       other actions, it may point to an  Action  datapath  ele-
       ment.   On high speed devices, this object instance defined implements
       the  least  significant  32  bits  of   diffServCoun-
       tActHCPkts.
       Discontinuities in some the  value  of  this  counter  can
       occur  at  re-initialization of the management system
       and at other MIB." times  as  indicated  by  the  value  of
       diffServCountActDiscontTime for this entry."
    ::= { diffServActionEntry diffServCountActEntry 4 }

diffServActionStatus

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

diffServActionNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This  Action  datapath  ele-
       ment.   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  should  be  used  on high speed
       interfaces.

       Discontinuities in the diffServActionTable using  value  of  this value, that operation will fail if  counter  can
       occur  at  re-initialization of the value has, in management system
       and at other times  as  indicated  by  the
       meantime, been used to create another row that is currently
       valid."  value  of
       diffServCountActDiscontTime for this entry."
    ::= { diffServObjects 4 diffServCountActEntry 5 }

-- DSCP Mark Action Table
--
-- Rows of this table are pointed to by diffServAction to
-- provide detailed parameters specific to the DSCP
-- Mark action.

diffServDscpMarkActTable

diffServCountActDiscontTime OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServDscpMarkActEntry       TimeStamp
    MAX-ACCESS   not-accessible   read-only
    STATUS       current
    DESCRIPTION
       "This table enumerates specific DSCPs used for marking or
       remarking
       "The value of sysUpTime on the DSCP field most  recent  occasion
       at  which  any  one  or more of IP packets.  The entries this entry's counters
       suffered a discontinuity. If no such  discontinuities
       have occurred since the last re-initialization of the
       local management subsystem, then this
       table may be referenced by object contains
       a diffServActionSpecific attribute
       that points to diffServDscpMarkActTable."
    REFERENCE
        "[MODEL] section 6.1" zero value."
    ::= { diffServTables diffServCountActEntry 6 }

diffServDscpMarkActEntry

diffServCountActStatus OBJECT-TYPE
    SYNTAX       DiffServDscpMarkActEntry       RowStatus
    MAX-ACCESS   not-accessible   read-create
    STATUS       current
    DESCRIPTION
       "An entry in
       "The  RowStatus  variable  controls  the  activation,
       deactivation, or deletion of this entry. Any writable
       variable may be modified whether the DSCP mark action table that describes a single
       DSCP used for marking."
    INDEX { diffServDscpMarkActDscp } row is active or
       notInService."
    ::= { diffServDscpMarkActTable 1 diffServCountActEntry 7 }

DiffServDscpMarkActEntry

--
-- Algorithmic Drop Table
--

diffServAlgDrop        OBJECT IDENTIFIER ::= SEQUENCE {
    diffServDscpMarkActDscp          Dscp diffServMIBObjects 5 }

diffServDscpMarkActDscp

diffServAlgDropNextFree OBJECT-TYPE
    SYNTAX       Dscp       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The DSCP that this Action uses for marking/remarking traffic.
       Note that
       "This  object  yields  a DSCP  value of -1  when  read  that  is not permitted
       currently  unused  for  a diffServAlgDropId instance.
       If a configuring system attempts to create a new  row
       in this table.  It
       is quite possible that  the only packets subject to this Action
       are already marked with  diffServAlgDropTable  using this DSCP.  Note also value, that Diffserv may
       result
       operation will fail if the value has,  in packet remarking both on ingress  the  mean-
       time,  been  used  to a network and on
       egress from it and it is quite possible  create  another  row  that ingress and egress
       would occur in the same router."  is
       currently valid."
    ::= { diffServDscpMarkActEntry diffServAlgDrop 1 }

--
-- Count Action Table
--

diffServCountActTable

diffServAlgDropTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServCountActEntry DiffServAlgDropEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This
       "The algorithmic drop table contains counters for all the traffic passing through entries describ-
       ing  an action element."  element that drops packets according to some
       algorithm."
    REFERENCE
        "[MODEL] section 6.5" 7.1.3"
    ::= { diffServTables 7 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         RowPointer,
    diffServAlgDropOctets           Counter32,
    diffServAlgDropHCOctets         Counter64,
    diffServAlgDropPkts             Counter32,
    diffServAlgDropHCPkts           Counter64,
    diffServAlgDropStatus           RowStatus
}

diffServCountActEntry

diffServAlgDropId OBJECT-TYPE
    SYNTAX       DiffServCountActEntry       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the count action table index that describes a single  enumerates  the  Algorithmic  Dropper
       entries.  The set of traffic counters. Entries such identifiers spans the whole
       agent. Managers should  obtain  new  values  for  row
       creation  in  this  table share indexing with
       those in the base diffServActionTable although they must be
       managed (e.g. created/deleted) by explicit management action,
       independently of the associated value of diffServActionSpecific."
    INDEX { ifIndex, diffServActionIfDirection,
            diffServActionId } reading diffServAlgDrop-
       NextFree."
    ::= { diffServCountActTable diffServAlgDropEntry 1 }

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

diffServCountActOctets

diffServAlgDropType OBJECT-TYPE
    SYNTAX       Counter32       INTEGER {
                     other(1),
                     tailDrop(2),
                     headDrop(3),
                     randomDrop(4)
                 }
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The number type of octets at the Action datapath element.  On high
       speed devices, algorithm used by this object implements the least significant 32
       bits dropper. A  value
       of diffServcountActHCOctets.

       Discontinuities 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 value depth of this counter can occur 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,  packets currently at re-
       initialization the head of
       the management system and 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 times as
       indicated by  packet(s)
       from  the value of diffServCountActDiscontTime for this
       entry."
    ::= { diffServCountActEntry 1 }

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

       Discontinuities in  proprietary.  For  this  algorithm,
       diffServAlgDropSpecific  points  to a diffServRandom-
       DropEntry that describes  the value of  algorithm.   For  this counter can occur at re-
       initialization
       algorithm,  diffServAlgQThreshold is understood to be
       the absolute maximum size of the management system queue and at other times as
       indicated by the value of diffServCountActDiscontTime for this
       entry." additional
       parameters are described in diffServRandomDropTable."
    ::= { diffServCountActEntry diffServAlgDropEntry 2 }

diffServCountActPkts

diffServAlgDropNext OBJECT-TYPE
    SYNTAX       Counter32       RowPointer
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The number of packets at
       "This selects the Action next diffserv  functional  datapath element.  On high
       speed devices,
       element  to  handle traffic for this object implements the least significant 32
       bits data path.  This
       RowPointer should point to an instance of diffServcountActHCPkts.

       Discontinuities in the one of:
         diffServClfrEntry
         diffServMeterEntry
         diffServActionEntry
         diffServAlgDropEntry
         diffServQEntry

       A value of zeroDotZero in this counter can occur at re-
       initialization attribute indicates no
       further Diffserv treatment is performed on traffic of
       this datapath.

       If the management system and at other times as
       indicated by row pointed to does not exist,  the  treatment
       is  as  if  this  attribute contains a value of diffServCountActDiscontTime for this
       entry." zero-
       DotZero."
    ::= { diffServCountActEntry diffServAlgDropEntry 3 }

diffServCountActHCPkts

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

       Discontinuities
       "Points to an entry in the value of this counter can occur at re-
       initialization of diffServQTable to indicate
       the  queue  that  a drop algorithm is to monitor when
       deciding whether  to  drop  a  packet.   If  the management system and at other times as
       indicated by  row
       pointed  to  does  not exist, the value of diffServCountActDiscontTime for this
       entry." algorithmic dropper
       element is considered inactive."
    ::= { diffServCountActEntry diffServAlgDropEntry 4 }

diffServCountActDiscontTime

diffServAlgDropQThreshold OBJECT-TYPE
    SYNTAX       TimeStamp       Unsigned32
    UNITS        "Bytes"
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The value of sysUpTime
       "A threshold on the most recent occasion depth in bytes of the queue being
       measured at which any
       one a trigger is generated to the drop-
       ping algorithm.

       For the tailDrop(2) or more of headDrop(3)  algorithms,  this entry's counters suffered a discontinuity. If
       no such discontinuities have occurred since
       represents  the last re-
       initialization  depth  of  the local management subsystem, then  queue, pointed to by
       diffServAlgDropQMeasure, at  which  the  drop  action
       will take place. Other algorithms will need to define
       their own semantics for this
       object contains a zero value." threshold."
    ::= { diffServCountActEntry diffServAlgDropEntry 5 }

diffServCountActStatus

diffServAlgDropSpecific OBJECT-TYPE
    SYNTAX       RowStatus       RowPointer
    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 6 }

diffServAbsoluteDropAction OBJECT-IDENTITY
    STATUS       current
    DESCRIPTION
       "This object identifier
       "Points to a table entry that provides further detail
       regarding a drop algorithm.

       Entries with diffServAlgDropType  equal  to  other(1)
       may be used as the value of have this point to a
       diffServActionSpecific pointer table defined in order another MIB
       module.

       Entries with  diffServAlgDropType  equal  to indicate that all
       packets following  random-
       Drop(4)  must have this path are point to be dropped unconditionally at
       this point. It is likely, but not required, that an entry in diffSer-
       vRandomDropTable.

       For all other algorithms, this action will
       be preceded by a counter action."
    ::= { diffServObjects 6 }

--
-- Algorithmic Drop Table
--

diffServAlgDropTable should take the  value
       zeroDotzero."
    ::= { diffServAlgDropEntry 6 }

diffServAlgDropOctets OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServAlgDropEntry       Counter32
    MAX-ACCESS   not-accessible   read-only
    STATUS       current
    DESCRIPTION
       "The algorithmic drop table contains entries describing an
       element number of octets that drops packets according have been dropped by  this
       drop  process.   On  high  speed devices, this object
       implements the least significant 32 bits of  diffSer-
       vAlgDropHCOctets.

       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 some algorithm."
    REFERENCE
        "[MODEL] section 7.1.3" this inter-
       face."
    ::= { diffServTables 8 } diffServAlgDropEntry 7 }

diffServAlgDropHCOctets OBJECT-TYPE
    SYNTAX       DiffServAlgDropEntry       Counter64
    MAX-ACCESS   not-accessible   read-only
    STATUS       current
    DESCRIPTION
       "An entry describes a process that drops packets according to
       some algorithm.  Further details
       "The number of the algorithm type are to octets that have been dropped by  this
       drop  process.   This  object  should be
       found used on high
       speed interfaces.

       Discontinuities in diffServAlgDropType the  value  of  this  counter  can
       occur  at  re-initialization of the management system
       and may be pointed to at other times  as  indicated  by
       diffServAlgDropSpecific."
    INDEX { ifIndex, diffServAlgDropIfDirection,
            diffServAlgDropId }  the  value  of
       ifCounterDiscontinuityTime appropriate to this inter-
       face."
    ::= { diffServAlgDropTable 1 diffServAlgDropEntry 8 }

DiffServAlgDropEntry ::= SEQUENCE  {
    diffServAlgDropIfDirection      IfDirection,
    diffServAlgDropId               Unsigned32,
    diffServAlgDropType             INTEGER,
    diffServAlgDropNext             RowPointer,
    diffServAlgDropQMeasure         RowPointer,
    diffServAlgDropQThreshold       Unsigned32,
    diffServAlgDropSpecific         OBJECT IDENTIFIER,
    diffServAlgDropOctets           Counter32,
    diffServAlgDropHCOctets         Counter64,

diffServAlgDropPkts             Counter32,
    diffServAlgDropHCPkts           Counter64,
    diffServAlgDropStatus           RowStatus
}

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

       Discontinuities in the  value  of  this algorithmic dropper entry
       applies on  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." inter-
       face."
    ::= { diffServAlgDropEntry 1 9 }

diffServAlgDropId

diffServAlgDropHCPkts OBJECT-TYPE
    SYNTAX       Unsigned32       Counter64
    MAX-ACCESS   not-accessible   read-only
    STATUS       current
    DESCRIPTION
       "This identifies the
       "The number of packets that have been dropped by this
       drop action entry. Managers  process.   This  object  should obtain
       new values for row creation be used on high
       speed interfaces.

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

diffServAlgDropType

diffServAlgDropStatus OBJECT-TYPE
    SYNTAX       INTEGER { other(1), tailDrop(2),
                           headDrop(3), randomDrop(4) }       RowStatus
    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  RowStatus  variable  controls  the depth  activation,
       deactivation, or deletion of the queue
       diffServAlgDropQMeasure at which all newly arriving packets will this entry. Any writable
       variable may be dropped.

       The headDrop(3) algorithm modified whether the row is described as follows: if active or
       notInService."
    ::= { diffServAlgDropEntry 11 }

--
-- Random Drop Table
--

diffServRandomDropNextFree OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "This  object  yields  a packet
       arrives  value  when the current depth of the queue
       diffServAlgDropQMeasure  read  that  is at diffServAlgDropQThreshold, packets
       currently at the head of the queue are dropped to make room unused 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 a diffServRandomDropId instance.
       If a configuring system attempts to create a new  row
       in its place. The
       specifics of the algorithm may be proprietary. For diffServRandomDropTable using this
       algorithm, an associated diffServRandomDropEntry is indicated by
       pointing diffServAlgDropSpecific at the diffServRandomDropTable.
       The relevant entry in value, that table is selected by
       operation will fail if the common
       indexing of value has,  in  the two tables.  For this algorithm,
       diffServAlgQThreshold is understood  mean-
       time,  been  used  to be the absolute maximum
       size of the queue and additional parameters are described in
       diffServRandomDropTable."  create  another  row  that  is
       currently valid."
    ::= { diffServAlgDropEntry diffServAlgDrop 3 }

diffServAlgDropNext

diffServRandomDropTable OBJECT-TYPE
    SYNTAX       RowPointer       SEQUENCE OF DiffServRandomDropEntry
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "The Next pointer indicates the next datapath element to handle
       the traffic e.g. random drop table contains entries describing  a queue datapath element.

       The value zeroDotZero
       process  that drops packets randomly. Entries in this variable indicates no further
       DiffServ treatment
       table is performed on this flow by the current
       interface for this interface direction. If the row  intended  to  be  pointed  to
       does not exist, the algorithmic dropper element is considered
       inactive."  by  diffSer-
       vAlgDropSpecific."
    REFERENCE
        "[MODEL] section 7.1.3"
    ::= { diffServAlgDropEntry diffServAlgDrop 4 }

diffServAlgDropQMeasure

diffServRandomDropEntry OBJECT-TYPE
    SYNTAX       RowPointer       DiffServRandomDropEntry
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "Points to an
       "An entry in the diffServQueueTable describes  a  process  that  drops  packets
       according to indicate 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 that a drop algorithm is to monitor when deciding whether
       to drop  depth  in  bytes,  beyond  which
       traffic  has a packet.  If the row pointed to does non-zero probability of being dropped.
       Changes in this variable may or may not exist, be  reflected
       in   the
       algorithmic dropper element is considered inactive."   reported   value   of  diffServRandomDrop-
       MinThreshPkts."
    ::= { diffServAlgDropEntry 5 diffServRandomDropEntry 2 }

diffServAlgDropQThreshold

diffServRandomDropMinThreshPkts OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "Bytes"        "packets"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "A threshold on the
       "The average queue depth  in bytes of the queue being measured at  packets,  beyond  which
       traffic  has a trigger is generated to the dropping algorithm.

       For the tailDrop(2) or headDrop(3) algorithms, non-zero probability of being dropped.
       Changes in this represents variable may or may not be  reflected
       in the depth reported value of the queue diffServAlgDropQMeasure at which the drop
       action will take place. Other algorithms will need to define
       their own semantics for this threshold." diffServRandomDropMinThresh-
       Bytes."
    ::= { diffServAlgDropEntry 6 diffServRandomDropEntry 3 }

diffServAlgDropSpecific

diffServRandomDropMaxThreshBytes OBJECT-TYPE
    SYNTAX       OBJECT IDENTIFIER       Unsigned32
    UNITS        "bytes"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "Points to a table (not an entry in the table) defined elsewhere
       that provides further detail regarding a drop algorithm.  Entries
       in such
       "The average queue depth beyond which traffic  has  a table are indexed
       probability indicated by the same variables as this
       diffServAlgDropEntry but note that those entries must be managed
       independently diffServRandomDropInvProbMax
       of those in this table.

       Entries with diffServAlgDropType equal to other(1) may have being dropped or marked. Note  that  this
       point to a table defined  differs
       from  the  physical  queue  limit, which is stored in
       diffServAlgDropQThreshold.  Changes in this  variable
       may  or may not be reflected in another MIB module. Entries with
       diffServAlgDropType equal to randomDrop(4) must have this point
       to diffServRandomDropTable.

       For all other algorithms, this should take the reported value
       zeroDotzero." of
       diffServRandomDropMaxThreshPkts."
    ::= { diffServAlgDropEntry 7 diffServRandomDropEntry 4 }

diffServAlgDropOctets

diffServRandomDropMaxThreshPkts OBJECT-TYPE
    SYNTAX       Counter32       Unsigned32
    UNITS        "packets"
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The number average queue depth beyond which traffic  has  a
       probability indicated by diffServRandomDropInvProbMax
       of octets that have been being dropped by this drop
       process.  On high speed devices, or marked. Note  that  this object implements  differs
       from  the least
       significant 32 bits of diffServAlgDropHCOctets.

       Discontinuities  physical  queue  limit, which is stored in
       diffServAlgDropQThreshold.  Changes in the value of this counter can occur at re-
       initialization of the management system and at other times as
       indicated by  variable
       may  or may not be reflected in the reported value of ifCounterDiscontinuityTime appropriate
       to this interface."
       diffServRandomDropMaxThreshBytes."
    ::= { diffServAlgDropEntry 8 diffServRandomDropEntry 5 }

diffServAlgDropHCOctets

diffServRandomDropInvProbMax OBJECT-TYPE
    SYNTAX       Counter64       Unsigned32
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The number worst case random drop probability, expressed as
       the  inverse  of octets that have been dropped by this  the drop
       process.  This object should be used on high speed interfaces.

       Discontinuities in probability.  With special
       case of the value zero meaning  zero  probability  of this counter can occur at re-
       initialization of
       drop.

       For example, if every packet may be  dropped  in  the management system and at other times as
       indicated by
       worst   case   (100%),   this   has   the   value  of ifCounterDiscontinuityTime appropriate
       to this interface."
       4,294,967,295."
    ::= { diffServAlgDropEntry 9 diffServRandomDropEntry 6 }

diffServAlgDropPkts

diffServRandomDropInvWeight OBJECT-TYPE
    SYNTAX       Counter32       Unsigned32
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The number weighting of packets that have been dropped by this drop
       process.  On high speed devices, this object implements past history in affecting the least
       significant 32 bits  cal-
       culation  of diffServAlgDropHCPkts.

       Discontinuities in  the value  current queue average.  The moving
       average of this counter can occur at re-
       initialization the queue depth uses the inverse  of  this
       value  as the management system and at other times factor for the new queue depth, and one
       minus that inverse as
       indicated by the value factor for  the  historical
       average.

       Implementations may choose to  limit  the  acceptable
       set  of ifCounterDiscontinuityTime appropriate  values to this interface." a specified set, such as powers of
       2."
    ::= { diffServAlgDropEntry 10 diffServRandomDropEntry 7 }

diffServAlgDropHCPkts

diffServRandomDropSamplingRate OBJECT-TYPE
    SYNTAX       Counter64       Unsigned32
    MAX-ACCESS   read-only   read-create
    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 per second the queue is  sampled
       for queue average calculation.  A value of ifCounterDiscontinuityTime appropriate
       to this interface." zero means
       the queue is sampled approximately each time a packet
       is enqueued (or dequeued)."
    ::= { diffServAlgDropEntry 11 diffServRandomDropEntry 8 }

diffServAlgDropStatus

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 this entry. Any writable
       variable may be modified whether the row is active or
       notInService."
    ::= { diffServRandomDropEntry 9 }

--
-- Queue Table
--

diffServQueue          OBJECT IDENTIFIER ::= { diffServMIBObjects 6 }

--
-- 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 row is active or notInService."
    ::= { diffServAlgDropEntry 12 }

diffServAlgDropNextFree 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
       currently  unused  for  a diffServAlgDropId diffServQId instance.  If a
       configuring system attempts to create a  new  row  in
       the diffServAlgDropTable  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."
    ::= { diffServObjects 7 diffServQueue 1 }

diffServRandomDropTable

diffServQTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServRandomDropEntry DiffServQEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The random drop table augments the algorithmic drop table.  It
       contains entries describing a process that drops packets
       randomly. This table is intended to be pointed to by Queue Table enumerates the
       associated diffServAlgDropSpecific in such cases." individual queues."
    REFERENCE
        "[MODEL] section 7.1.3" 7.1.1"
    ::= { diffServTables 9 diffServQueue 2 }

diffServRandomDropEntry

diffServQEntry OBJECT-TYPE
    SYNTAX       DiffServRandomDropEntry       DiffServQEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in  the  Queue  Table  describes  a process that drops packets according  single
       queue.  With each entry belonging to a
       random algorithm.  Entries in this table share indexing with a
       parent diffServAlgDropEntry although they must be managed (e.g.
       created/deleted) by explicit management action, independently of
       the associated value of diffServAlgDropSpecific." one and only one
       datapath."
    INDEX { ifIndex, diffServAlgDropIfDirection,
            diffServAlgDropId diffServQId }
    ::= { diffServRandomDropTable diffServQTable 1 }

DiffServRandomDropEntry

DiffServQEntry ::= SEQUENCE  {
    diffServRandomDropMinThreshBytes   Unsigned32,
    diffServRandomDropMinThreshPkts    Unsigned32,
    diffServRandomDropMaxThreshBytes   Unsigned32,
    diffServRandomDropMaxThreshPkts    Unsigned32,
    diffServRandomDropInvWeight        Unsigned32,
    diffServRandomDropProbMax
    diffServQId                      Unsigned32,
    diffServRandomDropStatus
    diffServQNext                    RowPointer,
    diffServQSchdParam               RowPointer,
    diffServQStatus                  RowStatus
}

diffServRandomDropMinThreshBytes OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "bytes"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The average queue depth in bytes, beyond which traffic has a
       non-zero probability of being dropped.  Changes in this variable
       may or may not be reflected in the reported value of
       diffServRandomDropMinThreshPkts."
    ::= { diffServRandomDropEntry 1 }

diffServRandomDropMinThreshPkts OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "packets"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The average queue depth in packets, beyond which traffic has a
       non-zero probability of being dropped.  Changes in this variable
       may or may not be reflected in the reported value of
       diffServRandomDropMinThreshBytes."
    ::= { diffServRandomDropEntry 2 }

diffServRandomDropMaxThreshBytes

diffServQId OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "bytes"
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
    DESCRIPTION
       "The average queue depth beyond which traffic has a probability
       indicated by diffServRandomDropInvMaxProb of being dropped or
       marked. Note
       "An index that this differs from enumerates the physical queue limit,
       which is stored in diffServAlgDropQThreshold.  Changes Queue entries. The  set
       of  such  identifiers spans the whole agent. Managers
       should obtain new values for  row  creation  in  this
       variable may or may not be reflected in the reported value of
       diffServRandomDropMaxThreshPkts."
       table by reading diffServQNextFree."
    ::= { diffServRandomDropEntry 3 diffServQEntry 1 }

diffServRandomDropMaxThreshPkts

diffServQNext OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "packets"       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The average queue depth beyond which
       "This selects the next diffserv  functional  datapath
       element  to  handle traffic has a probability
       indicated by diffServRandomDropInvMaxProb of being dropped or
       marked. Note that for this differs from the physical queue limit,
       which is stored in diffServAlgDropQThreshold.  Changes data path.  This
       RowPointer must point to an instance of one of:
         diffServSchedulerEntry

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

       If the row pointed to does not be reflected in exist,  the reported  treatment
       is  as  if  this  attribute contains a value of
       diffServRandomDropMaxThreshBytes." zero-
       DotZero."
    ::= { diffServRandomDropEntry 4 diffServQEntry 2 }

diffServRandomDropInvWeight

diffServQSchdParam OBJECT-TYPE
    SYNTAX       Unsigned32       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The weighting of past history in affecting the calculation of
       the current queue average.  The moving average of
       "This   RowPointer    indicates    the queue depth
       uses    entry    in
       diffServSchdParamTable  the inverse of  scheduler, pointed to by
       diffServQNext, should use to service this queue.

       A 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 zeroDotZero in this attribute indicates an
       incomplete  diffServQEntry instance.  An illegal con-
       figuration.

       If the row pointed to a specified set, such does not exist,  the  treatment
       is  as powers  if  this  attribute contains a value of 2." zero-
       DotZero."
    ::= { diffServRandomDropEntry 5 diffServQEntry 3 }

diffServRandomDropProbMax

diffServQStatus OBJECT-TYPE
    SYNTAX       Unsigned32       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The worst case random drop probability, expressed in drops per
       thousand packets.

       For example, if every packet may be dropped in the worst case
       (100%), this has the value 1000. Alternatively, if in  RowStatus  variable  controls  the worst
       case one percent (1%)  activation,
       deactivation,  or  deletion  of traffic a queue. Any writable
       variable may be dropped, it has modified whether the value
       10." row is active or
       notInService."
    ::= { diffServRandomDropEntry 6 diffServQEntry 4 }

diffServRandomDropStatus

--
-- Scheduler Table
--

diffServScheduler      OBJECT IDENTIFIER ::= { diffServMIBObjects 7 }

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

diffServSchedulerNextFree OBJECT-TYPE
    SYNTAX       RowStatus       Unsigned32
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls
       "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 activation, deactivation, or
       deletion of diffServSchedulerTable using this entry. Any writable variable may be modified
       whether value, that
       operation will fail if the value has,  in  the  mean-
       time,  been  used  to  create  another  row  that  is active or notInService."
       currently valid."
    ::= { diffServRandomDropEntry 7 diffServScheduler 1 }

--
-- Queue Table
--

diffServQTable

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

diffServQEntry

diffServSchedulerEntry OBJECT-TYPE
    SYNTAX       DiffServQEntry       DiffServSchedulerEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Queue Scheduler Table describes describing a  single queue in one
       direction on an interface."
       instance of a scheduling algorithm."
    INDEX { ifIndex, diffServQIfDirection, diffServQId diffServSchedulerId }
    ::= { diffServQTable diffServSchedulerTable 1 }

DiffServQEntry

DiffServSchedulerEntry ::= SEQUENCE  {
    diffServQIfDirection             IfDirection,
    diffServQId                      Unsigned32,
    diffServQNext                    RowPointer,
    diffServQPriority                Unsigned32,
    diffServQMinRateAbs              Unsigned32,
    diffServQMinRateRel              Unsigned32,
    diffServQMaxRateAbs              Unsigned32,
    diffServQMaxRateRel
    diffServSchedulerId                   Unsigned32,
    diffServQStatus                  RowStatus
}

diffServQIfDirection OBJECT-TYPE
    SYNTAX  IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "Specifies the direction for which this queue entry applies on
       this interface."
    ::= { diffServQEntry 1 }

diffServQId OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Queue Id enumerates the Queue entry. Managers should obtain
       new values for row creation in this table by reading
       diffServQNextFree."
    ::= { diffServQEntry 2 }

diffServQNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The Next pointer indicates the next datapath element to handle
       the traffic e.g. a scheduler datapath element.  If the row
       pointed to does not exist, the queue element is considered
       inactive."
    ::= { diffServQEntry 3 }

diffServQPriority OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The priority of this queue, to be used as a parameter to the
       next scheduler element downstream from this one."
    ::= { diffServQEntry 4
    diffServSchedulerNext                 RowPointer,
    diffServSchedulerMethod               INTEGER,
    diffServSchedulerSchdParam            RowPointer,
    diffServSchedulerStatus               RowStatus
}

diffServQMinRateAbs

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

       Note that this attribute's value is coupled to
       "An index that of
       diffServQMinRateRel: changes to one will affect enumerates the value Scheduler entries.  The
       set  of  such  identifiers  spans  the
       other. They are linked  whole  agent.
       Managers should obtain new values for row creation in
       this table by the following equation:

         diffServQMinRateRel = diffServQMinRateAbs * 10,000,000/ifSpeed

       or, if appropriate:

         diffServQMinRateRel = diffServQMinRateAbs * 10 / ifHighSpeed"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]" reading diffServSchedulerNextFree."
    ::= { diffServQEntry 5 diffServSchedulerEntry 1 }

diffServQMinRateRel

diffServSchedulerNext OBJECT-TYPE
    SYNTAX       Unsigned32       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The minimum rate that a downstream scheduler
       "This selects the next diffserv  functional  datapath
       element should
       allocate  to  handle traffic for this queue, relative data path.  This
       RowPointer should point to the maximum rate an instance of the
       interface as reported one of:
         diffServSchedulerEntry
         diffServQEntry  As  indicated  by ifSpeed or ifHighSpeed, in units of
       1/10,000  [MODEL]  section
       7.1.4.

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

       A value is zero, then there is effectively of zeroDotZero in this attribute indicates no minimum rate guarantee.  If the value
       further Diffserv treatment is non-zero, the
       scheduler will assure the servicing performed on traffic of
       this queue to at least
       this rate.

       Note that this attribute's value is coupled to that datapath.  The use of
       diffServQMinRateAbs: changes to one will affect zeroDotZero is the  normal
       usage for the value of last functional datapath element.

       If the
       other. They are linked by row pointed to does not exist,  the following equation:

         diffServQMinRateAbs = ifSpeed * diffServQMinRateRel/10,000,000

       or,  treatment
       is  as  if appropriate:

         diffServQMinRateAbs = ifHighSpeed * diffServQMinRateRel / 10"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"  this  attribute contains a value of zero-
       DotZero."
    DEFVAL       { zeroDotZero }
    ::= { diffServQEntry 6 diffServSchedulerEntry 2 }

diffServQMaxRateAbs

diffServSchedulerMethod OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"       INTEGER {
                     other(1),        -- not listed here
                     priorityq(2),    -- Priority Queueing
                     wrr(3),          -- Weighted Round Robin
                     wfq(4),          -- Weighted Fair Queuing
                     wirr(5),         -- Weighted Interleaved Round Robin
                     bsp(6)           -- Bounded Strict Priority
                 }
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The maximum rate in kilobits/sec that a downstream scheduler
       element should allocate to scheduling algorithm used by this queue. If the Scheduler.

       A value of priorityq(2) is zero, then
       there is effectively no maximum rate limit and that used  to  indicate  strict
       priority queueing: only the diffServSchdParamPriority
       attributes  of  the  queues/schedulers  feeding  this
       scheduler
       should attempt  are  used when determining the next packet
       to be work-conserving for schedule.

       A value  of  wrr(3)  indicates  weighted  round-robin
       scheduling.   Packets  are scheduled from each of the
       queues/schedulers feeding this queue.  If scheduler according to
       all   of   the   parameters   of   their   respective
       diffServSchdParamEntry.

       A value is non-zero, of wfq(4) indicates  weighted  fair  queueing
       scheduling.   Packets  are scheduled from each of the
       queues/schedulers feeding this scheduler will limit according to
       all   of   the servicing   parameters   of this
       queue to, at most, this rate in a non-work-conserving manner.

       Note that this attribute's   their   respective
       diffServSchdParamEntry.

       A value is coupled to that of
       diffServQMaxRateRel: changes  wirr(5)  indicates  weighted  interleaved
       roundrobin    queueing   scheduling.    Packets   are
       scheduled from each of the queues/schedulers  feeding
       this  scheduler  according  to one will affect  all the parameters of
       their respective diffServSchdParamEntry.

       A value of the
       other. They bsp(6) indicates bounded  strict  priority
       scheduling.   Packets  are linked by scheduled from each of the
       queues/schedulers feeding this scheduler according to
       all    the following equation:

         diffServQMaxRateRel = diffServQMaxRateAbs * 10,000,000/ifSpeed

       or, if appropriate:

         diffServQMaxRateRel = diffServQMaxRateAbs * 10 / ifHighSpeed"    parameters    of    their    respective
       diffServSchdParamEntry."
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
        "[MODEL] section 7.1.2"
    ::= { diffServQEntry 7 diffServSchedulerEntry 3 }

diffServQMaxRateRel

diffServSchedulerSchdParam OBJECT-TYPE
    SYNTAX       Unsigned32       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The maximum rate that a downstream scheduler element should
       allocate to this queue, relative to the maximum rate of
       "This   RowPointer    indicates    the
       interface as reported by ifSpeed or ifHighSpeed,    entry    in units of
       1/10,000 of 1.  If the value is zero, then there is effectively
       no maximum rate limit and
       diffServSchdParamTable  the scheduler  higher  level scheduler,
       pointed to by diffServSchedulerNext,  should attempt  use  to be
       work-conserving for this queue.  If the value is non-zero, the
       scheduler will limit
       service the servicing output of this queue to, at most,
       this rate in a non-work-conserving manner.

       Note that this attribute's value scheduler.  This attribute
       is coupled to that of
       diffServQMaxRateAbs: changes to only used when there is more  than  one will affect  level  of
       scheduler.   And should have the value of the
       other. They are linked by the following equation:

         diffServQMaxRateAbs = ifSpeed * diffServQMaxRateRel/10,000,000

       or, if appropriate:

         diffServQMaxRateAbs = ifHighSpeed * diffServQMaxRateRel / 10"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]" zeroDotZero
       when not used."
    DEFVAL      { zeroDotZero }
    ::= { diffServQEntry 8 diffServSchedulerEntry 4 }

diffServQStatus

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

--
-- 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 a queue.  Any writable variable may be modified
       whether
-- traffic shaping.  These attributes limits the row is active or notInService."
    ::= { diffServQEntry 9 }

diffServQNextFree 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
       currently  unused for a diffServQId diffServSchdParamId instance.
       If a configuring system attempts to create a new  row
       in  the diffServQTable diffServSchdParamTable using this value, that
       operation will fail if the value has,  in  the meantime,  mean-
       time,  been  used  to  create  another  row  that  is
       currently valid."
    ::= { diffServObjects 8 diffServScheduler 3 }

--
-- Scheduler Table
--
-- The Scheduler Table is used for representing packet schedulers:
-- it provides flexibility for multiple scheduling algorithms, each
-- servicing multiple queues, to be used on the same logical/physical
-- interface.

diffServSchedulerTable

diffServSchdParamTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServSchedulerEntry DiffServSchdParamEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Scheduler Scheduling Parameter Table enumerates packet schedulers.  Multiple individual
       sets  of scheduling algorithms parameter that can be used on a given interface, with each
       algorithm described used/reused
       by one diffServSchedulerEntry."
    REFERENCE
        "[MODEL] section 7.1.2" Queues and Schedulers."
    ::= { diffServTables 11 diffServScheduler 4 }

diffServSchedulerEntry

diffServSchdParamEntry OBJECT-TYPE
    SYNTAX       DiffServSchedulerEntry       DiffServSchdParamEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Scheduler Scheduling Parameter Table describing describes
       a  single instance  set  of
       a  scheduling algorithm."  parameter  for use by
       queues and schedulers.
       Notice multiple inter-mixed of  Queue  and  Scheduler
       entries can use the same Scheduler Parameter entry."
    INDEX { ifIndex, diffServSchedulerIfDirection,
            diffServSchedulerId diffServSchdParamId }
    ::= { diffServSchedulerTable diffServSchdParamTable 1 }

DiffServSchedulerEntry

DiffServSchdParamEntry ::= SEQUENCE  {
    diffServSchedulerIfDirection          IfDirection,
    diffServSchedulerId
    diffServSchdParamId              Unsigned32,
    diffServSchedulerMethod               INTEGER,
    diffServSchedulerNext                 RowPointer,
    diffServSchedulerStatus
    diffServSchdParamPriority        Unsigned32,
    diffServSchdParamMinRateAbs      Unsigned32,
    diffServSchdParamMinRateRel      Unsigned32,
    diffServSchdParamMaxRateAbs      Unsigned32,
    diffServSchdParamMaxRateRel      Unsigned32,
    diffServSchdParamStatus          RowStatus
}

diffServSchedulerIfDirection

diffServSchdParamId OBJECT-TYPE
    SYNTAX  IfDirection       Unsigned32
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "Specifies the direction for which
       "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."
    ::= { diffServSchdParamEntry 1 }

diffServSchdParamPriority OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The priority of this queue, to be used as a  parame-
       ter  to  the  next  scheduler element downstream from
       this one."
    ::= { 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  no  minimum  rate guarantee.  If the value is
       non-zero, the scheduler entry applies
       on will assure the servicing  of
       this interface." 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 = diffServSchdParamMinRateAbs
                                       * 10,000,000/ifSpeed

       or, if appropriate:

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

diffServSchedulerId

diffServSchdParamMinRateRel OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   not-accessible   read-create
    STATUS       current
    DESCRIPTION
       "This identifies the
       "The minimum rate that a downstream scheduler entry. Managers element
       should obtain new
       values for row creation  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.  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 table 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 reading
       diffServSchedulerNextFree." the
       following equation:

         diffServSchdParamMinRateAbs = ifSpeed
                      * diffServSchdParamMinRateRel/10,000,000

       or, if appropriate:

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

diffServSchedulerMethod

diffServSchdParamMaxRateAbs OBJECT-TYPE
    SYNTAX       INTEGER {
                     other(1),        -- not listed here
                     priorityq(2),    -- Priority Queueing
                     wrr(3)           -- Weighed Round Robin
                 }       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The scheduling algorithm used by maximum rate in kilobits/sec that  a  downstream
       scheduler  element  should allocate to this Scheduler.

        A queue. If
       the value of priorityq(2) is used  zero,  then  there  is  effectively  no
       maximum  rate  limit  and  that  the scheduler should
       attempt to indicate strict priority
       queueing: only be work-conserving for this queue.  If the diffServQPriority attributes of
       value  is non-zero, the queues
       feeding this scheduler are used when determining will limit the next packet
       to schedule.

       A value of wrr(3) indicates weighted round-robin scheduling.
       Packets are scheduled from each ser-
       vicing of the queues feeding this
       scheduler according queue to, at  most,  this  rate  in  a
       non-work-conserving manner.

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

         diffServSchdParamMaxRateRel = diffServSchdParamMaxRateAbs
                                       * 10,000,000/ifSpeed

       or, if appropriate:

         diffServSchdParamMaxRateRel = diffServSchdParamMaxRateAbs
                                       * 10 / ifHighSpeed"
    REFERENCE
        "[MODEL] section 7.1.2"
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServSchedulerEntry 3 diffServSchdParamEntry 5 }

diffServSchedulerNext

diffServSchdParamMaxRateRel OBJECT-TYPE
    SYNTAX       RowPointer       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "Selects the next data path component, which can be another
       "The maximum rate that a downstream scheduler or other TC elements. One usage element
       should  allocate  to this queue, relative to the max-
       imum rate of multiple scheduler
       elements the interface as reported by ifSpeed  or
       ifHighSpeed, in series is for Class Base Queueing (CBQ).

       The units of 1/10,000 of 1.  If the value zeroDotZero in this variable indicates no further
       DiffServ treatment
       is performed on this flow by zero, then there is effectively  no  maximum  rate
       limit  and  the current
       interface  scheduler should attempt to be work-
       conserving for this interface direction.  For example, for an
       inbound interface queue.  If the value zeroDotZero indicates is non-zero,
       the  scheduler will limit the servicing of this queue
       to, at  most,  this  rate  in  a  non-work-conserving
       manner.

       Note that this attribute's value is coupled  to  that the packet
       flow has now completed inbound DiffServ treatment and should be
       forwarded on
       of  diffServSchdParamMaxRateAbs:  changes to one will
       affect the appropriate outbound interface.  If value of the row
       pointed to does not exist, other. They are linked by the scheduler element is considered
       inactive."
    DEFVAL       { zeroDotZero }
       following equation:

         diffServSchdParamMaxRateAbs = ifSpeed
                        * diffServSchdParamMaxRateRel/10,000,000

       or, if appropriate:

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

diffServSchedulerStatus

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."
    ::= { diffServSchedulerEntry 5 }

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
       meantime, been used to create another row that is currently
       valid."
    ::= { diffServObjects 9 diffServSchdParamEntry 7 }

--
-- 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 monitoring mon-
       itoring or for configuration."
    MODULE -- This Module
    MANDATORY-GROUPS {
        diffServMIBClassifierGroup,
        diffServMIBDataPathGroup,
        diffServMIBClfrGroup,
        diffServMIBClfrElementGroup,
        diffServMIBSixTupleClfrGroup,
        diffServMIBActionGroup,
        diffServMIBAlgDropGroup,
        diffServMIBQueueGroup, diffServMIBSchedulerGroup
        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 diffServMIBTokenBucketMeterGroup diffServMIBTBMeterGroup
    DESCRIPTION
       "This group is mandatory for devices  that  implement
       token-bucket metering functions."

    GROUP diffServMIBDscpMarkActionGroup 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 creation crea-
       tion  of  rows  in any of the writable tables of this
       MIB."

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

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

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

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

    OBJECT diffServClassifierStatus 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
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

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

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

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

    OBJECT diffServTBMeterStatus
    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 diffServRandomDropMaxThreshPkts diffServRandomDropMinThreshPkts
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

    OBJECT diffServRandomDropMinThreshBytes 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 diffServRandomDropProbMax 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 diffServQPriority diffServQSchdParam
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
    OBJECT diffServQMinRateAbs diffServQStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."

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

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

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

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

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

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

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

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

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

    ::= { diffServMIBCompliances 1 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 }

diffServMIBClassifierGroup

diffServMIBClfrElementGroup OBJECT-GROUP
    OBJECTS {
        diffServClassifierFilter, diffServClassifierNext,
        diffServClassifierPrecedence, diffServClassifierStatus
        diffServClfrElementOrder, 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 element." classifier."
    ::= { diffServMIBGroups 1 3 }

diffServMIBSixTupleClfrGroup OBJECT-GROUP
    OBJECTS {
        diffServSixTupleClfrDstAddrType, diffServSixTupleClfrDstAddr,
        diffServSixTupleClfrDstAddrMask, diffServSixTupleClfrDstAddrType,
        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 matching match-
       ing on 6 fields of an  IP  and  upper-layer  protocol
       header."
    ::= { diffServMIBGroups 2 4 }

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

diffServMIBTokenBucketMeterGroup

diffServMIBTBMeterGroup OBJECT-GROUP
    OBJECTS {
        diffServTBMeterType,
        diffServTBMeterRate, diffServTBMeterBurstSize diffServTBMeterBurstSize,
        diffServTBMeterInterval, diffServTBMeterStatus
    }
    STATUS current
    DESCRIPTION
       "The Token-Bucket Meter  Group  defines  the  objects
       used in describing a single-rate token bucket meter element."
    ::= { diffServMIBGroups 4 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 5 7 }

diffServMIBDscpMarkActionGroup

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

diffServMIBCounterGroup OBJECT-GROUP
    OBJECTS {
        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 7 9 }

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

diffServMIBVHCCounterGroup OBJECT-GROUP
    OBJECTS {
        diffServCountActOctets, diffServCountActHCOctets,
        diffServCountActPkts, diffServCountActHCPkts,
        diffServCountActDiscontTime,
        diffServCountActStatus,
        diffServAlgDropOctets, diffServAlgDropHCOctets,
        diffServAlgDropPkts, diffServAlgDropHCPkts
    }
    STATUS current
    DESCRIPTION
       "A  collection  of  objects   providing   information
       specific  to non-
       high  very-high speed (non-high (very-high speed interfaces inter-
       faces transmit and receive  at  speeds less  greater  than or equal to 20,000,000
       650,000,000   bits/second) packet-
       oriented   packet-oriented  network
       interfaces."
    ::= { diffServMIBGroups 9 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 configuration." configura-
       tion."
    ::= { diffServMIBGroups 10 12 }

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

diffServMIBQueueGroup

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

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

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

diffServMIBStaticGroup OBJECT-GROUP
    OBJECTS {
        diffServClassifierNextFree,
        diffServClfrNextFree, diffServClfrElementNextFree,
        diffServSixTupleClfrNextFree,
        diffServMeterNextFree, diffServTBMeterNextFree,
        diffServActionNextFree, diffServDscpMarkActNextFree,
        diffServCountActNextFree,
        diffServAlgDropNextFree, diffServRandomDropNextFree,
        diffServQNextFree, diffServSchedulerNextFree 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 whenever  when-
       ever  row creation operations on such tables are supported." sup-
       ported."
    ::= { diffServMIBGroups 14 17 }

END

7.

9.  Acknowledgments

This MIB builds on all the work that has gone into the Informal
Management Model for Diffserv routers. routers, DiffServ PIB, and 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, Jeremy Greene, Dan Grossman, Roch Guerin, Scott
Hahn, Keith McCloghrie, Bob Moore, Kathleen Nichols, Ping Pan, Nabil Seddigh and
Seddigh, Bert Wijnen.

8. Wijnen, Victor Firoiu, John Seligson, Michael Fine, Walter
Weiss, Joel Halpern, and Harrie Hazewinkel.

10.  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.

9.

11.  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>,
     <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.

10.

12.  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
     ah_smith@pacbell.net

Table of Contents

1 The SNMP Management Framework ...................................    2
2 Introduction ....................................................    3    4
2.1 Relationship to the Diffserv Informal Management Model ........    3    4
2.2 Relationship to other MIBs and Policy Management ..............    3    5
2.3 MIB Overview ..................................................    4    5
3 Structure of this MIB ...........................................    5    6
3.1 DiffServ Data Paths ...........................................    7
3.1.1 Data Path Table .............................................    7
3.2 Classifiers ...................................................    5
3.1.1    8
3.2.1 Classifier Table ............................................    5
3.1.2    9
3.2.2 Classifier Element Table ....................................    9
3.2.3 Filter Table - IP Six-Tuple Classifier Table ...............................    6
3.2 ................    9
3.3 Meters ........................................................    6
3.2.1    9
3.3.1 Meter Table .................................................    6
3.2.2   10
3.3.2 Token-Bucket Meter Table ....................................    7
3.3   10
3.4 Actions .......................................................    7
3.3.1   10
3.4.1 DSCP Mark Action Table ......................................    7
3.3.2   11
3.4.2 Count Action Table ..........................................    8

3.3.3   11
3.4.3 Absolute Drop Action ........................................    8
3.4   11
3.5 Queueing Elements .............................................    8
3.4.1   11
3.5.1 Algorithmic Dropper Table ...................................    8
3.4.2   11
3.5.2 Random Dropper Table ........................................    9
3.4.3   13
3.5.3 Queues and Schedulers .......................................   11
3.4.4   14
3.5.4 Example of Algorithmic Droppers, Queues and Schedulers ......   12   16
4 MIB Usage Example ...............................................   16
4.1 Data Path Example .............................................   17
4.2 Data Path and Classifier Example Discussion ...................   17
4.3 Meter and Action Example Discussion ...........................   20
4.4 Queue and Scheduler Example Discussion ........................   21
5 Conventions used in this MIB ....................................   13
4.1   21
5.1 The use of RowPointer .........................................   13
4.2   21
5.2 Conceptual row creation and deletion ..........................   14
5   22
6 Editorial information ...........................................   15
5.1   23
6.1 Open Issues resolved in previous drafts .......................   15
5.2   23
6.2 Open Issues resolved in this draft ............................   17
5.3   25
6.3 Still Open Issues .............................................   18
6   26
7 MIB Outline .....................................................   27
8 MIB Definition ..................................................   19
7   33
9 Acknowledgments .................................................   70
8  118
10 Security Considerations .........................................   70
9 ........................................  118
11 References ......................................................   71
10 .....................................................  119
12 Authors' Addresses .............................................   74

11.  122

13.  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 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.